Agentic AI ContainmentLong read
How to Evaluate AI Agent Permissions, Audit Trails, and Pause Controls
A vendor checklist for agent permissions, audit trails, and pause controls.
Publication desk · · 13 min read · Updated

When you let an AI agent act on your data, standard access controls break down fast. This post explains what to look for in a platform before you deploy. It also gives you a plain checklist of questions to ask vendors.
Why the old way of controlling data access breaks when AI agents act on their own
- Traditional data controls were built for humans. AI agents break every assumption those controls rest on.
- Four things about agents make human-focused controls fail:
- Agents run continuously. Access given in January may still be active in August. The original reason for it may be long gone.
- Agents work at machine speed. A compromised agent can copy records before a daily check even begins. Monthly or quarterly reviews are useless.
- Agents have no judgment. They cannot tell the difference between data they were meant to reach and data they simply have permission to reach.
- When multiple agents work together, data flows in unpredictable ways. A compliance agent might pull in unmasked personal data from another agent's output. That can break privacy law even if no single agent went beyond its own permissions.
- The problem is not bad intent. It is bad architecture. Giving an agent instructions reduces mistakes, but it does not strictly prevent them. Neither instructions nor standard access controls reliably catch an agent crossing a data boundary by combining two separately permitted steps.
- Three failure patterns come up most often in security reviews:
- Shared credentials — one service account stands in for many real users, so everyone's access collapses into one
- Audit gaps — no record of which query came from which agent or user
- Scope creep — small permission increases that add up over time, until the agent can reach data nobody ever intended it to reach
- CData's governance guide identifies the shared service account — a single login standing in for real user identities — as the single pattern that stalls the most pilots in security review.
Why these controls are now a legal requirement, not just good practice
- The EU AI Act moves agent governance from internal policy into enforceable law. It applies to high-risk AI systems — those that make or support decisions that affect people's rights, safety, or access to services.
- Article 14 of the EU AI Act requires human oversight for high-risk AI systems. It becomes enforceable on 2 December 2027 for standalone high-risk systems listed in Annex III. This date was set by the Digital Omnibus regulation.
- Key frameworks that now shape what platforms must do:
- NIST AI Risk Management Framework — a US government standard that organises governance into four functions: govern, map, measure, manage. These map directly onto the runtime controls described below.
- GDPR (EU privacy law), HIPAA (US health data law), NAIC (US insurance standards), and SR 11-7 (US banking guidance) each carry specific audit-trail and access-control requirements. Platforms must be able to show they meet them.
- The EU AI Act, NIST AI RMF, and ISO/IEC 42001 (an international AI management standard) are the main compliance frameworks that governance platforms are measured against.
- In regulated industries — insurance, financial services, healthcare — AI that cannot explain its decisions is no longer acceptable. KPMG's 2026 research found 75% of large-enterprise leaders say security, compliance, and auditability are the most critical requirements for agent deployment. Regulators demand that any decision can be examined by a human auditor.
- Data sovereignty means data is subject to the laws of the country where it is held. Cloud region choices and on-premises hosting are how organisations put that into practice. US-incorporated providers remain subject to CLOUD Act demands regardless of where their servers are.
- Governance costs are operational costs. They are not optional extras. Every identity must be set up, protected, and retired. Every policy decision may need computation and logging. Every record must be stored, indexed, and retrievable.
Permissions: what controlling access must actually do at the moment an agent acts
- A production agent needs two identities checked before any action runs. The first is the agent's own identity. The second is the identity of the human user whose work the agent is doing. A single shared login fails both security and auditability.
- What real permissions control looks like in practice:
- Each user's login token (the credential that proves who they are) is stored separately. It is refreshed automatically. It is kept away from the AI model, so the model never sees it.
- For actions that change data, the platform asks for approval at the moment the action is needed — not at the start of the session.
- Before any action runs, the platform checks three things: what the user is allowed to do, what the agent is allowed to do, and what the specific task permits. This check happens at the moment of action, not just at login.
- The ability to read data and the authority to change data are kept separate. Changing data requires a distinct approval step.
- When these controls are missing, AI operates across cloud services, software tools, developer pipelines, and company data at the same time. Separate per-tool controls cannot keep up with that surface area.
- Scope creep means an agent's access quietly expands beyond what its task requires. Each small grant looks harmless. The total adds up to an agent reaching data no one ever authorised.
- Before you connect an agent to any data source, three things must already be in place. First, a central identity system — such as Microsoft Entra ID or Okta, which manage who is allowed to do what — using standard login protocols so agent queries inherit the real user's identity. Second, a named data owner and a sensitivity label for each data source. Third, role-based access controls at the source itself. Governance applied after connection governs nothing.
- Arcade.dev's 2026 platform comparison identifies the key question as where authorisation is enforced. Gateways and wrappers connect agents to tools. But a runtime — the layer where credentials are checked, permissions are confirmed, and policies are applied — is the actual control point for a specific user, agent, tenant, resource, and task.
- When you compare platforms on permissions, test three things separately. Does authorisation fire at the moment of action using the full context? Are credentials stored per user and refreshed automatically? Do consent and approvals happen at the moment they are needed for actions that change data?
Audit trails: recording why an agent acted, not just what it touched
- Traditional logs record what data was accessed. Agent governance requires more. You need to record why the agent accessed it, what reasoning step came before the action, and what decision resulted. Without that chain of reasoning, a log cannot satisfy a regulator or reconstruct what went wrong.
- Every agent action log must contain, at minimum:
- A unique identifier for the agent and its version — so behaviour is linked to a specific model and setup, not a generic "AI"
- The specific permissions granted for that run — separate from the agent's standing access
- The specific tool or interface used
- The governance policy decision — allow or deny — and which policy triggered it
- The reasoning step the agent produced before acting — this is what turns an access log into a decision record
- Superblocks' 2026 governance platform review identifies Fiddler AI's approach — recording every agent action and decision to produce audit evidence aligned with GDPR, HIPAA, NAIC, and SR 11-7 — as representative of audit-grade evidence trails for regulated industries. The key point is that enforcement is added on top of visibility, not substituted for it.
- In multi-agent environments the requirement grows. When agents call other agents, the trail must follow data across the whole chain. Auditing only the final action is meaningless if the steps that produced its inputs are unrecorded.
- Some enterprise AI platforms build and keep a connected record of business meaning across existing systems — a context graph. For these platforms, decision records that link evidence, recommendations, human reasoning, approvals, actions, and measured outcomes (including failed or inconclusive results) form the institutional memory. They let future decisions draw on what the organisation already knows. They also keep estimates separate from observed results.
- A fair objection: storing, indexing, and retrieving full reasoning traces at scale is expensive. But this cost is part of the true cost of a governed deployment. It is not optional overhead. The alternative is an incident that cannot be reconstructed.
Pause and revoke controls: stopping an agent before harm happens, not after
- Pause and revoke controls are only real governance when they are built into the workflow at defined decision points before deployment. Adding them to a running agent after the fact is incident response. It is not governance.
- Two distinct ways to intervene, each suited to different risk levels:
- Human-in-the-loop (HITL): certain actions pause until a named person approves. Use this for consequential, irreversible, or high-value operations.
- Human-on-the-loop (HOTL): lower-stakes actions continue under supervision while stop controls stay available. Use this for recurring work where delay matters.
- Both modes can run inside the same workflow. The design question is which actions belong in which category. That is set by risk level, policy rules, or how confident the system is.
- What pause and revoke controls must include at the platform level:
- Approval gates that can be set per action type — not a single on/off switch for the whole agent
- An agent inventory with live telemetry — you must see what every agent is doing before deciding to pause it
- Credential revocation that takes effect immediately and can be verified — suspending an agent that still holds live credentials is not a real suspension
- Log preservation on pause — the audit trail must be intact the moment the agent stops, not assembled afterward
- A named person accountable for decisions that fall outside the configured rules
- The main objection is that approval steps bring back the delay that automation was meant to remove. The answer is that pausing is proportionate to risk. Routine actions run under supervision. Sensitive operations pause for explicit approval. Friction matches consequence.
- You should be able to start with read-only access — looking and recommending only — then authorise actions step by step as quality and value are shown. That staged approach is itself a governance control, not a limitation.
- Governing agents from outside vendors or external frameworks running inside your workflows is a harder, specific requirement. Not all platforms handle it. Ask vendors directly whether pause and revoke controls extend to agents you did not build.
How the three controls depend on each other — and where platforms fail in between
- Permissions, audit trails, and pause controls are not three independent features. Each depends on the others. A platform that enforces permissions at session start but logs nothing at execution time gives you the appearance of governance, not the reality. The same is true if it pauses actions but cannot revoke the credentials behind them.
- Where platforms fail in the joins between controls:
- Permissions without audit trails: the agent stays within its defined scope, but you cannot show that to an auditor or trace a decision. The log exists at the identity layer but not at the reasoning layer.
- Audit trails without pause controls: the platform records everything but can only report after the fact. Detection without prevention is not enough for high-risk actions.
- Pause controls without fine-grained permissions: an approval gate pauses the agent, but it passes through an over-broad credential. Once approved, it still runs with excess access.
- All three controls present but not connected: governance policies exist in a document but not in the path the query travels. They enforce nothing at runtime.
- The multi-agent case is where disconnected controls are most costly. When agents direct other agents, each hand-off is a potential gap. A platform must enforce permissions, log reasoning, and preserve pause controls across the full chain — not only at the entry point.
- CData's governance guide states it plainly: governance that lives in a policy document but not in the path the query travels governs nothing. Controls must apply at the moment the model processes a query and produces an output.
- Some platforms keep company context — the connected record of business meaning, decision history, rules, and permitted actions — separately from any specific AI model. This means you can swap models and agents without rebuilding the governance layer. New models inherit the company's knowledge and rules without needing to be re-authorised from scratch. This is a structural advantage.
Where you run the platform — and why that changes what governance can actually enforce
- The deployment model sets the ceiling on what governance controls can actually enforce. Your choices are shared cloud, a private cloud environment (VPC — a section of cloud infrastructure reserved for one organisation), or your own servers. Data sovereignty, credential isolation, and custody of audit logs all depend on where computation happens and who controls the infrastructure.
- The guiding principle: bring the model to the data, not the data to the model. Run the AI model inside the region or environment where the data already lives, rather than moving the data out.
- Three deployment tiers and what they mean for governance:
- On your own servers: the strongest guarantee. Audit logs, credentials, and model files never leave your infrastructure. The operational burden is highest. This is right for defence, intelligence, and the most tightly regulated industries.
- Private cloud environment (single-tenant VPC): achieves the same compliance outcome as on-premises for most regulated industries. The operational cost is a fraction of running your own servers. This is the right choice for most enterprises with genuine regulatory mandates.
- Shared cloud (managed, multi-tenant): lowest operational burden. Governance controls depend on the vendor's enforcement architecture. This is right where regulatory requirements are less strict, or where the vendor provides contractual and technical isolation guarantees.
- Using an open-weight AI model — one whose parameters are publicly available — does not, by itself, set network policies, protect credentials, restrict administrator access, or control where usage data goes. The model choice is one part of the boundary. It is not all of it.
- SOC 2 Type II (an independent audit confirming a vendor's security controls work over time) is the main sign that a vendor has had its governance controls externally verified. HIPAA alignment and GDPR alignment are shown through internal documentation and contracts — a Business Associate Agreement and a Data Processing Agreement respectively — not through formal external certification. Verify these against the specific deployment tier you are buying, not the vendor's broadest offering.
- Arcade.dev's platform comparison maps deployment options — shared cloud, hybrid or private servers, private cloud environment, air-gapped (fully disconnected from the internet), and enterprise self-hosted on Kubernetes (a standard system for managing software containers) — to specific authorisation enforcement capabilities. It shows that deployment model and governance capability must be evaluated together.
- If you are evaluating platforms that work across different AI models and data systems, the deployment decision should let you swap AI models and agent frameworks without rebuilding the governance layer. New models should inherit the company's connected knowledge, business rules, decision history, and permitted actions without full re-authorisation.
A plain checklist for comparing platforms before you deploy
- Test each dimension with a specific, verifiable question. Do not rely on a vendor's documentation claim. Confirm it in a trial or technical review.
- Permissions — questions to put to every vendor:
- Where exactly is authorisation enforced — at login, at the gateway, or at the moment of action using the full context?
- Does the platform store each user's credentials separately, refresh them automatically, and keep them away from the AI model?
- Are read access and write or execute permissions separated, with distinct approval steps for actions that change data?
- Can the platform ask for consent for new access scopes at the moment they are needed, without requiring a new session?
- Audit trail depth — questions to put to every vendor:
- Does the log capture the reasoning step the agent produced before acting, or only the tool call it made?
- Are logs structured with agent identifier and version, permissions granted for that run, and the policy decision (allow or deny)?
- Can you retrieve audit logs and show them to a regulator without vendor assistance?
- In workflows with multiple agents, does the trail follow data across all hand-offs, or only log the final action?
- Pause and revoke controls — questions to put to every vendor:
- Can approval gates be set per action type, or is pause a single on/off switch for the whole agent?
- Does credential revocation take effect immediately, and can you verify it — not just see it recorded?
- Do pause controls extend to agents from outside vendors running inside the platform?
- Is there a named person accountable for decisions that fall outside the configured rules?
- Integration of the three controls — the hardest question:
- Do permissions, audit logging, and pause controls operate in the same execution path, or are they separate layers that can fall out of sync?
- If the AI model or agent framework is swapped, do the governance controls transfer automatically, or must they be rebuilt?
- Deployment model verification:
- Ask for the SOC 2 Type II report specific to the deployment tier you are buying, not the vendor's broadest offering.
- Confirm that custody of audit logs stays with you, not the vendor, across all deployment options.
- Start with one named workflow, an accountable owner, and a measurable outcome. Do not try to govern the full agent estate at once. Agree the baseline, success measures, and measurement period. Confirm the controls work for that workflow. Then expand. Usage numbers alone do not confirm that governance is working.
Sources
Filed underAgentic AI Containment
More in Agentic AI Containment
How to Decide What AI Agents Can Access and Change
Workflow Authority Editorial Desk
How to Keep a Record of Who Can Approve What in AI Workflows
Workflow Authority Editorial Desk
How to Assess AI Agent Blast Radius Before Going Live
Workflow Authority Editorial Desk


