Review · November 10, 2026
KYAPay Token Exchange Summary
This draft lets an agent trade a KYAPay token for an OAuth access token at a service it has never registered with. It is the one draft in the Skyfire family that is actually an OAuth protocol.
The Problem
An agent shows up at an API or MCP server on behalf of a user. The user has no account there, and the agent has no client registration there. Pre-provisioning both at every service an agent might visit doesn't scale.
The draft's answer is to treat the KYAPay token as the introduction. A third-party issuer has verified the human and the agent platform. The service's authorization server validates that token, creates or finds an account, and issues a normal access token.
The stated design goal is "enabling agents to create accounts and/or log in to accounts on behalf of their human principals."
How It Fits In
This fits the OAuth WG charter. It is a profile of Token Exchange (RFC 8693) plus one metadata parameter.
It adds very little new machinery:
- A token type URI,
urn:ietf:params:oauth:token-type:kyapay. - A grant profile identifier,
urn:ietf:params:oauth:grant-profile:kyapay. - An authorization server metadata parameter,
kyapay_issuers_supported. - A new client ID syntax with a
kyapay:prefix.
Discovery is all reused: Protected Resource Metadata (RFC 9728), RFC 8414 server metadata, and RFC 8707 resource indicators. The grant profile parameter comes from the Identity Assertion Authorization Grant draft. Client identity optionally uses Client ID Metadata Document.
The new relationship is between the authorization server and a third-party KYAPay issuer. The authorization server accepts a token from an issuer in another trust domain as proof of both who the user is and who the client is.
That is the same shape as ID-JAG, and the comparison matters. ID-JAG and the identity chaining draft both present a cross-domain assertion with the RFC 7523 jwt-bearer grant. The -01 revision of this draft did the same. -02 switched to RFC 8693 token exchange and doesn't say why. -01 had explicitly argued that token exchange was the wrong fit.
What It Defines
The flow has eight steps. The agent fetches the resource's metadata, picks an authorization server, and checks that server's metadata for the kyapay grant profile. It then posts a token exchange request with the KYAPay token as subject_token and the resource URL as resource. The authorization server returns an access token, bearer or DPoP-bound. The agent calls the resource.
There are two ways for the agent to identify itself as a client.
Direct method. The client ID is built from the token's own claims: kyapay: followed by iss, ori, apd.id, and aid.id, separated by |. There is no client authentication and no registration. The authorization server has to recognize the prefix and accept the client on sight.
CIMD method. The client ID is the agent's CIMD URL. The client should authenticate with private_key_jwt if it can hold a key. Otherwise it uses no authentication.
kyapay_issuers_supported optionally lists which KYAPay issuers the authorization server accepts. The list can be partial or empty.
That's the whole spec. The body is about five pages.
Significant Interoperability Concerns
There are no processing rules for the authorization server. The draft lists the request parameters and stops. It never says to validate the KYAPay token, how to decide the issuer is trusted, whether to check exp or jti, or what error to return. Section 3 says the server issues an access token "using information from the KYAPay token." Everything a second implementer needs is missing.
Audience checking doesn't work as written. A KYAPay token is audience-restricted to a target through aud, tsi, and tdm. The draft never says how those relate to the authorization server or to the resource parameter. The draft's own example shows the gap: the token has tdm set to auth101.dev and the request asks for https://mcp.acme.example/. Without a rule, a token minted for one site can be exchanged at another.
This is probably why -02 left jwt-bearer. RFC 7523 requires the assertion's audience to be the authorization server, and a KYAPay token's aud is an account ID at the issuer. Switching grant types removed the requirement. It didn't remove the problem.
The direct method is a bearer token redeemable for an access token. The client ID is derived from the token and there is no client authentication. Anyone holding the token is the client. KYAPay tokens are designed to be sent in a header to websites, CDNs, and bot managers. Any of those parties can now turn the token into an access token at the user's account. The token format has a cnf claim for proof of possession. This draft never mentions it.
The CIMD method doesn't bind the client to the token. The client proves it controls a CIMD URL. Nothing ties that URL to the apd or aid in the token. Any CIMD client holding any KYAPay token gets through.
Account matching is unspecified, and the use case describes matching by email. The intro has the server "extract claims associated with the human principal, such as email addresses" to log in to accounts. Logging in to an existing account from a third party's email claim is the classic account takeover path. The Using KYAPay Tokens review flagged the same thing. The security considerations here are one sentence pointing at other documents.
It targets the wrong version of the token. The normative reference is KYAPay Token -02. Token -03 was published the same day and made hid.email optional, with a pairwise hid.id as the default identifier. The example here has an email and no hid.id, so it isn't a valid -03 token. With -03, aid.id is also different at each target service. The direct-method client ID changes per target, which the draft doesn't acknowledge.
Payment tokens are not addressed. The token type URI is just kyapay. The intro mentions "payment capabilities." The draft doesn't say whether pay+jwt and kya-pay+jwt tokens are accepted. If they are, a single-use card cryptogram gets posted to a token endpoint with no rule about what happens to it.
Scope has no rules. The example token carries scope. The request has no scope parameter. How the granted scope relates to the token's scope is undefined.
The agent relationship isn't carried forward. The intro says the service can tell agent sessions from human sessions. The draft doesn't use act or say anything about what the access token conveys. That's fine if the access token is opaque to everyone but the service. It should say so.
Client ID encoding. The example sends kyapay:https://app.skyfire.xyz|https://... unencoded in a form body. ori and apd are optional, so the ID can contain empty segments like ||. ori is defined only as "URL of the token's originator," so this ID is built on a claim nobody can describe.
Mechanisms That Could Be Removed
- The
kyapay:client ID. RFC 8693 doesn't require aclient_id. The direct-method ID contains nothing the server can't read from the token. It adds a new client ID scheme, an encoding problem, and no security. Drop it and let the server derive whatever internal identifier it wants. - One of the two methods. Two ways to identify the same agent means the server sees two different clients. Pick CIMD, and bind it to the token.
kyapay_issuers_supported. It may be incomplete or empty, so an agent can't rely on it. An agent still has to try the exchange and handle rejection.urn:ietf:params:oauth:token-type:kyapay. RFC 8693 already hasurn:ietf:params:oauth:token-type:jwt. The JWT'stypheader already says which kind of KYAPay token it is.
Writing Quality
The draft is clean, standard IETF prose. Mike Jones's influence shows in the IANA sections, which correctly list the IETF as change controller this time.
It is too short. At 14 pages with five pages of body, it reads as an outline of a profile. The parameter lists in Sections 4 and 5 are identical. The space would be better spent on validation rules.
Smaller issues:
- The client ID construction in Section 4 is a list that collapsed into a sentence: "the string concatenation of - the string literal "kyapay:", - the iss claim value, -".
- "KYA Token" and "KYAPay token" are used interchangeably.
- "Mission" appears four times as a term and is never defined.
- The switch from
jwt-bearerto token exchange has no rationale, in the text or the history. - Security Considerations is one sentence. Privacy Considerations only covers the issuer list.
- The example
audandtsiare the same UUID.
Authors
Datatracker wasn't reachable from this session. This section is based on the drafts in the repo and on published history.
- Ankit Agarwal (Skyfire Systems): New to the IETF. Appears only on the Skyfire family of drafts, all of which are active right now.
- Michael B. Jones (Self-Issued Consulting): Author of dozens of RFCs, including JWT, Token Exchange, and Authorization Server Metadata. Co-author on every Skyfire draft and has many other active drafts.
- Abhishek Hingnikar (WorkOS): Appears to be new to the IETF. Joined in -01. Listed only on the Skyfire drafts in this repo.
- Jeffrey Hickman (Ory): Appears to be new to the IETF. Joined in -01. Listed only on the Skyfire drafts in this repo.
WorkOS and Ory both sell authorization servers. Like Akamai on the companion draft, that's a sign the consuming side is interested.
Bottom Line
This is the right place for the OAuth WG to engage with KYAPay. The problem is real: an agent arriving at a service with no client registration and no user account. The discovery story is well assembled from existing pieces.
The exchange itself is underspecified in exactly the places that matter for security. What should feedback push for?
- Write the authorization server's validation rules, including how
tdm,tsi, oraudmust match theresource. - Require proof of possession, or at minimum say what the server does with
cnf. A bearer token that travels through CDNs shouldn't be exchangeable for account access. - Drop the
kyapay:client ID. Bind the CIMD client to the token'sapdoraid. - Explain the move from
jwt-bearerto token exchange, or move back and align with ID-JAG and identity chaining. - Say that accounts are keyed on
issplus the pairwisehid.id, never on email alone. - Update to KYAPay Token -03 and say which token types are accepted.
For related reading, see the Identity Assertion Authorization Grant, which solves the same cross-domain problem with an enterprise IdP as the issuer, and the KYAPay Token draft this one consumes.