
AI agents are becoming identities in their own right, and Zero Trust for them comes down to one shift: trust has to be decided on every tool call, against the agent, the person asking and the task. Not once at login.
Three lines that show where agent access is going
The clearest picture of agent access we’ve seen this year fits in three lines. It’s how Claude Tag handles access when Claude works inside shared Slack channels:
- Shared credentials. The agent has its own accounts in each system, provisioned by an admin, instead of borrowing a user’s.
- Policy per compartment. Admins set what the agent can reach for the whole workspace, then widen or narrow it channel by channel.
- On behalf of the user in DMs. In a direct message, the agent runs on that person’s own connections and credentials.
The reasoning holds up. Agents now run long tasks on their own, well after the person who asked has logged off, and in a shared channel several people steer at once. No single user’s permissions are right every time. So the agent stops borrowing an identity and becomes one, with its own audit trail and one place to revoke it.
It also moves the hard question. When access belongs to the channel, a member who can’t open a repo can still ask the agent to read it, if the channel grants that. Anthropic says so openly and names what comes next: one-time approval for a single sensitive action, and a check that lets the agent act only when both the channel’s policy and the requester’s own permissions allow it.
That next step is the right one, and it is what Zero Trust for agents looks like in practice. Anthropic’s Zero Trust for AI Agents framework explains why it matters: traditional access controls won’t stop an agent from misusing permissions it legitimately holds. The token is valid, the policy allows the call, and the call is still wrong.
The session is the wrong unit of trust
Zero Trust was built around a moment: someone signs in, proves who they are, and gets a session. For people, that works. A person makes a few dozen access decisions a day, at human speed, and a quarterly review can keep up with how their role changes.
An agent has no single moment. It makes thousands of decisions per session, picks its own tools, and chains calls across systems in seconds. Often it acts for someone who isn’t watching. Verifying it once at the start and trusting the rest is the same mistake Zero Trust was meant to end, moved inside the session.
Three identity threats every team already knows look different on an agent’s clock:
| Threat | For people | For agents |
|---|---|---|
| Weak authentication | SSO and MFA at sign-in | Static keys and shared secrets: whoever holds the key is the agent |
| Credential sprawl | Vaults and PAM | Keys pasted into code and tool configs, long-lived and often unowned |
| Excessive privilege | Access reviews every quarter | Broad access granted up front, and a shared agent holds everyone’s |
None of these threats is new. What changed is the clock. A quarterly review cannot govern access that should live for minutes.
Six practices that move trust to the tool call
If the session is the wrong unit, the call is the right one. These six practices put that into operation, whatever agent platform or model you run.
- Every agent has a human who answers for it. An agent without an owner is a standing credential nobody will ever review. Ownership should come from real signals, such as HR data, activity and approval chains, and move automatically when the builder changes teams or leaves.
- An agent acts with the overlap of its owner’s and its invoker’s authority, never the sum. A shared agent that can do anything any of its users can do is the most privileged identity in the company. When Dana asks it for something, it should be able to do only what Dana and the agent are both allowed to do.
- Grant from the task, not the role. Scope each grant to the task in front of the agent, read from the evidence behind it: the ticket, the request, the approval. Not from what the agent says it will do. That is intent-based access, with the intent backed by a person. Let the grant end when the task does. A time limit on a broad grant is still a broad grant. When access is easy to get for the right task, nobody has a reason to over-ask.
- Let routine work flow and make risky calls wait. Decide each call against the task it serves (does this call fit the ticket?), the owner, the invoker and the session’s risk. Allow, narrow, or route it to a person. A control that blocks everything gets bypassed. A control that stops only the calls that matter gets used.
- Make the kill switch real. Ending a session should mean the agent can no longer reach anything: its key rotated, its tokens dead, everywhere at once. If stopping an agent takes a ticket per platform, you don’t have a kill switch.
- Put every call on record. For every action, you should be able to answer three questions in seconds: which agent acted, who asked, and why it was allowed. That record is your audit trail and your incident response.
Intent-based access: whose intent counts
Intent-based access scopes each grant to what the work actually requires. The question is where that intent comes from.
It can’t come from the agent. An agent’s plan is only as trustworthy as its inputs, and a prompt injection rewrites the plan without touching the agent’s credentials. If scope follows what the agent says it will do, a hijacked agent writes its own permissions, because the attacker writes the plan.
So intent has to come from evidence a person stands behind: the ticket, the access request, the approval. The agent can propose. The ticket decides. When an agent working a ticket to update one project’s docs reaches for the finance share, the call doesn’t fit the task, and it waits for a person.
Every control depends on one question: who should have what
Blocking a call is the easy part. Any proxy can say no. The hard part is knowing when to say no, and that depends on facts no gateway holds on its own.
The two-sided check Anthropic plans for Claude Tag, and practices 2, 3 and 4 above, all need the same inputs: what the task actually requires, and what the agent’s owner and its invoker are entitled to and really use. Point tools each hold one piece. Discovery tools see the agents. Gateways intercept the calls. Vaults hold the keys. None of them knows who should have what.
That is an identity governance question, and it existed long before agents. If your people hold access they haven’t used in a year, an agent acting for them inherits it. If no one knows who owns a service account, no one knows who owns the agent running on it. Agents didn’t create these gaps. They made them impossible to ignore.
So Zero Trust for agents can’t be solved at the agent layer alone. It has to sit on the same identity model as the people and machine identities the agents act for, built from real activity rather than granted entitlements.
How Oak delivers the framework’s identity controls
Anthropic’s framework sets out its controls in three tiers: Foundation, Enterprise and Advanced. Oak delivers the ones that are identity and access problems at heart, on the same activity-based identity graph it runs for your people and machine identities. Not only who has access, but who should.
Agent identity and authentication
The framework asks for a distinct identity for every agent, tracked from creation through retirement, and short-lived tokens in place of static keys. Oak finds every agent across Copilot Studio, Bedrock, Agentforce, n8n and the agents your engineers build, and records the identity each one borrows. Each agent is followed through its lifecycle: provisioned on request, re-owned when people move, retired when unused. Session-scoped tokens carry only what the agent needs for the task.
Access control: permission models
The tiers move from deny-by-default roles, to context-aware policies that weigh a risk score, to authorization at every action instead of at session start. Oak works at that last tier. It acts as the policy decision point for every tool call, weighing the task behind it (the ticket or request that started the work), the agent’s owner, its invoker, the session’s risk score and the identity graph, then allowing the call, blocking it or routing it to a person. Ask an agent to update one project’s docs from a Jira ticket, and it gets that project’s Drive folder, not the whole Drive.
Access control: privilege scoping
The framework starts with removing unused permissions, then adjusts privilege to the task, and at the top tier revokes access automatically when the task ends. Oak right-sizes from real usage, with the agent’s own usage as evidence: a reporting agent with write access to every finance table becomes read-only on the one table it uses. Access is intent-based: scoped from the ticket or request behind the work, and the token carries nothing after the task. Elevation runs through the approval flow you set: automatic, based on the agent’s inputs, based on session risk, or with a human in the loop.
Tool access and credentials
The framework’s implementation workflow asks you to allow-list tools per agent, pause high-risk calls for human review, and be able to cut off an agent’s credentials at once. In Oak, you decide who can request which agent, on which platform, with which tools, and every request is checked against that policy before the agent goes live. Risky calls wait for a person, and the decision is on record. One click ends a session: Oak rotates the agent’s key, and it can no longer reach anything.
Observability and traceability
The framework asks for a record of every tool invocation with the agent’s identity and the request context, linked back to the event that triggered it. Every tool call in Oak is on record: which agent made it, who invoked it, and in which session.
AI governance policies
The governance controls ask who approves agent deployments, how you handle shadow AI, and how policy moves from periodic review to continuous enforcement with an audit trail of decisions. Oak brings SaaS, homegrown and custom agents into one inventory, including those built outside any approval process, and ties each to an accountable owner from HR feeds, activity and approval chains. One policy in Oak governs every agent’s tools and permissions across every platform, enforced at the point you choose or through a pre-tool-call hook. No rebuilt agents.
Every change is explained, approved by your team, reversible, and on record.
{{small-cta}}
Five questions to test your agent program
If you can answer all five today, your Zero Trust program reaches your agents. If you can’t, start with the first one you miss.
- Pick any agent. Who answers for it, and what happens to it when that person leaves?
- When two people use the same agent, does it act with each person’s access, or with everyone’s?
- How long does an agent hold access after its task ends?
- Which tool calls wait for a human, and who decided which ones?
- If an agent goes wrong right now, how many minutes until it can reach nothing, and can you show every call it made?
Zero Trust for agents won’t be won at the perimeter, or at the login. It is won one tool call at a time, by knowing who should have what.
Discover related posts


