What happened
The check that caught it.
The reviewer agent, which reads the artifact with no shared context with the builder, went to OpenZeppelin's actual published source and checked. The line the builder pointed at was not the line the published fix had changed. The real fix was a different line, in the same function, in the same bug family. Everything mechanical about the case worked. The property fired on the planted twin. It held on the clean twin. The class was real. The one thing that was wrong was the credit line.
The case is being rebuilt so that claim is true. The corrected case ships shortly, on its own. This post is not that case. This post is about the process beat that caught the mistake before anything public went out.
The failure mode
Why this is the failure mode I built for.
An attribution error is the dangerous kind. It is not a typo. It is not a broken test. It is not a compiler error. It reads correct on the page. The words hang together. The firm's name is spelled right. The line number sits inside the right function. A reader skimming will nod and move on.
That is the shape of the mistake I am most afraid of shipping. Output that sounds like it knows what it is talking about, that follows a real firm's real reasoning about a real bug family, and that gets one specific claim wrong in a way only a source-check would catch. If you are reading a technical post and you see "the firm's fix was this line," the load on you as a reader is high. You are trusting the author to have checked. Most readers do not pull the primary source, diff it against the version before the fix, and confirm the specific line the author pointed at was the one that changed. You have other things to do with your afternoon.
That is the surface where a confident, wrong claim lives. Everything else about the artifact could be right, and this one line still makes the post dishonest. The structure I have been building is aimed at exactly that surface.
Independence
Why an independent reviewer, and why no shared context.
The build agent writes the artifact. The review agent reads it and checks it. Both are agents. Both run on the same underlying model. The difference between them is not raw capability. The difference is that the reviewer does not see the builder's plan, its framing, its confidence, or the chain of reasoning that got it to the claim.
If the reviewer had shared context, it would be anchored by how the builder framed the claim. Anchoring is the failure mode. A reviewer that already believes the claim is looking for confirmation, and finding confirmation on a plausible claim is not hard. A reviewer that has never seen the claim before is looking at the source cold, and the artifact separately. The check is closer to what a careful stranger would do, if that stranger were rigorous and had the primary source open in the next tab.
That is what caught this. The reviewer did not read the builder's writeup and think "that sounds right." It went to OpenZeppelin's source, found the commit the fix landed in, read what changed, and compared. The comparison did not match. It said so, in the review note that came back to me before the case was staged for its own writeup. That is the entire mechanism.
The mechanism has to be boring. If it depended on cleverness, it would fail the day the mistake was too subtle for cleverness to see through. It depends on independence, and on going to the primary source. Those two properties, held together, make the check harder to fool than a smart reviewer with shared context would be.
Honest scope
What this does not prove.
I want to be clear about what one catch is and is not.
It is not proof the structure catches every mistake. It is one catch. The reviewer looked at one specific claim, in one specific artifact, and got the check right that time. On other artifacts, on other days, the reviewer will miss. The confidence of the mechanism has to come from many catches over time, and from an honest log of the misses. I keep both. When something wrong ships and I catch it later, or someone else catches it, that goes into the miss log the builder and reviewer read at the top of every run. The log is not a reputation asset. It is the training surface for the next run.
It is not proof that independence solves the general problem either. Independence solves one shape of failure, the anchored review. There are shapes of failure it does not solve. If the primary source is itself wrong, the reviewer will not know. If the class of mistake is one both agents make in the same way, the review will confirm the mistake. Those are real gaps. The structure does not close them today.
And it is not proof that agents can be trusted without a human in the loop. I am in the loop. The draft that would have gone out had a wrong claim in it. The reviewer caught it before I saw the case as ready to stage. That is the flow I have been building toward, and it is the flow I trust for public output. Not because the agents are infallible. Because the layers are independent, and the layers are checked, and the operator with his name on the artifact sees what the layers produced.
The beat
The beat, in one line.
A confident, plausible, wrong claim. An independent check against the primary source. A correction before anything public shipped. That is the structure earning its cost on a specific day, on a specific artifact, in a way that is easy to describe and hard to fake.
The corrected case ships shortly, credited straight. [Editor's note, 2026-09-04: it did. It shipped four days after this was written, on 2026-07-10, as blog post 13.]
Michael Moffett, operator.
CaliperForge.