Start typing to search this publication.
techcirkle
Open menu

Subscribe to techcirkle

Get new posts delivered straight to your inbox.

Delegated Authorisation Just Became an Ordinary Requirement

When an agent calls your API for a user through a platform, identity has three answers. Most gateways were not designed for that.

techcirkle
5 min read
Cover image for Delegated Authorisation Just Became an Ordinary Requirement
Reviewing API integration and access data
Reviewing API integration and access data

Until fairly recently, most API authentication requirements fell into a small, well-served set. API keys for partner integrations. OAuth client credentials for machine-to-machine. JWT validation against a JWKS endpoint. Mutual TLS where the counterparty cared.

If your requirements were in that set — and most were — authentication was not a differentiating factor when choosing an API management tool. Everything handled it competently.

Then agent architectures arrived and moved a formerly exotic requirement into the mainstream, quickly enough that most tooling has not caught up.

The shape of the problem

A request arrives at your API. Behind it:

end user       — initiated the task, owns the data
agent          — constructed and issued this specific call
orchestrator   — the platform hosting the agent
credential     — a service token belonging to the orchestrator

Four parties. One HTTP request. And several different questions whose correct answers differ:

  • Whose permissions apply? The end user's. An agent acting for Alice must not read Bob's records, regardless of how broad the orchestrator's service credential is.

  • Whose quota does this consume? Usually the orchestrator's or the tenant's, since they control call volume.

  • Who is billed? The account holder, who may be neither.

  • Who appears in the audit log? All of them, ideally, with the relationship intact.

Systems that model identity as a single principal per request cannot express this. They force you to pick one answer and be wrong about the other three.

Why "just use the service credential" fails

The tempting shortcut is to authenticate the orchestrator and let it assert the user in a header.

Authorization: Bearer <orchestrator-service-token>
X-On-Behalf-Of: alice@example.com          ← unverified claim

This works right up until it matters. The user identity is now an unauthenticated assertion. Any party holding the service credential can claim to be any user, and your audit log records a claim rather than a fact.

For internal systems within one trust boundary this is sometimes acceptable. For anything crossing an organisational boundary — which is precisely the agent-platform case — it is a finding waiting for an auditor, and it is the mechanism behind a familiar class of confused-deputy vulnerability.

What a correct implementation needs

AI core connected to multiple API modules
AI core connected to multiple API modules

A verifiable user assertion. The user identity must arrive as something cryptographically bound to an authentication event — a token the user's identity provider issued, not a header the caller wrote. Token exchange flows exist for exactly this: the orchestrator presents its own credential plus the user's token and receives a token representing the combination.

Scope intersection. The effective permission set should be the intersection of what the user may do and what the user authorised this agent to do. An agent granted read access to invoices should not inherit the user's full permissions merely because the user holds them.

Multi-dimensional attribution. Rate limiting, quota and billing should each be attributable to a different party. Tools supporting only per-key attribution collapse them, which surfaces during a billing dispute or an access incident — the two moments when you least want an ambiguous answer.

Audit records preserving the chain. "Alice's data was read" is insufficient. "Read by agent X, on behalf of Alice, orchestrated by platform Y, at time T" is the record you need when someone asks what happened.

Short-lived credentials with rotation that does not require a redeploy. Delegated tokens should be narrowly scoped and expire quickly, because their blast radius is broader than a single service credential.

Testing this during a selection

This is now one of the few genuinely discriminating criteria in API management tooling, because the commodity features reached parity years ago.

Concretely, during a trial:

[ ] Can the gateway validate a token representing user+agent,
    not just a single principal?
[ ] Can policy decisions reference BOTH identities?
    e.g. "allow if user owns resource AND agent scope includes read"
[ ] Can rate limit / quota / billing attribute to DIFFERENT parties
    on the same request?
[ ] Does the access log preserve the full delegation chain?
[ ] Can credentials be rotated without redeploying anything?
[ ] Can scope be narrowed dynamically from request context,
    rather than only from static configuration?

Make the vendor demonstrate these in a working trial environment with configuration you can read. Not a slide, and not a roadmap commitment. Vendors are uniformly confident about authentication in sales conversations and uniformly specific about limitations during implementation.

If your tooling cannot do it

A pragmatic middle path, when the gateway handles single-principal auth well and nothing more:

Terminate the orchestrator's credential at the gateway, then have the gateway forward the user's verifiable token to the service, and perform the intersection logic in a small shared authorisation library used by every service.

This is more code than you want and it is honest about where the decision is made. What you must avoid is the version where the gateway strips the user context entirely and services trust an unverified header — that is the confused-deputy problem with extra steps.

Full guide — the five capabilities that matter, cost-weighted rate limiting, agent traffic patterns and the selection framework: API Management Tools in 2026. We also review API security architecture.

Frequently Asked Questions

What is delegated authorisation in an API context?

When one party acts on behalf of another — an agent calling your API for a user, through an orchestration platform, using a service credential. Permissions, quota, billing and audit each need a different answer about who the caller is.

Why can't the caller just send a user ID header?

Because an unverified header is a claim, not a fact. Anyone holding the service credential can assert any user, your audit log records assertions, and you have built a confused-deputy vulnerability. Across organisational boundaries this is not defensible.

What should the user identity look like instead?

A token cryptographically bound to an authentication event, obtained through a token exchange where the orchestrator presents both its own credential and the user's token, receiving one representing the combination.

What is scope intersection?

The effective permissions are the intersection of what the user may do and what the user authorised this specific agent to do. An agent granted read access to invoices should not inherit the user's broader permissions simply because the user holds them.

How do I test this when selecting a tool?

In a working trial, check whether the gateway can validate a combined user-plus-agent token, reference both identities in policy, attribute rate limiting and billing to different parties on one request, preserve the delegation chain in logs, and rotate credentials without a redeploy.

What if our gateway cannot support it?

Terminate the orchestrator credential at the gateway, forward the user's verifiable token to services, and do intersection logic in a shared authorisation library. More code than ideal, but honest — unlike stripping user context and trusting an unverified header downstream.

Subscribe to techcirkle