Your Agent Changed the Record. Can You Prove Why?
There are probably easier ways to ruin an audit committee’s morning than announcing that an AI agent has been quietly updating production systems.
Releasing a badger into the boardroom comes to mind. At least with the badger, somebody can usually establish where it came from, who opened the door and what it destroyed on the way through.
With the AI agent, we might not be quite so fortunate.
It has a perfectly reasonable explanation, of course. It acted in accordance with its objectives, followed the available instructions and successfully completed the requested operation.
Excellent. Very reassuring.
Unfortunately, nobody can quite establish which business records it used, whether the decision passed the relevant controls, or what actually happened after the receiving system accepted the change.
And therein lies another interesting problem with Agentic AI.
We’ve spent years developing data lineage to understand where information came from and how it changed. Now we’re introducing systems that can take that information, make decisions and change the business itself.
I suspect we’re going to need a considerably better audit trail.
A successful API call isn’t much of an explanation
Imagine a telecommunications operator using an AI agent to help manage network performance.
The agent monitors traffic patterns, examines available capacity, identifies congestion and recommends changes to network routing. This is precisely the sort of complex operational problem where intelligent automation could be genuinely useful.
One evening, it detects an unusual traffic pattern and adjusts routing preferences across several network segments.
The API accepts the request. The operation returns a success response. The agent records that the network configuration has been optimised.
Lovely.
The following morning, engineers notice that traffic is behaving rather strangely. Nothing catastrophic, but several services are now taking routes nobody particularly wanted them to take.
The operations team investigates. They can see the configuration change, know when it happened and identify the service account that executed it. The agent platform confirms that a tool was called successfully.
So far, so good.
But now come the more awkward questions.
Which network measurements did the agent actually see? Were they collected before or after a previous routing adjustment? Which operational constraints did it consider? Did it use the current topology or a cached version? Which policy permitted the change, and what did the receiving system actually do with it?
And, most importantly, can we reconstruct the evidence that justified the action rather than ask the agent to produce a plausible explanation afterwards?
Because those are two very different things.
An agent telling us why it thinks it did something is not the same as having an evidence trail showing why the enterprise allowed it to happen.
We already have data lineage. Surely that’s enough?
Not quite.
Data lineage is one of the more useful disciplines we’ve developed in enterprise data engineering. It allows us to understand where information originates, how it moves, which transformations have been applied and what depends on it.
Platforms such as Microsoft Purview help organisations discover and govern their data estates, including lineage across supported data assets.
If a report contains the wrong number, lineage gives us somewhere sensible to start looking. Was the source incorrect? Did a transformation change the value? Was the wrong version loaded? Did something break downstream?
All familiar territory.
But suppose an agent reads that information, combines it with a policy document, invokes another agent, proposes an operational change and eventually writes something back to a production application.
Traditional data lineage might tell us where the underlying information originated. It doesn’t automatically tell us why the agent selected that action, which evidence supported its proposal, which controls passed, who approved it or whether the resulting business change matched what was requested.
We’ve crossed from understanding the journey of information into understanding the journey of a decision that actually changes something.
That’s a different requirement.
I think of it as action lineage.
Not just where the data came from, but how a particular set of evidence became a particular action and, eventually, a particular business outcome.
We have logs. A great many of them.
Before somebody accuses me of wanting to reinvent monitoring, we don’t need to.
AI observability is improving considerably.
Microsoft Foundry supports agent tracing, providing visibility into execution, tool calls, retrieval operations and diagnostic information. Microsoft’s Azure SRE Agent auditing also captures tool execution, model activity and approval decisions in its operational environment.
Meanwhile, standards such as OpenTelemetry are helping make distributed tracing and instrumentation more consistent across systems.
All useful developments, and exactly the kind of visibility enterprise agents should have.
But I think we need to be careful not to confuse a detailed execution trace with a complete business audit trail.
A trace might tell us that the agent called UpdateNetworkRoute at 02:17 and received a successful response.
That’s useful for debugging the agent.
The network operator may need rather more.
What business evidence supported the routing change? Which version of the operational state was used? Did the proposal satisfy the applicable business rules? Was the final request identical to what had been approved? Did the target system actually commit it, and was the resulting state verified?
Those details may be scattered across entirely different systems.
One in the agent framework. Another in the integration layer. Another in an approval service. The actual transaction in an operational application.
Each platform may have done a perfectly respectable job of recording its own activities.
Unfortunately, the investigation requires the whole story.
And those stories rarely assemble themselves.
The interesting bit is what happens between the logs
This becomes particularly awkward when several agents work together.
Imagine a company using AI to review and maintain commercial agreements. One agent extracts contractual obligations, another checks them against internal policies and a third prepares the corresponding updates to operational records.
Everything looks beautifully modular on the architecture diagram.
Then an incorrect contractual classification appears in a downstream system.
Which agent introduced the problem? Was the original extraction wrong? Did the compliance agent use an outdated policy? Did the final agent modify the proposed action? Or did the receiving system apply an unexpected mapping?
The logs may show three successful agent executions, two tool calls and one completed update.
Wonderful.
A clean bill of health for a process that produced the wrong business outcome.
And the more we distribute work across agents, tools, platforms and operational systems, the harder it becomes to reconstruct events unless we’ve designed that relationship into the architecture.
This follows rather naturally from our earlier discussion about MCP, AI agents and live enterprise data. Getting an agent connected to the business is one problem. Giving it reliable, governed context is another.
Once it starts changing things, we inherit a third.
We need to preserve the relationship between the context it received, the action it proposed and the change that actually occurred.
So how would we actually engineer this?
The good news is that much of the engineering already exists.
We don’t need to invent an entirely new AI platform, build a special database for agent memories or persuade the ERP to embrace artificial intelligence. It has enough problems.
What we need is a consistent production workflow connecting evidence, proposed actions, business controls and outcomes.
That is the architecture we’ve been developing around IOblend.
Our existing production data layer already handles batch, CDC, streaming, state, transformation, validation, reconciliation, exceptions and record-level lineage. It can integrate operational information from different systems and maintain the governed context needed by downstream applications or AI.
Just as importantly, IOblend pipelines can execute Python and SQL logic. That means the business-specific rules surrounding an AI action don’t have to live inside the agent’s prompt or depend entirely on whatever controls its framework happens to provide.
Consider how this could work.
An IOblend pipeline assembles the operational context, reconciles the relevant records and validates the information before exposing it to an agent. Alongside that context, we generate an evidence reference identifying the source records, versions and relevant business rules used to construct it.
The agent receives the approved context through its existing environment. It does whatever clever reasoning it was built to do and returns a structured proposal, including the evidence reference.
At this point, we still haven’t changed the business.
Good.
The proposal then enters a controlled IOblend workflow, where Python can correlate it with the original evidence, retrieve the latest operational state, apply deterministic business rules, check approval requirements and determine whether the proposed action is still legitimate.
If the controls pass, the authorised request is submitted through the appropriate operational API or service. The target system enforces the final transaction conditions, and its response comes back into IOblend for reconciliation.
We can then record not merely what the agent intended, but what actually happened.
The important difference is that the entire process can carry a common action identifier connecting the evidence, proposal, validations, approval, execution and outcome.
Suddenly we have something rather more useful than a collection of successful tool calls.
We have a reconstructable business event.
Python is what makes this practical
This is the part I particularly like about the approach.
We aren’t suggesting that every enterprise needs to buy another specialist agent-governance product simply to implement business rules around an AI workflow.
IOblend already supports Python inside its production pipelines, so the required logic can be explicit, versioned and specific to the customer’s actual systems.
For our telecommunications example, a Python validation step might compare the proposed network adjustment against current topology, routing policy, capacity constraints and maintenance restrictions. It could reject the proposal if the relevant configuration had changed since the agent received its context.
Another organisation might apply completely different controls to financial transactions, manufacturing instructions or service operations.
The business rules would naturally differ, but the underlying architecture could remain consistent.
The evidence reference could be created through Python logic and retained in customer-controlled storage. An action identifier could be carried between the agent and IOblend. Validation results, policy versions, approvals, execution responses and reconciliation outcomes could be recorded as the workflow progresses.
There is no requirement for all this evidence to sit in a new IOblend-owned database. It can be stored in the customer’s existing infrastructure under their retention, security and access policies.
Nor does the agent have to run on a particular platform. Microsoft, Databricks, a custom agent framework or another suitable AI environment can continue doing the reasoning.
The production relationship between that agent and the operational estate is a separate architectural decision.
I think that’s an important distinction.
It means we’re not asking customers to dismantle their existing AI architecture. We’re giving them a way to apply familiar enterprise engineering disciplines around it.
One small detail before somebody lets the agent loose
There is an important engineering distinction here.
If IOblend checks the current state before submitting an action, that doesn’t necessarily guarantee the state will remain unchanged while the request is being processed.
We covered this in The Data Was Right. The Action Was Wrong.
A valid decision can become invalid in the time between reading the business and acting on it.
The same applies here.
The final transaction should use the receiving system’s own concurrency controls wherever they are available. That might involve a version check, an ETag-based conditional update or another transactional mechanism that prevents a stale instruction from overwriting more recent changes.
Microsoft’s API architecture guidance describes this kind of optimistic concurrency control through conditional requests.
We also need to account for retries. An agent or integration process may receive a timeout even though the original transaction succeeded. Without duplicate protection, the retry may execute the same business action twice.
AWS addresses this directly in its guidance on idempotent agent execution.
The point is that the production layer should validate and control the process, while the target system retains responsibility for enforcing the atomic transaction where necessary.
For some environments, the final write may go through an existing transactional API or a lightweight execution service. IOblend handles the distributed data processing, validation, state management and reconciliation around it.
No need to turn Spark into something it was never designed to be.
That distinction makes the architecture more robust, not less.
We don’t need to record every thought the model ever had
There is another temptation here: solving the problem by logging absolutely everything.
Every prompt, response, intermediate message, retrieved document, tool argument and token that ever passed through the system.
Which should keep the storage vendors cheerful.
It would also create a wonderful new collection of privacy, security, retention and governance problems.
More logging doesn’t automatically mean better evidence.
For operational purposes, I’m much more interested in preserving the information that allows us to reconstruct a change reliably.
What evidence was supplied? Which records and versions did it represent? What did the agent propose? Which deterministic checks passed? Who approved the operation, if approval was required? What was submitted to the target system, and what was the final outcome?
Those records can be linked through identifiers, versions, controlled snapshots and metadata rather than storing complete copies of sensitive information everywhere.
There is a place for AI execution traces, and a place for operational evidence.
They should complement each other without turning every audit investigation into an archaeological expedition through several terabytes of prompts.
This is an implementation pattern, not another platform
I think we should be clear about what we’re proposing.
IOblend already has the underlying production capabilities: data integration, SQL and Python processing, state, validation, record-level lineage, exception handling and reconciliation.
A complete cross-system action-evidence workflow brings those capabilities together with additional configuration and integration logic. We would implement action correlation, evidence storage, approval integration and target-specific execution controls for the environment concerned.
That doesn’t mean pretending every possible agent action already has a ready-made button in IOblend Designer.
It means we can use an existing, flexible production architecture rather than starting from scratch or forcing the problem into an entirely new platform.
The result can also be reused. Once an organisation establishes a consistent evidence and action contract, different agent workflows can apply their own business rules while following the same underlying control pattern.
And the logic is held in portable pipeline definitions rather than buried inside a collection of agents that may change as the technology evolves.
Given the speed at which AI frameworks come and go, that strikes me as a useful arrangement.
The agent might be replaced next year. The business will still want to know who changed the network configuration.
And what happens when the agent was right?
There’s another reason I think this matters, and it isn’t necessarily about something going wrong.
Suppose an agent identifies an unusual operating condition, recommends a change and improves the outcome.
Excellent.
Wouldn’t it be useful to know exactly what worked?
Not simply that the model generated a good answer, but which evidence informed the proposal, what conditions existed at the time, which controls were relevant and what actually improved after the action.
That gives us a much better foundation for assessing agent performance.
A good recommendation, a successfully executed transaction and a genuinely useful business outcome are not automatically the same thing.
Once we can connect those stages, we have something more substantial to evaluate as models, workflows and business rules evolve.
Instead of asking whether the new model sounds more convincing, we can start asking whether its proposals lead to better operational outcomes under comparable conditions.
That seems a rather more useful measure of enterprise AI maturity than the number of agents we’ve deployed.
The question nobody wants to answer on Friday afternoon
Agentic AI is going to become considerably more capable. It will handle complicated workflows, interact with more enterprise systems and take on responsibilities that previously required several people and an alarming number of spreadsheets.
I’m looking forward to that.
But every time we allow an agent to change production data, we create another responsibility for the architecture around it.
Somebody will eventually want to know what happened.
An engineer investigating an incident. A finance team reconciling a transaction. A compliance officer reviewing a decision. Or a director who has just discovered that an automated process has been exceptionally productive in entirely the wrong direction.
At that point, “the agent thought it was a good idea” is unlikely to receive the standing ovation its developers were hoping for.
Here’s a useful test for anyone already putting agents into production.
Pick one business action your agent is allowed to perform. Can you trace it from the information the agent received, through its proposal and the controls applied, to the actual change in the operational system?
If answering that question requires opening six different consoles and locating the developer who left three months ago, there may be an architectural conversation worth having.
We’re working on this approach with IOblend, using the production capabilities we already have and Python to implement the controls required by different environments.
If you’re working through the same challenge, we’d be interested in comparing approaches. Bring us an agent workflow and let’s look at the architecture.
Because if we’re going to give agents the authority to change the business, the business probably shouldn’t have to take their word for it.
The agent can write its own incident report. Wonderful. I’d still prefer the receipts.