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.

Reason
AgentsQuoxMindAgentic TeamsMirror & QuoxHatQuoxLensRemember
QuoxMemoryQortexCompoundingQuoxPlanCodebase MirrorAct
QuoxFlowQuoxEngineQuoxAgentQuoxChatAutonomyRun
EnterpriseOrganisationsPowers & ToolsmithQlusterQuoxBastionInterfaces
QuoxMCPQuoxCLIQuox ConsoleQuoxBoxQuoxVoiceGovern
HITL ApprovalsQuox SecurityAgent HonestyQuoxVaultAI GovernanceAgentic AIProve
For AuditorsVerifiable AI OpsLoggingQuoxSEOEU AI ActCompliance SuiteChannels
Matrix RoomsDiscord ProTelegram ProQuoxSignalCoreCommsAll products A-ZBuild
QuoxProofDeveloper KitPlugin SDKBring your tool to QuoxQuoxpertQuoxSkillsShip and sell
Browse MarketplaceDownloadsProtocolsDev Suite
Dev ServersQuoxBuildQuoxSlotsShared Skills + RulesQlarityDev workflow
RepoBrainGripeTriageFixLoopProofLoopDoneEngineAll products A-ZAn 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.

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.
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.
Eight things, captured as the action happens. Leave one out and there is a question you cannot answer later.
| Record | The question it answers |
|---|---|
| Who asked: the person or agent, and the organisation | Whose authority was this action taken under? |
| What was asked: the request and its intent | Was the action what the person actually wanted? |
| The policy decision, made before any model runs | Was the agent allowed to try this at all? |
| The tool call: which tool, its inputs, how long it took, whether it succeeded | What did the agent actually do, as opposed to what it said it did? |
| The result that came back | What did the agent see before it decided its next step? |
| The approval: who approved or denied, and when, or a note that none was needed | Did a person sign off on the risky part? |
| The thread: one correlation id shared by every step of the job | What 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 checkpoint | Has 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.
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:
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
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.
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.
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:
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.
# 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>
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.
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.
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.
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 proved | Status | Receipt |
|---|---|---|
| One action is in the record and unchanged (legal journey) | Verified on 5 and 6 November 2026 | ev_mw4qso4v_ae9cc6 |
| A 30-day SOC 2 readiness report with a witnessed evidence record (compliance journey) | Verified on 6 and 7 November 2026 | ev_mw6e0ac8_2652f2 |
| A signed security posture report an auditor checks offline (security journey) | Machine verified; passed on 6, 7 and 9 November 2026 | ev_mw9las1z_35366f |
| A drafted reply held for human approval, nothing sent (inbox journey) | Verified on 6 and 7 November 2026 | ev_mw6cvo24_3d5089 |
Quox-verified, not independently audited. Every run is listed on the evidence explorer at quox.ai/evidence.
Being precise about the limits is part of the proof. Four of them come up every time.
Whatever you run your agents on, these questions separate an audit trail from evidence. Ask them of your vendor, or of your own build.
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.
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.
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.
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.
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.
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.
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.
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
Open the recorded runs, download the evidence bundles and recompute them. Then try the same checks on your own install.