The accountability question for AI has been discussed for years at a level of abstraction that has made it easy to defer. When AI systems produced outputs -- text, images, recommendations -- the human who acted on those outputs remained accountable for the action. The AI was a tool. The decision remained human.
Agentic AI changes that in a way that most organisations are not yet governing correctly. An agentic system does not produce an output for a human to consider. It takes an action. The API has been called, the record updated, the message sent, the transaction initiated -- before any human has reviewed what happened. The question of who is accountable for that action is no longer an abstraction about future AI risk. It is a live operational question for any organisation running agentic systems today.
What makes agentic accountability different
With conventional AI, the failure mode is a bad recommendation. The human acts on it, and accountability for the action sits with the human. Remediation is possible because the human decision is the intervention point.
With agentic AI, the failure mode is a bad action. There is no human intervention point between the agent's decision and the consequence. Recovery requires understanding what the agent did, in what sequence, under what conditions, with what data, and with what downstream effects -- and then determining whether the action can be undone, partially reversed, or only documented. In many cases, it cannot be undone. A communication sent to a customer, a regulatory filing submitted, a financial transaction settled -- these are not reversible in the way that a bad recommendation can be simply not acted upon.
The accountability gap this creates is structural. Someone approved the deployment of the agentic system. Someone defined its objectives and constraints. Someone integrated it with the systems it operates against. Someone is responsible for monitoring its behaviour. But when a specific wrong action occurs, the chain from deployment decision to operational consequence is rarely documented in a way that enables accountability to be clearly assigned.
The three accountability gaps I see most often
The first is the deployment gap. Agentic systems are frequently deployed through technology or transformation programmes that do not carry clear operational accountability forward. The team that built and deployed the system has moved on to the next project. The team that operates the system did not design it and does not have full visibility into its decision logic. When something goes wrong, there is no single owner.
The second is the scope gap. Agentic systems are typically deployed with a defined objective and a set of constraints on what they can do. In practice, the constraints are often underspecified, and the systems find paths to their objectives that were not anticipated. This is not a failure of the AI in the technical sense -- it is behaving consistently with its instructions. But the organisation did not intend or anticipate the action it took. The question of who is accountable for actions that are consistent with instructions but inconsistent with intent is genuinely difficult and most organisations have not worked through it.
The third is the audit gap. Accountability after the fact requires the ability to reconstruct what happened. Most agentic deployments do not have logging and traceability sufficient for that reconstruction. The system took an action. The action had consequences. The decision path that led to the action is not recorded in a form that enables post-hoc review. Without that record, accountability is asserted rather than demonstrated.
What the regulatory environment is beginning to require
The EU AI Act addresses human oversight in terms that are clear in principle but challenging in practice for agentic systems. The requirement is for human oversight mechanisms that are "genuinely operative" -- not theoretical controls that exist in documentation but have no practical effect on system behaviour. For a system taking dozens of actions per minute, the question of what "genuinely operative" oversight looks like is one that organisations must answer in their architecture before regulators answer it for them.
The emerging regulatory direction across jurisdictions is toward a traceability requirement: the ability to reconstruct, for any action taken by an AI system, the decision path, the data inputs, the objectives being optimised, and the constraints in effect at the time. This is the technical foundation for accountability. It is also the technical requirement that most current agentic deployments cannot meet.
Product liability frameworks are also evolving. Several EU member states are actively working through how existing product liability law applies to AI-caused harm. The direction is toward treating AI systems deployed by enterprises as products for which the deploying enterprise bears liability -- which means the absence of traceability documentation is not just an audit problem. It is a legal exposure.
Building accountable agentic architecture
The starting point is what I would call a decision log with integrity. Every action taken by an agentic system should be logged with sufficient context to reconstruct the decision: the objective being pursued, the state of the environment at the time of the decision, the constraints in effect, the data inputs consulted, and the action selected. This log should be tamper-evident and retained for a period appropriate to the risk profile of the actions being taken.
This is not exotic technical infrastructure. It is a discipline of design. The organisations that have built it have done so because they understood from the outset that agentic systems operating at scale in consequential domains require the same audit infrastructure that any other consequential operational system requires. The organisations that have not built it typically deployed agentic capability quickly, under competitive pressure, without asking what responsible deployment required.
The second element is explicit scope definition with a human review gate for scope extension. The constraints on what an agentic system can do should be documented, version-controlled, and subject to approval when they change. When the system encounters a situation outside its defined scope, the default behaviour should be to halt and escalate rather than to find the closest available action within its capability. Most current deployments do not have this architecture. The default behaviour when the agent is uncertain is typically to continue rather than to pause.
The third element is named accountability. For each agentic system in production, there should be a named individual accountable for its operational behaviour -- not the team that built it, not the vendor that supplies the model, but a named person with operational responsibility for what the system does and the authority to intervene or halt it. That accountability should be documented, reviewed periodically, and carried forward when the system changes or when organisational responsibility shifts.
The board and senior leadership dimension
The accountability question for agentic AI ultimately reaches the board because the decisions that determine whether an organisation is exposed were made at the deployment level, but the consequences of that exposure reach the organisation at the level the board is responsible for.
A regulatory finding against an agentic system that was deployed without adequate oversight architecture is not primarily a technology failure. It is a governance failure. The organisation approved deployment. The organisation is responsible for what it deployed.
The conversation I would encourage senior leaders to have is not "do we have AI governance policies?" -- most organisations do. It is "for each agentic system we are running, can we reconstruct any action it has taken in the past twelve months, and is there a named person accountable for that system's behaviour?" If the answer to either question is no, the governance posture is not adequate, whatever the policy documentation says.
The organisations that will navigate the agentic AI transition well are those that treat accountability as an architectural requirement, not a retrospective assignment. The decision log, the scope constraint, the named owner -- these are not bureaucratic additions to an agentic deployment. They are what makes the deployment responsible. The cost of building them in is low relative to the cost of reconstructing accountability after something has gone wrong in a way that cannot be undone.
The decision log concept extends beyond agentic operations into research and evidence workflows as well. When AI is used to produce the analysis that informs an agentic system's objectives or constraints, the provenance of that analysis matters too. I have been building infrastructure for exactly that problem at Epistamate -- an evidence intelligence layer that scores claims by verifiable evidence quality and maintains a tamper-evident record of the reasoning behind research conclusions.