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

Review · November 10, 2026

An Attenuated Delegation Profile for Automated Agents

draft-hamr-oauth-agent-delegation -03View on Datatracker →

The problem it's solving

An API can't tell whether an accountable person stands behind an agent. It also can't trust the agent to stay inside the task, because "only search" is a request to a model and not a limit on it.

The draft's example: a person asks an agent to find a flight under $400, and the agent books a non-refundable seat. The person asked for a read. The agent made a call that can't be undone.

The unique angle in -03 is a per-job scope in one provider-neutral form. Every API call is r, w, or x, read as in chmod. A delegation link sets the highest class it allows and an optional count per class. A verifier outside the model refuses anything above it.

How it fits in the working group

The draft cites the OAuth charter's agent authorization work item and says it targets it directly. The topic is in charter.

The mechanism is not OAuth. There is no client, no authorization server, no access token. The normative references are HTTP Message Signatures, Structured Fields, HTTP Semantics, JWS, and SHA-256. RAR appears once, informatively. Token Exchange and the act claim are still never mentioned, four revisions in.

The abstract now says so openly: this "builds on HTTP Message Signatures." It defines five roles of its own: Delegator, Delegate, Relying Service, API Provider, and Attestation Issuer. It would sit as naturally in HTTPAPI or WIMSE.

The closest neighbor is still draft-asor-wimse-agent-delegation-chain. This draft now borrows asor's comparators and dropped its own registry in favor of asor's. It did not borrow asor's token format or its parent-link commitment.

What the mechanism actually does

An Agent-Delegation header carries a list of signed links, root first. The sender covers it with an RFC 9421 signature tagged agent-delegation.

Each link can only narrow its parent. Scope shrinks, compared octet-for-octet. Floors tighten. Expiry moves earlier. The verifier checks every adjacent pair and rejects the whole chain on any violation.

Floors now cover two unrelated things.

The first is the person behind the agent. An Attestation Issuer, such as a mobile operator, answers a signed yes, no, or refusal to questions like "line held two years, no SIM swap in 90 days" or "at least 18." It never returns the underlying value.

The second is what the agent may do. r reads. w changes something a later call can set back. x can't be undone. Without other information the HTTP method decides: GET is r, PUT and PATCH are w, everything else is x. A signed "menu," a JWS mapping METHOD path-template to a class, overrides the method default. The API Provider signs it, or the party running the agent signs its own.

Budgets cap calls per class. The verifier holds the count, keyed by a SHA-256 digest of the root link's signature.

So who runs the verifier? Until API Providers adopt this, the draft says the party running the agent holds the real API credential and places the verifier in its own harness.

Significant interoperability concerns

The link format is still undefined. Section 4 says the credential format sets the encoding and the draft doesn't mandate one. Two implementations cannot exchange a chain. The chain identifier is a hash over bytes the draft never defines, so two verifiers can compute different budgets for the same chain.

Nothing binds a link to its parent or to the presenter. The terminology says a link's signature binds it to its parent. No normative section says how. Parent and child are established by position in the list, so links from different chains can be spliced. Nothing ties the RFC 9421 signing key to the leaf link, so a captured chain works for anyone. This is a bearer credential with signatures on it.

There is no key model for link signers. Step 5 says the Attestation Issuer's key comes from a configured trust source. The draft never says whose key signs L(1) through L(n) or how a verifier in another company learns it.

The attestation nonce can't be delivered. Step 8 requires every floor attestation to echo the nonce the verifier issued. Section 5 defines one nonce delivery, Accept-Signature, and says it must not be treated as the attestation nonce. There is no other. The root attestation also exists before the final verifier is known.

The interim deployment needs no standard. When the agent's operator signs the menu, issues the link, and runs the verifier in its own harness, one party is on every side. The API Provider sees an ordinary credential and never sees the header. That is a product feature. The author's bareguard already does it without this header.

The class definition has changed in every revision. -01 used idempotency. -02 used reach. -03 uses reversibility, and the changelog calls it "a new definition, not a refinement." DELETE moved from w to x. PATCH moved from x to w. A link reading "rw" has meant three different things in two months.

Reversibility is not risk. The draft admits that resetting another user's password is w because it can be set back. A link allowing w admits it.

Budgets still leak. A Delegator can sign a new root link and get a fresh count, and Section 7 tells deployments to issue a new root to widen. The count is spent before the Relying Service applies its own policy. Uniform rejection means an agent can't tell an exhausted budget from an expired link.

"Published floor" is still undefined. Inheritance of every omitted axis depends on it. The draft never says how it is expressed, fetched, or authenticated. It also implies a mobile operator could publish an xBudget, which makes no sense.

Mechanisms that could be removed

The person floors and the action classes are two specifications. Split them. The attestation half has no working issuer: Appendix A says none of its four directions meets Section 11 today.

Section 12's agent identifier is a requirement with no mechanism and no place on the wire.

Section 9.6 requires every path to an effect to cross an enforcement boundary. That's deployment architecture. Nobody on the wire can tell whether you complied. The same applies to verifying refusals along an "independent path."

Section 3's layer taxonomy, the MCP hint mapping, the classifier accuracy figures, and Appendix A are blog material. The 82.3% figure appears in the Introduction of a Standards Track document.

Writing quality

The prose improved a lot. Sentences are short and plain. The defensive hedging from -00 and -01 is mostly gone. The document is 37 pages, down from 48 in -01. RFC 9651 replaced the obsoleted RFC 8941.

Section 9.6 is the exception. It reads like list-thread consensus pasted in: "an invariant over the complete set of effect-capable paths to a given protected effect."

Terminology still blurs. Step 5 says "the root attestation, L(0)," but L(0) is a link. Section 11 is titled Attestation Properties and is cited for link signatures. "Harness" and "the party that runs the agent" do most of the work in the deployment story and neither is a defined role.

Appendix B points to the expired -01 for the full test vectors, with axis names that no longer exist.

Implementation status

The draft is candid here, and the answer is that nothing implements it.

No code implements action classes, the menu, or budgets at this revision. The proof-of-concept still uses -01 axis names and has no header, no RFC 9421 signatures, and no chain longer than two links. The action-class test suite from -02 was dropped because the definition changed under it. No code runs the test vectors.

The classifier trial measures a tool, not the protocol. Its truth labels were written by language models, which the draft discloses.

About the author

Amr Hassan, Independent, San Francisco. Sole author.

I could not load the Datatracker profile for this review. As of the -01 review on September 2 it showed zero published RFCs, one active Internet-Draft (this one), and no expired drafts. That is a new IETF author.

The pace is high: four revisions in about eight weeks, each with new mechanisms. The references list seven of the author's own GitHub projects and two CAMARA proposals. The acknowledgments show real engagement on the OAuth and WIMSE lists.

Where the working group should push

The core idea is useful. A coarse, provider-neutral read/write/irreversible label on API operations, signed by the API Provider, is something MCP tool annotations already want. That piece could stand alone as a small draft.

The delegation chain underneath it is not ready. The questions from -00 are still open after three revisions:

  • What encoding does a link use?
  • How does a link commit to its parent and to the Delegate presenting it?
  • How does an attestation get the verifier's nonce?

Two more for -03:

  • When the agent's operator signs the menu and runs the verifier, what is being standardized between two parties?
  • Why should the WG believe the r/w/x definition is stable now, given it changed in each of the last three revisions?