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

Review · November 10, 2026

Proof-of-Intent (PoI) Chained State, Multi-Party Escalation, and Concurrency Extension Summary

draft-williams-oauth-poi-chained-state -00View on Datatracker →

Problem Statement

An AI agent proposes a high-stakes action, like a loan or a prescription. A human has to approve it before the resource server executes it.

The companion PoI Core draft covers the simple case: one human, one signature, right now. This draft covers what Core leaves out:

  • The human reviews hours later, and the underlying data may have changed in the meantime.
  • The human edits the agent's proposal beyond their own authority, so a second human has to sign off.
  • Two approvers act on the same pending item at the same time.

How the Spec Fits In

This is an extension to an extension. It depends entirely on PoI Core, which is also a -00 individual draft submitted the same day. Nothing here can be evaluated or implemented without Core.

Does it fit the OAuth charter? Not really. The authorization server does not appear in this document at all. There are no changes to tokens, grants, or the token endpoint. Everything happens between a client-side "Signing Vault" and the resource server, at the application layer.

Core borrows the challenge pattern from Step-Up Authentication and positions itself as a replacement for RAR round trips, which it calls the "OAuth Redirect Tax". This draft's own references are JWS, JWT, JCS, and Problem Details. It cites zero OAuth RFCs directly.

What it adds is a lot of new behavior for the resource server. The RS becomes a stateful approval workflow engine. It stores pending intents, routes escalations to approval queues, enforces ordering between approvers, and evaluates quorum.

High-Level Summary

There are three mechanisms.

Asynchronous approval. When the agent proposes an action with no human present, the RS stores the proposal as pending and records a hash of the relevant domain state. It does not issue a signed challenge yet. When the approver opens the item later, the RS checks the state has not changed and mints a challenge valid for 5 minutes. The approver signs that. The RS checks the state hash again at commit.

Escalation chains. Core's envelope holds two nodes: the proposal and one human decision. This draft allows up to 16 hash-linked nodes. If a loan officer raises a loan above their limit, the RS parks the chain and routes it to a senior underwriter. The underwriter's challenge includes the full prior chain. Their Signing Vault must display the original proposal, every edit, and who signed each one before they sign.

Concurrency. The RS tracks the hash of the latest node for each intent. A new signature is only accepted if it references that exact hash. The loser of a race gets a 409 with the updated chain and must review and sign again. Nobody may rewrite the loser's signature to point at the new head.

There is one rule in the verification algorithm that matters for security. Approvals signed before the most recent edit do not count toward quorum for the edited parameters.

Interoperability and Necessity

Significant interoperability concerns

The wire protocol for the new flows is missing. There is no endpoint for listing pending intents, no endpoint for requesting a challenge by intent_id, and no way for the agent to learn the outcome after a 202. Two independent implementations could not talk to each other.

context_state_hash and prior_chain are registered as JWT claims but never given a format. The state hash is fine as an opaque value since only the RS checks it. prior_chain is different: the Signing Vault has to parse and render it, so it needs a definition.

Several responses offer a choice with no guidance for the client. Escrowing returns "202 Accepted (or 403 Forbidden)". Escalation returns 202 with a poi_status field or 403 with a header. A client has to handle every combination.

The abstract promises "multi-party co-signatures". The body only shows sequential approvals in a linear chain. Quorum is left to the policy engine, and nothing stops the same signer from appearing twice.

current_head_node_hash is registered as a JWT claim. It is a field in a Problem Details error body, not a JWT claim.

Mechanisms that could be removed

Most of the draft describes internal RS behavior. Compare-and-swap on a head pointer is optimistic concurrency control, which any database-backed service already does. Escrow states, queue routing, and the three policy outcomes of an edit are workflow engine design. None of it affects what goes over the wire.

The step-up outcome in Section 4.2 restates behavior Core already defines.

So what actually needs standardizing here? The n-node envelope format, the chain verification algorithm including the quorum rule, and the two 409 error bodies. That could be a section in Core instead of a separate document.

The bigger question is whether any of this needs an RFC. The client, the Signing Vault, and the RS are typically built by the same organization. The draft does not explain where cross-vendor interoperability is needed.

Writing Quality

The draft follows IETF structure and uses BCP 14 keywords correctly. Sentences are grammatical. At 16 pages it is a manageable length.

It is dense with invented terms and acronyms: EIK, KCT, ICO, PoIE, CIR, Signing Vault, plus node labels like R_(k+1)_A. Almost all are defined only in Core, so this document cannot be read on its own.

Other problems:

  • "SUPERCEDE" is misspelled throughout, including in protocol identifiers like supercedes_node_hash. The correct spelling is "supersede". This is worth fixing before anyone implements it.
  • Numbered lists are collapsed into running paragraphs in Sections 3 and 4.3, likely a markdown conversion problem.
  • Several behavioral statements carry no normative keyword. "Approver 2's Signing Vault alerts Approver 2..." reads as a requirement but is not written as one.
  • There is no informative references section. WebAuthn is used in examples and assurance tiers but never cited.
  • There is no privacy considerations section, even though prior signers' identities and justifications are forwarded to each next approver.

The level of detail is uneven. Race condition timelines are spelled out to the millisecond. The HTTP requests that make up the actual protocol are absent.

Background of the Author

Paul Charles Williams of Barefoot Coders, LLC is the sole author. The author URI points to mandrelproject.ai, which suggests the drafts document a design from that project.

The author's Datatracker profile could not be retrieved for this review, so RFC and draft counts are not confirmed. The two PoI drafts are the only documents from this author among the OAuth individual drafts tracked here, and both are -00 revisions dated 30 October 2026. This looks like a new IETF author making a first submission.

Publishing a core protocol and its extension as two simultaneous -00 drafts is a sign the design was completed elsewhere and brought to the IETF afterward. Feedback on scope and charter fit should go to the Core draft first, since this one cannot move without it.