I Spawned 4 Autonomous Agents. Review Is Where It Broke

Spawning the agent was 5 minutes. Reading the 14 decisions it made on my behalf took 90.

The setup that worked on paper

I run herdr to spawn Claude in autonomous mode. Each agent gets its own worktree, its own branch, its own scope. Four agents can ship four PRs while I do something else. On paper, this is the leverage everyone promised.

The first sprint exposed the real bottleneck.

Where it broke

The first agent PR arrived with a 200-line diff and zero rationale. It added a vitest config, picked a specific GROQ query scope, chose one error-handling pattern over another. None of it was wrong. All of it was unexplained.

Review became archaeology. I read the diff, guessed at why, opened the test file to check the guess, re-read the diff, asked the agent in chat (it had already exited), and finally merged based on vibes.

The work was fine. The review was unsafe.

The contract I added

Before any agent starts, the worktree gets a decisions/agent-decisions.md file. Every autonomous decision the agent makes on my behalf gets one entry with this shape:

## Decision 001: Test infrastructure for apps/web

Timestamp: 2026-08-08
Trigger: Agent found apps/web has no test runner; ticket requires TDD.

Question from agent:
  apps/web has no test runner configured. How should I handle this?

Options considered:
  1. Add minimal vitest (Recommended)
  2. Skip automated tests, verify manually

Decision: Option 1, Add minimal vitest.

Reasoning:
  - TDD is a hard requirement.
  - vitest setup is one config file.
  - The helper is a pure function, perfect test candidate.

Impact: +vitest.config.ts, +test file, +test script in apps/web.

That block is from a real run. I did not invent it.

What changed

The same agent, on the same scope, now produces a PR with two artifacts: the diff and the decisions log. The diff is implementation. The log is judgment.

Review is no longer archaeology. I read the log first. If I disagree with a Decision field, I know exactly where to push back. If I agree with the reasoning, the diff becomes a sanity check instead of a forensic exercise.

Four parallel agents still produce four PRs. The difference is that I can actually review them in parallel.

What the log does not do

It does not replace code review. A bad decision with clean reasoning still ships bad code. The log tells me what the agent decided and why. It does not tell me if the implementation matches the decision. That step is still mine.

It also does not catch decisions the agent did not log. If an agent makes a silent choice, the log is silent too. The format only works if the agent treats logging as part of the work, not a side task.

The shift

The bottleneck in autonomous agents is not the spawn. It is the absence of a contract for what they decided.

Once the contract exists, the leverage scales. Without it, four agents means four archaeology projects.

Try this

Open your last merged agent PR. Count decisions the agent made that you did not pre-approve. If that number is above zero and you cannot find the rationale in 30 seconds, you do not have a review problem. You have a logging problem.