Every delegation chain in circulation today proves the same narrow thing: no hop granted more than the hop before it. None of them proves that the entity at the root had the right to grant anything. A new Internet-Draft in the IETF’s WIMSE group tries to close that gap.
What happened
On 24 October 2026, Claudiu Hulea (Braincap SRL) published draft-hulea-wimse-agent-mandate-00, “Verifiable Mandates for Agents Acting Across Administrative Domains” — a 44-page individual Internet-Draft with Standards Track intended status, filed for the IETF working group on Workload Identity in Multi System Environments (WIMSE). It expires on 27 April 2027. It is an individual submission, not a working-group document, and carries the usual notice that the IETF has not endorsed it.
The problem statement is one paragraph and it is the reason the draft is worth reading:
“What is not yet defined is evidence that the party at the root of a mandate was entitled to grant it. A chain that only narrows proves that no hop exceeded its parent. It does not prove that the root was within the delegator’s own authority, for example within the powers of a company’s legal representative.”
draft-hulea-wimse-agent-mandate-00, §1
That is the scenario the industry keeps describing and rarely specifying: a treasury agent run by a company initiates a payment at the company’s bank; an agent run by a broker submits an instruction to a custodian. In both cases the relying party has to decide whether to accept an action from an agent configured, authorised and operated in another administrative domain — and, the draft argues, the delegated-authority chain it is shown says nothing about whether the human or firm at the top was empowered to hand that authority onward.
The mechanism: an authority assertion, separate from the mandate
The draft splits what is usually one artifact into two statements made by two different parties.
- An Authority Source issues an Authority Assertion: a JWT (`typ: authority+jwt`) or an SD-JWT (`typ: authority+sd-jwt`) stating that, according to that source’s records at the time of issuance, the delegator may delegate to agents, on behalf of the principal, the powers listed. It is a statement about delegable powers, not about what the delegator may do in person. The draft is explicit that “a delegator entitled to perform an action may still be barred from delegating it, and such an action does not appear in powers.”
- A Mandate Issuer, on the delegator’s instruction, issues the root Mandate Assertion, bound to the agent instance’s key and referencing that Authority Assertion.
- The operator issues the agent instance a WIMSE Workload Identity Token for the same key, and a RATS verifier may add an attestation result.
- A Validator runs a deterministic validation procedure under an explicit Validation Profile, and returns a Validation Result. The relying party then applies its own policy — the draft keeps validation and authorisation strictly apart, so that two conforming validators given the same inputs reach the same result.
The Authority Assertion’s required claims are `iss`, `jti`, `iat`, `exp`, `principal`, `delegator`, `powers` and a trust-framework identifier `tf`, with optional `loa`, `status` and `max_depth`. Two details carry most of the weight:
- Powers cannot be hidden selectively. When the assertion is an SD-JWT, every claim inside `powers`, at any nesting depth, must sit in the issuer-signed payload and must not be selectively disclosable. An assertion whose powers contain a disclosure marker is malformed. The reason is stated plainly: hiding a restriction on the delegator’s powers would otherwise make those powers appear broader.
- Budgets are not inherited from the principal. `powers` must not contain stateful constraints, and cumulative limits on the delegator’s own authority are out of scope for this version. A `sum_max` budget in a root mandate is a limit on that mandate only; two root mandates built on one Authority Assertion have separate budgets, because accounting is keyed by the root mandate.
The authority check has three outcomes, and the third one is the interesting one for anyone building audit trails. If the root’s delegator equals its principal, the basis is “self” and no assertion is needed. Otherwise the result is Established (a supporting assertion validated with no code recorded), Unknown (the only status code was `status_unavailable`, so the outcome is indeterminate rather than invalid), or Refuted, with `authority_missing` when no referenced assertion was presented, `authority_mismatch` when none matches the parties, and `authority_insufficient` otherwise.
Attribution: who asserted what
The draft’s other useful contribution is a table that assigns each claim to the party that can actually make it — and records what each party does not assert:
| Artifact | Issuer role | Asserts | Does not assert |
|---|---|---|---|
| Authority Assertion | Authority Source | the delegator may delegate the stated powers for the principal, per the source’s records | that any mandate was issued or intended |
| Root Mandate Assertion | Mandate Issuer | the delegator granted the permissions to the key | that the delegator had authority |
| Sub-delegated Mandate Assertion | Delegating agent instance | further delegation within the parent’s scope | anything beyond the parent |
That separation is the part a compliance or audit function can use immediately: it turns “the agent was authorised” into a set of claims with named issuers, instead of a single signed blob whose provenance is a matter of trust.
The draft also sets a boundary rather than pretending to cover everything. A trust framework, identified by the `tf` URI, must define the accepted entities and anchors, identifier schemes, assurance levels, algorithms, maximum lifetimes, validation-profile bounds, requirements on Authority Sources, issuer obligations and liability, retention of validation results, and how a mandate issuer establishes that the instruction really came from the delegator. The protocol verifies that the delegator holds authority and that the mandate issuer says the delegator granted the mandate; it cannot verify the link between those two inside the delegator’s organisation. That link rests on the mandate issuer, under the framework. The draft also names its non-goals: it does not judge whether the agent’s reasoning is correct or reflects the principal’s present intent, does not define assurance levels or legal effect, does not define how consent is shown, and does not replace the relying party’s policy.
In the EU, the draft notes, an Authority Source could derive Authority Assertions from electronic attestations of attributes about powers and mandates to represent natural or legal persons under eIDAS 2 — which is where this stops being a protocol question and becomes a supervisory one.
Why it matters for KYA
Know Your Agent has been verifying the wrong end of the chain. Most agent-identity work answers is this agent what it claims to be — SPIFFE IDs, X.509 certificates, workload attestation, registries — and most delegation work answers did each hop narrow. Both are necessary. Neither answers the question a relying party actually needs answered before accepting a payment instruction from another company’s agent: was the person or firm that granted this authority entitled to grant it?
“May perform” and “may delegate” are different permissions, and most systems conflate them. The draft’s insistence that an action can be within a person’s own powers and outside their delegable powers is a small sentence with large consequences for entitlement design. If your agent mandate format has no way to express that distinction, your entitlements data probably cannot answer it either.
Indeterminate is a legitimate result. `Unknown` — because status information was unavailable — is modelled separately from `Refuted`. That is the correct shape for an audit trail: “we could not establish authority” is not the same finding as “authority was not there”, and collapsing the two either overstates your assurance or hides an outage.
The attribution table is a template for your own logs. Even without implementing the draft, the “asserts / does not assert” split is a useful test for any agent-authority record you produce: for each field, can you name the issuer that was in a position to assert it, and would that issuer disclaim the rest?
What a practitioner should take from it
- Ask for the authority basis, not just the chain. When an agent presents a delegated mandate from another organisation, a narrowing chain answers a different question. Require the statement about delegable powers and the issuer that stands behind it.
- Keep validation separate from your policy. A deterministic, profile-driven validation result that your systems can reproduce is what makes an agent-authorisation decision reviewable later. Mixing the two produces decisions nobody can reconstruct.
- Model “unknown” explicitly. Status and revocation lookups fail; design the result space so a failure is visible rather than silently treated as a denial or a pass.
- Key budgets to the root mandate. If two mandates from the same delegator share one counter, the limit means something different from what the delegator signed.
Caveats
This is an individual Internet-Draft by a single author, with no working-group adoption and no implementations listed in the document. Its chain mechanics deliberately overlap with several other drafts in the same space — `draft-asor-wimse-agent-delegation-chain`, `draft-hamr-oauth-agent-delegation`, `draft-reece-wimse-cross-org-delegation` and `draft-yossif-agent-mandate-problem` — and the author says the chain format could be replaced by another draft’s if the working group prefers one. Appendix D lists open issues, including alignment with that other chain format, a CBOR/CWT encoding, shared budget accounting across relying parties, cumulative limits on a delegator’s authority across root mandates, batch atomicity, refund predicates and signed test vectors. The trust framework — the part that decides which Authority Sources count — is not defined here and is not going to be defined by a protocol document.
Sources
- C. Hulea, “Verifiable Mandates for Agents Acting Across Administrative Domains”, `draft-hulea-wimse-agent-mandate-00`, IETF Internet-Draft, 24 October 2026 — datatracker.ietf.org (plain text).
- IETF WIMSE working group — datatracker.ietf.org/group/wimse.
- Related KYA coverage: “WIMSE draft: an agent’s identifier should not carry its roles and entitlements” (16 October 2026) — kya.fi; “IETF draft gives AI agent authorization decisions a portable, verifiable audit record” (16 October 2026) — kya.fi; “IETF draft ‘ID MANDAT’ gives a company’s agents a machine-readable mandate” (16 October 2026) — kya.fi.
Note: the description above follows the draft text; no implementation or independent review of this format has been published.
Know Your Agent (KYA) explains agent identity, verification and accountability. This is an explainer, not legal or compliance advice — see our Sources & methodology. New to KYA? Start with What is Know Your Agent? and the glossary.