Design the rules, not the agent.
Models decide what an agent can do. Harnesses decide what it can do reliably. Neither decides what happens when a hundred agents act at once: who checks, who approves, who can stop it, and who carries the risk. That layer is the institution, and this is a primer on designing it.
October 2026. Builds on our note “Institutional Engineering: designing the rules, not the agent”, with the corrections hosaka made in its reply, the October 2026 lab landscape, and two worked references.
The design problem moved up a floor.
For three years the frontier was model quality, then harness quality: tools, memory, retries, context. Both are now good enough that the binding constraint sits above them. The new design object is the institution, the standing rules a population of agents works under. Swap the model and the rules remain. Change the rules and the same model behaves differently.
Can it do the task at all?
Fails as wrong answers, weak reasoning, missing capability.
Can it do the task reliably?
Fails as dropped context, broken tool calls, loops that never end.
What happens when many agents act and no human is in the loop?
Fails as correct work in the wrong place, compounding error, and nobody able to stop it.
A layer-3 failure can't be fixed at layer 1. A better model that does slightly more than you asked, faster, across more systems, is a bigger institutional problem, not a smaller one.
A rule without an enforcer is a costume.
This is the line between institutional engineering and writing policy. A rule in a prompt, a style guide or an acceptable-use PDF is a request. A rule checked by something that can reject the work is a constraint. They look the same in a spec. They behave nothing alike under load.
Rule in the system prompt
Never publish a claim without a cited source.
Compliance depends on the agent reading carefully and not being helpful in a slightly different direction. It holds most of the time, and the failures are silent.
Gate in the publish path
REJECT if a quantity is present and a citation is absent → return to author with the rule
Compliance is a property of the pipeline, not the agent. The rule survives a model swap and a bad day, and its failures are visible and cheap.
- Evidence
- In the Institutional AI study, an enforced institution with a keyed append-only log cut severe collusion from 50% to 5.6% of runs (90 runs per condition). The same rules as a prompt-only constitution gave no reliable improvement.
- Who fails
- DeepMind's review of roughly a million coding-agent tasks found most flagged events came from misreading or overeagerness, not malice. Design the gate for the eager agent first. It tends to catch the hostile one too.
- Limit
- A gate is not proof against prompt injection. Rules written as command-text fences can be bypassed through indirection and encoding. The strong case is a gate on the artifact as it crosses a boundary, checked by code the agent cannot edit.
Detection is not enforcement.
In a 100-agent DeepMind swarm experiment, 24% of agents spotted the exploit and raised a flag. The exploit still spread through the swarm in 27 minutes, because the whistleblowers had no tool to stop it.
A flag is a message to someone who can act. If that someone is a human reviewer, the question is whether they arrive in time, and any honest estimate of a review loop is longer than 27 minutes.
Detection still has a place. It is legitimate when it is declared non-blocking and routed to something obligated to act, with the severity of the finding choosing who that is. A check that notices and tells nobody in particular is decoration.
The first boundary is the environment, not the model.
The largest labs and the protocol bodies they steer are converging. Containment starts in the execution environment. The harness is versioned, tested code. Autonomy is becoming a structured object a machine can check. Identity and authority are moving to per-agent signatures and chains of signed mandates. The protocol texts, meanwhile, leave enforcement to whoever implements them.
| Who | What they write down | Institutional idea |
|---|---|---|
| Anthropic | Containment in layers: the environment first (sandboxes, egress allowlists, filesystem bounds), then model-level classifiers, then tool permissions with MCP auditing. Claude Code auto mode reports a 0.4% false-positive rate on 10,000 actions and 17% false negatives on 52 over-eager actions. | Enforce at the boundary, and publish the error rates of the gate. |
| OpenAI | A scope of autonomy with fields such as allowed tools, latest time and maximum cost, where every scope needs an ending condition. A chain of command in which tool outputs and untrusted text carry no authority by default. | Autonomy as a bounded, expiring grant. Standing set by source, not by content. |
| Google DeepMind | An AI control roadmap with tiered coverage targets, and the million-task review of coding-agent behaviour. | Measure what the controls actually catch. |
| Microsoft | A separate identity for each agent and an accountable human role in its adoption guidance. | Every agent is an identity, and every identity has an owner. |
| GitHub | The Copilot cloud agent can't approve, merge or mark its own pull request, and the person who asked for the work can't approve it either. | Separation of duties, written into the product. |
| Protocols | A2A signable Agent Cards and opaque execution. AP2 mandate chains. MCP, AGENTS.md and x402. | Declared capability and signed authority on the wire. Enforcement left to implementors. |
Figures as reported in hosaka's October 2026 landscape note, which read the lab documents directly. Some OpenAI material was read through mirrors with unverified dates. One more number from the same note: under 1% of agent configuration files declare permission boundaries, against 33% of GitHub Actions workflows.
Six things a permission list can't express.
A permission is a yes or no on one action by one actor. It is necessary and nowhere near sufficient. The institution is everything a permission list has no grammar for.
Who may propose, approve or halt?
Permissions grant capability. Standing is authority over other agents, including whether anything can stop something else mid-flight.
What can each agent see of the others?
Under A2A's opaque execution, agents exchange results and declared capabilities, not reasoning. Nobody watches a problem form; they only see the output.
What is worth a human's attention?
Attention is the scarcest input. A reviewer who reads everything reads nothing closely, so the design question is what reaches a person at all.
Where does rejected work go?
Back to the author with a reason, parked for review, or dropped. Each choice produces a different system a month later.
What does the system remember?
A fact one agent writes is read by another that didn't exist when it was written. Shared memory without governance is shared error.
What does the arrangement reward?
Hold the agents constant, change the market rules, and outcomes move. That result, from the Artificial Institutions work, is the case for the whole discipline.
Human institutions already solve this, and they lack one axis.
The AGI Institutions wiki maps existing human institutions on two axes: seven mechanism types and five scales, from two parties to the whole world. It is a useful catalogue of patterns to borrow. What it doesn't record is whether a mechanism is merely stated, monitored, or enforced, and for agents that is the axis that decides whether it works.
| Mechanism | What it is | Human example | The enforcement question for agents |
|---|---|---|---|
| Protocols | Standards and coordination | TCP/IP, W3C, ISO | Does a malformed message get rejected at the gateway? |
| Preferences | Aggregated wants | Elections, participatory budgets | Whose preferences count, and who tallies them? |
| Rights | Formal entitlements and adjudication | Courts, bylaws, grievance boards | Who adjudicates a dispute between two agents? |
| Incentives | Structured payoffs | Bounties, escrow, cap-and-trade | Is the payoff settled by code, with balances that must reconcile? |
| Expertise | Credentialed epistemic authority | Licensing boards, peer review | Does an agent have to pass an entrance exam before it gets trust? |
| Norms | Behavioural expectations | Codes of conduct, team culture | Which norms are binding (MUST) and which only orient (SHOULD)? |
| Thick commitments | Articulated shared understanding | Constitutions, mission documents | What survives as precedent the next agent inherits? |
Mechanism types and examples from the AGI Institutions wiki's “Existing human institutions” grid. The right-hand column is ours.
Every company already has an institution, written in prose.
It sits in a delegation-of-authority matrix, an employee handbook, a legal opinion from 2019, licence conditions and a strategy deck nobody reopens. None of it is executable. The first real job is policy compilation: turning rules that live in documents and in reviewers' heads into checks a machine can run, each traced back to the clause it came from.
What you compile from
- Delegation of authority and spend limits
- Employment and conduct policy
- Sector regulation and licence conditions
- Data protection duties, per jurisdiction
- Contracts with customers
- Strategy: what the firm will and won't do
What compiling means
- Name the decision class
- Find the clause that governs it
- State a test a machine can run
- Set the confidence floor, and its owner
- Name the fallback when the test can't run
- Keep the trace: rule → clause → person
Compiled artifacts
- A gate that rejects
- A confidence floor per decision class
- A routing rule to a named human
- An audit record linking action to rule
- A list of classes still off-limits
What doesn't compile.
Judgment. Proportionality. “Reasonable in the circumstances.” Novel cases with no precedent. Anything that depends on a relationship the system can't see. Don't force these through to raise a coverage number.
The honest output of a compile pass is two lists: what is now enforced, and what stays a human call. The second is the more valuable document, and most organisations never write it down.
Autonomy is granted in bands, not switched on.
The useful frame isn't autonomy against oversight. Each class of decision sits on a band and moves up only on measured evidence. Different parts of the same business will sit on different bands for years, and that is correct, not untidy.
- ObserveThe agent watches and nothing leaves the building. The point is a baseline error rate on your own work, not the vendor's benchmark.
- ProposeThe agent drafts and a person reviews every item in full. Slow by design. This is where the disagreement data comes from.
- Act on approvalThe agent acts once a named person approves. The decision arrives framed, so the reviewer decides rather than drafts.
- Act with samplingThe agent acts and a sample is reviewed afterwards. The sample rate is now the control, and lowering it is a decision with a name on it.
- Act under auditOnly exceptions and breaches reach a person. The gates carry the load, so they had better be able to reject.
Approve, reject, remand.
Below its confidence floor, an action shouldn't just fail. It should be remanded: sent back with the missing information named, for the agent to fetch or a person to supply. Most systems have two of the three outcomes, so borderline work is waved through or dies in a queue.
Where remand lives matters. It belongs at review, where the feedback names the change required. The final publish door can stay binary: one person, approve or stop.
A threshold is a promise to measure.
A model's stated confidence isn't a probability until it has been scored against outcomes. An uncalibrated floor is a number that makes people feel governed. Every floor needs a row with an owner, a measurement method and a review date, or it shouldn't exist.
The opposite discipline also works: publish no confidence numbers at all, because published metrics become targets.
Someone's name is on every decision class.
Every agent action has to trace to a person who carries the legal risk, in a named jurisdiction, under a named instrument: the liability anchor. If you can't name one for a decision class, that class isn't ready for any band above Propose. The anchor isn't whoever is nearest. Advertising liability doesn't move to the engineers who built the marketing agent.
| Decision class | Floor | Below the floor | Liability anchor | What binds |
|---|---|---|---|---|
| Statutory filing, UK | 0.99 | Remand to the signatory | The accountant or director who signs | Companies Act duties. The signature is personal and doesn't delegate to a tool. |
| Advertising claim, EU | 0.95 | Remand with a request for substantiation | Head of marketing in the publishing entity | Unfair-competition and consumer protection rules, which vary by member state. |
| CV screening, New York City | No band | A person decides | The employer and the hiring manager | Local Law 144: a yearly bias audit and notice to candidates before an automated tool is used. |
| Customer data transfer | 0.99 | Reject, don't remand | The controller named in the privacy notice | GDPR. Controller duties don't move to the processor, the vendor or the model. |
| Price change under £5k | 0.90 | Remand to the category owner | Category owner, under delegation of authority | Internal policy only, so you set the floor yourselves. |
Rows are illustrative, to show the shape of the artifact. Confirm the instruments with counsel in every jurisdiction you operate in.
Jurisdiction follows the work, not the model.
A worked example, also illustrative. An agent run by a London team, on a model hosted in the US, writes a product claim for the German storefront and quotes reviews from French customers. The claim answers to German unfair-competition rules. The reviews are personal data, so GDPR applies and the controller named in the privacy notice carries it. The London team's delegation of authority decides who may sign the page off. Three regimes in one task, and none of them is where the model runs.
Approval without information is a rubber stamp. Liability stays with the anchor whether or not they understood what they approved, so the approval screen has to give them what they need to carry it.
Shape is not authority.
Hounfour (loa-hounfour) is an open, schema-only protocol library that one agent fleet uses as its wire format for identity, money, reputation, governance and memory. It is a clear example of a split every institution needs: the library ships shape, and the systems that use it ship authority.
- Four invariants
- Valid JSON is not an authorised action. A valid signature doesn't establish the signer's competence. A valid action shape doesn't permit a change. A valid object is not current truth.
- Three verdicts
- Checks return conserved, violated or unverifiable, and unverifiable never counts as passing. Money is integers, and balances must reconcile.
- Typed obligations
- Rules the library can state but not enforce are handed to a named consumer in a manifest of checks still owed, instead of being dropped.
- Agreement
- Reference runners in TypeScript, Go, Python and Rust must return identical verdicts on a shared corpus of test vectors, or the release is blocked.
- Honest gaps
- It has no enforcer of its own and no point where an action can be blocked before it happens, and one agent can't halt another through it. Its maintainers say so, and call the result a whistleblower without an enforcer.
From the Hounfour protocol page and hosaka's October 2026 landscape note, at version 8.7.0. The fit ratings in that note are self-assessed by the library's maintainers.
Almost every mechanism here is an interface.
This isn't a topic that lands only on legal's desk. Most of these mechanisms surface as screens, and most are badly designed today because nobody treated them as design problems.
The approval moment.
Design the decision, not the dialog: what the agent intended, what will change, what can be undone, what happens if the person does nothing, and how to ask for the one missing thing.
Work in flight.
With twelve agents running, “in progress” isn't a state anyone can act on. Show what is queued, blocked, waiting on you and shipped. Borrow from production boards, not chat.
Rejection copy.
A gate's rejection is interface copy: what failed, which rule, what would pass. Vague rejections push agents into guessing, which is the overeager failure again.
The escalation inbox.
If people are reserved for escalation, their queue is the product. It needs triage, severity and a fast path to a decision, and it must be strict about what gets in.
The stop control.
Someone must be able to halt a running population. Design the aftermath too: half-finished work, open commitments, and how to resume.
The rules, visible.
Show the live rule set in the product: what is enforced, what is only advised, what changed this week and who changed it.
Confidence, honestly.
A percentage beside a decision implies a calibrated probability. If it isn't calibrated, show the band, the floor and what it's measured against, or show no number.
The accountability record.
What was decided, on what basis, under which rule and by whom, readable at the moment of approval and again eighteen months later.
What nobody has solved yet.
- Compiling above the repo
- When the source clause is a licence condition rather than a code rule, what does the compile pass look like, and who owns the trace from rule to clause to person?
- Standing between agents
- Which primitive could let one agent halt another mid-flight, without putting a second model in the loop?
- Calibration at scale
- Confidence floors need outcome data. Gate rejection records, each tied to its rule, are one half of the evidence. Calibration curves scored against outcomes are the other.
- Memory across organisations
- One owner per fact works inside one fleet. What does provenance look like when the writer and the reader belong to different institutions?
- Oversight as work
- Approval steps without time or material give only the appearance of oversight. What does an approver need, and who pays for their time?
Nothing published yet reports a production deployment at the scale this primer describes. The institutional papers are preprints and simulations, and the swarm result has one experiment behind it. Treat the direction as well argued and the specifics as unsettled.
What this primer draws on.
- Institutional engineering: sources, agreement and pushback. hosaka, October 2026. The reply to our earlier note, with the corrections used here.
- Harness and governance design at the largest AI labs. hosaka, 14 October 2026. The lab landscape in section 04.
- Hounfour protocol. hosaka. The worked reference in section 10.
- Existing human institutions. AGI Institutions wiki. The grid in section 06.
- A rule without an enforcer is a costume and Governance engineering. hosaka. Source of the section 02 title and the closing test.
- Whistleblowers without enforcement and Design the institution, not the agent. hosaka.
- Institutional AI. DEXAI Icaro Lab with Sapienza, Sant'Anna and VU Amsterdam. Preprint.
- Artificial Institutions. Chupilkin, Oxford. Preprint.
- Agentifying Agentic AI. Dignum and Dignum, WMAC at AAAI 2026.
- Securing the future of AI agents. Google DeepMind.
- A2A protocol specification. Agentic AI Foundation.
- Approval steps without time or material. Mitchell, Ghosh and Passi. Position paper.
- Agent governance guidance. Microsoft Cloud Adoption Framework.
- Cloud agent risks and mitigations. GitHub.
- RFC 2119, the MUST and SHOULD of binding and advisory rules.
If it can't reject something without a person present, it's a policy, not an institution.
Run it against your own AI guidelines, model cards and prompts. Ask which of them has a gate behind it, and what that gate does to work that fails. We help funds and their companies compile the answer.