Get started
Security & GovernanceEvidenceGovernanceCompliance

What an AI agent audit trail should record, and how to prove it

An AI agent audit trail should record who asked, the policy decision, each tool call, approvals and a witness receipt. How to prove it, with real runs.

Adam Cowles9 November 202614 min read
A single glowing action node sealed inside a chain of linked glass blocks, one block lit by a signed checkpoint, cyan and violet over near-black

What is an AI agent audit trail?

An AI agent audit trail is the record of everything an agent did on your behalf: who asked, what it was allowed to do, which tools it called, what came back, and who approved the risky steps. Written as each action happens, into a store the agent cannot edit, it lets anyone check later what happened and that the record has not changed since.

To prove what an agent did, the trail needs three things the agent cannot supply on its own word. A record of every action, written at the moment it happened. A witness that makes any later edit detectable. And a check that someone else can run without trusting you. With only the first, an audit trail is a diary. With all three it is evidence.

This guide covers what to record for each action, how human approvals fit in, how to prove a single action and the history around it, and how to hand that proof to an auditor or a client. Every example comes from a recorded run you can open and recheck yourself.

Why "we have logs" is not proof

Most teams can show logs when something goes wrong. The trouble is what logs are. They are written by the same system whose behaviour is in question, they can be edited or quietly restored from an older copy, and they are scattered across tools that were never designed to be read together.

An AI agent makes this worse, because it acts. It reads a request, picks a tool, calls it, reads the result and decides again, often several times a minute.

When a payment goes out or a record changes, the question is not only what happened. It is who asked, whether the agent was allowed to, whether a person approved it, and whether the record you are reading now is the record that was written then.

A plain log answers the first question at best. The comparison of logs, traces and cryptographic evidence sets out the gap in detail.

What to record for every agent action

Eight things, captured as the action happens. Leave one out and there is a question you cannot answer later.

RecordThe question it answers
Who asked: the person or agent, and the organisationWhose authority was this action taken under?
What was asked: the request and its intentWas the action what the person actually wanted?
The policy decision, made before any model runsWas the agent allowed to try this at all?
The tool call: which tool, its inputs, how long it took, whether it succeededWhat did the agent actually do, as opposed to what it said it did?
The result that came backWhat did the agent see before it decided its next step?
The approval: who approved or denied, and when, or a note that none was neededDid a person sign off on the risky part?
The thread: one correlation id shared by every step of the jobWhat led to this action, and what did it set off?
The witness receipt: the entry's place in an append-only chain, covered by a signed checkpointHas anyone changed this record since it was written?

The last row is the one most audit trails leave out, and the one that turns a log into proof.

What one recorded action looks like

In Quox each action travels in an envelope, defined by the AEE protocol. The envelope names who sent it, who it went to, what it was for, and the correlation id that ties it to the rest of the job. This is a real envelope for one tool call, from the trace one action guide:

One envelope from the audit trail
quox aee get ENV_MW4196IY_B2O4CQ5Y
type      event
from      agent.quox
to        system.aocl
intent    aocl.tool.execute
corr      cli-mw4190yv-lt0k4izj
payload   tool_name: backup_status
          agent_id: quox
          duration_ms: 656
          success: yes
          source: mcp
id        ENV_MW4196IY_B2O4CQ5Y
ts        2026-11-05T21:03:37.546Z
# every envelope from the same job shares the corr value
quox aee query --corr cli-mw4190yv-lt0k4izj
From a real run on the demo workspace, as published on the guide. Ids on the payload left out.

The corr line matters more than it looks. Pull every envelope with the same value and you get the whole job in order: the tool ran, and 9 milliseconds later the same call was handed to the policy layer. You found the thread from the record itself, not from anyone's summary.

The policy decision is recorded too. In every recorded run linked below, the request passed Quox's identity and policy checks before any model ran, in between 7 and 21 milliseconds, and those checks appear in the run as their own steps.

Approvals belong in the trail, not beside it

A human approval is part of the action, so it needs the same treatment as the action. A yes recorded in a chat thread, an email or someone's memory cannot be tied back to the exact thing that was approved. As the post on real human-in-the-loop approvals puts it, an approval nobody can see, scope or be held to later is theatre.

In the inbox journey, Quox was asked what in a mailbox needed a reply today. It named the three people waiting, set aside a look-alike phishing mail, drafted a reply to the most urgent one and queued it for approval.

Nothing was sent. The draft waits as a proposal until a person approves or denies it with quox mail resolve.

The same principle covers the rules themselves. As the policy changes guide sets out, a change to a governance policy can need a second person to sign it off, so one login cannot quietly loosen the rules, and quox governance policy history shows which changes were made and by whom. The wider design is on the human in the loop page.

How to prove one action, step by step

The cleanest test of an audit trail is a sceptic. In the legal journey, a client will not take your word that the system keeps an honest record, so Quox is asked to prove one action end to end. The recorded run went like this:

  1. Do a real action. Quox logged an outbound call on a demo contact in the scratch workspace used for proof runs.
  2. Find that action's own envelope. It queried the audit trail, got 39 envelopes back, and picked out the one this exact call wrote.
  3. Check the witness receipt. The first check came back UNTIPPED: the entry was already on the chain, but no signed checkpoint (a tip) covered it yet.
  4. Wait for the settled verdict. Quox checked the chain status, waited for the next tip and checked again: WITNESSED, under a signed tip whose signature verifies, with the 33 entries between the entry and the tip re-hashed and matching.

The whole job took 50 seconds and six tool calls. The point of step 4 is that a check made seconds after an event can come back before the next tip lands. An honest answer gives the final verdict, not the provisional one.

Prove one action is on the record
# find the envelopes for the work you care about
quox aee query --corr <id>
# check one envelope's witness receipt
quox governance ward verify --envelope <envelope-id>
WITNESSED means the entry is on the chain under a signed tip. UNTIPPED means it is recorded but not yet covered, so run it again after the next tip.

Quox was also clear about the limit of that proof. It shows that the system's record of the call is intact and unchanged since 08:58:59 UTC on 6 November 2026. It does not show that the call happened in the real world. That distinction belongs in every answer about agent evidence, and it is covered properly further down.

For the same four layers told as a story, one overnight refund traced from envelope to offline check, read how to prove what your AI agent did.

The witness behind these receipts is WARD, which writes each envelope into a hash chain without needing to see its content, and signs checkpoints over the newest entries.

Prove the history around it, not just one entry

One receipt proves one event. An auditor will also want to know that nobody rewrote the history around it, removed an inconvenient entry, or regenerated the whole chain after the fact. Two checks cover that.

Check a stretch of the chain. The check the chain guide re-hashes a window of entries and verifies every signed tip inside it. A chain can hold millions of entries, so you verify it in slices.

A slice that passes is reported as PARTIAL with the reason WINDOWED, because the rest of the chain was not part of that check. The CLI says so rather than rounding up to "verified". Start the window at entry 1 and it also confirms the chain's first link is the real one.

Check a recorded run on your own machine. The recorded run guide pulls one run down as a file with quox volt fetch and checks every link locally with quox volt verify.

In the published run the chain passed and the signature was valid, with one honest warning: the signing key was not pinned, so the check proved the file was intact but not who signed it. Pass the key you expect with --key and that gap closes.

Why both? A hash chain proves a record is internally consistent. On its own it cannot prove that it is the same record that existed yesterday, because someone with write access could rebuild the whole chain.

Signed checkpoints, held keys and an independent witness are what close that gap. Beyond tamper-evident receipts walks through the regeneration attack, and the cryptographic audit trail guide covers the four properties that turn a log into evidence.

Hand the proof to someone who does not trust you

Proof that only you can check is not much use in an audit. The record has to travel, and the person receiving it has to be able to verify it without access to your systems and without taking your word for anything.

A readiness report with checkable evidence. In the compliance journey, an auditor asks for 30 days of evidence. Quox's compliance agent built a SOC 2 readiness report from 4,277 audit records across 450 conversations, scored it 82 with the status partially evidenced, and named the controls that still need work.

Quox then checked the first evidence record the report sampled against the witness chain: WITNESSED. The auditor can rerun the same check on the same id.

Quox was explicit about what that report is not: an audit opinion or a SOC 2 attestation. Only an independent CPA firm can issue those.

A signed report the auditor checks offline. In the security journey, Quox ranked the vulnerabilities on two servers by whether attackers are actually exploiting them, then produced a posture report signed with Ed25519.

The auditor gets the report file from you and the public key through a separate channel, and runs quox wazuh report verify on their own machine with no call to your Quox server. A changed report, or a different key, fails.

Quox flagged the remaining dependency itself: that check still uses Quox's own verify command. An auditor who wants to verify with no Quox software at all needs the exact rule for putting the report into canonical form before hashing, and should ask for it with the bundle.

Evidence bundles for every journey. Each published journey links an evidence bundle and a small verifier script. Run it and it passes only if the bundle is the copy that was published and witnessed, unchanged. The evidence pack walkthrough shows the same idea from the auditor's side.

The runs behind this guide

Each one is a real turn on our own install, checked by the proof engine against the running system. Open the receipt and recompute it.

What was provedStatusReceipt
One action is in the record and unchanged (legal journey)Verified on 5 and 6 November 2026ev_mw4qso4v_ae9cc6
A 30-day SOC 2 readiness report with a witnessed evidence record (compliance journey)Verified on 6 and 7 November 2026ev_mw6e0ac8_2652f2
A signed security posture report an auditor checks offline (security journey)Machine verified; passed on 6, 7 and 9 November 2026ev_mw9las1z_35366f
A drafted reply held for human approval, nothing sent (inbox journey)Verified on 6 and 7 November 2026ev_mw6cvo24_3d5089

Quox-verified, not independently audited. Every run is listed on the evidence explorer at quox.ai/evidence.

What the proof does not cover

Being precise about the limits is part of the proof. Four of them come up every time.

  • An intact record is not a true event. A witnessed receipt proves the system's record has not changed since it was written. It does not prove the thing it describes happened in the world. The legal journey's logged call was a record, not a telephony event, and Quox said so.
  • Evidence present is not a control that worked. The compliance report scores whether evidence exists for each control. Whether the control operated effectively over the period is the auditor's question.
  • One receipt is not the whole chain. Checking one record says nothing about the others. That is what slice checks and whole-run checks are for.
  • Self-verified is not independently audited. Every run above was checked by Quox's own proof engine against the running system, with the evidence published so you can recompute it. It is not a third-party audit, and the journey pages say so.

A checklist for any agent platform

Whatever you run your agents on, these questions separate an audit trail from evidence. Ask them of your vendor, or of your own build.

  1. Is every tool call recorded as it happens, with who asked and under which policy decision?
  2. Does a human approval live in the same record as the action it approved?
  3. Can you pull every step of one job from a single id?
  4. Is the record append-only, with each entry chained to the one before it?
  5. Are there signed checkpoints, and can you check the signature against a key you hold?
  6. Can you verify one action's receipt yourself, and does the answer say when it is not yet final?
  7. Can you export a record that a third party verifies offline, without access to your systems?
  8. Does the platform tell you plainly what its proof does not cover?

The regulator's side of the same list is on the audit trail requirements page, and the OWASP Agentic Top 10 post maps where evidence sits among the other agent risks.

Frequently asked questions

What should an AI agent audit trail capture?

At minimum: who asked, what they asked for, the policy decision, each tool call with its inputs and result, any human approval, a correlation id that links the steps of one job, and a witness receipt that shows the entry has not changed. The table near the top of this guide lists the question each one answers.

Is a log file enough to prove what an AI agent did?

No. A log shows what a system says happened. It can be edited, back-dated or restored from an older copy, usually by the same people and systems whose behaviour is in question. Proof needs an append-only record, signed checkpoints and a check that someone outside your team can run.

What is the difference between tamper-evident and tamper-proof?

Nothing stored on a computer is truly tamper-proof. A tamper-evident record makes any change detectable: alter or remove an entry and the hashes or signatures stop matching, so the verification fails. That is the property an auditor can test.

How long should you keep AI agent records?

It depends on the regime: from at least six months for logs of high-risk systems under the EU AI Act to seven years for some financial records. The retention reference lists the periods with sources. Whatever the window, the record should still verify at the end of it.

Does a human approval need its own record?

Yes. The approval is part of the action. Record who approved or denied, when, and what exactly they were shown, in the same trail as the action, so the two can be tied together later.

Can an auditor check the record without access to my systems?

They should be able to. With Quox, a signed report or an evidence bundle can be checked on the auditor's own machine against a public key they received separately, with no call to your server.

Does this prove the agent made the right decision?

No. It proves what the agent did, under which rules, with whose approval, and that the record has not changed. Whether the decision was right is a judgement for people, and the record is what lets them make it on facts rather than recollection.

Check it yourself

Every run in this guide has a receipt

Open the recorded runs, download the evidence bundles and recompute them. Then try the same checks on your own install.