01
Discovery
We sit with your team and watch the real work happen. Then we turn how your best people do it into playbooks the whole team can run.
From prompting to a team playbook.
Set it up once. Run it every time.
Working with Constraint
02
Tooling
Playbooks live in Constraint with runs, reviews, and versions. We connect it to the AI tools you already use and handle the setup.
03
Training
We make your team fluent in agents, MCP, and CLIs. Hands-on, until your team can run and improve everything without us.
Your first two weeks
Before anything gets built, we learn the work as it actually happens. We pair with your expert and run one focused loop, start to ship, in two weeks.
Pair
We work with your domain expert, the person who owns the work.
Shadow
We watch the real workflow, every step and every exception.
Prioritize
Together, we pick what repeats, matters, and is ready.
Build together
We draft the playbook with the expert, not for them.
Validate
Others on the team run it. It has to hold up without its author.
Ship
The playbook, its review gates, and its record live in Constraint.
The unit of improvement is the workflow, not the task. The method stays yours.
Our product
Discovery hands you playbooks. Constraint is where they live. Our product is how your team runs, versions, and expands the work you can accelerate with AI.
Four ways to start.
However you begin, you end up with one thing: a shared playbook your team can run, review, and version. Pick the on-ramp that fits what you already have.
01
Load what you have
Bring your existing SOPs, wikis, and checklists. Constraint structures them into a shared playbook your team can review and version.
02
Create from an interview
Answer a few questions about the work: the goal, what “done” means, and how you verify it. From your answers, a first playbook is generated for you to shape.
03
Start from a good run
Already have a run or prompt set that produced a great result? Send it over, and we turn it into a playbook your team can run.
04
Select from the Bank
Start from an expert-built playbook in the Bank, then shape it to your team’s context instead of beginning from a blank chat.
Browse the BankWhichever way you start, the boundary is the same: Constraint manages the shared playbook layer; your AI tool stays where the work happens.
Shape it once, run it every time.
Set it up once, then run the loop. Open any step to see what happens.
- Set it up once
-
Name the recurring task, lay out the steps, and attach the context a good result needs: instructions, examples, and references. No one rebuilds it from scratch, and that becomes the current version everyone runs.
A playbook holds
StepsRequired contextWhat “good” looks like -
Mark the steps where judgment counts. At a gate, a person checks the work before it moves forward, so the risky step gets a look while it still matters.
Steps
StepDraft prepared from the playbookReview gateA person checks before it moves forwardStepWork continues once it is signed off -
Publish the playbook to your team. What lived in one person’s chats becomes a shared method anyone can run the same way, with the same steps and context. New teammates start from the current version instead of a blank chat.
What changes
One person’s methodthe whole team’s playbook - The recurring loop
-
Your team runs the playbook with Claude, Codex, and other AI agents, in the tools they already use. Constraint keeps the shared method, the gates, and the records around the work. The AI tool stays where the work happens.
Where it runs
Claude, Codex, and other AI agentsthe method stays in Constraint -
Each run leaves a record of the steps followed, the files used, and which steps were checked. You can trust the result now and see exactly how it got there. A manager can confirm the work was reviewed from the record itself.
A review record keeps
ReviewedWhat was reviewed
The playbook and the step that mattered.
Visible evidence
The context and sources the work was based on.
Review gate
Who signed off before it moved forward.
Result
What the run produced, ready to trust.
-
Reviews can surface playbook improvements, which can be adopted and released as the next version. Every future run then starts from the improved method instead of repeating old mistakes.
Carry learning forward
the approved change becomes what future runs inherit
Frequently asked questions.
Does Constraint replace Claude, Codex, and other AI agents?
No. Constraint does not replace your AI tool. It gives recurring AI-assisted work a shared shape: agreed steps, the context each needs, and a review trail your team can version. Your team keeps working in the AI tools it uses today.
What does Constraint actually manage?
The process, not the model. It holds the playbooks and everything that keeps them accountable: where a person reviews, what each run recorded, and which version is current, plus a manager-level view of how work is moving. Your AI does the work; Constraint holds the method around it.
What does a manager see?
A process-level view: which playbooks are running, what’s waiting for review, the evidence behind each result, and which version is current. When someone finds a better way, that becomes the next version, and the baseline rises.
What do I actually install?
MCP is an open standard for connecting AI tools to shared context. Your team’s Constraint workspace becomes available inside the AI tools people already use, through one connector configured once. Nothing else is required to start. Teams that want Constraint skills inside coding tools like Codex or Claude Code can optionally add them with a small CLI package; the AI tools people already use keep doing the work.
Do we have to change tools?
No. Your team keeps working the way it does today. What changes is the method, which becomes shared and reviewable; the tools stay the same.
How do I know where a playbook’s content came from?
Every line of a playbook carries its source: material you provide, approved context, or clearly marked guidance. You can see where each part came from before you approve it.
Do we own what we build?
Yes. Your team can inspect its own playbooks, records, and history at any time. Constraint adds reviewability around the work; it never hides the method from the team that owns it.
Start with one workflow.
Bring one workflow your team repeats, and we’ll turn it into a shared, reviewable playbook.