
TL;DR
|
It's 4pm and a PR lands in your queue. Fourteen files changed. The description says "Implements rate limiting for the public API, per issue #812." The tests pass. The code is clean, consistently formatted, and plausibly correct.
You didn't write it. Neither did anyone on your team. An agent did, from a two-line issue someone filed last week.
So you start reading. Why a sliding window and not a token bucket? Why does the limit live in middleware instead of at the gateway? Was the Redis dependency a deliberate choice, or the first thing that worked? Did the agent know about the internal client that hammers this endpoint every night?
The diff can't tell you. The commit message can't either. And the author isn't available for a quick question, because the author was a model that finished its work and moved on.
Key takeaway: an agent PR arrives without an author you can question, so its reasoning is lost unless something captured it during the run.
Code review has always relied on something outside the diff. When a teammate opens a PR, you know roughly how they think. You were in the planning meeting. You can ask them in Slack why they picked one approach over another, and they can answer.
An agent PR removes all of that. The reasoning happened inside a model run: the prompt it received, the files it read, the options it weighed, the plan it settled on. Unless something recorded that run, it's gone by the time the PR reaches you. What's left is the output, and output alone is a poor guide to intent.
Agent code also tends to fail quietly, because it usually looks right. In Stack Overflow's 2025 Developer Survey, 66% of developers named "AI solutions that are almost right, but not quite" as their biggest frustration with AI tools, and 45% said debugging AI-generated code takes more time. Code that is almost right is hard to review, because nothing in it flags itself as wrong.
The same survey found that experienced developers are the most cautious group, with the highest rate of strong distrust in AI output. Those are often the same people who get the review requests.
Key takeaway: without the reasoning, review becomes a choice between slow, risky, or wasteful. The fix is to give reviewers the context back.
Faced with a diff and no reasoning, reviewers tend to fall back on one of three habits. Each makes sense in the moment, and each has a cost that shows up later.
The careful option is to re-derive the reasoning. You read the issue, read the code, and reconstruct what the agent must have been thinking. It works, but a quick review turns into a long one, and you've redone the planning work the agent was supposed to save.
The fast option is to approve on trust. The tests pass, the code looks idiomatic, and the queue is long, so you skim and approve. That holds up until an assumption the agent made turns out to be wrong and nobody can say why the code was written that way.
The safe option is to send it back, or rewrite it yourself. You don't merge what you can't follow, and you also throw away most of the time the agent saved.
All three are reasonable responses to the same situation: being asked to sign off on work without the context you'd normally have. As agents take on more of the code, the review queue grows, and the cost of each habit grows with it.
Key takeaway: plan, checks, and record turn an agent PR from an unexplained diff into work a reviewer can actually evaluate.
You can't ask an agent what it was thinking once the run ends, but you can make the context travel with its work. A reviewable agent PR carries three things beside the diff.
These three things have costs. A plan adds a step before any code exists, and approving it puts a person in the loop earlier. Checks have limits too: a review against the plan won't notice if the plan itself was wrong. A person still makes the call on every agent PR, and the plan, checks, and record make that call better informed.
Key takeaway: Upsun Dispatch keeps the plan, the critic's findings, and the run record attached to the agent's work, so reviewers start with context instead of a bare diff.
Upsun Dispatch is the platform for governed collaboration between AI agents and cross-functional human teams. It works alongside the tools your team already uses: GitHub, GitLab, Jira, and Linear. Its Issue to code workflow is built so the plan, the checks, and the record arrive with the work.
The plan goes to the issue first. A planning agent reads the issue and writes an implementation plan, and Upsun Dispatch posts it back to the issue or ticket before any code is written. For runs started from Jira, you can turn on a plan approval gate (it's off by default) so the run waits for a person to approve, reject, or revise the plan.
A critic reviews the change before the PR opens. After the coding agent finishes, a separate critic agent reviews the change against the plan. Serious problems, such as code that won't compile or that contradicts the plan, stop the PR from opening at all. Lesser findings go into the PR description, so the reviewer sees them up front. The critic runs once, and Upsun Dispatch doesn't rewrite the code in response to its findings, so anything short of a blocker is yours to weigh.
Every run leaves a record. Every prompt, diff, approval, and usage event is captured as it happens. In the Upsun Dispatch console, each run shows its status, its steps, a timeline of events, and its logs. When questions come up later, there's a record to check.
The Code review workflow adds one more layer: it reviews pull requests and merge requests and posts its findings as inline comments and, depending on your settings, a summary, alongside your team's own review.
Months after a merge, the run record may be the only place the agent's reasoning still exists. Our technical guide walks through what Upsun Dispatch captures for each run, and how an engineer uses it to reconstruct intent and debug a change later.
Read the guide: Reconstruct any agent run later: what gets captured, and why
Why are AI agent pull requests hard to review?
The diff shows what changed but rarely why. The prompt, the plan, and the options the agent weighed usually aren't recorded anywhere the reviewer can see, so the reviewer has to reconstruct the reasoning or approve without it.
Is passing tests enough to approve an agent PR?
Tests confirm the code does what the tests check. They don't confirm the change matches what was asked, or that the agent's assumptions were sound. Agent code is often almost right, which is exactly the kind of problem tests can miss.
What should an agent PR include to be reviewable?
The plan the agent worked from, the results of any checks it already passed, and a record of the run: what it was asked, what it changed, and who approved what.
How does Upsun Dispatch help reviewers?
In the Issue to code workflow, Upsun Dispatch posts the agent's plan to the issue, runs a critic agent that can block the PR if it finds serious problems, and captures every prompt, diff, approval, and usage event as it happens.
Does Upsun Dispatch replace human code review?
No. People still review and approve agent work. Upsun Dispatch gives them the context to do it well.