Review · November 22, 2026
A Verifier-Side Acceptance Profile for Channel-Bound Agent Identity and Authorization
The Problem
A token can be perfectly valid and still be accepted for the wrong thing. The draft calls this "context diversion": a grant and proof of possession that verify correctly, but get applied to a different service, tenant, actor, task, or target than the verifier intended.
The draft's answer is a checklist for the verifier. An agent is accepted only when the grant, the holder-of-key proof, the specific TLS connection, the replay state, any attestation, and local policy all describe the same interaction.
How It Fits In
This is an individual submission with no stream or working group set. It sits in the agent protocol discussions, but pulls from TLS, RATS, OAuth, and WIMSE.
It does not extend any existing RFC. It builds on TLS 1.3 exporters, Exported Authenticators, and the RATS roles, without changing them.
The OAuth connection is thin. OAuth and WIMSE specs are treated as optional inputs:
- ID-JAG can serve as the authority grant, if it carries a
cnfclaim withjkt. - DPoP counts as an "inherited" possession input. It cannot replace the draft's own session proof.
client_idmust not be mapped to the acting agent automatically.resource,scope, andauthorization_detailsare "observed" values, never expected policy.
There is no authorization server, client, or resource server in this draft. The roles are a policy authority that issues grants, an actor that holds a key, and a verifier. No new relationships between OAuth roles are created.
What It Actually Defines
The draft is a "core profile". It says outright that it is not a complete wire specification. A separate "binding profile" has to supply the wire format before anything can interoperate. No binding profile exists yet.
Here's what the core does define:
- An authority grant. A signed statement from a policy authority saying what the actor may do, bound to the actor's key. No new token format is defined.
- A session proof. The actor signs a statement tying that exact grant to this exact TLS connection.
- A channel binding construction. The verifier builds a context string from the endpoint role, interaction type, audience, grant hash, task, target, and a verifier nonce. That context goes into the TLS exporter. The proof carries hashes of the result.
- An optional attestation binder. A hash that ties RATS evidence to the same connection.
- A verification procedure. Eleven authentication steps, four policy steps, then an atomic replay commit before the application sees a result.
- An "accepted assertion". The typed internal output the application is allowed to consume. Anything absent from it was not accepted.
Policy is organized into eight "dimensions", D0 through D7, covering channel, attestation, binding, service, actor, task, target, and authorization.
The consistent rule is that nothing the peer sends defines what the verifier expects. Expected values come from local policy only.
Interoperability Concerns
Two conforming implementations cannot talk to each other. Table 4 lists more than twenty items a binding profile must define, including token types, claim names, the exporter label, nonce delivery, and how task_context and target_context are built. The draft defines no exporter label and makes no IANA requests. Appendix A is a non-normative "sketch" of an HTTPS binding.
The byte-level parts are fixed while everything around them is open. The grant hash prefix, the context field order, and the length encoding are all normative. The values that go into those fields are not. This is the wrong way around for a document that calls itself Informational and defers the wire format.
The holder has to reproduce the verifier's context exactly. The exporter context includes the nonce, the task context, the target context, and an attempt ID, all drawn from "verifier-local state". The actor needs every one of those bytes to compute the same exporter value. How they reach the actor is left to the binding profile. This is the part most likely to break in practice.
Direct mode needs end-to-end TLS. If a load balancer, CDN, or service mesh terminates TLS, the verifier cannot get the exporter value, and the draft says Direct-Agent mode "is not applicable". That describes most production deployments. Token Binding failed for the same reason, and DPoP moved proof of possession to the application layer to avoid it. The gateway-routed alternative is a list of requirements for a future profile, not a mechanism.
One proof per task per connection. Every task needs a fresh nonce, a fresh exporter computation, a fresh signed proof, and a strongly consistent replay store. Resumption and 0-RTT are excluded. That is a heavy cost for agents making many tool calls.
What Could Be Removed
A lot of the text states requirements for documents that don't exist yet. These could be cut or moved to the binding profiles that need them:
- The gateway-routed mode section
- Human approval evidence rules and the hospital consultation example
- Operation retry and result recovery in Section 20
- Reverse requests and callbacks
- Path migration and application-session continuation
- The Permit/Deny/Indeterminate/NotApplicable paragraph
- Diagnostics guidance
- The key cache scoping tuple
What's left would be the invariant, the channel binding construction, and the verification procedure. A stronger version of this draft would be that core plus one complete HTTPS binding with a registered exporter label.
Writing Quality
The prose is grammatical and uses BCP 14 keywords correctly. Individual sentences are clear.
The document is too long for what it specifies. It runs 43 pages and the mechanism fits in about three. The same rule, that peer-supplied values are not policy, is restated in nearly every section. Much of the text is defensive negation: lists of things that do not prove something else.
The scope has grown by accretion. The relationship table engages with three other individual drafts, including security principal binding, and several paragraphs read like replies to mailing list comments. The D0 through D7 labels collide with another draft's D1 through D7, and the draft has to say so.
One justification is missing. The draft never explains why DPoP or mutual TLS sender-constrained tokens, combined with ordinary audience and scope checks, are insufficient. The negative test table rejects a "valid sender-constrained token" with no exporter binding, but no concrete attack is shown that those mechanisms miss.
Author Background
Akira Okutomi is listed as an individual with no affiliation.
- No published RFCs.
- Two active Internet-Drafts, this one and
draft-okutomi-agent-human-interaction. No expired drafts. - A new IETF author. Both drafts are in the agent space.
This draft has had eight revisions since June 23, 2026. Six of them landed in the first ten days. The title has changed since the draft name was chosen, from session-bound to channel-bound.
Bottom Line
The underlying point is correct. Verifying a token is different from accepting it for this request on this connection, and agent deployments that stack grants, proofs, and attestation make that gap easier to fall into.
The draft is a framework for future profiles, not something to implement. The questions to put to the author are which single protocol binding comes first, and how it works behind a TLS-terminating gateway.