Skip to main content

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.

A person
Only when the agent acts on someone’s behalf
Your AI agent
Identity layer
Everything about the agent’s identity, in one place
Registers the agenta principal with its own credential and owner
Decides what it may reachthrough the roles you assign it
Issues its tokensnaming the agent, the person, or both
Asks for a token for this call
Minted by the identity layer
Signed token
who is acting, and on whose authority
Sent with the tool call
Verified, then authorized against what it carries
Your APIs
the tools the agent calls

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.

Not Your Pattern?

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.

Explore with AI

ThunderID LogoThunderID Logo

Product

DocsAPIsSDKs
© Copyright Linux Foundation Europe.For web site terms of use, trademark policy and other project policies please see https://linuxfoundation.eu/en/policies.