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

Review · November 10, 2026

Cryptographic Proof-of-Intent (PoI) Core Protocol for Human-in-the-Loop (HITL) Step-Up Authorization Summary

draft-williams-oauth-poi-core -00View on Datatracker →

Problem Statement

An AI agent holds a valid access token and calls a high-consequence API, like originating a loan or writing a prescription. The resource server cannot tell whether a human reviewed those exact parameters or the agent made them up.

The draft wants a signature from the human over the specific parameters of each transaction. It also wants that without an authorization server round trip per approval, which it calls the "OAuth Redirect Tax" of RAR plus Step-Up Authentication.

How the Spec Fits In

This is mostly a new protocol, with a small OAuth extension attached.

The OAuth part is small. The authorization server issues a new token type at login and accepts a new token type at the token endpoint through Token Exchange. Everything else happens between the client and the resource server at the application layer, which is a stretch for the OAuth charter.

It cites five OAuth RFCs (6749, 8693, 9396, 9449, 9470) plus RFC 7800 and the JOSE family. It reuses less of them than the citations suggest:

  • It borrows the idea of a step-up challenge from RFC 9470 but defines its own PoI-Challenge header instead of using WWW-Authenticate.
  • It borrows the authorization_details name from RAR, but the RS creates the object and the AS never sees it.
  • It requires a key separate from the DPoP key.

It changes the roles significantly:

  • The AS becomes a certificate authority for short-lived client signing keys.
  • The RS becomes an issuer of signed challenges and signed receipts, so it needs its own published signing keys.
  • The client splits in two: the agent, which is untrusted, and a "Signing Vault" in the frontend, which is trusted.

The companion Chained State draft depends entirely on this one.

High-Level Summary

There are four pieces.

A session signing key. At login, the Signing Vault generates a non-extractable keypair, the Ephemeral Intent Key. The AS issues a Key Certification Token (KCT), a JWT that binds the user, the session, and a 30-minute window to that public key. The Vault rotates the key by signing a rollover request with the old key and sending it to the AS.

A signed challenge from the RS. The agent calls the API. The RS returns a 403 with an Intent Challenge Object: a JWS containing the proposed parameters, their hash, and display_facts. The display facts are the RS's own human-readable rendering of the parameters, like a patient name instead of a UUID. The agent cannot alter what the human sees without breaking the RS's signature.

A signed decision from the human. The Vault verifies the challenge, shows the display facts, and the human chooses APPROVE, REJECT, or SUPERCEDE (edit the parameters). The Vault signs the decision at one of three tiers:

  • Tier 1 is a button click signed with the session key.
  • Tier 2 is a WebAuthn ceremony with user verification.
  • Tier 3 is a WebAuthn ceremony with a hardware security key.

The RS picks the tier per action. The challenge and decision travel back to the RS as a two-node "envelope".

A receipt. The RS verifies the envelope, executes the parameters directly, and signs a receipt with its own timestamp. Auditors use the receipt to prove the signature existed while the session key was still valid.

So what does this mean for the AS? Tier 1 approvals never touch it. The AS only sees login and a key rotation every 30 minutes.

Interoperability and Necessity

Significant interoperability concerns

The AS interface is the part that most needs a standard, because the AS is usually a different vendor from the client and RS. It is the least specified part of the draft.

  • Initial KCT issuance has no wire format. The draft says the client "submits the EIK public key" during authentication. There is no parameter, no endpoint, and no proof that the client holds the private key.
  • Key rollover over Token Exchange is a MAY. No other transport is defined.
  • There is no AS metadata to advertise support.

The envelope is never defined. The draft names fields like node_type, node_hash, seq, and assertion_jws in passing, but there is no schema and no example. The Tier 2 and Tier 3 node format is missing entirely. A verifier needs authenticatorData, clientDataJSON, a signature, and a credential ID, and the draft does not say where they go.

Hashes are "lowercase hexadecimal or base64url". Two implementations that pick differently will never match.

The Vault has to verify the RS's signature on the challenge. The draft never says how the Vault finds the RS's keys.

WebAuthn tiers assume the RS can look up "the registered credential public key associated with the signer". WebAuthn credentials normally live at the AS. The draft does not say how the RS gets them or who the relying party is.

Nothing ties the human signer to the request. The verification algorithm never compares the KCT sub to the access token, or to the user the agent is acting for. That is left to the "orthogonal policy layer", which is where the confused deputy problem gets solved or not.

The protocol is called stateless, but it is not. The RS has to track consumed challenge_id values, cache challenges for detached mode, and return session_revoked. The draft gives the RS no way to learn that a session was revoked at the AS.

The HTTP details conflict with existing RFCs:

  • Many errors return 401 without WWW-Authenticate, which RFC 9110 requires.
  • authorization_details is a single object here. RFC 9396 defines it as an array.
  • session_id duplicates the existing sid claim.
  • A JWS typ value with a parameter (poi+jwt;kind=chal) will trip up libraries that compare typ as a plain string.

The IANA section registers display_facts and raw_params_hash as JWT claims, but they are members of authorization_details. The real top-level claims (session_id, challenge_id, intent_id, required_tier) and the kcert header parameter are not registered.

Mechanisms that could be removed

  • Key chaining rotation. The draft justifies it by calling refresh tokens "smuggle-prone". DPoP-bound refresh tokens already solve that. A refresh request could return a new KCT.
  • The parameterized media type. Five typ values in the style of dpop+jwt would be simpler and safer.
  • Detached challenge mode and the PoI-Envelope header. Sending the envelope in the request body always works. The header variant exists only to be worked around when it exceeds 4 KB.
  • Browser implementation rules. Iframe isolation, CSP strings, extractable: false, and Permissions-Policy headers are implementation guidance. They belong in security considerations, not normative protocol text.
  • Tier 3. It differs from Tier 2 only in which credentials the RS allows. That is RS policy.
  • 19 error codes. Most of them tell an attacker exactly which check failed. A handful would do.

The bigger question is the same as for the companion draft. The Signing Vault and the RS are usually built by the same organization. The cross-vendor piece is the AS issuing KCTs, and that is the piece the draft leaves open.

Writing Quality

The draft follows IETF structure and uses BCP 14 keywords. Sentences are grammatical. It has security, privacy, and IANA sections, and a thorough error table.

It is 30 pages with no end-to-end example. There are examples for the KCT payload, the 403 challenge, and an error body. There is none for the challenge payload, the assertion, the envelope, or the receipt, which are the core of the protocol.

It is heavy on invented acronyms: EIK, KCT, ICO, PoIE, CIR. The "OAuth Redirect Tax" framing is marketing language.

Other problems:

  • "SUPERCEDE" is misspelled throughout, including in the supercedes_node_hash claim. The correct spelling is "supersede". Fix this before anyone implements it.
  • Numbered lists are collapsed into running paragraphs in Sections 4.1 and 7.2, with a stray asterisk in 4.1. This looks like a markdown conversion problem.
  • The abstract lists seven specs it builds on. That reads as borrowing credibility more than describing a dependency.
  • The main design choices are asserted without analysis. The draft never explains why RAR with step-up is too slow, why a DPoP-style proof cannot carry the approval, or why Tier 1 is meaningful when it only proves that code in an iframe signed something.

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.

The design reads as finished elsewhere and brought to the IETF afterward. The most useful feedback is about scope: specify the AS interface for certifying a client signing key, define the envelope format with examples, and move the browser architecture out of the normative text.