The Failures Register: Every Mistake Becomes a Rule
An append-only failures register: each production failure closes as a new test, a contract amendment or a signed risk acceptance, so the same failure cannot return silently.
Published November 2026, dated to the month the work was done.
TL;DR: A repeated failure is a silent betrayal: the same mistake returns after everyone believed it was fixed. A failures register closes that gap. Each failure becomes an append-only row, and a row is not closed until it ends in a new test, a contract amendment or a signed risk acceptance. Tests are preferred, because a test runs every time.
Most of the rules that govern agents on our platform were not designed up front. They exist because a failure showed us a guarantee we had not written. What matters is how the failure is closed: with evidence the system can enforce.
The common response is to fix the problem and move on. The fix works, the incident fades, and months later a different session makes the same mistake, because the lesson lived in one person's memory instead of in the system. The production response is a failures register: one place where every failure is recorded and tied to the rule or test that now prevents it.
What a row holds
A row is short. It records what happened, which rule or clause it touched, whether the system or a person caught it, and what changed afterward. The last field is the one that matters. Every row must end in one of three outcomes:
- A new test that would have caught it, added to the checks that run on every build or every run.
- An amendment to the contract or the agent constitution, with the date and the reason.
- A signed decision that the risk is accepted, and by whom.
A row that ends in none of these is not finished. "We will be more careful" is not an outcome.
Why append-only
Rows are added, not edited or removed. If a later fix replaces an earlier one, that is a new row that points back. Corrections follow the same path, and retention follows the organization's records policy. There are three reasons for the rule.
First, the history is the evidence. When someone asks why a rule exists, the answer is a dated row, not a story. Second, it prevents quiet loosening. If an old row cannot disappear, a rule cannot disappear either without a new row that says who removed it and why. Third, it changes how the system learns. Rules arrive one at a time, each with its reason, instead of all at once in a rewrite after a bad week.
Patterns from production
The register started as structured failure notes next to the governing rules: the symptom, the cause and the fix. Over time the useful notes took the same shape, and the best ones pointed to a check, not just a sentence. Recurring patterns from production:
- Completion claims were not verified. Worker sessions reported tasks as finished when the work had failed. The rule: work is accepted only by a check, never by the worker's own report. Each brief now carries an acceptance command, and the runner executes it and returns failures to the worker.
- Stale blockers held work. Coordinating sessions kept waiting on a blocker recorded earlier, after it had cleared. Now a blocker carries the time it was last checked, and one outside its validity window is treated as unverified.
- Missing evidence was read as health. Repeated runs of a scheduled job hit their time limit, and the status check showed silence as fine. The rule: every run leaves a record, success or failure, and a missing record is an alarm.
- Fixed defects returned. Every confirmed defect now becomes a regression case with an automated check, and a release is refused if any case fails.
None of these rules is clever. Each is what remained after a failure, written so the failure is harder to repeat.
Tests beat sentences
A rule written only as a sentence for an agent to read is weaker than a rule enforced by a test. Sentences get skimmed, lost in long sessions or argued away. A test runs every time. When a row could end in either, we choose the test, and keep the sentence too, so the agent knows why the test exists.
The Contract Decides shows how this pays off during a model upgrade. A quality check on a specific class of documents regressed under the new model version, and the deploy gate held the upgrade. The team fixed the affected processing step, the check passed again, and the register row linked the test, the fix and the approval. Nobody had to remember the incident. The test remembers it.
How to start
Start small and controlled: a register with an owner, restricted write access and five required fields (date, what happened, rule touched, caught by, outcome). Add a row the same day a failure is found, while the details are fresh. Once a month, review the rows that still have no outcome and close them. As the register grows, feed its rows into the incident, risk and compliance tools the organization already uses, so it does not become a separate world.
The register is how a contract learns without being rewritten under pressure. It is part of Governance-Driven Contract Design (GDCD), and Chapter Ten of The Contract Decides: Governing AI at Every Door covers it alongside the rules for changing a contract safely. The companion post, Give Every Agent a Constitution, shows where the amendments land.
Tools for tracking incidents come and go. The principle holds: no failure is closed until it leaves enforceable evidence. Every line holds.