Give Every Agent a Constitution
AI
Unwritten agent rules do not scale. A short constitution of purpose, authority, prohibitions and stop-and-ask lines sits under role rules and briefs, and the stricter layer always wins.
Published November 2026, dated to the month the work was done.
TL;DR: Rules that live in an operator's head do not scale to many concurrent agents. Each agent on our platform reads a short written constitution before it starts: its purpose, its standing authority, a few hard prohibitions and clear stop-and-ask lines. It sits under role rules and task briefs, and where two layers differ, the stricter rule wins.
Unwritten rules fail in silence. When agent work is small, standing rules can live in the operator's head and be repeated when an agent drifts. At production volume, with many concurrent sessions across the compute tier, that model breaks. The sessions that never heard a rule are the ones that act against it.
So the rules are written once, in one place, and every agent that works in a given area reads the same short document before it starts. We call it a constitution.
What a constitution is
A contract attaches to a door: a tool, an API, a database. A constitution attaches to an agent. It is the small set of rules that hold for that agent no matter which door it uses. In Governance-Driven Contract Design (GDCD), the two work together: contracts at every door, and a constitution for every agent that walks through them.
A constitution should stay short enough to review, version and apply consistently. Long policies make it more likely that critical rules are missed or applied inconsistently. A useful one answers four questions:
- Purpose. What the agent is for, in one sentence. Anything outside it is out of scope by default.
- Standing authority. Which doors it may use, and where the rules for each door live.
- Hard prohibitions. A handful of things it may never do. Typical classes: no external communication without a human release (the agent drafts, a person sends), no unreviewed change to a shared codebase, and no credential written to any log or session output.
- Stop-and-ask lines. The points where it must pause and get a person.
The stop-and-ask lines
Prohibitions get the attention, but the stop-and-ask lines do most of the work. Preventive controls always have gaps the policy did not anticipate. An agent that knows when to ask reaches a person before it reaches the gap.
Our lines are explicit approval boundaries. Stop before any write to production. Stop before any change to infrastructure, identity, access or security posture. Do not delete anything that is not already in the system of record. And the most important one: when unsure, stop and write the question into the status record. That last line turns uncertainty into something the operations team can see on a board, instead of a guess an agent makes without accountable review.
Asking has to be cheap, or agents will not do it. The question goes into a record the agent already writes, and a coordinating session reads those records on every pass. No one has to be watching a live console for a question to be seen.
Layers and precedence
One document is not enough once there are different kinds of work, so the rules are layered. At the base is a short safety file that binds every session everywhere. Above it is the constitution for one area of work, with rules about ownership, change control and cleanup. Above that are role rules, for example the rules for a session that coordinates other sessions instead of writing code. At the top is the brief for one task.
Layers raise the obvious question: what happens when two of them disagree? That has to be decided before the day it happens. The rule is one sentence near the top of the constitution: where two layers differ, the stricter rule wins. A brief can narrow what a session may do. It can never widen it.
Our governance model extends this into a written order of precedence: law, then organizational policy, then the contract, then a human request, then the prompt. The prompt is always last. A prompt is a request, never an authority.
Keeping it in force
A few controls keep a constitution from becoming a forgotten file:
- One home, one owner. The constitution lives in one place, with a version, an owner and a keeper. Execution environments receive a controlled read-only copy on a fixed refresh. Nobody edits a copy.
- Read before work. Every session, whatever tool it runs in, reads the constitution before it starts.
- Every session states what it is doing. Each one has a name and a status record that changes when its state changes. A constitution that cannot be checked is a wish.
- Rules come from reviewed events. New articles are added through reviewed incidents and near misses, each with its reason. That is the subject of the companion post.
Text alone is not enforcement. A model can misread a rule, lose it in a long session, or be argued out of it by content it finds in the data. The fuller pattern keeps one source of truth with two readers: the model reads it as instructions, and a gateway enforces the same rules as policy, with a test that checks the two still agree. Our core lines are enforced by the system. Lines that are still instruction-level move into deterministic enforcement in order of risk.
Where this comes from
Chapter Nine of The Contract Decides: Governing AI at Every Door covers the constitution, identity and delegation in more detail. The companion post, The Failures Register, covers how a constitution grows from real events.
The tool an agent runs in will change. The principle will not: authority is written, escalation is cheap, and the guarantees that matter most are enforced outside the model. That is how an agent earns trust. Every answer is earned.