FOUNDRYOS FIELD NOTE 03

The builder doesn't get to say it passed

How we run AI builds so that "it passes" means something: two lanes, evidence cited by hash, and the verdicts in between.

12 min read · 10 sections · jump to any of them below
FoundryOS Field Note 03. Headline: A pass is testimony, not proof. By Dan Merchant, Founder, FoundryOS. Subhead: The agent that writes the code doesn't get to say it passed. On a dark amber-lit floor, two lanes of light, one starting at a wrench and hammer block and one at a magnifying glass block, converge on a glowing document sealed with a wax seal stamped with a hash symbol. foundryos.ca.
The lane that builds the work never decides that the work is done.
Sections

When an AI agent finishes a build, it will tell you the tests passed. It usually believes that. It is also the one piece of information you cannot take at face value, because the agent that did the work is the same agent grading it.

So on our builds, the agent that writes the code never decides whether the code is done. One session builds. A separate session reviews the evidence and issues the verdict. A passing claim from the build session is testimony, not proof. It becomes PASS only when evidence tied to the exact source state survives review.

This is the evidence model we run across the FoundryOS fleet. None of the individual rules are new. Regulated industries have run versions of them for decades. What is unusual is running them on AI agents, at the size of a one-person studio, with the judgment written down and the evidence frozen by hash. The failures explain why each rule is there.

What Went Wrong

The problem: a passing claim is testimony, not proof

On one build, a checkpoint cited its evidence by an abbreviated hash, the kind that shows the first characters and the last characters with an ellipsis in the middle. It looked fine. The review lane went to confirm it and found the citations had been spliced: a real prefix and a real suffix from two different artifacts, joined to look like one hash that authenticated nothing.

Whether it was careless abbreviation or invented recall, the citation authenticated nothing. An abbreviated hash is just a convenient way to refer to a commit, and convenient is exactly the problem. A short hash points at a commit without authenticating it. If a result can point at evidence without anyone checking that the evidence is real and matches, then the result is only as trustworthy as the session's memory of it. That is what we are trying not to rely on.

Principle: An agent reporting success is making a claim. A claim is not a measurement. The gap between them is where false completion lives.

This failure mode is well known. Agents report that tests pass when they did not run, special-case the one test that was failing, and otherwise optimize for the appearance of done. You do not fix that by trusting a better-behaved agent; you fix it by building a place where the claim has to meet the evidence, and making progress depend on that meeting.

Two lanes

Contract: The lane that builds the work never decides that the work is done.

The work splits into two lanes that do not share authority.

The Build Lane owns implementation: writing code, running tests, diagnosing failures, repairing them, retesting, capturing raw evidence, committing, and cutting immutable checkpoints. It does everything except decide the outcome. It never claims or completes its own handoff.

The Evidence Lane owns judgment: reading the evidence the Build Lane produced, writing the adjudicated records, and promoting to PASS. It works only the handoff scope it was authorized to work. If nobody said how much to take, it takes one handoff, finishes it, confirms it left the inbox, and stops. It does not drain the queue because the queue was there.

BUILD LANE                        EVIDENCE LANE
implement, test, repair           read evidence, adjudicate
capture raw evidence       →      write the record
commit, checkpoint                issue PASS / FAIL / ...
(never grades itself)             (never built the thing)
        └──────── handoff inbox ────────┘

The separation only means something if the Build Lane cannot reach across it. So there is one more rule: no self-proof across lanes. The Build Lane cannot complete a handoff using the Evidence Lane's authority and then cite that as acceptance. If it could, the wall would be decorative.

Principle: A build checkpoint that says "the user ruled X" is testimony. I confirm it with the user before it becomes a binding rule. The session is not a witness to my decisions.

Where the evidence lives

Contract: A record cites a commit by full hash and evidence by full SHA-256, and cited evidence never changes.

Each evidence location has its own rules.

Location Holds In version control
Commits Source, tests, tools yes
Evidence folders Suite output, observations, screenshots, run logs, each with a checksums file no
Release folders The frozen build, manifests, receipts, checksums no
Records Adjudicated test, issue and decision records yes
Handoff inbox Checkpoints, moved to processed when done yes

The evidence and release folders are immutable the moment a record or a checkpoint cites them. A rerun does not overwrite the old folder. It gets a new one. Because they sit outside version control, they are backed up separately. Because they never change after citation, a record written last week still points at exactly the bytes it was written against.

That is the whole point of citing by full hash. An abbreviated hash is a nickname. A full SHA-256 is an identity. When a record says a result tested a particular commit and a particular build, recalculating the hash either reproduces that identity or it does not, and there is no room in the middle for a result to drift onto different inputs unnoticed. A matching hash proves the artifact has not changed since it was cited. The Evidence Lane separately judges whether that artifact supports the claimed result.

Results name their bytes

Contract: A saved result carries the commit and the hashes of exactly what it tested, or it is not acceptance evidence.

A result that does not say what it tested is a rumor. So the suite runner writes the commit, a dirty-tree flag, the input-manifest hash (the set of files the suite actually read, hashed) and the build-receipt hash directly into the result. That is the trust boundary: the runner writes those hashes, not the agent narrating the run. An agent can claim a pass; it does not get to author the bytes that prove one. Changing one of the inherited tests fails the run's own input-map check, which compares each pinned file against a recorded hash. A result produced from a dirty working tree is not acceptance evidence, full stop, because we cannot reconstruct later what was actually in the tree when it ran.

A few rules sit underneath that, and each one is there because skipping it let something through once.

  • Oracle independence. What the test expects comes from a contract or a design, never from the output being tested. The moment the expected value is read from the thing under test, the test only proves the code agrees with itself.
  • Keep the count. A suite passes at 13 of 13, not at exit code 0. Zero tests found is a failure, not a success. An exit code tells you the runner finished. It does not tell you anything ran.
  • Fail closed. Missing, malformed or unavailable evidence is PARTIAL or BLOCKED. It is never promoted to PASS because the absence of a failure is not the presence of a pass.
  • Read back the mutation. When a change writes something, capture the before and the after where it is practical. Unknown state is not evidence that nothing changed.
  • Copy live state. When a check runs against a running store or a live journal, the evidence holds a hash-frozen, secret-scanned copy. The live file keeps moving. The copy is what the record stands on.

Principle: Fix the failure, then fix the rule that let it pass. Every line above is a rule that was not there until something got through without it.

The verdicts

Contract: A record states a verdict from a fixed vocabulary and names its scope.

"It works" is not a verdict. It hides how much was checked and under what conditions. So records use a fixed vocabulary, and each one states the scope it covers.

Verdict What it means
PASS Proven, within the stated scope
PASS_BOUNDED Proven, but only under a named limit worth stating out loud
PARTIAL Some of it proven, the rest not yet
FAIL Tested and did not hold
BLOCKED Could not be tested; evidence missing or unavailable
UNSUPPORTED Out of what this check can establish
INVALID_ORACLE The check did not actually exercise the property it claimed to

When an acceptance check turns out not to test what it said it tested, the result is not deleted and rerun as if it had never failed. It is kept and classified INVALID_ORACLE. One check asserted that a mock returned the value the mock had been told to return, so it proved only that the code agreed with itself, not that the behavior was right. A check that proved nothing is itself a finding, and erasing it would erase the evidence that the suite had a blind spot.

There is a matching step at the end of every handoff: before it closes, the work is classified as having a reusable lesson, no reusable lesson, or a blocked lesson extraction. Blocked or unclassified fails closed. The learning is part of the terminal state, not a nicety that happens if someone remembers.

A real refusal

One refusal cost ninety minutes.

A full acceptance suite on one product takes about an hour and a half to run. On a release candidate, five checks failed. The Build Lane fixed them and proposed the obvious shortcut: rather than burn another ninety minutes re-running everything, reuse the earlier passes for the suites that had not changed, and only rerun the five.

The Evidence Lane refused it as release proof.

The reasoning was not that reuse is wrong. It was that nothing present could prove the reused suites had the same inputs as before. "Unchanged" would have rested on a hand-written map from file paths to suites. That map stops at the first path it matches. It cannot see a file a suite reads if no rule links that file to the suite. Reusing passes on that basis would have dropped the proof down to "the map is complete," and nothing proved the map was complete.

Principle: A reused pass is only as good as the proof that its inputs did not change. A rule that says what a suite should read is not proof of what it did read.

The ruling rejected that shortcut and set the conditions for reuse. Reuse becomes acceptable only once each suite declares its inputs, the runner enforces those declarations so a read of anything undeclared fails the run, and each suite's input manifest is hashed into the result. Then a reused pass counts only when its manifest hash matches, on a clean tree, and timing-sensitive suites always rerun regardless. That is more work than the shortcut. It is also the only version of the shortcut that does not lie.

None of the parts are new

Contract: Credit the established practice each rule matches, and claim only the part that is actually ours.

Every rule here maps onto something a serious field already does. Saying so makes the model more credible, not less.

Our rule The established practice it matches
The build lane never grades its own work Independent Verification and Validation (IEEE 1012); maker-checker and separation of duties in auditing
Evidence reviewed by someone outside the work The independent Quality Assurance unit in Good Laboratory Practice
Results name their bytes; evidence never changes once cited Supply-chain provenance (SLSA, in-toto, reproducible builds); data-integrity records under ALCOA+
Expected behavior comes from a contract, never the output under test The test-oracle problem, studied in software-testing research for years
Never rewrite a checkpoint; keep decision records Append-only logs and Architecture Decision Records
A release record listing commit, build hash, results and known issues The accomplishment summaries and release dossiers used in safety-critical software

Our contribution is narrower: this is built for AI agents, where the thing producing the work also narrates it, so an agent's statement is treated as testimony to be checked rather than a fact to be filed. The handoff inbox, the full-hash evidence citations, and verdicts like INVALID_ORACLE and PASS_BOUNDED are how that testimony gets held to account. The generator-and-checker split is a familiar pattern now. The heavier version, with frozen evidence and written judgments, is rarer, at least as far as I have found.

The weak spot

I would rather name this than have a reader find it.

Independent verification, done properly, is independent on more than one axis. The standard that defines it names three: technical, managerial and financial independence. Our two lanes are independent in procedure. They are not independent in substrate. They run on the same model family, under the same operator, reading from the same sources.

That means they can share a blind spot in a way two separate organizations would not. A mistake rooted in how the model reasons can pass the Build Lane and then pass the Evidence Lane for the same reason, and the wall between them does nothing, because the wall separates authority, not cognition.

Principle: Procedural independence reduces correlated error. It does not eliminate it. Two lanes of the same model are still one model's blind spots, twice.

The runner that writes the evidence is itself code the Build Lane owns, and the Evidence Lane re-hashes the frozen output rather than re-running the suite. So a runner rewritten to lie would pass here for the same reason a shared-model blind spot would. It is the same gap, one layer down.

The existing rules push back on this as far as procedure can: oracle independence, confirming rulings with me instead of trusting the checkpoint, no self-proof across lanes. The stronger lever is a reviewer from a different model vendor. Not a guarantee, but independence of substrate instead of just procedure. FoundryOS already uses this approach on higher-risk work: an audit by a different-vendor model, reached over a separate channel so it does not share this environment. The build and evidence lanes are now wired to route their output through it. That run has not happened yet, so I am not counting it as independence I have earned. Until it does, the honest verdict on our own independence is PASS_BOUNDED, and the cross-vendor pass is the next axis, not a claim.

Why a one-person studio runs like this

Regulated industries carry this discipline because an auditor will eventually ask for it. A solo founder has no auditor. So the usual question is why bother.

FoundryOS sells software that AI agents built, and that business has an obvious trust problem: why would anyone believe the agents built it right? "We tested it" is not an answer when the thing that tested it is the thing on trial. A passing claim that survived a separate lane, cites its evidence by hash, and states the limit it was proven under is a different kind of answer. It is one the buyer can inspect. A record has this form, with placeholders for the identifiers:

verdict:        PASS_BOUNDED
scope:          release acceptance on the candidate commit
commit:         <full 40-char git SHA>
dirty:          false
input-manifest: <full 64-char SHA-256>
build-receipt:  <full 64-char SHA-256>
suites:         37 of 37, each with its own input-manifest hash
evidence:       evidence/<run-id>/RESULTS.json  <full 64-char SHA-256>
limits:         independence is procedural; both lanes share a model family

Nothing in it is prose the Build Lane gets to color. The commit and the SHA-256 strings either match the bytes or they do not, and anyone with the release folder can recalculate the hashes themselves.

The discipline also pays for itself inside the studio before any buyer sees it. The ninety minutes the Evidence Lane protected was not ceremony. It was the difference between a release proven on its own candidate and a release resting on an assumption nobody had checked. Over a fleet of builds, the assumptions you skip are the incidents you get back later, and the operator is the one who absorbs them.

What the Evidence Does and Does Not Prove

What this does not prove

This is an operating model, not a theorem. It does not prove the code is semantically correct; it proves that a claim of correctness met independent evidence tied to a known state. It runs on one operator's workload across a handful of products, not a controlled study. And its independence is procedural, with the cross-model version still ahead of it.

What it does is make "it passes" mean something specific: a claim that a separate lane checked, against evidence frozen by hash, with the scope and the limits written down and the failures kept on the record. The transferable part is smaller than the whole apparatus and more useful than it sounds. Decide in advance who is allowed to say the work is done, make that a different party than the one who did it, and make them cite bytes instead of trusting a summary. Everything else here is detail hung on those three decisions.