Data Capture for Communications Governance

Why Every Agent Action Needs an Identity Chain

Share with your network!

Ask your personal assistant agent to find time with a colleague next week, and more happens behind the scenes than you might expect. The assistant delegates the request to a scheduling agent, the scheduling agent calls the calendar agent your IT team built for every agent in the company to share, and a few seconds later the meeting is booked. Three agents took part, none of them was you, and each one decided on its own what to do next.

Now picture that same chain when something goes wrong. If one of those agents deletes the wrong meeting or writes to a calendar that isn't yours, your security team needs to know who did it and whether it should ever have been allowed, and if you swap the calendar for a CRM full of customer records, the stakes climb quickly. Identity chaining is how you answer both questions. With each request, it propagates the identity of the user or event that started the work along with the identity of every agent in the delegation chain, so attribution is preserved across the entire delegation chain.

To see why agents need this when traditional applications never did, start with how applications have always handled identity.
 

Traditional Applications Never Needed to Propagate User Identity

Most enterprise applications connect to the systems behind them with a service account. An application that works with SharePoint, for example, usually gets broad access to SharePoint and then decides for itself what each user may do, checking its own role-based access control (RBAC) before it reads or writes anything. That model has served enterprises well because the application is deterministic. Whether a finance analyst or a sales rep clicks the button, the code follows the path its developers wrote, and those developers decided in advance which users could trigger which actions. The application never had to propagate the user's identity to downstream systems, because its own authorization logic enforced the limits.
 

Agents Lose the Originating User's Identity after the First Delegation

Agents start the same way applications do, with a trigger. Sometimes a user invokes the agent directly, and sometimes an incoming email or another event starts an autonomous workflow with no user involved at all. After the trigger, the resemblance ends. An agent decides which tools to call and which data to access, and a goal-oriented agent plans its own path entirely, delegating parts of the task to other agents that make their own choices and may call still more agents in turn. A single request can become a loop inside a loop inside a loop, following a path no developer wrote in advance, which is why AI agents and traditional applications present different attack surfaces.

That difference has a direct consequence for identity. Give each of those agents a service account, the way enterprises have always provisioned applications, and every agent holds every permission its credential grants, at every step, for every user who invokes it. The shared calendar agent can edit any calendar in the company, so whether it edits yours or your CEO's depends entirely on what the agent above it asks for, and that agent knows only what its own caller sent it. Without identity propagation, each agent sees only its immediate caller, and the originating user's identity is lost after the first delegation. It's the classic confused deputy problem, repeated by every agent in the chain, and it leaves security teams unable to say who was behind an action or to hold an agent to what that user was allowed to do.
 

Identity Chaining Preserves Every Identity in the Delegation Chain

Identity chaining solves this by propagating identity to every agent in the delegation chain. When you invoke your assistant, the token it sends downstream identifies you and the assistant. When the assistant calls the scheduling agent, the next token identifies you, the assistant, and the scheduling agent. By the time the request arrives at the calendar agent, the token contains the full delegation chain, so the calendar agent knows on whose behalf it is acting and which agents delegated the request to it. An autonomous agent builds its chain the same way, starting from the triggering event and its own identity instead of a user.

None of this requires new identity infrastructure. Every time you sign in to a cloud console, an identity provider authenticates you and the console checks what you are authorized to do, and agents rely on the same identity providers and OAuth flows. The difference is that each agent behaves like an application in its own right, so a chain of agents amounts to a chain of applications calling one another on someone's behalf.

The standards are maturing quickly. OAuth 2.0 Token Exchange (RFC 8693) already defines an actor claim that records when one party acts on behalf of another, and nesting those claims expresses a full delegation chain. There is a catch worth knowing about, though. RFC 8693 treats every actor before the current one as informational only, so a resource deciding whether to honor a request evaluates only the subject and the current actor, and the intermediate agents play no part in the access decision. The IETF OAuth working group's Identity and Authorization Chaining Across Domains draft preserves a user's identity and authorization information across trust domains, so a downstream resource can tell on whose behalf a request started and what was authorized, and the Identity Assertion JWT Authorization Grant (ID-JAG) applies the same approach through the enterprise identity provider. Newer drafts, including one for cryptographically verifiable actor chains, go further and make the entire chain authoritative for authorization decisions, which is exactly where multi-agent workflows need the standards to go.
 

Every Agent Action Needs Full Attribution

The first payoff shows up the moment something goes wrong. Suppose customer data turns up in a Telegram channel. Without an identity chain, the log entry points to whatever credential the agent used, usually a shared service account that belongs to no one in particular or the user whose session the agent borrowed. You know what happened and which credential was involved, but not which agent did it, what invoked that agent, or who set the workflow in motion.

With the chain intact, the audit trail tells the whole story. A specific user started the job, a specific agent picked it up, that agent invoked a handful of subagents, and the record shows which subagent accessed the customer data, which tools it called, and where it sent the result. Responsibility lands on a named entity, whether that entity is a person, an agent, or the event that triggered an autonomous workflow, and each action is attributed to both the human who initiated the workflow and the agent that executed it, because those are distinct actors with distinct accountability.

Attribution also keeps an investigation from blaming the wrong party. Agents can be manipulated through indirect prompt injection, misled by tool poisoning, or thrown off course by their own reasoning errors, and when one of them goes rogue, the chain shows which agent took the action, on whose behalf it acted, and every downstream step that inherited the request. Security teams can separate the agent that deviated from the user who made a perfectly reasonable request and from the agents that faithfully did what they were asked.
 

Effective Permissions Can Only Narrow with Each Delegation

The second payoff is authorization, and this is where the calendar agent earns its keep. When the request includes the full delegation chain, the authorization server for the target resource can evaluate the request against everyone in it. The user and each agent have their own provisioned permissions, and the effective permissions for the request are the intersection of all of them, so access can narrow with each delegation and never expand. It's least privilege applied to the entire delegation chain rather than to one identity at a time.

Go back to that shared calendar agent, which can create and delete meetings on any calendar in the company. When your assistant calls it through the scheduling agent, the chain shows the work belongs to you, so the calendar agent operates only on your calendar, even though the scheduling agent could serve anyone. Now suppose marketing puts a lead-generation agent on the website so prospects can book a call. Those visitors are anonymous, and the lead-gen agent was provisioned for a single resource, the marketing team's calendar. Every request it sends downstream inherits that scope, so no visitor, however creative the prompt, can talk the calendar agent into accessing the CEO's calendar. It's the same calendar agent with very different powers, and the difference comes entirely from the identities upstream in the delegation chain.

The same rule holds for individual actions. If you can read and write your calendar and every agent in the chain can too, the request can read and write, on your calendar only. If you can only read, a request that passes through an agent with write access still gets read-only access, because delegating to an agent never escalates your privileges. And if an agent built only to read calendars shows up in a chain that is trying to write, the request fails. That failure is a useful signal in its own right, since an invalid combination of identities and actions is one of the clearest signs that an agent has been manipulated or has strayed from its task.

Identity chaining pairs naturally with just-in-time (JIT) authorization. JIT starts every agent with zero standing privileges and grants task-scoped access only when the workflow's intent justifies it, and the identity chain makes the result provable. You can show that each agent acted on behalf of another agent that acted on behalf of the user, and that no agent along the way held more access than the user's task required.
 

Delegation Chains Are Starting to Cross Trust Domains

So far the chain has stayed inside one company, and even there it rarely stays in one place. One agent may operate on an employee's endpoint, another on a low-code agent platform, and a third on a cloud service such as Amazon Bedrock, each authenticating to different systems through different identity providers. Endpoint, network, and cloud security each have partial visibility into that chain, and none of them sees all of it. A partial chain can't attribute an action or constrain a permission, which is why the full delegation chain has to be captured wherever each agent operates.

The chains are about to get longer, too. Personal assistant agents already act on behalf of consumers, and agentic commerce is the next step. Within the next year or so, we expect assistants to stop browsing travel sites and start talking to airlines' and travel providers' own agents, querying several at once, negotiating, and offering $9 for the $10 fare to see who says yes. Every business on the receiving end of those requests needs to know which agent is asking, whom it acts for, and what that person authorized it to do.

Businesses that can't get a verifiable answer will simply say no. When United Airlines restricted third-party AI agents on November 11, it drew the line at "unauthorized" personal agents and cited the exposure that comes from sharing account credentials with outside tools, along with the risk of purchases and account changes nobody intended. Separating authorized agents from unauthorized ones, at the volume agents generate, is the problem identity chaining across trust domains is built to solve.
 

Identity Tells You Who Acted, and Intent Tells You Whether They Should Have

An identity chain tells you who acted and how much access each actor could hold. It doesn't tell you whether a particular action served the task the user asked for. An agent can stay within the narrowest permissions its chain allows and still use them for something no one intended, which is the pattern behind semantic privilege escalation. That's why Proofpoint evaluates access, intent, and behavior together at runtime, with the identity chain tying every evaluation back to the user and the agents behind the action.

Proofpoint AI Security captures the chain as agents operate. Full Transaction Forensics traces each workflow from the user's request through every agent, tool call, data access, and LLM interaction, and attributes every action to both the agent that took it and the user on whose behalf it acted. On-behalf-of (OBO) tokens scope agents to the invoking user, JIT authorization limits each grant to what the task requires, and Intent-Based Access Control (IBAC) evaluates each action against the scope of the originating user request.

Agents will keep calling other agents, and the chains behind every request will keep getting longer. Security teams that can look at any action and say who started it, which agents executed it, and whether it should have happened at all will be ready for wherever those chains go next.

Learn more here: Proofpoint AI Security.