← All posts
SOOT · BLOG

Delegation Without the Token: Identity in the Agent Era

Zalando open-sourced the Agentic Identity Broker: agents get delegated authorization without holding the user's root token. The same idea runs inside Soot — installing a pack is not granting permission, the model proposes, the runtime decides, the trace keeps the evidence.

Zalando just open-sourced a project called *Agentic Identity Broker* (AIB) on GitHub — zalando-incubator/agentic-identity-broker. It's an identity broker that solves OAuth2 delegation for AI agents calling MCP services: agents get delegated authorization to act without holding the user's root token, tool approval is centralized, and every decision flows through a transparent audit log.

It may look like a niche enterprise utility. In fact, it points straight at the biggest hole in how we run agents today: we keep handing agents our whole identity instead of delegating a narrow permission.

The Core Problem: Agents Holding Root Credentials

When an agent needs to call an API on your behalf — read an inbox, file a ticket, place an order — teams usually pick one of two shortcuts:

  • Give the agent the user's token: You obtain an OAuth token and drop it into the agent's config or environment. From then on, everything the agent does carries *your* identity. Nobody can tell which action was yours and which was the agent's. If the token leaks into a log or gets exfiltrated through prompt injection, your authority goes with it.
  • Create a separate account for the agent: Cleaner identity-wise, but the agent loses your context and legitimate permissions — so it's either over-privileged to compensate or under-privileged to actually work.

Both fail at the same point: there's no notion of *"this action was taken by agent X, on behalf of user Y, within scope Z."* No delegation chain — just shared secrets.

What a Proper Delegation Chain Needs

From AIB's approach, a minimal delegation architecture has four components:

  1. Scoped delegation tokens: The agent receives its own token, bound to that agent and carrying only the permissions its task requires — instead of holding the user's root token.
  2. Revocability: You can pull an agent's permissions — or an entire delegation chain — without touching the user's session.
  3. Centralized approval: The decision "which tools may be called" lives at one clear control point, instead of being scattered across credentials each agent keeps for itself.
  4. A central audit log: Who delegated to whom, which agent called which service, under what scope — all traceable, so you can answer *"who did this, on whose behalf, with what authority?"*

The golden rule mirrors the work-handoff problem: an auditor must be able to verify who did what, with which permission — not just see an anonymous action wearing your identity.

In Soot, Permission Is Always Separate from Installation

Soot's philosophy matches this delegation mindset exactly — the difference is that Soot puts it at the runtime layer, on your own machine:

  • Installing a pack is not granting permission: A Soot may have a pack installed with all its tools, but what the pack declares it needs — credentials, the workspace folder, environment variables — remains a separate grant, approved by you, piece by piece. A tool being present does not mean a tool is permitted.
  • Every tool call passes a runtime decision: The model *proposes* a tool call; the runtime *decides*, based on the permission matrix. Sensitive tools go through the operator or wait for your approval — a centralized control point, playing the same role the broker plays in AIB, instead of letting each agent decide for itself.
  • The trace records the whole chain: Every tool call stores the model's proposal, the permission decision and the execution result. Even a call denied for missing permission is preserved as a receipt in the trace. An agent blocked by missing access reports a blocker — it never silently works around it with a stashed secret.
  • Least privilege by design: One small Soot, one clear task — each Soot carries only the tools and permissions its mission requires. More power means asking for another grant; permissions never "inherit" silently from an installation.

In other words: AIB places a broker between the agent and the service to centralize decisions and record evidence; Soot places the runtime between the model and the tool to do exactly that — the model proposes, the runtime decides, the trace records the proof.

One Small Soot, One Clear Task, Clear Evidence

Which is, once again, why Soot holds to its motto: one small Soot, one clear task, clear evidence.

  • One small Soot: narrow scope means a narrow permission surface — easy to grant minimally, easy to revoke.
  • One clear task: measurable completion, so the grant can match the mission instead of handing out excess privilege "just in case."
  • Clear evidence: permission decisions and outcomes live in the trace — verifiable proof, not faith that the agent "probably stayed in bounds."

Good delegation isn't sharing your identity. Good delegation is handing over narrow, revocable permission — with evidence.

---

Learn more about how Soot separates permission from installation and records every grant decision in the trace at trysoot.com/docs. Download Nest to run it on your machine at trysoot.com/download.