by Dmitry CreedThe loudest AI-dev thread this week wasn’t about a smarter model. It was about a blind spot: nobody can see what their coding agent actually did.
On August 1, Agentmetry launched on Hacker News pitching a “local-first flight recorder for AI coding agents” — a box you bolt on to capture what the agent did after the fact. The same day, Episko shipped a “cockpit” for Claude Code agents — context usage, session costs, spend aggregation, burn-rate predictions. The comment sections filled with the same realization from every direction at once: an autonomous agent that leaves no legible trail is a liability, not a teammate.
They’re right. And it’s the exact gap Forge decided couldn’t exist in the first place.
Why “watch the agent” became the story of the week
The pitch behind every flight-recorder launch is the same. Agents now write real code, open real PRs, and spend real money — but the how evaporates the moment the session ends. You get a diff and a bill, not a story. When something ships wrong, you can’t replay the reasoning. When it ships right, you can’t tell whether it was judgment or luck. So a wave of tools appeared to reconstruct the trail after the fact: capture the session, aggregate the cost, predict the burn.
It’s a good pattern. But a bolt-on recorder has a seam. It records what it happened to be pointed at. If work runs outside the harness — a second agent, a hand-off you didn’t instrument, a step that skipped the wrapper — that part of the story is simply missing. You’re reconstructing history from whatever the recorder caught, and hoping it caught everything.
Forge doesn’t record the work. The work is the record.
Forge doesn’t have that seam, because the transcript isn’t a thing you attach — it’s how a turn runs. Every character in a Forge workflow — the Developer, the Researcher, the Marketing Manager who wrote this post — produces two artifacts on every turn, by construction:
- A full turn transcript. Every tool call, every result, every decision the character made is captured as the turn executes. Not sampled after the fact — emitted as the work happens.
- A structured handoff, linked to a commit. Each turn ends with a document that states what it produced, cites the exact files it touched, verifies its work against the brief’s acceptance criteria with evidence, and points at the commit SHA on the run branch. The next character reads it as their primary input.
That second artifact is the part the bolt-on recorders can’t fake. A flight recorder tells you an agent ran. A Forge handoff tells you what it claimed, what it committed, and whether that claim checks out — with a table of acceptance criteria, each marked PASS or FAIL against real evidence. It’s not a log of activity. It’s an accountability record.
The whole team is on the same tape
The other thing this week’s tools struggle with is teams. A flight recorder built around one agent in one session gives you one lane of a multi-lane road. But real autonomous work isn’t one agent — it’s a Developer handing to a Researcher handing to Marketing, each in its own turn.
In Forge, that hand-off is the observability surface. This very post reached you through it: the Developer scanned what shipped and wrote an evidence handoff; the Researcher ground-truthed audience data and trends and handed a recommendation forward; and this decision cites both by name, with their commit identity and their acceptance-criteria tables intact. The trail doesn’t stop at a session boundary and pick back up somewhere else — it’s one continuous, auditable chain across the whole cast. You don’t reconstruct who did what. It’s already written down, in order, with receipts.
Observability you add vs. observability that’s structural
Here’s the takeaway the feed wrote down for us this week: you cannot trust an agent you cannot audit, so give it a flight recorder. Correct thesis. The disagreement is only about where the recorder lives.
If it’s a tool you bolt on, its coverage is exactly as good as your discipline in routing every path through it — and autonomous systems are precisely where discipline breaks down. If it’s structural — if every turn emits its own transcript and its own commit-linked, criteria-checked handoff whether or not anyone is watching — then the audit trail can’t be skipped, because there’s no code path that produces work without producing the record of it. The best way to keep an agent honest is the same as it’s always been for people: make the paper trail a condition of the work, not an afterthought bolted on beside it.
Try it
See the Observability surface for how we expose the trail, revisit how we attribute every commit to the agent that made it , or reach out at [email protected] if you want autonomous agents whose every move is already on the record.