How to give AI agents identities and permissions
Give each AI agent its own identity, delegate rather than impersonate when it acts for a user, and grant short-lived, task-scoped access.
By Sycamore.
Key takeaways
- Each AI agent should have its own identity, separate from the people who use it and from shared service accounts, so its actions can be attributed and its access revoked without affecting anything else.
- When an agent acts for a person, use delegation that records both the person and the agent, not impersonation, where the agent simply becomes the user.
- Agents should hold no standing access. Grant credentials just in time, for one task, for a short period and for a specific service.
- Decide whether an agent may take an action in a policy layer outside the model. Instructions and guardrails in the prompt are not an access control.
- Every agent identity needs a named owner, a place in a registry, a review schedule and a tested way to disable it.
To give AI agents identities and permissions safely, issue each agent its own identity, separate from the people who use it and from shared service accounts, and manage that identity through its own lifecycle with a named owner. When an agent acts for a person, use delegation that records both the person and the agent instead of letting the agent log in as the person. Grant access just in time, scoped to one task, one service and a short period, decide each action in a policy layer outside the model, and log the agent’s identity and the delegation behind every action.
Why do AI agents need their own identities?
An agent without its own identity cannot be told apart from the people or systems whose credentials it borrows. That breaks attribution, least privilege and revocation at once.
Government security agencies now say so directly. Joint guidance from the cyber security agencies of Australia, the United States (CISA and NSA), Canada, New Zealand and the United Kingdom, often called the Five Eyes, says developers “should construct each agent as a distinct principal, a cryptographically anchored identity with its own unique keys or certificates”.1 The same guidance warns that attackers can steal an agent’s keys or tokens when organizations keep them static, share them across multiple agents or protect them poorly, and then act under a trusted agent identity in ways that evade audit controls.1
An initial set of design tenets for agent identity management that NIST proposed in October 2026 makes the same point about lifecycle: “Agents should have an identity, credential, and access management lifecycle distinct from human principals.”2 Agents are created, changed and retired far faster than employees, and they do not authenticate the way people do. Microsoft’s documentation for its agent identities notes that agents may exist for minutes during a single task, and that the identity model is “designed for scale and ephemerality rather than permanence”.3
Should an agent use its own identity, a service account or the user’s login?
Use the agent’s own identity when it acts on its own authority, and delegated access when it acts for a specific person. Avoid shared service accounts and never give an agent a person’s password or session.
| Approach | When it fits | Main risk |
|---|---|---|
| Agent’s own identity | Background or autonomous work for a team or process | Over-broad standing permissions if not scoped per task |
| Delegated access for a user | The agent acts for one person, within their rights | Losing track of who acted if the token does not record both parties |
| Shared service account | Rarely; legacy systems that support nothing else | Many agents look like one, so no attribution and no targeted revocation |
| The user’s password or session | Never | The agent becomes the user, with all their rights and none of the record |
Major cloud platforms now offer dedicated agent identities. Microsoft Entra Agent ID lets an agent act autonomously with access rights given to the agent identity, or act on behalf of a user with rights the user delegates.3 Amazon Bedrock AgentCore Identity implements agent identities as workload identities and supports both the OAuth 2.0 client credentials grant for machine-to-machine access and the authorization code grant for user-delegated access.45 Google Cloud’s Agent Identity gives each agent a cryptographic identity based on the SPIFFE standard and, unlike service accounts, these identities are not shared by multiple workloads by default and cannot be impersonated.6
How should an agent act on behalf of a user?
Use delegation, not impersonation. The difference is defined in OAuth 2.0 Token Exchange (RFC 8693): with impersonation, the acting party becomes the user for the purposes of the token; with delegation, the acting party “still has its own identity separate from” the user, and its actions are understood as taken on the user’s behalf.7 The same RFC defines an “act” (actor) claim that expresses in a token “that delegation has occurred” and identifies who is acting.7
The OpenID Foundation’s 2025 paper on identity management for agentic AI recommends that “user impersonation by agents should be replaced by delegated authority”, with a token that identifies both the user and the agent acting for them.8 In practice:
- Record both parties. The token and the log carry the user and the agent as separate identities.
- Cap the agent’s authority. The agent can do no more than the user delegated, and no more than the agent itself is approved to do.
- Narrow it down the chain. When an agent hands work to another agent, authority can only shrink. NIST’s tenets state that “downstream entities can never claim more authority than the parent”.2
- Let the user see and withdraw consent. A person who delegated access should be able to see which agents hold it and revoke it.
How do you keep agent permissions to a minimum?
Give agents no standing access and issue credentials per task. NIST’s tenets put it as zero standing privilege, where agents hold “no persistent rights when idle”, and say that “all access grants are Just-In-Time (JIT), time-bounded and audience-specific”.2 The Five Eyes guidance recommends replacing static, long-lived secrets with ephemeral credentials that expire when the job is complete, and requiring just-in-time credentials for high-impact or privileged actions.1
Concretely:
- Scope by task. Grant only the operations, resources and time the current task needs, then let the grant expire.
- Bind tokens to one service. A token issued for one service should not work at another. The Model Context Protocol specification makes authorization optional, but when an HTTP-based MCP server implements it, the server must validate that access tokens were issued specifically for it and must not accept or pass on any other tokens.9 For token passthrough and the other risks specific to MCP servers, see how to secure and govern MCP servers that AI agents use.
- Keep secrets out of agent code. Use short-lived credentials from a platform that verifies the workload. Google Cloud, for example, issues agent certificates that are valid for 24 hours and renewed automatically.6
- Stop agents from granting themselves access. The Five Eyes guidance recommends prohibiting agents from modifying their own privileges or initiating unapproved delegation without explicit expiry timers and recorded grant chains.1
Where should permission decisions be made?
Outside the model. A model can be steered by the content it reads, so a rule written into an agent’s prompt is not a control. NIST’s tenets call for architectural separation of policy from reasoning and state plainly: “Guardrails alone are insufficient.”2 Check each request in the systems the agent calls, or in a gateway in front of them, against the agent’s identity, the delegating user and the approved scope. For the wider runtime controls around this, see how to govern AI agents in production.
Some actions also need a person. NIST’s tenets describe risk thresholds that, when reached, trigger human review, and warn that approvals can become routine through consent fatigue.2 Reserve human approval for actions that are hard to undo, so reviewers still look at what they approve.
How do you manage an agent identity from creation to retirement?
Treat an agent identity like any other privileged account, with a faster cycle:
- Register it. Every agent identity belongs in a registry with its owner and approved scope. The Five Eyes guidance recommends a trusted registry that binds identities to authorized roles, regular reconciliation against the agents actually running, and denying access to any agent not in it.1 For building one, see how to find and inventory every AI agent in your company.
- Name an owner. The UK’s National Cyber Security Centre advises being clear about “who owns an agentic system, who approves its access, who monitors its behaviour”.10 Microsoft, for example, records the person who creates an agent in Copilot Studio as its sponsor.3
- Review access on a schedule and whenever the agent’s scope, tools or model change.
- Keep a record. Log the agent’s identity, the delegation behind each action and the result, in storage the agent cannot change. NIST’s tenets call for an append-only body of evidence kept independent of the agent.2
- Disable it cleanly, and test that you can. Revocation should cut off every credential the agent holds at once, and retiring an agent should remove every grant it held. Platforms differ here: Microsoft says agent identities can be retired without leaving orphaned credentials or permission assignments behind,3 while on Google Cloud, deleting an agent leaves the IAM bindings that reference it in place as inactive grants until you remove them.6 Rehearse the disable step before an incident needs it.
Which standards apply to agent identity?
Existing identity standards do most of the work, and agent-specific guidance is still being written. OAuth 2.0 and its extensions, such as token exchange, cover delegation.7 SPIFFE, a set of open-source standards for identifying software systems, defines short-lived cryptographic identity documents that platforms such as Google Cloud use for agents.116 NIST’s National Cybersecurity Center of Excellence published a concept paper in February 2026 on applying identity standards to software and AI agents, covering identification, authorization, auditing and non-repudiation.12 In the IETF, the WIMSE working group’s AI Identity Management System draft proposes best practices for authenticating and authorizing AI agent interactions using existing standards; it is a draft, not a finished standard.13
Where Sycamore fits
Sycamore Govern is an AI governance control plane that gives every agent an identity, with model, tool and data access routed through policy. Approval gates and scoped controls bound high-impact actions, and an agent’s authority expands through evaluations and operating evidence, then contracts when behavior or policy changes. Govern can stop an agent by revoking its identity, pausing execution, removing a connection or blocking model and tool paths, and records who acted, why and what changed.
For teams building agents, Sycamore Build defines identity, access, testing, review and release standards once in a workspace blueprint, and connects to existing systems through approved connectors, APIs and MCP tools while respecting the organization’s identity, permissions and data boundaries.
Frequently asked questions
Can an agent use the API key of the developer who built it?
It should not. A developer’s key carries the developer’s permissions, which are usually broader than the agent needs, and every action the agent takes is logged as the developer’s. When the developer changes role or leaves, the agent either breaks or keeps access it should have lost. Issue the agent its own identity and credentials, separate for each environment, and revoke any access it inherited from its builder.
Do AI agents need multifactor authentication?
Not in the human sense. An agent cannot respond to a push prompt or a passkey request. The equivalent is strong, short-lived cryptographic credentials, such as certificates or tokens bound to the agent and the service it calls, issued by a system that verifies where the agent is running. Keep human multifactor authentication for the people who approve, own and administer agents.
What should we do about agents already running under shared service accounts?
Move them one at a time, starting with the agents that have the broadest access. Give each agent its own identity, grant it only the permissions its current task needs, switch it over, and watch for failures that reveal access you missed. Then remove the agent’s use of the shared account, and retire the account once nothing else depends on it. Until then, record which agents use it so an incident can be traced.
How does a person withdraw access they delegated to an agent?
The same way they would for any app they granted access, by revoking the consent or grant in the identity provider or the service that issued it. Revoking consent may not end access tokens the agent already holds, so keep their lifetimes short. Give people a single place to see which agents act for them, and revoke delegations automatically when someone changes role or leaves.
Sources
-
Australian Signals Directorate’s Australian Cyber Security Centre, CISA, NSA, Canadian Centre for Cyber Security, NCSC-NZ and NCSC-UK, “Careful adoption of agentic AI services”, https://www.ncsc.govt.nz/assets/guidance/Documents/Careful-adoption-of-agentic-AI-services_FINAL.pdf
-
NIST, “Design Tenets for Agent Identity Management Systems”, Cybersecurity Insights blog (October 27, 2026), https://www.nist.gov/blogs/cybersecurity-insights/design-tenets-agent-identity-management-systems
-
Microsoft Learn, “What are agent identities?”, Microsoft Entra Agent ID documentation, https://learn.microsoft.com/en-us/entra/agent-id/what-are-agent-identities
-
AWS, “Provide identity and credential management for agent applications with Amazon Bedrock AgentCore Identity”, https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/identity.html
-
AWS, “Features of AgentCore Identity”, Amazon Bedrock AgentCore Developer Guide, https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/key-features-and-benefits.html
-
Google Cloud, “Agent Identity overview”, IAM documentation, https://docs.cloud.google.com/iam/docs/agent-identity-overview
-
IETF, “RFC 8693: OAuth 2.0 Token Exchange” (January 2020), https://www.rfc-editor.org/rfc/rfc8693.html
-
OpenID Foundation, “Identity Management for Agentic AI” (October 2025), https://openid.net/wp-content/uploads/2025/10/Identity-Management-for-Agentic-AI.pdf
-
Model Context Protocol, “Authorization”, specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization
-
UK National Cyber Security Centre, “Thinking carefully before adopting agentic AI” (May 15, 2026), https://www.ncsc.gov.uk/blogs/thinking-carefully-before-adopting-agentic-ai
-
SPIFFE, “SPIFFE Overview”, https://spiffe.io/docs/latest/spiffe-about/overview/
-
NIST NCCoE, “Accelerating the Adoption of Software and Artificial Intelligence Agent Identity and Authorization”, concept paper, initial public draft (February 5, 2026), https://csrc.nist.gov/pubs/other/2026/02/05/accelerating-the-adoption-of-software-and-ai-agent/ipd
-
IETF, “AI Identity Management System (AIMS)”, draft-ietf-wimse-aims-01 (November 2, 2026), https://datatracker.ietf.org/doc/draft-ietf-wimse-aims/