The Contract Decides: Governing AI at Every Door
AI
A field guide to governing production AI agents with written contracts at every door: tools, APIs, streams, memory and other agents. Outcome first, enforced and evidenced.
TL;DR: AI agents enter a system through many doors at once: tools, APIs, data stores, event streams, browsers, terminals and other agents. Most governance still guards only the code-review door. The Contract Decides is a field guide to Governance-Driven Contract Design (GDCD): start from the business outcome, write guarantees, and enforce them as contracts at every door, with evidence. The model proposes. The contract decides.
Agents do not stop at the pull request. In a single task, one agent can read a repository, query a database through a tool, open a browser, run commands in a terminal, publish to an event stream, draft a message to a person and hand part of the work to another agent. Each of those is a door into production. A door without a written contract is where trust fails quietly.
For many delivery teams, version control became the main control point for software change, and much of the governance built over two decades still sits there. It is one door among many. That gap is the subject of The Contract Decides: Governing AI at Every Door, Book 1 of a series on Governance-Driven Contract Design (GDCD).
From data swamps to AI swamps
A decade ago, many organizations moved their data into data lakes, and many of those lakes became data swamps. Nobody knew who owned a table, what a column meant or whether the numbers could be trusted. Explicit data contracts were a large part of the way out: written agreements about what each dataset means, who owns it and what it promises.
The same pattern is now forming around AI. Prompts, agents and tools reach production without a clear owner, a change record or enforceable limits. The guide calls this the AI swamp, and it treats the cure the same way: make ownership, meaning and limits explicit, then enforce them.
Where the method comes from
The method goes back to 2022, to delivery work with the early AI coding models of that time. Those models kept no change history and no memory of earlier work. Each requested change could rewrite a module and break behavior that already worked. The answer was to write a contract for every module: what it guarantees and what it requires, checked on every change.
The models changed. The contracts did not need to. Speed changes and technology changes. The contract stays. Tools are fashion. Trust is the work.
GDCD also borrows from financial discipline. Every door is treated like an account, with an owner, a limit and a ledger. Every guarantee can be traced along one line, from the outcome the business pays for down to the line item of cost. The guide calls this the guarantee line.

What is in the book
- Every door is a boundary. A boundary map with five columns (door, authority, data, blast radius, lifecycle) that turns "think in all dimensions" into a table a team can fill in.
- How much rigor. The approach of safety-critical engineering, tiered by risk. Probabilistic parts are bounded and monitored, never described as guaranteed.
- The contract. Six clauses plus tolerances and precedence; enforcement at design, deploy and run time; evidence instead of assertions; an agent constitution; and contracts that evolve through a failures register.
- The guarantee layers. Security, visibility and cost, each written as contract clauses that protect the outcome the business pays for.
- The organization. Federated governance across every layer, why this is not service-oriented governance again, and where contracts fail.
Why now
Agents act on the permissions that were actually granted, not the ones that were intended, and they act at machine speed. Governance debt that stayed hidden for years becomes visible quickly once an agent starts walking through the doors. The response the guide argues for is governance first: layer by layer, boundary by boundary, focused on the guarantees of the system rather than on any one model or framework.
In practice that means three things. The outcome is written down before the agent is built. Each guarantee that protects it is a clause at a specific door, enforced by a gateway or a policy check, not only by text in a prompt. And every allowed or blocked action leaves evidence that a reviewer can read later.
The GDCD series
The series continues with one field guide per layer: Outcome First, Security by Contract, Visibility by Contract, Cost by Contract, Data by Contract, Agents by Contract, and a GDCD Field Manual with templates. Each will link back here. Two companion posts apply the method today: Give Every Agent a Constitution and The Failures Register.
A useful first question for any AI system in production: how many doors does it use, and which of them has a written, enforced contract? The model proposes. The contract decides. Every answer is earned.