Understand It
An AI agent is no longer just generating an answer.
It can search your systems, read customer data, call APIs, create records, make decisions, and perform actions on someone's behalf. Once an agent can do these things, your systems need to know which agent is acting, what it is allowed to do, and who it is acting for.
Consider a customer using a travel application. They ask an assistant to find flights for an upcoming trip. The assistant searches available flights and returns the options. The customer selects one and asks the assistant to book it.
To the customer, this is one conversation. To your backend, however, the two actions can represent different identity situations:
- The agent searches for flights using its own authority.
- The agent books a flight on behalf of the customer.
That distinction matters. Your APIs need to be able to tell not only what happened, but also which agent performed the action and whose authority it was using.
The Problem
Giving an agent an existing API key gets its first request working. But when several agents share that credential, your services cannot reliably tell them apart. Running those agents raises questions that the shared key cannot answer:
- Onboarding
How do teams collect the details each agent needs? A booking assistant needs an owner and customer sign-in settings; a fare monitor needs a different setup. Missing details end up in tickets or spreadsheets.
Identity and accountability
Which agent made the call, and who owns it? Shared credentials leave logs naming an application instead of the individual agent responsible for the action.
Access and credentials
An agent allowed to search bookings should not automatically be able to cancel them. Its access needs limits, and a leaked credential needs to be replaced without disrupting other agents.
Delegation
Is the agent acting for itself or a customer? A booking request needs to identify both the person who authorized it and the agent carrying it out.
Access to the agent
Who can use its capabilities? An assistant that reaches private systems must check its callers, not accept every request sent to it.
Autonomous work
Who authorizes a scheduled run when nobody is signed in? The agent still needs its own identity and defined permissions to call protected services.
These are not separate problems. They all come back to one fundamental requirement:
An agent that can act in your system needs an identity of its own.
How It Works
AgentID management gives each agent a distinct identity that your systems can recognize, authenticate, authorize, and trace.
Instead of treating an agent as an extension of another application or user, the identity layer registers the agent as its own principal. The agent gets credentials of its own, and its access can be controlled through the roles and permissions associated with that identity.
The agent schema defines the information your organization needs, such as the model provider each agent runs on. A configurable onboarding flow brings those fields into Console creation and controls the steps that collect and validate them. Teams can use a dedicated path for agents that act on their own or collect the extra settings needed to act for users.
As requirements change, you can update the schema and onboarding flow. The required information is collected where the agent is registered, and the agent service validates the resulting record. See Create and Manage Agents for configuration.
When the agent calls a protected API, it presents a token issued for that identity. Your services can then make authorization decisions based on what the token represents rather than trusting information supplied by the agent itself.
The identity represented by the token depends on how the agent is acting.
When the agent acts on its own, the agent is the subject of the token. The receiving service can determine that the request came from that specific agent and authorize it according to the agent's permissions.
When the agent acts on behalf of a user, the token can represent the user as the subject while identifying the agent as the actor. This lets a service answer both questions at once:
- Who authorized the action? The user.
- Who performed the action? The agent.
This distinction is important for both authorization and accountability. Your services can enforce the appropriate permissions while retaining a clear record of the agent involved in the operation.
Each protected service can verify the token itself or rely on the identity layer to validate it, and then authorize the request based on the identity and permissions represented by the token.
The result is an identity model where agents are no longer anonymous pieces of application logic. They become manageable, independently identifiable principals with controlled access and traceable actions.
- Your users sign in to a consumer application and no agent is involved: see Secure Consumer Access to Your Application.
- You are protecting a Model Context Protocol (MCP) server rather than an agent: see Securing MCP.
- Your customers bring their own AI assistants to call your APIs: see Let Customers Bring Their Own AI Assistant.
None of this is a proprietary protocol. It is standard OAuth2 and OpenID Connect, so the token your services already know how to verify is the token an agent presents. By the end of this section you will have agents registered with their own credentials, roles that decide what each one may reach, and APIs that authorize every call against the token it presents.