As AI agents move from chat interfaces to autonomous system actors, traditional identity models break. AAM provides a framework to manage machine-speed risks, ensuring agents operate with ephemeral, task-specific least privilege that can't be bypassed via prompt injection.
For the last twelve years, enterprise security has moved away from trusting the network. BeyondCorp made the case that a request's origin, inside the corporate perimeter or on the open Internet, should not decide whether it is allowed. Identity and device health should. That model won: it now underpins much of Zero Trust.
Google’s BeyondCorp assumed a specific principal: a human at a device, acting at human speed. Organizations are now deploying agents, software principals that reason, act, and reach into systems on our behalf. A task-scoped agent run is ephemeral. It ends when its work is done. A long-lived agent service may handle many such tasks and move data far faster than a person.
The controls we built for humans do not fail loudly when we point them at agents. They fail quietly, by granting too much, seeing too little, and trusting for too long.
This paper proposes an access model for agents: the Agent Access Model (AAM). We describe the model and show how its components can be built. We then walk through a concrete example and separate the single-principal controls available today from the harder problem of multiplayer access control.
Much of the current work tries to make each access decision smarter. AAM takes a different approach: make the agent's capability smaller, so there is less to judge in the first place.
A decade ago, the hard question in enterprise security was where is this request coming from, and do I trust that place? BeyondCorp's answer was that you should not trust the place at all. You authenticate the user, interrogate the device, and make an access decision for that specific request. Location became one signal among many, not a verdict.
That reframing worked because the principal was legible. A human logs in each morning, carries a device or two, works at human speed, and generates a trickle of access decisions a system can reason about. We built an entire industry around that shape of principal: single sign-on, device posture, conditional access, session risk scoring.
Agents do not have that shape.
An agent service may run many tasks. In this paper, an agent is one task-scoped run. We use task execution graph for all work belonging to that run and governed by the same capability ceiling and trust level. The same harness solving a different task, consuming a different event, or running on tomorrow's schedule creates a new graph. A single human instruction (reconcile these two ledgers, triage the overnight alerts, open a pull request that fixes this bug) can dispatch one or more such tasks. Each may need to reach databases, source control, logs, ticketing systems, knowledge bases, documents, or spreadsheets. The task may need broad access. It needs it now, for this task, and ideally not one second longer.
An agent must have enough authority to complete its task and no more. Least privilege is as old as access control. What changes is how quickly and often it must be enforced. For a workforce of humans, least privilege is often a policy reviewed every quarter. For large populations of short-lived agents, it is a system that runs in real time and leaves an audit trail.
Agents look like service accounts or very fast users. Four properties make both sets of controls a poor fit.
Agents are ephemeral. Credentials are durable. Service accounts were designed for long-lived software: a payroll system, a nightly batch job. They often come with long-lived keys, broad scopes, and rare rotation. Applied to short-lived agents, those credentials outlive the work they were issued for and remain in memory, logs, or environment variables where they can be replayed. The lifetime of the credential should match the lifetime of the task. For an agent, that is often minutes.
Agents act at machine speed. Anomaly detection, rate limits, and data-loss controls tuned for human activity may react too slowly. An agent with a database connection and an outbound network path can read a table and POST it to an external endpoint before a human-tuned control has finished sampling. Preventive controls therefore have to run inline, at the point of action.
The prompt is not a perimeter. Teams commonly tell an agent do not access production or never send data to third parties. Those instructions help shape behavior, but they do not enforce access. A model can be manipulated by content injected into the data it reads or can produce an unsafe action on its own. Inferred intent can inform a risk decision, but an attacker can shape that signal through the same text. Enforcement belongs in the harness that mediates tool calls and at the network layer that mediates packets. A boundary you can talk your way past is not a boundary.
Agents compose authority across hops. An agent can invoke a tool that invokes another agent, which calls an API on behalf of the original human. Somewhere in that chain, the answer to who is this for, and what are they allowed to do can disappear. Existing primitives handle a single hop of delegation better than they handle many hops or several humans.
The Agent Access Model starts with one rule: Do not trust the run. Authorize every action against the task and its accumulated state.
BeyondCorp removed implicit trust from the network. AAM removes implicit trust from the task execution graph. Authorization for one action does not carry over to the next. Every action is evaluated against three things: who the agent is, what task it was authorized to perform, and which policy-relevant resources the graph has already touched. That accumulated state can only reduce the graph's remaining capabilities.
Google's Beyond Zero makes the same opening move: shrink the trust boundary from the application to the individual action and make the decision at machine speed. Beyond Zero puts a reasoning engine behind each authorization decision. AAM bounds the capability set that engine must judge. The two approaches fit together. For actions that cross a declared mediation boundary, AAM records the agent, principal, and task behind each authorization decision.
AAM has five principles.
1. Credentials are short-lived and bound. An agent receives a credential minted for the task and expiring with it. Tokens are sender-constrained, so a stolen token alone cannot be replayed without the harness-held proof key.
2. Enforcement lives in the harness and the network, not the prompt. Policy is applied where tool calls and network requests actually happen. The prompt is where you express intent. It is never where you enforce a boundary.
3. Human oversight is exceptional. Approvals are reserved for decisions that warrant them. A person to approve every step creates fatigue and reflexive clicking.
4. Grants are reviewed from evidence. Directly captured activity can show where a task template is too broad or too narrow. The system proposes a change for review, and an approved change applies to future tasks. It never widens the active task.
5. Capability state moves in one direction. When a declared protected event occurs, the Trust Ratchet removes capabilities across the task execution graph according to policy. Authority removed by the Trust Ratchet returns only in a newly authorized task.
The architecture has four active controls and two supporting systems. The active controls govern the task. The Agent Activity Log and Grant Review Loop operate on the evidence it leaves behind. AAM defines how these pieces fit together and what each one must guarantee. This is a reference architecture, not a wire-level specification.
At dispatch, the Agent Identity Broker issues a short-lived, verifiable credential scoped to the task. That credential expires no later than the task ends.
The credential is task-scoped: it encodes "this is agent X, acting for principal H, to do task T." It is also sender-constrained, bound to a proof key held by the harness. A leaked token alone cannot be replayed without that key, and the model never receives it.
Existing standards provide both primitives. OAuth 2.0 Token Exchange (RFC 8693) defines an exchange through a Security Token Service and can produce a token narrowed by audience, resource, or scope. The authorization server's policy determines what it issues. The token's act claim identifies the current actor, while nested act claims can retain prior actors for attribution. DPoP (RFC 9449) binds an OAuth token to a client key and requires proof on each protected request. That proof covers the HTTP method and target URI, but not the request body, query parameters, or tool arguments. The harness must therefore authorize an immutable request representation and execute that same request.
Neither standard defines AAM's task template, Trust Ratchet state, or cross-layer enforcement. AAuth draft 09 addresses agent-to-resource identity and authorization, including per-instance identity, optional missions, tool permissions, audit, and asynchronous authorization. It could realize part of this model and remains a work in progress. AAM depends on four properties of the credential: it is short-lived, task-scoped, sender-constrained, and attributable. It does not depend on one protocol winning.
The credential establishes who the agent is and which task it is performing. The Task-Scoped Access Engine decides, per request, whether this identity may perform this action against this resource. It extends BeyondCorp's Access Control Engine by making the task itself a first-class input to the decision.
Its job is to make least privilege both the default and the ceiling. A task grant might read: "agent X, for task T, may read tables A, B, and C for the next ten minutes." That is the envelope. Undeclared actions are denied.
Where does the envelope come from? A task's scope is declared when the agent is dispatched, not negotiated by the agent at runtime. In the common case, a human or a system acting on a human's standing authority defines a task template once: "Reconciliation may read these three tables and post to this channel." Each dispatch instantiates it. Templates are the unit of configuration, so the number of policies tracks the number of distinct tasks rather than the number of runs. At dispatch, the Access Engine intersects the approved template with the authority of the initiating principal and agent service, then applies resource-owner and tenant policy. That intersection is the task's capability ceiling. The agent can ask for less, and the Trust Ratchet can remove capabilities. Broader authority requires a newly authorized task.
For each action, the adapter constructs and freezes the complete request representation, including the operation, resource, arguments that affect scope, tenant, and recipient. The Access Engine authorizes that representation against the current capability ceiling, and the adapter executes the same representation. Credential renewal revalidates the original ceiling and current Trust Ratchet state. It cannot restore a removed capability or extend the maximum task lifetime.
The Mediation Layer governs two boundaries: the tool paths exposed by the harness and outbound traffic forced through the deployment's network boundary.
The first is the harness, the runtime that brokers the agent's tool calls. It intercepts calls through declared tool paths, checks them against task policy, and emits enforcement events, subject to the collection gaps described in Section 4.6. The harness can distinguish a read from an update and constrain the arguments that affect scope. MCP standardizes requests over defined transports and supplies an OAuth resource-server boundary for HTTP transports. Its authorization layer does not define AAM's per-tool or argument policy. The harness or tool server must enforce that. A remote MCP server remains a separate enforcement boundary with its own downstream access and egress.
The second is the network layer, the egress path the agent's connections take. A perfectly mediated set of tool calls means nothing if the agent can still open an arbitrary socket to the Internet. Network-layer controls decide which destinations and protocols are reachable for traffic routed through them, including traffic from child processes and delegated runtimes. The network can usually see destination and transport attributes. It can enforce an HTTP method, tenant, recipient, or application operation only when the protocol exposes that information or traffic terminates at a trusted mediation point.
A harness earns the name only if it enforces. Its default is deny: a tool call is allowed because the task-scoped policy names it, not because the agent asked for it. The same discipline applies at the network layer. MCP step-up authorization also stays inside the task's capability ceiling. A scope challenge cannot restore a capability removed by the Trust Ratchet or add authority to the active task.
The two enforcement points fail differently. A request that exploits a harness bug should still meet network policy. A network misconfiguration should not grant tool access. The two implementations should fail independently where possible, although they share task policy and Trust Ratchet state. That control plane is a common dependency and must fail closed.
The Trust Ratchet makes trust stateful. Its primary purpose is to limit data exfiltration. "Trust" is shorthand for what the task execution graph can still do, not a judgment about the model's intent or reliability. Like a ratchet, its capability state can only narrow during the task.
Policy declares up front the protected events that engage the ratchet, the restrictions applied by each transition, and the components that must observe the new state. A protected read might remove external destinations while preserving a narrowly typed internal output. Another task might narrow database scope after a particular class of query.
A graph can start in a restricted state. Before credentials, tools, or egress are enabled, dispatch policy evaluates initial prompts, restored memory, and transferred inputs. A task with unknown or unclassified inputs starts restricted or fails closed.
We initially built data-loss controls for people, who leak data at human speed and in human quantities. An agent that has read a system of record while retaining an outbound path can exfiltrate data at machine speed. The Trust Ratchet narrows that path before releasing the sensitive response. What "narrower" means is named by the policy, not left to the agent or the model to interpret. For the network, it may be a destination allowlist. For data, it may be a narrower resource or query scope. The axes are declared up front, so an operator can see exactly which capabilities each transition removes.
Parallel work makes this more than a simple two-state transition. The harness holds the response until all enforcement points adopt the new state. The state store uses compare-and-set or a single writer to serialize updates. Each component stops using the old state, clears cached decisions, and acknowledges the new version. Harnesses cancel or drain old work. Network enforcement closes or reauthorizes persistent connections. The harness releases the response only after all acknowledgments arrive. Any conflict, timeout, error, or missing acknowledgment blocks the response. The transition fails closed.
The same rule applies to streams. When classification is known, the transition completes before the stream begins. If classification depends on the returned content, the response stays buffered until classification and transition finish. The restricted state applies to the whole task. Work that needs a removed capability starts as a newly authorized task across a fresh isolation boundary. Protected data may enter that task only through a dispatch input classified at least as restrictively as its source. The dispatcher initializes the new graph in that state unless an authorized declassification step produces a lower classification.
The Trust Ratchet gives operators a deterministic capability boundary they can inspect and test. It does not prove that every permitted output is safe. Destination policy, recipient scope, typed operations, and payload constraints still matter. A broad ratchet policy will deny benign activity along with malicious activity, especially while classifications and destination policies are coarse. Those denials are evidence for refining the next task template.
Least privilege has always had an operational problem. Someone has to decide what "least" means. Policy owners may over-grant to avoid support tickets. For large populations of short-lived agents, hand-tuning permissions one run at a time is impractical.
The Grant Review Loop uses activity captured by the enforcement points to review task templates against actual runs. It asks two questions:
- Is this task template over-permissioned? A grant has gone unused across many successful runs. Propose revoking it.
- Is this task template under-permissioned? A recurring denial correlates with failed work, and the task definition and resource owner support the request. Propose widening it, with the evidence attached.
Repeated denial alone proves very little. An attacker can repeat a forbidden action until it looks routine, while an unused permission may cover a rare recovery path. The loop attaches that evidence to a recommendation for a policy owner. Approved changes apply only to future task templates. The active task keeps its original ceiling and Trust Ratchet state. The policy an auditor reads is the policy that runs.
Agent activity is hard to reconstruct from ordinary application logs. The Agent Activity Log is an append-only, queryable record of activity captured by the Identity Broker, Access Engine, harness, Trust Ratchet state store, and network enforcement point. It does not depend on the model's account of its own behavior.
A SIEM remains the destination for these records. The gap is at the source. Agent activity is often emitted by application code outside the enforcement path, in a shape that does not distinguish a read from a delete or connect an action to the person on whose behalf it was taken. The Agent Activity Log's contribution is a common event contract fed by external control points and built for the questions an investigation actually asks.
Agents are instrumented software. Their records can contain information about people, customers, and other organizations. Those records remain subject to applicable privacy, access, retention, and data-governance requirements. Useful logging does not require wholesale capture of prompts, reasoning, responses, or packet contents. How much of the record an organization keeps, who may read it, and for how long remains a policy decision.
Authoritative enforcement evidence cannot depend solely on model self-report. An attacker can influence the model's account through the same inputs that influence its actions. Model-produced reports may supplement events emitted by external control points. They cannot replace them.
A useful record preserves two distinctions. First, it records whether each covered action read, created, updated, or deleted data, and the scope it touched. An agent that read ten thousand records is a very different risk from one that modified ten thousand. Second, it ties each covered enforcement event back to the task and its initiating principal or effective authority, so that "what did this agent do?" and "what has been done on behalf of this person?" are both answerable within the recorded boundary. The Agent Activity Log turns that part of an incident from an archaeology project into a query.
Each record identifies the task execution graph, task template, initiating principal, current actor, enforcing component, operation, requested and resolved scope, resource or destination, policy result, Trust Ratchet version, outcome, and correlation identifiers. When the resource reports them, the record also includes returned scope, classification evidence, and bytes transferred.
Coverage follows the mediation boundary. The harness can record the operations and arguments it mediates. The network can record connections it observes, often without application payload semantics. Encrypted traffic, activity outside the boundary, and telemetry failures create collection gaps that deployments should make explicit. Deployments should minimize sensitive payloads, restrict access to the log, and define retention. If tamper evidence is required, the storage system must provide it.
Use a security-event schema supported by the target SIEM. OpenTelemetry can carry and correlate the events, including its developing conventions for generative AI and agent activity. The Open Cybersecurity Schema Framework can normalize security-relevant records for analysis. Both can reduce integration work. AAM still needs a common event contract across them.
The six components form an active path and a supporting path. At dispatch, the Access Engine establishes the capability ceiling and the Identity Broker issues a task-scoped credential for that ceiling. During execution, the Access Engine, Mediation Layer, and Trust Ratchet decide what the graph can still do. Their directly captured events flow to the Agent Activity Log, and the Grant Review Loop uses that record to propose changes to future task templates.
The active controls – Access Engine, Identity Broker, Mediation Layer, and Trust Ratchet – live outside the model. The Agent Activity Log and Grant Review Loop are supporting systems outside the request path. Prompt text confers no credentials or authority. Within the mediated paths described in Section 4.3, it cannot widen a task grant or reverse the Trust Ratchet. That guarantee depends on execution and traffic being unable to bypass mediation and on the shared control plane failing closed.
The Access Engine, harness, and network therefore have to share the current task identity, capability ceiling, and Trust Ratchet state. A programmable network and compute platform can place credential issuance, tool mediation, egress, and the Trust Ratchet in the path the agent already takes, at machine speed.
The components also need a shared vocabulary. Grants, narrowing steps, and log entries should use the same names for operations, resources or destinations, scope, task, and state version. A common event contract can then correlate the Access Engine, Trust Ratchet, and Agent Activity Log and expose mismatches.
Take a routine agent task. A finance team runs a nightly reconciliation agent. On a schedule, it collects a settlement report from an approved processor API, compares it with two production ledgers, and posts a short summary to a messaging channel. A vendor-support operation handles defined exceptions. The task is boring, useful, and touches a system of record. A bad configuration can turn a routine read into a data leak.
A trusted adapter validates and stores the structured result, then returns a server-generated opaque identifier bound to the task and tenant. post_reconciliation_summary(result_id) accepts only that identifier and posts the stored result to the fixed finance channel. The result follows a fixed schema limited to reconciliation status and numeric aggregates, with a size limit and no free-text field. The model cannot bind the identifier to arbitrary bytes.
Nothing here relied on the model behaving. Within the deployment boundary, the processor and support paths close before protected data reaches the model, and the task has no generic output tool. The design still cannot prevent leakage through a compromised approved destination, an overbroad output schema, or a path outside mediation.
Many teams equate safety with a human approving every consequential step.
Put a human in the loop at every turn and approval becomes routine. The person faces a stream of prompts, most of them benign. Before long they click approve without reading because almost every prompt is harmless. We have run this experiment before: Windows User Account Control asked users to confirm so many actions that the prompt became noise. An approval that is always granted is not a control. It is a ritual that trains people to ignore the one prompt that matters.
AAM keeps oversight selective and meaningful. Task-scoped enforcement lets actions inside the envelope proceed and denies actions outside it. Human judgment is reserved for creating or changing a task template, or releasing a high-risk action that policy already placed inside the current capability ceiling. That approval names a fixed resource, scope, and lifetime. It does not widen the ceiling.
An action outside the ceiling, or one removed by the Trust Ratchet, requires a newly authorized task across a fresh isolation boundary. A person cannot clear the restricted state of the active task. The Grant Review Loop can help identify which future template changes deserve review. Humans stay in the loop for questions worth their attention, and their no still means something.
The single-principal case assumes a clean chain: a human authorizes one task, and the agent acts within that authority. RFC 8693 can represent the current actor and retain a nested chain of prior actors. Standards already provide many of the identity and delegation primitives needed for the single-principal case. The Trust Ratchet, cross-layer mediation, and common event contract remain AAM architectural requirements rather than existing standards.
We are not comfortable saying that multiplayer access control can be built end to end today.
Picture an agent that serves a shared workspace, a channel, or a team. It acts for Alice and for Bob, and they have different permissions. Alice can see revenue data. Bob cannot. The agent summarizes a thread that draws on a source only Alice can read, and then Bob asks it a question. What is the agent allowed to say? If it answers from Alice's data, it has leaked across a boundary the organization drew on purpose. If it refuses anything either party cannot see, it is limited to their common grant, reducing what it can do in shared context. Caching makes it worse: an answer computed under Alice's authority and reused for Bob is an authorization bug, not a performance optimization.
We call this the multiplayer access control problem. Actor chains, AAuth's may_act claims, and per-principal scopes provide useful building blocks. None carries item-level authority and provenance through retrieval, shared model context, generation, caching, and delivery. Recent work formalizes multi-user agents as a multi-principal decision problem and reports unstable prioritization under conflicting objectives, increasing privacy violations over multi-turn interactions, and coordination bottlenecks.[9] CI-Work reports privacy-violation rates of 15.8% to 50.9% and leakage up to 26.7% in simulated enterprise workflows.[10] We do not know of a widely deployed end-to-end system that closes the whole chain.
One direction is to treat the agent's context as labeled data: each retrieved item, tool result, and cached answer retains the authority and provenance under which it was obtained. The serving path would compare those labels with the entitlements of the person asking now, before data enters context and again before output leaves it. Enforcement cannot rely on the model to preserve those labels through generation.
AAM does not claim to solve this problem. Its current boundary is a task execution graph governed by one effective authority fixed before dispatch. Shared agents can isolate work per principal or use a conservative common grant, at a real cost to shared context and utility.
BeyondCorp removed implicit trust based on network location: the goal of AAM is to extend that rule to the task: authorization at dispatch is not enough.
A short-lived task needs a short-lived credential. Enforcement belongs in the harness and the network, where it can act on the operation that will run. Protected data should trigger declared restrictions before that data reaches the model. The agent is instrumented software. The people represented in its context retain their privacy rights, and their data remains subject to governance requirements. Evidence should inform reviews of least privilege, and human approval should be spent on decisions that warrant it. Multiplayer access control remains an open systems problem.
Start with one bounded agent that touches a system of record: the nightly reconciliation job, log triager, or pull-request bot. Make two changes: give it a short-lived, task-scoped credential instead of a standing key, and route its declared tool paths through harness enforcement and every outbound connection through network enforcement. Turn on the Agent Activity Log. Use that to scope granular credentials and access based on the observed behaviour of that agent.
Organizations already make these decisions whenever they deploy an agent. AAM makes the boundaries explicit, so an implementation can enforce them at machine speed, record every covered authorization decision, and show where coverage was incomplete.
1. R. Ward and B. Beyer. BeyondCorp: A New Approach to Enterprise Security. USENIX ;login:, Vol. 39, No. 6, December 2014.
2. M. Jones, A. Nadalin, B. Campbell, J. Bradley, and C. Mortimore. OAuth 2.0 Token Exchange. RFC 8693, January 2020.
3. D. Fett, B. Campbell, J. Bradley, T. Lodderstedt, M. Jones, and D. Waite. OAuth 2.0 Demonstrating Proof of Possession (DPoP). RFC 9449, September 2023.
4. Model Context Protocol. Authorization. Specification revision 2026-07-28.
5. J. Valente and M. Zalewski. Beyond Zero: Enterprise Security for the AI Era. May 2026.
6. D. Hardt. AAuth Protocol. draft-hardt-oauth-aauth-protocol-09, work in progress, July 4, 2026.
7. Open Cybersecurity Schema Framework. OCSF.
8. OpenTelemetry. Generative AI semantic conventions.
9. S. Yang, S. Zhu, H. Zhu, J. R. Enríquez, D. Wang, A. Pentland, M. A. Bakker, and J. Pei. Multi-User Large Language Model Agents. March 2026, revised April 2026.
10. W. Fu et al. CI-Work: Benchmarking Contextual Integrity in Enterprise LLM Agents. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics: Industry Track, July 2026.
Continue reading on the original blog to support the author
Read full articleTraditional bot defense is a losing game of static rules vs. agile attackers. Adaptive Intelligence shifts the focus to economic deterrence, using non-deterministic models and continuous retraining to make bot operations too expensive and feedback-poor to sustain.
This feature automates the alignment between edge-enforced bot policies and robots.txt directives. It ensures AI crawlers respect training preferences without manual file maintenance, preventing discrepancies that lead crawlers to ignore site preferences or impact search visibility.
As AI agents move from simple chatbots to autonomous actors, developers need specialized infrastructure for security, orchestration, and observability. Cloudflare's new primitives and Zero Trust extensions provide the necessary framework to build and manage these agents at scale.
As AI agents become primary web consumers, engineers must shift from human-centric UIs to machine-readable interfaces. These open standards prevent platform lock-in, reduce compute costs, and provide robust frameworks for agent identity, discovery, and payments.
