The Scope Creep Automated reviews of new AI-related working group submissions

Review · November 20, 2026

Capability-Bound Delegation Chains with Scoped Context Disclosure for AI Agents

draft-atakora-wimse-sadp-delegation -01View on Datatracker →

The Problem

An agent that hands a sub-task to another agent passes along two things: authority and information. Delegation tokens narrow the authority. Nothing narrows the information.

Brokers, queues and gateways between agents also see the task content in the clear.

This draft wants one signed chain to do both jobs. The chain says what the next agent may do. The same chain decides which encrypted context objects that agent can get keys for.

How It Fits In

The draft is named for WIMSE, but it uses nothing from WIMSE. It defines no relationship to the Workload Identity Token, the Workload Proof Token, or SPIFFE IDs. The WIMSE architecture appears once, as an informative pointer for key lookup, which is declared out of scope.

It uses nothing from OAuth or JOSE either. The seven normative references are all building blocks: JSON, base64url, SHA-256, Ed25519, timestamps. The grant format, the signing input, the canonical JSON profile and the principal identifier syntax are all new.

It is one layer of a larger new protocol. The Secure Agent Delegation Protocol (SADP) has a companion draft, draft-atakora-sadp-protocol, that defines the encrypted "task capsules" these grants ride in. End-to-end encrypted agent messaging is not in the WIMSE charter.

The draft positions itself as a complement to draft-asor-wimse-agent-delegation-chain. That draft builds its chain from JWT access tokens and Rich Authorization Requests. This one shares the parent-hash idea and nothing else. A JWT profile is deferred to "a future revision".

How It Works

A grant is a JSON object signed with Ed25519. It names an issuer, a holder, one action, one resource, a task ID, an expiry, a remaining delegation depth, and a list of caveats.

To delegate, the holder signs a child grant with its own key. The child embeds the entire parent grant and a SHA-256 hash of it. A chain on the wire is one nested object.

Six rules govern each link:

  • The child's issuer is the parent's holder.
  • The action is identical.
  • The resource is the same or a /-separated sub-path.
  • The expiry is no later.
  • The depth counter drops by at least one.
  • Caveats can be added but never dropped.

The receiving agent verifies the whole chain itself. It checks the root against a configured set of trusted issuer keys. It looks up each intermediate key through a resolve_key function. No authorization server is involved at any hop.

Caveats are plain strings such as delete_after_result and no_external_network. A verifier that doesn't recognize one must reject the grant. The draft is honest that these are promises. Cryptography can't make an agent delete what it has already decrypted.

Scoped context disclosure works by naming. A resource such as blob:contract_pdf/sections_3_8 identifies an encrypted object. Whoever holds the content key releases it only to a principal with a valid chain covering that name.

Each capsule also carries an unsigned audit record that hash-links it to its parent capsule.

Significant Interoperability Concerns

The headline feature has no protocol. Section 6 says a content key "MUST be released only to" a principal with a valid chain. It doesn't say how a key is requested, how a chain is presented, or what encrypted_key_ref points to. The usual case in the draft is the delegator wrapping the key directly to the delegatee inside the capsule. That is the sender encrypting what it chooses to share. The chain plays no part in it.

The parent hash is not reproducible. Verifiers must rebuild hash inputs from parsed values instead of hashing the received bytes. The draft then allows parent and parent_grant_hash to be either absent or null on a root grant. Those two forms serialize to different bytes and produce different hashes. expires_at has the same problem: 13:00:00Z and 13:00:00+00:00 are the same instant with different hashes. Number canonicalization is left for a future revision.

Key resolution is out of scope. Every signature check past the root depends on resolve_key. The draft doesn't define it, and it doesn't tie principal identifiers to any existing identity format. Two implementations can agree on every rule and still fail to verify each other's chains.

Actions and resources have no meaning. action is an opaque token compared for equality. Nothing maps a requested operation to an action and resource pair. The related Asor draft has the same gap.

Everything else lives in the companion draft. The algorithm reads capsule.to and capsule.task_id, and audit records hash the capsule. The draft calls itself self-contained, and lists the companion as an informative reference.

Two smaller issues are worth fixing. max_delegation_depth allows values up to 8, but a root at depth 8 implies nine grants, and the parser rejects chains longer than 8. A grant issued to a subject without a runtime segment is allowed at the leaf, but the draft doesn't say which key signs a child of that grant.

There are no test vectors. The signatures in the worked example are placeholders.

Mechanisms That Could Be Removed

  • The audit chain. It commits to capsule bytes, so it belongs in the capsule draft. The draft admits it is unsigned, checked one hop deep, and only useful against a head the verifier already trusts.
  • The custom canonical JSON profile. The draft calls it "intentionally close to" JCS. Use JCS, or sign the received bytes as JWS does.
  • no_further_delegation. A max_delegation_depth of 0 already says this.
  • The behavioral caveats and their IANA registry. No verifier can check delete_after_result. A registry of unenforceable promises is premature in an experimental draft.
  • The privacy claims for intermediaries. In the current profile grants travel as outer capsule fields that brokers can read. The profile that hides them is future work.

Writing Quality

The writing is clear and uses IETF conventions well. The verification algorithm is compact and easy to follow. The security considerations are frank about what the design can't do.

At 27 pages it is a reasonable length. The related-work text is the padding. Eight of the cited drafts have no revision or date, and the comparison table scores this draft "Yes" on properties it defers.

There are signs of a quick conversion from product documentation. The text refers to a "v0.2 capsule profile" and an audit prefix of v0.1 as if readers know the product history. Step 5d of the algorithm contains an unresolved cross-reference, {{caveat-processing}}. The design goals use MUST for aspirations. The terminology defines attenuation as a "strict subset" while the rules allow an identical child.

The Author

Hamdy Atakora (Imara Labs) is the sole author. Datatracker lists no RFCs and two active Internet-Drafts, this one and the SADP capsule protocol. Both were first posted in 2026. This is a new IETF author.

Bottom Line

The split between authority and information is a useful way to describe a real gap. Most agent delegation drafts only narrow what an agent may do.

The draft doesn't yet close that gap. The chain rules are specified, and they duplicate what several other drafts already do with JWTs. The new part, releasing decryption keys against a chain, is a requirement with no mechanism behind it.

So where does this go? It is not WIMSE work in its current form. The idea would travel further as a key-release extension to one of the existing chain formats, such as draft-asor-wimse-agent-delegation-chain, than as a fifth grant syntax.