
TL;DR
|
An alert fires on a Tuesday morning. Exports for a handful of customers are timing out, and only for accounts created before 2023. You trace it to a query change that shipped months ago.
git blame points at a merge commit from a branch called company/issue-418. The PR was opened by an agent and approved by someone who has since moved teams. The commit message says "Optimize export query for large accounts."
That's a start. What you need to know is why the agent chose to drop the index hint, whether it knew about the legacy account schema, and whether anyone flagged the risk at the time. Those answers lived in the agent's run, and whether you can still get to them depends on whether anything recorded it.
Key takeaway: git records the result of a change. For agent work, the context that explains the result lives in the run, and it disappears unless something keeps it.
For human-written code, git history plus a bit of asking around usually gets you to the reason behind a change. The commit message gives you a hint, the PR discussion fills in some gaps, and the author can usually remember the rest.
Agent work breaks that chain in three places.
You can patch some of this with discipline, like pasting plans into PR descriptions or adding them to a docs directory. That works until the queue gets long. A record that's captured automatically, as the run happens, holds up better than one that depends on someone remembering.
Key takeaway: every prompt, diff, approval, and usage event is logged against the run that produced it, and each piece answers a specific question you'll have later.
Upsun Dispatch is the platform for governed collaboration between AI agents and cross-functional human teams. Every workflow execution becomes a run in the Upsun Dispatch console, and the record is captured as the run happens rather than assembled afterward. Here's what it holds and where to find each part.
| What's recorded | Where you find it | The question it answers |
|---|---|---|
| Prompts and tool calls | Run detail, in the activity feed | What was the agent told, and what did it look at? |
| The plan: summary, full plan, files affected, complexity, assumptions, and risks | Posted on the originating issue or ticket | What did the agent intend, and what did it assume? |
| Plan approvals and revisions (Jira runs with the plan approval gate on) | Run detail | Who signed off on the approach, and what changed before coding? |
| Diffs, artifacts, opened PRs, and push outcomes | Run detail, and the PR itself | What exactly changed, and where did it land? |
| Critic findings | The PR description, and run detail | What problems were flagged before anyone reviewed it? |
| Steps, attempts, and timeline events | Run detail | What happened in what order, and where did it retry or fail? |
| Logs | Short excerpts in run detail, full logs per job | What did each step output? |
| Usage | Run detail, plus usage reports by model or workflow | What did the run consume? |
| The related PR's current state: title, lifecycle, review decision, head commit | The related entity view | What happened to the change after the run? |
The record is append-only: entries can't be edited or deleted through normal use. Re-running a finished run starts new work and leaves the original run as it was.
Key takeaway: start from the code, follow the links back to the issue, then open the run. Each hop answers a different part of "why."
Back to the timed-out exports. Here's how you'd work from the merged commit to the agent's reasoning.
By the end, you know what the agent was asked, what it assumed, what it looked at, what was flagged, and who signed off. That's usually enough to tell a bad assumption from a bad review, and to fix the right thing.
Key takeaway: the record shows what an agent was given, what it planned, what it did, and who approved it. It can't tell you whether the change was right, and it only covers work that ran through Upsun Dispatch.
The record earns its keep in a few recurring situations: debugging a change long after it merged, writing a postmortem, reviewing a PR with context instead of a bare diff, and explaining to a teammate why the code looks the way it does.
It also has edges worth knowing before you rely on it.
The fastest way to understand what a run captures is to look at one from your own repository. Connect GitHub or GitLab, store a model key, and trigger a code review on a pull request. Every new organization starts on a free tier with no credit card required.
What is an AI agent audit trail?
A record of what an agent was asked, what context it used, what it planned and did, and who approved its work. It lets a team trace an agent-written change back to its intent after the fact.
What does Upsun Dispatch record for each run?
Every prompt, diff, approval, and usage event, captured as it happens. Run detail in the console also shows steps, timeline events, tool calls, findings, artifacts, logs, and the related PR.
Where can I see an agent's plan?
For Issue to code runs, Upsun Dispatch posts a structured plan to the originating issue or ticket before writing code. It includes a summary, the full plan, files affected, complexity, assumptions, and risks.
Can the record be edited after the fact?
The log is append-only, so entries can't be edited or deleted through normal use. Re-running a finished run creates a new run and leaves the original unchanged.
Does the record show agent work done outside Upsun Dispatch?
No. It covers runs that go through Upsun Dispatch workflows. Agent sessions on a developer's machine or in other tools aren't included.