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:
- 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.
- Revocability: You can pull an agent's permissions — or an entire delegation chain — without touching the user's session.
- 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.
- 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.