Review · October 26, 2026
JWT Access Tokens as W3C Verifiable Credentials
The problem it's solving
OAuth access tokens and W3C Verifiable Credentials are both signed statements from an issuer about a subject, presented by someone holding a key. Today a deployment that wants both issues two objects and runs two stacks.
This draft makes one JWT serve as both. It's an RFC 9068 JWT access token, bound to the client's key with DPoP, and it's also a valid VC secured with JOSE. The resource server sees a normal DPoP-bound access token and changes nothing. A verifier running VC tooling can process the same object as a credential.
AI agents are the motivating case. An MCP server is already an OAuth resource server. The pitch is that the token the agent sends to the MCP server is also a credential that says which user the agent is acting for.
How it fits in the working group
In charter. It's a pure profile. It defines no new claims, header parameters, endpoints or IANA registrations. It only says which existing claims must be present and how the JWT claims map to VC properties.
Normative OAuth/JOSE dependencies are RFC 7515, 7519, 7638, 7800, 8725, 9068 and 9449. All are published. RFC 8414, 8693, 8707 and the Token Status List draft are informative.
The two other normative dependencies are W3C specs: VC Data Model 2.0 and VC-JOSE-COSE. That's the unusual part. The profile's success depends on how VC verifiers behave, and the OAuth WG has no say in that. The author admits this in the open issues.
It maps OAuth roles directly onto VC roles. The AS is the issuer, the client is the holder, and the RS may be the verifier. No new relationships between parties are created. The draft also tightens RFC 9068 in a few places:
audmust be exactly one value naming one protected resource.issandsubmust be URIs.- DPoP is mandatory. Bearer use is prohibited.
What the mechanism actually does
- The AS issues a JWT with
typ: at+jwtandcty: vc. Thetypkeeps RFC 9068 resource servers happy. Thectymarks the content as a VC. - The payload carries both sets of fields side by side.
iss/issuer,sub/credentialSubject.id,exp/validUntilandjti/idmust match.cnf.jktbinds the token to the DPoP key. @contextmust start with the W3C credentials context. Sinceclient_id,scope,jtiandcnf.jktaren't defined there, the token must also include the "undefined terms" context.- Presenting to a resource server: standard DPoP. Seen as a VC, the DPoP proof is the holder binding. No separate presentation object is created.
- Presenting to a verifier: the client wraps the token in a presentation protocol such as OpenID4VP. The verifier checks the signature,
validUntil, holder binding viacnf, and the token'saud.
Significant interoperability concerns
The verifier path only works when the verifier is a resource server. Because of the single-audience rule, a verifier accepts the token only if aud names it. So the AS must know the verifier as a protected resource it can issue tokens for. An OpenID4VP verifier is an OAuth client known by a client ID. That's exactly the case the draft puts out of scope. What's left is a party the AS already treats as a resource server, which could just accept the token over DPoP. The draft needs a concrete deployment where a party is a known resource server but still wants the token through a VC presentation protocol.
What does the VC actually tell the verifier? In the example, credentialSubject holds only id. Everything meaningful, like client_id and scope, sits in top-level claims the VC context doesn't define. A VC library sees a credential that says "this subject exists" and little else. The "on whose behalf the agent is calling" claim from the introduction is just sub, which every RFC 9068 token already carries.
typ: at+jwt depends on VC verifiers being lenient. VC-JOSE-COSE recommends vc+jwt. Any verifier that enforces that rejects these tokens unless it adds a special case. The draft can't fix this from the IETF side. It needs a statement from the W3C VC WG before anyone can count on it.
Holder binding through cnf.jkt isn't defined in the VC context. The VC context defines cnf.jwk and cnf.kid, but not jkt. Verifiers that only understand the defined members can't find the holder's key. The open issue asks whether to add cnf.jwk. That should be decided, not left optional. A token that's valid but has no holder key a verifier can find doesn't interoperate.
Two status mechanisms, with no way to tell which one applies. A deployment can use a Bitstring Status List or a Token Status List, or both. It "MUST specify which mechanism it uses," but nothing in the token or metadata says so. For tokens that live for an hour, pick one or drop status entirely.
The DID options are a second profile in disguise. Section 3.2.1 lets sub be a DID that resolves to the holder's key when the subject is the holder. Section 3.2.2 allows a non-https iss where keys are configured out of band. Both cut against the draft's own rules. The holder is the client identified by client_id, and RFC 8414 means iss is an https URL in practice. Each option adds a code path that most implementations won't support.
Mechanisms that could be removed
DID as sub/credentialSubject.id. It also forces a long-lived DPoP key, which undercuts the draft's own advice to use per-token keys. Cut it.
Non-https iss. Almost no RFC 9068 deployment can use it. Cut it.
Bitstring Status List. If status stays, use the OAuth WG's Token Status List and drop the W3C alternative. Better still, rely on short lifetimes and drop status entirely.
"SHOULD express the same instant" for validUntil. Make it a MUST, or remove it. A SHOULD leaves room for VC and OAuth validators to disagree, which the paragraph exists to prevent.
Writing quality
Very good. It uses normal IETF register and precise section-level citations, and it states its scope up front. The Applicability section is a model of how to bound a profile: five conditions, each one testable. The justifications sit next to the decisions they explain. The typ/cty argument is one example.
It's concise. The main text runs about ten pages, with two mapping tables that do most of the work. Some sentences are long and stack qualifications, especially in Sections 3.2.1 and 4.2. The Document History is unusually honest. It flags a wrong statement in -02 and corrects it.
The -02 rewrite took feedback from the list seriously. The draft dropped SD-JWT and arbitrary credential presentation, and that narrowed it a lot. That shows in how tight it reads now.
Author background
I couldn't reach Datatracker from this session, so this is based on the local draft corpus.
Su-hyeon Forten Lee is the sole author, using a personal email address with no listed affiliation. Their name doesn't appear on any RFC in the local corpus, so they look like a new IETF author. They're very active right now, with three OAuth individual drafts this month:
- This draft, already at -03.
- draft-forten-oauth-sd-jwt-access-token, which adds selective disclosure to RFC 9068 tokens.
- draft-forten-oauth-scope-metadata-document, about dereferencing URI scopes.
The first two follow the same pattern. Each gives the RFC 9068 token a second job while the RS stays unchanged.
Questions worth raising
- Who is the verifier in a real deployment? If it has to be a resource server the AS already knows, why not just accept the token over DPoP? Give one concrete MCP or agent scenario where the VC path does something DPoP can't.
- Has the W3C VC WG weighed in on
at+jwtwithcty: vc? Without that, the verifier path depends on lenient implementations. - Should the meaningful claims move into
credentialSubject? Otherwise VC tooling gets a credential with almost no content. - Can the profile commit to one holder-binding form, one status mechanism, and https
issonly? Each optional branch removed makes interop more likely.
For the token being profiled, read RFC 9068. For the binding mechanism, read DPoP.