Topic: Identity

SPIFFE names the workload. It can't say who the agent works for

SPIFFE proves which workload is calling. An agent also needs to say who it acts for and what the task allows. Four options, with what each costs.

In this post 8 sections
  1. SPIFFE is doing exactly what it says
  2. Why the user doesn’t belong in the SVID
  3. What WIMSE says agents need
  4. A team that hit it at scale
  5. Four options, and what each costs to run
  6. What you can do this week
  7. The layer above the one you run
  8. Sources

If you already run SPIRE or a service mesh, you’ve done the hard part of workload identity. Every pod gets a short-lived, attested credential, and nothing in your estate holds a static secret just to prove what it is. So when agents arrived, it was reasonable to assume they’d slot into the same model.

They do, up to a point. Then every replica of your agent service shows up downstream with the same identity, acting for different people on different tasks, and the logs can’t tell those calls apart. I went through the SPIFFE specs, the IETF’s workload identity drafts and the public write-ups from teams who’ve hit this, to work out where the line sits and what it costs to cross it.

SPIFFE is doing exactly what it says

SPIFFE defines a workload as “a single piece of software, deployed with a particular configuration for a single purpose; it may comprise multiple running instances of software, all of which perform the same task.” A SPIFFE ID “uniquely and specifically identifies a workload”. Put those together and replicas share one ID by design.

The default most people run makes it concrete. The SPIFFE project’s hardened Helm chart for SPIRE ships a default template of spiffe://{{ .TrustDomain }}/ns/{{ .PodMeta.Namespace }}/sa/{{ .PodSpec.ServiceAccountName }}. Ten replicas under one service account, one identity.

For a payments service that’s right, because every replica does the same job. An agent breaks the “all of which perform the same task” assumption. Two replicas of one agent service can be working for two different people at the same moment, and one replica works for many people over an afternoon.

The IETF’s WIMSE working group, which is standardising workload identity, states the condition precisely. Instances may share an identifier “when they are intended to be treated as the same workload for the purpose of authentication, authorization, and auditing.” Agent replicas acting for different users don’t meet that test.

Why the user doesn’t belong in the SVID

The obvious fix is to put the user into the identity document. SPIFFE’s own spec argues against it, with reasons. Section 4.1.1 of the SPIFFE ID standard separates assertions that are stable for a workload’s life, such as its SPIFFE ID or region, from ones that change. “The name of a service owner, role or group membership, and access policies are all examples of assertions that are more likely to change”. Its advice: if volatility isn’t clear, “err on the side of caution and exclude it from the SVID.”

An agent’s current user and current task change with every request. By SPIFFE’s own test they’re the most volatile assertions there are. A JWT-SVID makes the point physically: its claims are iss, sub, aud, exp and iat, and sub “MUST be set to the SPIFFE ID of the workload”. The slot OAuth uses for the user is already taken.

So SPIFFE didn’t forget the user. It chose to identify the runner and leave the authority to another layer. Karl McGuinness, one of the authors of the IETF’s Cross App Access draft, put it in one line: “Workload identity names the runner; it does not describe the job.”

What WIMSE says agents need

The WIMSE architecture draft (-08, July 2026) has a section on AI agents. It calls them “a special case of delegated workloads”, which “inherit the upstream principal’s security context and are expected to operate strictly within the constraints of that delegation.” And: “each hop in the chain MUST explicitly scope and re-bind the security context”.

That’s two layers. Workload identity says which software is calling. A separate, per-request context says for whom, and within what bounds. The newer AIMS draft for agents follows the same split: the agent can be identified by a SPIFFE ID, and when it acts for someone, the user goes in the OAuth token.

The SPIFFE community is weighing where the second layer lives. An open SPIRE issue from June asks for RFC 8693 act claims in JWT-SVIDs: “Without this, every agent call collapses to a single identity. Resource servers can’t tell whether agent A or agent B is operating.” The maintainers moved it to a discussion in the spec repository, where the direction so far is a separate exchanged token, with the SVID as its anchor.

A team that hit it at scale

Uber issues its workload identities from SPIRE. In May its engineers wrote up what happened when agents arrived: the systems an agent touched “could only see a generic service identity at each hop.” Their SVID proves the compute environment is legitimate “but doesn’t yet identify the agent.”

They kept SPIFFE and added a layer: an agent registry, and a token service that authenticates callers by their SVID and mints a short-lived token for each hop, carrying the chain from the user through each agent. The system has been adopted by “thousands of internal agents”, and they report that the token exchange stays “consistently below 40 milliseconds” at the 99th percentile.

Four options, and what each costs to run

All four keep SPIFFE as the proof of which workload is calling. They differ in what they add on top.

Per-replica SPIFFE IDs Token exchange on the SVID Transaction tokens A broker layer
Which replica Yes If the token service records it If the token service records it If the broker sees it
For whom No Yes Yes Yes, as per-user policy
For which task No Only if your policy narrows scope Yes, and scope can’t widen Yes, per call and endpoint
Outside your trust domain Identity only, via federation Needs trust on both sides No, one domain Yes, for calls routed through it
What you run A template change, then policy rewrites A token service, a registry, a verifier in every service One token service per domain, a verifier everywhere The broker, kept highly available
Hardest part Writing policy for many IDs Deciding the narrower scope Building to a draft Trusting one more component

Per-replica IDs are a one-line template change if you use the SPIRE controller manager: add the pod name. They’re worth it for audit and for cutting off one bad replica. They don’t answer who the agent was working for, and your authorisation policies now have to match patterns instead of names.

Token exchange is the standards-aligned answer and what Uber runs. The agent authenticates with its SVID, presents the user’s token and gets back a short-lived token naming both. The cost is a token service on every hop (Uber’s 40 milliseconds, multiplied by however many hops a task takes) and the policy that decides how narrow each token should be. RFC 8693 only “suggests” narrowing; that part is yours to write.

Transaction tokens carry the user and the transaction’s purpose through every hop inside one trust domain, and the draft forbids widening scope along the way. It’s the closest standard to identity that carries the task. It’s also still a draft, it stops at your domain’s edge, and I couldn’t find a mature open-source token service, so expect to build one.

A broker sits between agents and the tools they call. It authenticates the agent, holds or mints the downstream credential, applies per-user and per-action policy, and records each call. It works across SaaS APIs that will never speak transaction tokens, but it only sees calls that go through it, and it has to be hardened like a secrets store.

What you can do this week

Pick one agent deployment. Count its replicas, and check the SPIFFE ID template they get. Then open one downstream service’s logs for yesterday and look for any field that says which user each call was for. If all you find is the SPIFFE ID, you’ve found the collapse, and you know which column of that table you need.

The case for doing identity first is in identity is the control plane for AI agents, and least agency in practice covers how narrow each grant should be.

The layer above the one you run

Whatever you choose, SPIFFE stays where it is, proving which workload is calling. The layer above it needs an identity for each agent, short-lived credentials scoped to specific endpoints, policies that apply per person the agent acts for, approval for risky actions, and a record of every call that names both the agent and the person.

That’s the layer AgentValet provides, and its MCP broker is open source. The security page covers how it’s built.

Sources

  • SPIFFE concepts: spiffe.io; SPIFFE ID standard, section 4.1.1: github.com; JWT-SVID: github.com
  • SPIFFE hardened Helm charts, SPIRE server values: github.com
  • IETF, draft-ietf-wimse-identifier-03: ietf.org; draft-ietf-wimse-arch-08, section 3.4.11: ietf.org; draft-ietf-wimse-aims-00: ietf.org
  • SPIRE issue #7077 and SPIFFE issue #408: github.com, github.com
  • Karl McGuinness, A Layered Strategy for ID-JAG, WAG, and Cross-Domain Delegation: gist.github.com
  • Uber Engineering, Solving the Identity Crisis for AI Agents (22 May 2026): uber.com
  • RFC 8693, OAuth 2.0 Token Exchange: rfc-editor.org
  • IETF, draft-ietf-oauth-transaction-tokens-11: ietf.org

Filed under

  • identity
  • spiffe
  • workload-identity
  • agent-security

Give your agent only the access it needs

Grant each agent a narrow set of actions, hold the risky ones for your approval, and keep a signed record of every call.