The letter from the regulator is polite and specific. A customer complained that their small-business credit line was reduced without explanation. The bank’s records show the decision was made by an AI-assisted review process. The regulator wants to know which data the system looked at, which rules and tools it applied, in what order, who or what approved the outcome, and how the bank can be sure that record hasn’t been changed since.
For a growing number of banks, lenders and fintechs, this is no longer a hypothetical. AI agents are moving from internal copilots into processes that touch customers: KYC refreshes, transaction monitoring triage, credit line reviews, dispute handling, collections outreach. The models are often good enough. What’s missing is the ability to answer a simple question with confidence: what exactly did the agent do?
This article is for the people who will have to answer that question: compliance officers, model risk managers, internal auditors, and the engineering leads who build the systems they’ll be asked about.
Why “we have logs” isn’t an answer
Most teams assume their existing observability stack has this covered. There are application logs, LLM tracing tools, maybe a data warehouse of prompts and responses. In practice, these fall short in four ways when a regulator or auditor starts asking questions.
Logs are incomplete. Agents are long-running and branch dynamically. A log line that says “called tool get_credit_report” rarely captures the exact input, the exact output, the retry that happened before it, and the decision that came after, all linked together.
Logs are scattered. The LLM call is in one tool, the API call in another, the human approval in a ticketing system, and the final write in the core banking system. Rebuilding one decision means joining four sources by timestamp and hoping the clocks agree.
Logs are mutable. Most log stores let administrators delete or edit entries. Even if nobody ever does, you can’t prove nobody did. For a regulator, that difference matters.
Logs don’t establish identity. “The agent called the payments API” isn’t enough. Which agent, running which version, under whose authority? If three services share one API key, the log can’t tell them apart.
Model risk frameworks and emerging AI regulation in many jurisdictions increasingly expect firms to explain automated decisions, show human oversight where it applies, and keep records that hold up to scrutiny. Traditional logging was built for debugging, not for evidence.
What an evidence-grade agent record looks like
Before choosing tools, it helps to define what “good” looks like. An agent execution record that will satisfy an auditor typically has five properties:
- Complete: Every step the agent took (each model call, tool call, decision branch, wait and human input) is recorded with its inputs and outputs.
- Ordered: The steps are recorded in the sequence they actually happened, including retries and failures, not reassembled later from timestamps.
- Attributable: Every step is tied to a verifiable identity: which service, which agent, which version, and, for human steps, which person.
- Tamper-evident: Any change to the record after the fact is detectable.
- Portable: The record can be exported and verified by someone outside the engineering team, such as an internal auditor or an external examiner.
Notice that the first two properties come almost for free from a particular way of running agents, which is the key to solving this problem without building a custom compliance system.
Durable execution gives you the record by design
Durable execution engines run multi-step processes by recording every step in an append-only event history, mainly so they can recover from crashes. When an agent runs on such an engine, each model call and tool call becomes a recorded activity with its inputs and outputs persisted before the agent moves on. Human approvals become recorded external events. Timers and waits are recorded too.
That history wasn’t designed as an audit trail, but it has exactly the shape one needs. It’s complete, because the engine can’t recover without it. It’s ordered, because replay depends on the exact sequence. And it’s produced by the runtime, not by developers remembering to add log lines.
What a plain execution history doesn’t give you is properties three and four: strong identity and tamper evidence. That’s where newer platforms have started to add a layer on top.
Adding identity and tamper evidence
Two techniques, both borrowed from security engineering, turn an execution history into evidence.
Workload identity. Instead of shared API keys, each service and agent gets a cryptographic identity, commonly using the SPIFFE standard, and all calls between them are authenticated with mutual TLS. Every step in the history can then be attributed to a specific, verifiable workload rather than a shared credential.
Signed, hash-chained history. As each batch of events is written, it’s hashed and signed, and each signature covers the previous one. This is the same idea as a blockchain or a certificate transparency log, without the distributed-consensus overhead. If anyone alters or removes an event later, the chain no longer verifies.
Combined, these let a bank show an auditor a record that says: this agent, with this identity, called these tools with these inputs, received these outputs, waited for this approval from this person, and made this decision, and here is cryptographic proof that the record is intact.
Some durable execution platforms now offer this as a built-in capability. For example, Diagrid, a company founded by the creators of the open-source Dapr project, has added workflow history signing, signed-context propagation across service boundaries, and external attestation to its Catalyst platform. A third party can validate the signed history against the platform’s trust anchors without having to trust the engineering team that produced it. Teams evaluating this should note that signing typically has to be enabled per workflow and requires mTLS to be in place, so it’s worth planning from the start rather than retrofitting.
Don’t forget the human in the loop
Regulators often care less about whether an AI was involved than about whether a human had meaningful oversight. That means the record has to capture human decisions just as precisely as machine ones.
With durable execution, a human approval step is modelled as the agent pausing and waiting for an external event. The pause can last minutes or weeks without holding any compute. When the reviewer approves, rejects or amends the recommendation, that input is recorded in the same history, attributed to the reviewer’s identity, and signed with everything else. The audit trail then shows not only what the agent proposed but who signed off, when, and what they saw at the time.
Where the data lives matters too
For banks, an audit trail that sits on a vendor’s multi-tenant SaaS can create a new problem: execution histories contain customer data, often including personal and financial information. Many institutions can’t let that leave their own cloud accounts or data centers.
When you evaluate platforms, check whether the execution history (and the signing keys) can stay in infrastructure you control, such as your own cloud account, a private VPC or an on-premises environment. Some vendors, including the durable execution platform from Diagrid, support bring-your-own-cloud and fully air-gapped deployments for exactly this reason.
A practical roadmap for compliance and engineering teams
Getting to evidence-grade agent records is as much an organizational project as a technical one. A sensible sequence:
- Inventory your agents. List every AI agent or AI-assisted workflow that influences a customer outcome, and classify them by risk.
- Agree on the evidence standard. Compliance, model risk and engineering should agree on what a “complete record” means for each risk tier before any tooling is chosen.
- Run high-risk agents on a durable execution engine. This gives you a complete, ordered history as a by-product of reliability work you probably need anyway.
- Replace shared credentials with workload identity. Give each agent and tool its own identity, and enforce mTLS between them.
- Turn on signing for regulated workflows. Start with the highest-risk processes, and test that an auditor can verify a record independently.
- Model human oversight explicitly. Make approvals real workflow steps, not side conversations in chat or email.
- Rehearse an examination. Pick a real past decision and have someone outside the engineering team reconstruct it from the record alone. Fix whatever gaps that exercise reveals.
Conclusion
The question regulators are starting to ask, “show us what your AI actually did,” is fair, and it’s going to get more common. Banks and fintechs that treat it as a logging problem will spend a lot of time stitching together partial evidence after the fact. Those that treat it as an execution problem, running agents on infrastructure that records, attributes and signs every step by design, will be able to answer in minutes rather than weeks. The technology for that now exists. The harder part is deciding, before the next regulator’s letter arrives, that evidence is a requirement and not an afterthought.