Who Can Prove What an Agent Decided?
Traces, audit logs and tamper-evident ledgers each prove something different. For a consequential agent-assisted decision, the evidence that must survive is the binding between proposal, versioned evidence, delegated authority, approval and the change that was actually made, and someone outside the writing team must be able to check it.
Written as at 9 November 2026.
governanceauditevidenceagentic-aiai-securityassurance
Six months on, three systems remember three different things
Illustrative scenario: a fictional composite written to make the point concrete. It does not describe a real organisation, and its figures are not reported outcomes.
A regional water utility runs its supplier inbox through three agents. On 14 April an inbox agent reads a letter from a pump-maintenance contractor, supplier P-3318, asking for payments to go to a new account. A verification agent calls the number held in the vendor master, records that someone confirmed the change, and matches the ABN on the letterhead. A payments agent drafts the vendor-master update; it is above the agent’s limit, so the accounts payable team lead approves it in the console at 11:42. The payment run on 21 April sends $48,600 to the new account.
In October the contractor disputes it: it never asked for a change, and the April payment never arrived. The investigator opens three systems and finds three pasts. The agent platform kept full traces for fourteen days and sampled thereafter; the April run is gone. The ERP audit log shows the change on 14 April and, two hours later, a nightly synchronisation that wrote the old account back; it does not say which record the payment run read. The approval console shows “approved, case 7731” with a time and nothing about the payload the team lead saw. The model behind the agents has been replaced since.
The utility may have been defrauded, and it may not. What it cannot do is prove what was decided, which evidence it rested on, whose authority allowed it, and whether the record it shows now is the record it had then.
Logs, traces and ledgers answer different questions
Every system above kept records. The question is what each kind can establish.
A trace shows that calls happened, in what order, and with what content where capture is on. It is incomplete by design. LangSmith documents sampling, masking, a fourteen-day base retention and an API for deleting runs. Amazon Bedrock AgentCore writes OpenTelemetry-compatible telemetry to CloudWatch, where retention follows each log group’s setting. The OpenTelemetry GenAI span conventions both build towards are marked “Status: Development”, with message content opt-in because it is “likely to contain sensitive information”. None of these documents a cryptographic integrity proof for traces. A trace is what the platform chose to keep.
An audit log shows that an event occurred as the platform saw it. Microsoft Purview records who interacted with Copilot and which resources were referenced; its documented message fields are identifiers and flags, not text. AWS CloudTrail logs management events by default and data events only when switched on. CloudTrail is also the one mainstream service here that documents a cryptographic check: with log file integrity validation enabled, hourly digest files are signed and chained, so you can “determine whether a log file was modified, deleted, or unchanged after CloudTrail delivered it”. Read the limit: after delivery. If logging stops, the chain has no digests for the gap.
A tamper-evident ledger shows that an entry was committed at a position in an append-only structure and has not changed since. Azure Confidential Ledger describes “immutability, tamper-evident records, and append-only operations” and returns a receipt holding a Merkle proof and a node signature. Certificate Transparency (RFC 9162) is the public pattern: inclusion proofs place an entry in the log and consistency proofs “prove the append-only property of the tree”. The RFC is equally clear about the hole: a log that “shows different, inconsistent views of itself to different clients” defeats the auditing, and the remedies are “outside the scope of this document”. A single log, however well hashed, is a trusted third party.
So a hash chain proves order and non-alteration from the point an outsider began checking. It does not prove that an omitted event happened, that cited evidence was true, or that a model’s explanation describes what it computed; Chen and colleagues (2025) found reasoning models disclosed a hint they had used less than 20 per cent of the time in several settings. The investigator needs all three records, each for what it can prove, and a fourth thing none supplies: the binding between them.
The CAE interpretation: the record is a shell component, and the binding is the product
In the Contextual Agentic Enterprise (CAE), Contextual Agentic’s architecture and operating model for governed agents, the model proposes inside the Probabilistic Core and the Deterministic Shell decides identity, authority, schema, state transition and commitment. The Evidence-First Decision Record is the shell’s memory of one consequential decision: claims, evidence, policy decisions, approvals, versions and outcomes kept separately retrievable, each claim marked observed, declared or inferred, each piece of evidence referenced by version. That article gives the reconstruction test; this one asks who can prove the record is the record.
Three constructs do the binding. The Commit Boundary is where a proposal becomes an effect, and the only place a record can describe the change actually made. The Authority Envelope supplies the delegated authority, with its limits and expiry, so that “approved” means a named person, within a named grant, approved a specific payload. The Minimum Action-Evidence Bundle, in grouped form, is what the record must hold at that boundary: identity and authority, evidence by version, typed claims, proposal, policy result and approval, scaled to the risk.
The CAE reading is that a consequential decision has not been recorded until a record binding proposal, versioned evidence, delegated authority, approval and committed change exists, sealed, before the change lands. A ledger that stores whatever the agent platform chose to send is a trace with better hashing.
A decision procedure: what must survive, and who holds it
Nine things must survive the model, the policy, the source documents and the system state all changing, and each must be checkable without trusting the team that wrote it.
- A decision identifier bound at opening to tenant, principal (and whom it acts on behalf of), the delegated authority reference and its expiry, the purpose, and the business object at a named version. Written before any control runs.
- Evidence by reference, version and digest. The content stays in its governed store, which must keep old versions for the challenge window. A reference to “latest” is refused at write time.
- Claims typed by how they are known. “The letter arrived from the registered domain” is observed, with the gateway as source. “The supplier asked for the change” is declared, naming who. “The letterhead matches earlier correspondence” is inferred, with the model version and stated confidence. The model’s explanation is itself an inference, never the basis.
- Versions of everything that reasoned: agent, model, policy set, configuration and Context Contract revision. Identifiers, with no claim that they reveal internal reasoning.
- An approval bound to a payload digest, with an expiry and the approver’s own authority reference. An approval of case 7731 is not an approval of an account number.
- The outcome and the committed result: permit, deny, escalate or hold, then what the receiving system did, with its own reference and the object’s version afterwards. The commit is refused when any of items 1 to 5 is missing, when the payload differs from the one proposed and approved, when approval or authority has lapsed, or when the object has changed version since the evidence was taken. If the evidence service cannot write, the action is held. An unavailable record is a hold, never a permission.
- Signed, hash-linked events with key identifiers, so rotation is routine and a revoked key fails loudly, plus signed checkpoints handed to a witness the writer and key holder cannot reach. The chain catches edits and middle deletions; only the witness catches a cut end or a wholesale rewrite.
- Trusted time where it matters. A timestamp is the writer’s claim; order comes from the chain. Where the date is contested, an RFC 3161-style timestamp on each checkpoint is the inexpensive answer.
- Retention past the longest challenge window, digests rather than content, and a periodic drill. Payloads, prompts and documents never enter the record. Once a month, someone outside the integration team verifies a decision at least thirty days old from the export and the keys alone.
The decision ladder is short. A governed store with signed digests and one external witness is enough for most enterprise decision classes. Several independent witnesses earn their cost when two organisations will each rely on the record, or when one custodian could be compelled. Distributed consensus or a blockchain is justified only when the parties trust no custodian at all and need the record to keep working if some of them misbehave: a narrow trust model, rarely the one inside an enterprise. Agent votes never substitute for delegated business authority: a quorum of agents is a signal, and a human grant within an Authority Envelope is the approval.
Failure tests, and what each control cannot see
| Failure | What detects it | What stays undetected |
|---|---|---|
| Omitted event | Nothing in the record. The commit gate makes a change impossible without its record on the paths it guards; reconciling the receiving system’s changes against decision identifiers measures the rest | Changes on a path the gate does not sit on |
| Rewritten event | Hash mismatch; if the hash is recomputed, the signature fails; the store refuses updates in place | An insider with write access and the key, before a witnessed checkpoint |
| Deleted event in the middle | Sequence gap and broken link | |
| Deleted events at the end, or a wholesale rewrite | Only the witnessed checkpoint | Anything after the last checkpoint |
| Deleted source version | A reference that no longer resolves at drill time | The content cannot be restored |
| Forged or stale approval | Digest mismatch, expiry, wrong named approver | An approver who did not read |
| Ledger fork | Head hash differs from the witness’s copy | Collusion with the witness |
| Clock error | Out-of-order timestamps are visible; order comes from the chain | True time without a timestamp authority |
| Compromised signing key | Revocation makes its records fail verification; checkpoints bound the exposure in time | Forgeries made before revocation and before a checkpoint |
| Privacy leakage | Payloads absent from the record by construction | Content a writer puts into free-text reasons |
| Retention expiry | The drill fails | Purged sources |
| Plausible but false inference | The claim is visibly inferred, with source and confidence; a correction is appended, never written over | Whether it was true |
Who does what
Executives decide which decision classes must be reconstructable by an outsider, for how long, and who the witness is. That last choice is organisational: a second team’s locked storage, a cloud confidential ledger or a transparency log all work, and none works until someone owns it. The cost is mostly operating burden, not storage: the record is around a dozen digest-sized events per decision in the local slice, while integration at each commit path, key custody, the witness relationship and the monthly drill are the real spend.
Architects design the record at the Commit Boundary rather than in the agent platform, keep payloads out of it, run one chain per tenant with per-tenant keys, and plan to emit receipts in a standard shape: the IETF has just published the SCITT architecture (RFC 9943) for signed statements and transparency services, and individual drafts now propose agent-action receipt profiles on it.
Engineers implement and test the gate as code that fails closed, with tests for the ordinary commit, denial, stale authority, conflicting state, idempotent retry, crash recovery, missing evidence, tampering, deletion, truncation against a witness, key rotation, concurrent writers and tenant isolation. Then they say what the tests are: synthetic. Passing them shows the design works in a laboratory, not that a production system captures every action, which only reconciliation in that system can show.
What the investigator can verify six months later
Replay April with the record in place. The investigator exports the utility’s chain and the witness’s checkpoints and verifies them with the public key alone, without the agent platform, the ERP or the evidence service’s vendor.
| Question | What the record shows | How it is checked |
|---|---|---|
| Which record did the agents see? | The vendor master for P-3318 at version 7, with its digest, pinned at opening | Resolve version 7 in the ERP’s history; compare digests |
| Who said the supplier asked? | A declared claim attributed to the letter’s sender, and an observed claim that the call went to the number in version 7 | Claim types and sources in the sealed events |
| What did the team lead approve? | The digest of the payload containing the new account, bound in the approval event, with expiry 15:42 | Recompute the digest of the proposal; compare with the approval |
| Did the payment run read the changed record or the restored one? | The committed event names the ERP change reference and the object’s version 8; the nightly synchronisation that wrote version 9 has no decision identifier | Reconcile ERP history with the record; the gap is itself a finding |
| Has any of this been altered since? | Hashes and signatures verify; the head matches the checkpoint the witness holds from 14 April | Verifier output, with its list of what it could not establish |
The record does not settle whether the letter was genuine. It shows that “confirmed” rested on a declared claim and an inferred letterhead match, that the team lead approved the exact payload that was committed, and that the utility’s copy of events is the copy an outside party saw in April. That is a different conversation with the contractor and the bank than three systems remembering three pasts.
Key takeaways
- A trace, an audit log and a tamper-evident ledger each prove something different, and none of them proves that an omitted event occurred, that cited evidence was true, or what a model computed.
- The evidence that must survive a consequential agent-assisted decision is the binding between proposal, versioned evidence, delegated authority, an approval tied to a payload digest and the change actually committed, written at the Commit Boundary before the change lands.
- A hash chain is tamper-evident, not tamper-proof: it catches edits and middle deletions, and only a checkpoint held by an independent witness catches a cut end or a rewrite by a key holder.
- An unavailable evidence service holds the action; a commit that cannot be recorded is not permitted.
- A governed store with signed digests and one witness is enough for most decision classes; multi-party consensus is for the rare case where no custodian is trusted, and agent votes never replace delegated authority.
Sources and further reading
- The Contextual Agentic Enterprise, Chapters 7, 16 and 17.
- Chen, Y., Benton, J., Radhakrishnan, A. et al. (2025) “Reasoning Models Don’t Always Say What They Think”, arXiv:2505.05410.
- AWS, “Validating CloudTrail log file integrity”, “CloudTrail digest file structure” and “CloudTrail concepts”, AWS CloudTrail User Guide. One vendor’s documented behaviour, opened 9 November 2026.
- Microsoft, “Azure confidential ledger overview” (last updated 19 October 2026), “Write transaction receipts” and “Verify write transaction receipts”, Microsoft Learn. One vendor’s documented behaviour.
- Laurie, B., Messeri, E. and Stradling, R. (2021) “Certificate Transparency Version 2.0”, RFC 9162, IETF, December 2021 (Experimental; obsoletes RFC 6962). Sections 2.1.3, 2.1.4, 4.10 and 8.3.
- Birkholz, H. et al. (2026) “An Architecture for Trustworthy and Transparent Digital Supply Chains”, RFC 9943, IETF, June 2026 (Proposed Standard). The architecture does not mention AI agents; agent-receipt profiles exist only as individual Internet-Drafts.
- W3C (2013) “PROV-O: The PROV Ontology”, W3C Recommendation, 30 April 2013. A vocabulary for provenance (Entity, Activity, Agent;
wasDerivedFrom,actedOnBehalfOf), with no integrity mechanism of its own. - OpenTelemetry, “Semantic conventions for GenAI agent and framework spans” (Status: Development, opened 9 November 2026).
- LangChain, “Manage traces” and “Administration overview”, LangSmith documentation. One vendor’s documented behaviour.
- AWS, “Observability for Amazon Bedrock AgentCore”, Developer Guide, and “Working with log groups and log streams”, CloudWatch Logs User Guide. One vendor’s documented behaviour.
- Microsoft, “Audit logs for Copilot and AI applications”, Microsoft Purview documentation (updated 26 August 2026). One vendor’s documented behaviour.
- Regulation (EU) 2024/1689 (AI Act), Articles 12, 19, 26(6) and 86, as amended by Regulation (EU) 2026/1744 of 8 July 2026 (the Digital Omnibus on AI, in force 27 July 2026), which deferred the application dates for high-risk systems; check the Official Journal text for the dates that apply to a given system. These articles create logging, retention and explanation duties, not an integrity requirement.
- 17 CFR § 240.17a-4(f), the one rule found in this review that requires an integrity property for records (write-once storage or a complete time-stamped audit trail). It applies to US broker-dealers and is cited as an example of the requirement’s shape.
The book develops the record and the replay at length
The book treats the evidence-first decision record, the distinction between when something was true and when the system knew it, and the difference between forensic and counterfactual replay, in the chapters listed above; it also gives the full evidence bundle by risk tier and how it binds to approval, which this note summarises only in grouped form. Any adoption of CAE should be tailored to the organisation in consultation with Contextual Agentic or another advisory service. More about the book.
This article is part of CAE Field Notes, a series accompanying the book, The Contextual Agentic Enterprise.
Related
Evidence-First Decision Records: Reconstructing What the Agent Knew
A model's explanation is not an audit record, and logs are not a reconstruction. An Evidence-First Decision Record keeps claims, evidence and versions retrievable long after everything has changed.
The Commit Boundary: Where AI Recommendations Become Enterprise Consequences
Controls placed at the start of an agent conversation check the wrong thing. The decisive check evaluates the exact action about to become real, at the moment it becomes real.
Why Enterprise AI Needs a Deterministic Shell
Don't try to make the model deterministic or simply trust it. Let it propose, and put identity, authority, schema, state and commitment in a shell that decides at the Commit Boundary.
The Minimum Action-Evidence Bundle: What Must Accompany a Consequential Action
Evidence for an agent's action is neither a log of everything nor a fixed form. It is the smallest verifiable set that lets a control decide, and approval must bind to it.
Zero Trust for AI Agents: Identity, Authority and Continuous Verification
An agent is neither a user nor a service account. Zero Trust still applies, but it has to verify the agent, the principal and each action, and treat content as influence, never authority.
Contextual Agentic Memory: What an Enterprise Agent Should Remember, Retrieve and Recheck
Agent memory is more than a bigger prompt or a vector store. Keep remembered evidence apart from business state, instructions and permission, control its lifecycle, and recheck before acting.