On this page
Good ways of working with AI are often trapped in individual heads and chat histories. One person knows the right sequence. Another knows where judgment matters. The company cannot easily see, share, or improve either.
Constraint gives that method a shared home beside the AI tools a team already uses, including Claude, Codex, and other agents. The AI tool does the work of the moment. Constraint keeps the recurring process legible across people and runs.
01What Constraint is
Constraint is the shared playbook and version control layer for recurring AI assisted work. It keeps four things that should outlast any single session:
- Playbooks define the sequence. They name the steps, their order, and the intent of each stage.
- Gates hold human judgment. They pause a run until a person confirms that the work can continue.
- Records show what ran. They keep step state, notes, attestations, and optional transcripts with the run.
- Versions improve the method. Each edit creates an immutable version, while an active pointer determines what future runs use.
Together, these make a system of record for recurring AI work. A run snapshots its steps and relevant company memory when it starts. That preserves the process used for the work, even after the active playbook changes.
One time exploration can stay in a chat. A weekly brief, triage loop, partner assessment, or launch memo benefits from a method the team can run, review, and improve. To see these pieces in one concrete structure, step inside a working playbook.
02What Constraint is not
The category is easier to understand when its edges are plain:
- Not a chat tool. Prompting, iteration, model responses, open files, and tool permissions remain in the AI environment.
- Not an agent framework. Constraint builds on the skills and agent stacks a team already uses. It does not ask the team to replace them.
- Not a work tracker. A playbook is a repeatable method someone can run or refer to, not a ticket someone assigns to themselves.
- Not the tool doing the drafting. Claude, Codex, ChatGPT, Copilot, Gemini, and other tools still generate and execute the work.
If the question is "where do I draft?", the answer is the AI tool. If the question is "where does our team keep the agreed way this work should run?", the answer is Constraint. The two can connect through MCP, while skills are distributed through the Constraint CLI.
Draft in the AI tool. Keep the method, the gate, the record, and the version in Constraint.
03A worked hand-off
Take a weekly partner assessment. The team needs to gather signals, draft a recommendation, get human sign off, and preserve what happened. Here is what each surface holds as the work moves.
Before the run. Constraint holds the current playbook version, its ordered steps, and the human gate. The AI tool holds nothing for this run yet.
At the start. Constraint creates the run from the active version and snapshots the rendered steps and relevant memory records. The AI tool becomes the workspace for reading source material and drafting.
During the draft. The AI tool holds the working context, model responses, and recommendation. Constraint holds the current step, its status, and any note the person chooses to record.
At review. The reviewer makes the judgment. Constraint holds the gate and the human attestation required to complete that step. The AI tool remains the place to revise the prose if the work needs another pass.
After approval. The AI tool can prepare the approved next action. Constraint advances the remaining steps and keeps the completed run, its version, notes, and attestation. An optional transcript can also be attached to the run.
When the method changes. An editor adds a buying journey fit check. Constraint creates a new playbook version and makes it active for future runs. Earlier runs remain tied to the process they used. The AI tool needs no process migration.
This is the hand off: working material moves through the AI environment, while run state and review decisions accumulate in Constraint. Each surface keeps the part it is built to answer for.
04Why the separation is the point
It can feel simpler to keep everything in one chat. For a single person on a single task, it often is. The cost shows up when the work is recurring, multiplayer, or worth improving over months. If the method only lives inside the tool that drafts, then switching tools, rotating owners, or tightening a step means starting over. Private excellence does not become team capability.
Separation is what makes the method portable. AI tools will keep changing: new models, new agent surfaces, new permissions models, new defaults. Teams will keep switching seats and mixing tools across functions. That churn is normal. If the playbook, the gate, the record, and the version are tied to one chat product, every change scrambles the process. If they live in a shared layer beside the tools, the team can change drafting environments without losing the way the work is supposed to run.
Separation is also what lets the method compound. A better step order, a clearer gate, a stronger definition of done: those improvements belong on the playbook, not in a prompt someone might forget. Versions turn feedback into a better shared default. Records turn "we usually check X" into evidence that X was checked on this run. None of that requires the AI tool to become a process system, and none of it requires Constraint to become a chat product. Each side stays good at its job.
Other AI tools still matter, deeply. They are where speed and quality of generation show up. Constraint does not compete for that role. It focuses on the shared playbook layer so recurring AI-assisted work has shape the organization can see, run, review, and improve. The boundary is not a missing feature. It is the design.
The takeaway
Constraint is the shared playbook layer around recurring AI-assisted work: playbooks, gates, records, and versions. It is not a chat tool, not an agent framework, and not a replacement for the AI tools that draft and execute. In a healthy setup, drafting happens in the AI tool while the method lives in Constraint, with a clear hand-off at every step of a run.
That separation is the point. Tools can change. The method compounds. When recurring work needs shared shape, start with one workflow, keep generation where it already thrives, and put the durable process beside it.
Ready when you are, start with one workflow.
Prefer to look first? View playbook examples, no email needed.