Make the agent show its work

Agents act. You can't see why.

I've been using AI coding agents for a little over a year now, and honestly the friction hasn't really changed. You either babysit the tool command by command, or you let it go wild and come back to a massive diff with no idea what it did. Neither's a great flow.

The tooling's gotten better at showing the run. Cursor, Claude Code, and Codex all stream the events. But a trace answers the wrong question: you can see the action it took at each step, and still have no clue whyit took it. (That's the panel on the right: every span, in order, telling you nothing.)

Before the agent stuff, a simpler lesson in legibility. I built a recommender kind of the stubborn way: fourteen different designs, one shared evaluation, and a metric (not my taste) picking the winner. You ask it for a wine, and it ranks the cellar.

What stuck with me wasn't the leaderboard. It was that every result came with its score decomposed (the filters it cleared, the lexical hit, the semantic match) instead of just a bare rank. No prose, nothing the model wrote: just the parts that added up to the number. Scrub the panel from score-only to with-why, and a rank on its own is kind of just an assertion, but the same rank with its parts is something you can actually check.

Show me the parts a score is made of and I can actually argue with it.

A recommendation you can't interrogate is kind of just a number you're told to trust. Switch the query on the right and you can watch the score components and the matched attributes shift along with the rank.

Outputs were one thing. But an agent doesn't hand you a ranking. It hands you actions. So picture a coding agent refactoring auth across your routes: up top you get its raw event log. Every action, in order, and none of it telling you why, which is pretty much the kind of tool we've got today.

This is the experiment I actually care about. I wanted to manage an agent the way you'd review a colleague: you read the handful of decisions that actually shaped the work, and you trust them with the keystrokes in between.

So here's the harness: every n events, prompt the agent to look back and figure out whether it actually made a decision, and if it did, collapse those records into a single DECISION. Flip the panel from raw log to decisions and eight events become one: “chose a shared middleware over per-route guards.”

Collapsed, the decision isn't just shorter. It's something you can actually interrogate. Click it on the right and ask why this approach over that one, and the answer pulls from the full context up to that turn. The reasoning finally gets recorded alongside the action.

Each decision also carries a confidence, plus an honest source tag: did the agent actually state this, or did I infer it? This is the part I keep coming back to: the decision is the unit of trust here, and nothing in the standard stack was recording it. (full write-up)

You're not really betting on what the agent typed. You're betting on the call it made.

A surface can infer decisions from the outside. But what if the model just… told you itself? To see how small a trustworthy model could get, I trained a GPT-2 from scratch on a single consumer GPU, with wine metadata baked into the pretraining.

It couldn't follow an instruction to save its life, which honestly was the lesson. The gap between a small model and a frontier one turned out to be mostly breadth: mine had simply seen too little of the world. A bigger pretrain won't happen on one consumer GPU, so the plan is one extra behavior, emitting the exact object the surface already renders: { options, chosen, confidence }. Coding's a harder domain than wine, though, so the next thing I'm building is a LoRA you attach to a capable model, taught to explain its coding calls.

The model itself would explain the call as it made it. That's the goal, anyway. The specialist deliberates out loud: here are the options it'd weigh for an auth refactor, and the one it goes with. Same decision object, except now the model writes it out itself, straight from the weights.

And it knows when not to answer. Try the harder questions on the right: if it's not confident enough, it escalates to a stronger model; if the call is irreversible and high-stakes, it hands off to you. Deferring is a decision too, and the model just says so.