Most of what your agent built has no "why", because there never was one

Because for most of it, there was nothing to write down. Everyone assumes the reasoning behind an agent's change existed and simply went unrecorded. Our own numbers say otherwise: on the codebase where Backthread captures the reasoning behind every merged change from the agent sessions, so the team can keep understanding the system, most decisions never carried an alternative or a trade-off at all. That changes the fix. You cannot recover a rationale that was never held; you can only see which changes were made without one.

What we measured, and how

The extractor reads agent session transcripts and pull-request prose and pulls out decisions: a choice that was made, and, where they exist, the alternative that was weighed and the trade-off that was knowingly accepted. It is built to emit nothing rather than to pad. When a transcript contains no deliberation, the decision is recorded with the choice and an empty deliberation, and an evaluation gate checks that the extractor does not start inventing alternatives to look thorough.

That design choice is what makes the number below meaningful. A pipeline that fills in plausible reasoning would report 100 percent deliberation and be wrong about all of it.

We ran the count on our own production repository, over every decision captured since the deliberation fields shipped:

Sixty-two percent of decisions made inside agent sessions record no alternative and no trade-off. Same repo, same extractor, same bar. The PR-prose figure is a little higher, which makes sense: writing a PR description is the one moment a human is asked to justify something.

Two readings, and why the second one is right

The first reading is the comfortable one: the reasoning happened, the transcript just did not capture it. Some of that is real. Squash merges flatten context; work split across sessions loses the earlier session's thinking; the extractor misses things.

But the same extractor, on the same repo, finds deliberation in 37 percent of session decisions. If capture were the whole problem, the miss rate would not cluster so cleanly by what kind of change it was. The undeliberated decisions are overwhelmingly the small, cheap, reversible ones: a helper added here, a default changed there, a retry wrapped around a call. And that points at the second reading.

When a choice is nearly free to reverse, the person making it stops weighing it. Why compare two approaches when trying one costs thirty seconds and the agent will rewrite it on request? The choice gets deferred, and a deferred choice leaves nothing to record, because nothing was decided. Film crews found the same thing when digital post-production made every decision reversible: if the room can be changed later, you stop committing to the room while you shoot it. Cheap reversibility does not just move decisions later. It dissolves them.

Agents make almost every code decision that cheap. So the reasoning behind most of what they write is not missing from the record. It is missing from the world.

What this means for a team

If you lead a team shipping with agents, three consequences follow.

• "Ask the agent to explain it" is a fresh guess. The standard answer to "why is it like this" is to have the agent reconstruct a rationale from the code. For the 62 percent, that reconstruction is fiction with good grammar: there was no rationale to reconstruct. Treat an on-demand explanation as a hypothesis, not a record.
• The deliberated 37 percent is the part worth keeping. Those decisions, the ones where an alternative was actually rejected, are the high-level model of the system. They are rare, dated, and they only exist in the transcript. Capturing them at the moment of the change is worth doing whether or not you ever look at the rest. We wrote up one way to make the agent write the why into the PR.
• The absence is itself a signal. An area of the system where every recent change was undeliberated is an area nobody has thought about as a whole for a while. That is the pattern we called "merges without models" in the method for finding out who understands what, and it is where the next misunderstood-subsystem incident tends to come from.

What the number does not show

Two honest limits. First, this is one repository, ours, with our conventions and our agents; the ratio on yours will differ, and we would expect it to differ most with how much the team writes in PR descriptions. Second, "no recorded alternative" is not the same as "a bad decision." Plenty of the undeliberated changes were correct. The claim is narrower: for most agent-written changes, a why was never held by anyone, human or model, and so cannot be retrieved later by anyone either.

That narrow claim is enough to change what a team should build. Not a better search over reasoning that is not there, but a way to see which changes had reasoning, keep it, and teach it to the people who were not in the session. That is what Backthread's how-it-works view is for: the recorded decisions and trade-offs on a map of the system, with the gaps left visible as gaps.

Connect one repo and you get the same count for your own codebase, with the undeliberated changes shown honestly as blanks rather than as invented reasons; the trial runs fourteen days.