Review · October 26, 2026
KYAPay Token Summary
This draft defines a JWT that an agent shows to websites and APIs. The token says who the human behind the agent is, which agent platform it runs on, and optionally carries a single-use payment credential. There are three flavors: kya+jwt (identity), pay+jwt (payment), and kya-pay+jwt (both in one token).
The Problem
Bot management systems block AI agents because they can't tell them apart from scrapers and credential-stuffing bots. Skyfire's answer is a signed token from a third-party issuer that has done KYC on the human. The token is meant to be "a strong signal of human presence behind agentic requests." Bot managers, fraud systems, CIAM systems, and the target service all read the same token on the way in.
The payment half lets the agent pay the merchant in the same request. It carries a Visa Intelligent Commerce or Mastercard Agent Pay credential, or a USDC payment.
The draft is explicit that it only defines the token format. How the token is presented, consumed, or exchanged is left to companion drafts: Using KYAPay Tokens and KYAPay Token Exchange.
How It Fits In
This is a JWT profile, not an OAuth protocol extension. It doesn't touch any OAuth endpoints or flows. The OAuth RFCs it cites are mostly there for definitions: RFC 6749 for "public" and "confidential," Token Exchange (RFC 8693) for the scope claim, and RFC 7800 for cnf. The rest of the normative references are the JOSE stack, which co-author Mike Jones wrote most of.
The OAuth WG has published JWT profiles before, like the JWT access token profile (RFC 9068). A payment credential format is a different story. Card network tokens and stablecoin settlement are well outside anything the OAuth WG has worked on. The authors admit as much and offer to split PAY out "if desired by a working group."
So where does the identity half belong? Its main use case is getting past bot management. That's the job of the Web Bot Auth WG, which already uses HTTP Message Signatures to identify agents. The cnf processing in the companion draft uses HTTP Message Signatures too. The draft doesn't mention Web Bot Auth at all.
It also overlaps with several agent drafts in this same batch. The actor chain and actor profile drafts model "agent acting for a human" with RFC 8693's act claim. KYAPay does it differently: sub is the agent's account ID, and the human is nested inside a new hid claim. The human identity sub-claims reuse OpenID Connect claim names (email, given_name, family_name) but invent their own verification fields instead of using OpenID's verified_claims.
What It Defines
There are three parties, all of which must be known to the issuer:
- Initiator: the human or org (
hid), their agent platform (apd), and the agent itself (aid). - Target: the merchant, website, or API receiving the token.
- Issuer: a "trusted neutral entity" that does KYC/KYB on initiators and targets and signs the tokens. The draft compares it to a Certificate Authority.
Common claims: iss (must be an origin), sub, aud, iat, exp, jti, plus optional tdm (target domain), tsi (target service ID), itg (initiator's internal tag), ori (originator URL), env (production/sandbox), and cnf.
Identity claims:
hid: email (required), names, phone, org name, plusverifier,verified,verification_id.apd: platform ID, name, contact info, same three verification fields.aid: agent name, the IP address it requested the token from (creation_ip, required), and the IPs or domains it will make requests from (source_ips).
Payment claims: amount (amt), currency (cur), amount in settlement units (val), settlement type (stp: card or coin), and settlement info (sti). sti holds the network token, expiry, and a single-use cryptogram. There are also optional pricing claims: target price (tpr), pricing scheme (tps), and max requests (mnr).
Keys are found at /.well-known/jwks.json on the issuer's origin. The draft registers that well-known suffix with IANA.
Tokens are bearer tokens by default. Including cnf makes them sender-constrained. How a recipient enforces that is defined in the companion draft.
The -02 revision added a lot of real substance. It added cnf, the issuer key discovery section, clock skew rules, alg-substitution protections, a ban on PANs and static CVVs, and much better security considerations.
Significant Interoperability Concerns
The aud claim is an account ID at the issuer. Every example uses a UUID labeled "Target Agent Account ID." So a target has to be registered with each issuer and learn its ID at each one before it can validate aud. That's a closed network, not an interoperable format. The optional tdm (target domain) is the claim that would work across issuers, and it isn't required.
There's no trust model. Validation says to "ensure that the token is signed by the expected valid issuer." How does a merchant decide which issuers to trust? The CA analogy in the intro is the right comparison, but CAs come with root programs, audits, and policies. Here a target has to configure each issuer by hand. In practice that means a bilateral deal with Skyfire.
verified: true doesn't say anything specific. It's a boolean with a verifier URL and an opaque ID. There's no level of assurance, no method, and no timestamp. The sibling ID verification methods and AML methods drafts were written to fill this gap, but this draft doesn't use them. Two issuers can both say verified: true after an email confirmation and after a passport check.
Payment credentials go to every intermediary. The security considerations say the token is meant to be read by "bot management and fraud systems at the edge, identity providers, and the target service." That's why it isn't encrypted. It also means a CDN's bot manager sees a live card network token and cryptogram for every paid request. The single-use argument holds for replay. It doesn't hold for a compromised intermediary that sees the credential before the merchant uses it.
The payment semantics are thin. val is "token amount in settlement network's units," and units are never defined for either stp value. There's nothing about capture, refunds, partial use, or what happens when mnr runs out. tps includes pay_per_mb and subscription with no definitions at all. Two merchants will interpret a 1600-request, $15 pay-per-use token differently.
Required fields that don't fit every case. hid is listed as "REQUIRED (Required for human identity use cases)," which contradicts itself. hid.email is required even when the principal is an organization. creation_ip is required, but nothing says what a recipient should do with it, and an agent's IP in a cloud environment rotates.
source_ips has no defined processing. It accepts CIDR ranges, start-end pairs, and DNS names. The draft doesn't say if recipients should reject requests from other IPs, or how often to resolve the domain names.
Generic names in the global JWT claim registry. env, cur, amt, val, ori, and sti are short, generic names registered for one application. The next spec that wants an "amount" or "environment" claim will collide with them. All 16 new claims could be nested under one or two top-level claims, which would avoid this.
Claiming /.well-known/jwks.json. The registration describes it as the keys "with which the origin signs KYAPay tokens." That's a generic URL lots of sites already serve for other purposes. RFC 8414 metadata with a jwks_uri already solves key discovery without claiming a generic name.
Mechanisms That Could Be Removed
- The PAY token and
kya-pay+jwt. Split them out like the authors suggested. They need a different working group and a much deeper spec. tpr,tps,mnr. These describe the merchant's pricing, which the merchant already knows. Validation step 5 just checks that they match the merchant's own config.env. Use separate issuers or separate keys for sandbox. Anenvclaim the recipient forgets to check is a sandbox token accepted in production.itgandori.itgis opaque and internal to the initiator, so it's useless to recipients.oriis never defined beyond "URL of the token's originator."- The repeated
verifier/verified/verification_idtriplet inhid,apd, andsti. Replace it with theivm/amlclaims from the sibling drafts, or with OpenIDverified_claims.
Writing Quality
The technical sections added in -02 are tight and clearly written, with standard IETF language. The JWT validation, clock skew, and security considerations sections are the best parts of the draft.
The introduction is a sales pitch. Agents need "ubiquity of access across the Internet," which is "a feat made possible by KYAPay Token Issuers." It also says the tokens let agents "bypass common blocking mechanisms." That's a bad way to pitch this to the bot management vendors it needs on board. The four use case paragraphs could be cut to one.
Smaller issues:
- The privacy section is in first person ("If I authorize an agent to shop for a widget...").
- The PAY validation steps say "the price that you configured" and use no normative language.
jtimust be a UUID according to validation step 5, but the claim definition doesn't say so.- "Pairwise unique within a given issuer" for
subis confusing, since "pairwise" usually means per relying party. - Typos: "a way for the target list how it charges," "maintain a direct customer relationships."
- All IANA registrations list Mike Jones personally as change controller instead of the IETF.
At 36 pages, the length is mostly IANA boilerplate and examples. The real content is reasonably compact.
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, JWS, JWK, and Token Exchange. Co-author on every Skyfire draft and has many other active drafts.
Bottom Line
This is a vendor token format from a production system being brought to the IETF. The -02 revision fixed many security basics. The bigger problem is structural. aud is an issuer-specific account ID, there's no issuer trust model, and the protocol that actually uses the token lives in another draft. That makes this a description of the Skyfire network more than an interoperable standard.
Feedback should push for four things. Split out PAY. Nest the claims rather than registering 16 short global names. Make aud or tdm something a target can validate without registering at every issuer. Coordinate with Web Bot Auth, since that WG is already working on the bot management use case.
For related reading, see the companion Using KYAPay Tokens draft and the Web Bot Auth WG.