Why this matters now: Enterprise AI agent deployments accelerated sharply in 2026, with many teams shipping agentic workflows that read files, write database records, send emails, call external APIs, and trigger downstream business processes. The build timeline for an agent can be days. The governance timeline is much longer, and most teams do not start it until something goes wrong. When it does, the typical discovery is that all agent actions are attributed to the human whose credentials the agent was using, that there is no way to determine what the agent did versus what the human did, and that the actions the agent took before it was stopped cannot be reversed. Each of these is a compliance problem on its own. Together, they make the agent ungovernable after the fact.

Why building an agent and governing it are two different projects

An AI agent is a program that uses an LLM to plan a sequence of tool calls in response to a goal. It reads documents, queries databases, writes outputs, sends notifications, and may trigger other agents. The LLM is not what creates the governance problem. The tool calls are. When an agent reads a file, that action is reversible: nothing changed. When it writes to a customer record, sends an outbound email, or approves a transaction in a connected system, the action may be irreversible, may have an external audience, and may be legally attributable to the organization that deployed the agent.

Most agents in enterprise deployment today inherit the credentials of the user who triggered them. If a sales manager runs an agent that processes customer contracts, the agent's API calls appear in every connected system's audit log as actions taken by the sales manager. The agent and the human are indistinguishable in the record. That is not an edge case or a configuration oversight. It is the default behavior of agents built on user-delegated OAuth tokens, which is how most enterprise integrations work. The compliance implication is that the organization cannot demonstrate after the fact which actions were taken by a human exercising judgment and which were taken by an agent operating autonomously.

The governance decisions below address the five points where enterprise agent deployments most commonly fail compliance and audit requirements. They are ordered by where the failure causes the most damage: attribution and reversibility first, then oversight quality, then escalation handling, and finally the deployment gate that keeps ungoverned agents from reaching production.

“You can build an AI agent in a day. Making it auditable, reversible, and compliant takes longer. Most enterprises start the second project only after the first incident.”
1 in 5
Companies has a mature governance model for autonomous AI agents, according to Deloitte's 2026 survey. The remaining four lack defined escalation paths, meaningful human oversight controls, or audit trails that separate agent actions from human actions
Lowest
Score of any governance dimension. McKinsey's enterprise AI governance framework analysis found “Agentic AI Controls” scores lower than data governance, model risk management, and output safety across the organizations it assessed in 2026
88%
Of IT and security leaders in Rubrik Zero Labs' survey of 1,600+ organizations say they cannot roll back agent actions without disrupting their systems. Stopping the agent is possible. Undoing what it already did is not

The 5 governance decisions and what an audit or incident reveals when each is missing

These decisions apply to any agent that takes actions with external effects: writing to production systems, sending communications, calling APIs that trigger downstream processes, or modifying records that other systems or users depend on. Agents that only read and summarize face a narrower set of these concerns, but every agent that writes should be evaluated against all five.

Governance decisionWhat most teams doThe compliance gap it createsHow it surfacesRisk level
Build an action inventory: classify every tool the agent can call as reversible or irreversible before deploymentThe agent is given access to all tools needed to complete its workflow. No distinction is made between reading a document, writing to a CRM record, and sending an outbound email. All actions are treated the same in terms of access control and loggingNo differential controls exist. The agent applies the same level of autonomy to a read operation as to an irreversible write. When an incident involves an irreversible action, the organization has no documented basis for why the agent was permitted to take that action without additional authorization, because the question of reversibility was never asked at design timeAn agent managing a customer onboarding workflow sends 400 account confirmation emails to customers in a data quality review queue before the queue was validated. The emails cannot be recalled. The team stops the agent but cannot demonstrate that a human reviewed and approved the email-sending step. Audit question: why was an agent permitted to take irreversible customer-facing actions without a documented authorization checkpoint?Critical
Give agents their own identity: agent actions must appear under agent credentials in every system log, not under human credentialsAgents run on the OAuth token or API key of the user who triggered them. All agent actions appear as that user's actions in downstream system logs. The agent and the human are indistinguishable in the audit recordAttribution failure. The organization cannot demonstrate after the fact which actions were taken by a human exercising judgment and which were taken autonomously by the agent. For regulated industries, this collapses the distinction between supervised human action and autonomous AI action, which is precisely the distinction that human oversight requirements exist to preserve. When an agent causes a compliance incident, the logs show it as a human action, which prevents both root cause analysis and regulatory defenseA compliance audit of a financial document processing workflow asks for a log of all actions taken on customer files. The log shows all edits attributed to the analyst who triggered the agent. The auditor asks which actions the analyst reviewed and authorized versus which the agent took autonomously. The organization cannot answer the question from the existing log. Finding: inadequate audit trail for automated processing of regulated documentsCritical
Define human-in-the-loop as decision authority, not approval presence: the human must have context, recourse, and the ability to overrideHuman-in-the-loop means a human sees a notification or approval prompt before the agent takes a specified action. The notification typically shows the action name and a description. The human approves or times out. No context is provided about the agent's reasoning, the data it reviewed, or the alternatives it consideredOversight without authority. The human cannot make an informed decision from the information provided, so approval becomes a habit rather than a control. The EU AI Act's human oversight requirement for high-risk AI explicitly requires that the responsible person be able to understand the system's output, detect and correct failures, and override the system's decisions. A notification that shows “action: update customer record” with an approve/decline button does not satisfy that requirement. If a regulator asks whether a human reviewed and authorized a specific agent action, the answer depends on whether the approval prompt gave the human enough information to actually make that determinationAn EU AI Act audit reviews a healthcare documentation agent. The human oversight record shows that a clinician approved 847 document updates in a single shift, averaging 12 seconds per approval. The auditor determines that the approval process did not provide sufficient information for a clinician to review each update meaningfully. Finding: human oversight does not meet the EU AI Act's standard of enabling detection and correction of failuresHigh
Define an escalation path for every stuck state: when the agent cannot proceed, there must be a named person who receives the case and a defined resolution processWhen an agent encounters an error or a decision it cannot resolve, it logs the error and stops. No notification is sent to a human. The workflow sits incomplete. The user who triggered the agent may not know it stopped until they check manuallySilent workflow failure. Long-running agent workflows can halt midway through a multi-step process, leaving downstream systems in an inconsistent state: some records updated, others not. Because no escalation fires, nobody investigates. The inconsistency propagates through connected systems until something downstream fails or a human reconciles the records manually. For time-sensitive workflows, the halt may cause a deadline miss or a compliance gap that neither the triggering user nor the compliance team is aware ofAn agent automating a contract renewal workflow stops at step 4 of 7 after encountering an unexpected data format in a vendor record. No notification fires. The contract renewal deadline passes. The compliance team discovers the lapse during a quarterly review. The agent's log shows it stopped cleanly, but no one was notified. Finding: no defined escalation path for agent workflow failures in time-sensitive compliance processesHigh
Build rollback into the deployment design: define before go-live how completed agent actions can be reversed for every irreversible action classRollback is not addressed at design time. If the agent needs to be stopped, the team kills the agent process. Actions already completed by the agent remain in place. Manual remediation is performed case by case if neededNo recovery capability. When an agent takes a wrong or unauthorized action, the organization can stop further actions but cannot reverse what has already occurred. Rubrik Zero Labs found 88% of organizations are in this position. For regulated workflows, this creates a situation where the organization must demonstrate that an erroneous agent action has been remediated, but has no documented process for how that remediation works because rollback was never designed. Manual remediation on a case-by-case basis is both slower and harder to audit than a defined rollback processAn agent updating financial period-end records applies an incorrect calculation to 1,200 records before an error is detected and the agent is stopped. The records must be corrected manually. The process takes three days and requires coordination across two departments. Audit question: what is the organization's documented procedure for reversing autonomous AI actions on financial records? Answer: manual correction, case by case, no documented process. Finding: inadequate change management controls for autonomous AI processing of financial dataModerate

The two Critical-level gaps share a structure: the agent was designed to accomplish a task, and the team focused entirely on whether it could do the task. Whether it could be held accountable for doing it, and whether the organization could demonstrate that human judgment was involved in the right places, was left for later. Later usually means after the first incident forces the question.

Not sure where your AI agent governance gaps are?

10decoders builds agent governance frameworks for enterprise workflows: action inventories, agent-scoped credential architecture, meaningful HITL checkpoint design, escalation routing, and rollback planning. We review your current agent deployments and produce a governance gap report covering what is auditable, what is not, and what changes would satisfy regulatory review.

Book a Free AI Assessment →

Why the token reuse problem is harder to fix than it looks

Giving agents their own identity sounds straightforward. In practice, most enterprise AI frameworks are built on top of OAuth integrations that were designed for human users. When an agent needs to write to Salesforce, send a message in Teams, or update a Jira ticket, the most direct path is to use the access token of the user who triggered the agent. The integration already works. The agent can take the action. The fact that the action appears as a human action in the downstream system's log is not visible at the point of building the agent, because nobody is looking at the audit log yet.

The technical fix is to provision a service account for each agent, grant it the minimum permissions needed to complete its workflow, and configure every tool call to authenticate with that service account rather than the user's token. This requires the agent framework to support multi-credential management, and it requires someone to decide what permissions the agent service account should have, which forces the action inventory decision earlier in the process. Organizations that implement agent-scoped credentials almost always also build an action inventory, because the two decisions are connected: you cannot define the agent's permissions without first knowing what actions it will take.

Beyond cleaner attribution, scoped credentials also limit the blast radius. An agent that authenticates as itself, with its own permissions, can only do what that service account is authorized to do. If the agent is compromised, misconfigured, or makes an unexpected decision, the damage is bounded by the service account's permission set. An agent running on a user's token can do anything that user is authorized to do in every connected system, which is typically far more than any agent should be able to do autonomously.

Stage 1
Uncontrolled deployment

No governance baseline

Agents run on user credentials, take actions with no classification, have no escalation path, and cannot be rolled back. All agent actions are attributed to the triggering human. The first audit or incident starts from scratch with no documentation. Governance must be reconstructed retroactively, action by action.

Stage 2
Partial governance

Attribution and inventory in place

Agents have their own service account credentials, and an action inventory classifies reversible and irreversible tool calls. Basic HITL checkpoints exist for irreversible actions, though without adequate context in the approval prompt. The audit trail attributes agent actions correctly. Escalation routing and rollback procedures are still missing, and oversight design needs work.

Stage 3
Full governance baseline

Auditable, reversible, governed

All five decisions in place before go-live. Each agent authenticates with its own scoped service account. HITL checkpoints provide context, reasoning, and an override option for every irreversible action class. Every stuck state routes to a named owner with a tested notification path. Rollback procedures are documented and exercised in staging before the agent ships. Governance sign-off sits alongside functional testing as a go-live requirement.

The enterprise AI agent governance checklist

This checklist covers the governance documentation and design decisions an organization should have in place before any agent that takes external-facing or system-modifying actions reaches production. These are the records most likely to be requested in an audit and most likely to be absent when the organization built the agent to accomplish a task and treated governance as a later concern.

Enterprise AI agent governance checklist
Action inventory: every tool call classified as read-only, reversible write, or irreversible write before deployment.Produce a table of every tool the agent can invoke. For each tool, document the system it affects, whether its action can be undone (and how), whether it has an external recipient or audience, and what authorization is required for the action to be taken. Read-only tool calls need no additional controls. Reversible writes should be logged with before-state captured. Irreversible writes or external-facing actions require either a human authorization checkpoint or a documented justification for why autonomous action is acceptable for that specific tool call. This document is what an auditor will ask for when they want to understand the agent's decision envelope. Producing it at deployment time is significantly easier than reconstructing it after an incident.
Agent-scoped credentials: each agent authenticates with its own service account, not the triggering user's token.Provision a service account for each agent workflow. Grant it the minimum permissions required to complete the workflow and nothing beyond that. Document the permission set and the justification for each grant. Configure every tool call to authenticate as the service account. Verify in the downstream systems' audit logs that agent actions appear under the agent service account identity, not the user identity. Run this check before go-live by triggering the agent in a test environment and reviewing the audit logs in every connected system. This is the only way to confirm that attribution will work correctly in production, because many enterprise integrations silently fall back to user credential delegation when service account configuration is incomplete.
HITL checkpoint design: human approval prompts must show the agent's reasoning, the data it reviewed, and the alternatives it considered for every irreversible action class.For each irreversible tool call identified in the action inventory, design the human approval checkpoint to include: a plain-language description of what the agent intends to do and why; the specific data or documents the agent reviewed to reach that decision; at least one alternative the agent considered and rejected, with the reason it was rejected; and an explicit override option that allows the human to substitute a different action or stop the workflow entirely. The checkpoint should time out to a hold state, not an automatic approval, if the human does not respond within the defined window. Log the human's decision, the information presented to them, and the timestamp. This log is the evidence of meaningful human oversight. An approval log that records only “approved” and a timestamp does not demonstrate that oversight in the sense regulators mean the term.
Escalation routing: every stuck state has a named owner and a defined resolution process, documented before go-live.Map every error condition and unresolvable decision state the agent can reach. For each, define who receives the escalation, what information they receive, what they are expected to do, and within what time window. For workflows with regulatory deadlines, the escalation time window must be short enough that the resolution can be completed before the deadline even if the escalation fires at the last moment. The escalation routing document should be reviewed by the compliance or operations team, not just the engineering team, because the routing decisions have process and liability implications beyond the technical scope of the agent. Update the routing document whenever the agent's workflow changes. An escalation path that was correct at launch may no longer be correct six months later if the team structure or process has changed.
Rollback procedure: for each irreversible action class, document the specific steps needed to reverse or remediate a completed agent action before go-live.For each irreversible tool call in the action inventory, write the rollback or remediation procedure before the agent reaches production. For actions that can be technically reversed (record updates, file writes), implement a before-state capture that makes reversal possible, and test it. For actions that cannot be reversed (sent emails, completed financial transactions), document the remediation process: who is notified, what communication goes to affected parties, what manual correction is needed in which systems, and who has authority to execute the remediation. Test the rollback procedure in a staging environment before go-live. The 88% of organizations that say they cannot roll back agent actions without disrupting their systems are largely in that position because rollback was never designed; the agent was stopped and manual remediation was invented case by case. The documentation is not just for auditors. It is what the team will need to work from when they are under time pressure after an incident.
Governance sign-off as a go-live gate: no agent that takes external-facing or system-modifying actions reaches production without governance documentation reviewed and approved by a named compliance or operations owner.Add a governance review to the agent's deployment checklist alongside functional testing. The review should confirm that an action inventory exists, that agent-scoped credentials are verified in the audit logs of every connected system, that HITL checkpoints provide adequate information for the oversight standard the deployment context requires, that escalation routing has named owners and tested notification paths, and that rollback procedures have been tested in staging. The reviewer should be from compliance, legal, or operations, not from the engineering team that built the agent. When governance documentation is built as part of design rather than retrofitted after build, a review takes hours, not weeks. Organizations that treat the gate as bureaucratic overhead are usually the ones reconstructing governance retroactively after an incident.
“88% of organizations cannot roll back agent actions without disrupting their systems. That is not a capability problem. It is a design problem. Rollback was never on the requirements list.”

What to do this week

Inventory every agent in production and classify its tool calls

Start with a list of every agent or agentic workflow your organization currently runs in production. For each one, list every tool it can invoke and classify each tool call as read-only, reversible write, or irreversible write. This exercise will almost certainly surface tool calls that the team did not think of as irreversible when they built the agent. The most common surprises are email sends, messaging platform notifications, CRM record updates, and API calls to vendor systems. This exercise exists to find out which of your current agents are taking actions that cannot be undone, with no documented procedure for what happens if something goes wrong.

Check the audit logs of your connected systems to see whose identity agent actions are logged under

Pick the two or three connected systems your most active agent integrates with and pull the audit logs for the past week. Find actions you know were taken by the agent and check what identity they are attributed to. If they appear under a human user's name, your attribution is broken and those logs will not support a compliance defense that separates human judgment from autonomous agent action. This check takes less than an hour and answers a question most teams do not know the answer to until an audit forces it.

Review your most recent HITL approval prompts and ask whether they provide enough context for a human to actually make a decision

For each approval checkpoint in your agents, review what information is shown to the human approver. Ask: if a regulator reviewed this approval log, would they conclude that the human had enough context to exercise meaningful oversight? If the prompt shows only an action name and a yes/no button, the answer is almost certainly no. Adding the agent's reasoning, the data it reviewed, and an explicit override option to the prompt design is usually a few hours of engineering work. That change is typically a few hours of engineering work, and the difference between an approval log that demonstrates oversight and one that demonstrates only that a human was present.

Document the rollback procedure for your highest-risk agent action before this week is out

Pick the one agent tool call that would cause the most damage if it executed incorrectly at scale: the email send, the payment trigger, the record update that feeds downstream systems. Write down, in plain language, what happens if that action fires incorrectly on 100 records: who is notified, what manual steps are taken in which systems, who has authority to execute those steps, and what gets communicated to affected customers or counterparties. This is not a legal document and does not need to be comprehensive to be useful. The goal is to have an answer ready before the incident forces an improvised one, because improvised remediation after an agent incident is always slower, more expensive, and harder to defend in an audit than a procedure that was written and tested before the agent went live.

Let 10decoders govern your AI agent workflows before the first incident

We produce action inventories, agent credential architecture, HITL checkpoint designs, escalation routing maps, and rollback procedures for enterprise agentic workflows. Our AI engineering practice has built governed agent deployments for healthcare and FinTech organizations where compliance review is part of the production gate, not an afterthought. We deliver governance documentation that holds up to audit review, not just internal review.