Review · October 13, 2026
Client Instance Identification for Attestation-Based Client Authentication
This is the second of two companion drafts published together on top of Attestation-Based Client Authentication (ABCA). The first, Client Attester Endorsement, answers "who may attest for this client?" and is reviewed in a separate post today. This one answers "which instance is this, and is it the same one I saw yesterday?"
The problem it's solving
One client_id, many instances. An app on every managed laptop, a container per replica, an agent runtime per host. ABCA gives each instance its own key and a short-lived attestation for that key. That's enough to know "this is a legitimate instance holding this key right now."
It's not enough to know "this is the same instance as before." ABCA Section 10.6 requires a fresh attestation for every new key, and the attestation only carries the key. After a rotation, a continuing installation looks exactly like a brand new one. If the AS suspended an instance, it can't tell whether the thing knocking with a new key is that instance or a different one. Audit history tied to the old key stops.
The fix is one new claim in the Client Attestation: client_instance_id, an attester-assigned identifier that survives verified key changes.
How it fits in the working group
In charter. It's a claims profile of ABCA, using the extra-claims allowance in ABCA Section 4 and the profiling rules in Section 13. No new authentication method or grant type.
Registrations:
client_instance_idJWT claim, in the Client Attestationclient_instanceJWT claim, in access tokensclient_instanceintrospection response member
This replaces the author's earlier Client Instance Assertion draft, which defined a whole separate signed assertion and a new client_instance_assertion request parameter. Moving the identifier into the existing ABCA attestation is a big improvement. One credential instead of two, and no new request parameter.
There's still an unreconciled sibling. draft-mcguinness-oauth-ai-agent-instance profiles the old Client Instance Assertion for AI agents, with its own attested agent instance identifier. That draft needs to be rebased on this one or withdrawn, otherwise there are two instance identifier claims from the same author.
Like the endorsement draft, this references ABCA -11. ABCA -12 made iat REQUIRED, so the text calling it "the optional iat claim" in Section 4 is now stale.
What the mechanism actually does
There are two independent halves.
Instance identity in the attestation. The attester adds client_instance_id alongside the usual sub, cnf, and exp. The value is opaque, at least 128 bits of randomness or keyed PRF output, never reassigned, and scoped by default to one Receiver (AS or RS). The attester keeps it stable across verified key changes and issues a new one on reinstall, clone, or anything where continuity can't be established. Section 6.2 has a useful table of lifecycle events and outcomes.
The AS treats (iss, client_instance_id) as the instance's identity. It records that pair when issuing a refresh token and requires it to match on refresh. Local policy like suspension keys off it. Rejections all return invalid_client_attestation so the client can't tell unknown from suspended from retired.
Instance context in tokens (optional). The AS can put a client_instance object, {iss, id}, in access tokens or introspection responses so a resource server can see which instance was involved without seeing the attestation. The id is the AS's own pairwise mapping per resource server, the same idea as pairwise subject identifiers. It grants no authority and, unless the token is sender-constrained to a per-instance key, doesn't prove the instance is the one presenting it.
What does the identifier actually buy at the AS?
Less than the introduction suggests, at least for refresh.
ABCA Section 10.3 binds refresh tokens to the Client Instance Key. This draft doesn't change that. Section 5.1 admits that after a key change, a refresh fails key-binding validation regardless of the instance identifier. With the original key, the identifier check only catches an attestation that names a different instance under the same key, which shouldn't happen with a correctly behaving attester. The draft says the identity check governs refresh across key changes "only under a profile that rebinds refresh tokens," and no such profile exists.
So the refresh-token rules are mostly ceremony today. The real value is everywhere else: audit logs that survive key rotation, suspension that sticks, rate limits and anomaly detection per installation. Those are real. They're also mostly AS-local uses of a claim, which is a much smaller thing to standardize than what's here.
Does this belong as a separate document?
The claim, yes. The downstream context, probably not in this document.
The client_instance_id claim answers a question ABCA deliberately doesn't. ABCA is about authenticating an instance's current key. Long-lived instance identity drags in enrollment, lifecycle, fork detection, and privacy tradeoffs that ABCA shouldn't have to carry. Keeping it in an optional profile is the right call. ABCA's Section 13 exists for exactly this kind of extension.
The downstream half, Section 7, is a different concern. It's about how an AS represents an instance in tokens, how token exchange preserves or remaps it, and what a resource server may conclude. That's the same territory as actor claims and delegation chains, and it leans on a "consuming profile" that doesn't exist yet. Section 7 is optional and "independent of the rest of this specification," in the draft's own words. That's a strong hint it should be its own document, or part of the author's actor profile work.
A split would leave a short, implementable profile for the claim and AS processing, and let the token-level question get debated on its own.
Significant interoperability concerns
Receiver Scope is invisible on the wire. Identifiers are scoped per Receiver by default, but the scope is an enrollment input, not a claim or an audience. Section 4.1 says a Receiver can't verify it and can't detect an attestation presented outside its scope. The privacy property depends entirely on the client asking the attester for the right scope and then using it only there. The client also has to keep separate Client Instance Keys per scope. That's a lot of correctness pushed onto the client with no way for anyone to check it.
Pairwise scoping leaks the Receiver to the attester. ABCA's abstract promises that the client proves its authenticity without revealing its target audience to the attester. Per-Receiver identifiers require the client to tell the attester which Receiver it's about to talk to. Section 10.3 states the tradeoff honestly. It's a real regression from ABCA's privacy model, and it's the default.
Combined-mode DPoP collides with per-scope keys. In DPoP combined mode the attested key is the DPoP key. If the AS and RS are separate scopes with separate keys, a token issued in combined mode at the AS can't be presented in combined mode at the RS. The workaround in Section 4.1 is to use normal mode at the AS with the RS-scoped key as the DPoP key, which then lets the AS and RS correlate through the key thumbprint. Implementers will get this wrong.
No discovery or metadata at all. Section 3 says claims MUST NOT select the profile and the profile adds no discovery parameter. Selection lives entirely in a trust agreement. That's defensible for managed fleets, which is the stated target, but it means a CIMD client meeting a new AS has no way to learn whether client_instance_id will be honored.
Continuity evidence is deployment-defined. What counts as proof that a new key belongs to the same enrollment is up to the deployment. That's fine, since it's between the client and its attester. But it means the identifier's meaning varies across attesters, and an AS consuming identifiers from more than one attester can't compare their guarantees.
Mechanisms that could be removed
Refresh-token identity checks (Section 5.1). Under default ABCA binding they detect almost nothing. Keep "record the identity at issuance" for audit, and drop the rest until a profile that rebinds refresh tokens exists.
Section 7, or at least most of it. Preservation and remapping through token exchange, Instance Context Authority provenance, multi-issuer introspection, and the consuming-profile hooks are about eight pages of rules for a profile that isn't written. Moving it out would also remove about half of the thirteen defined terms.
Execution vs. Installation granularity. The deployment picks the granularity and records it in enrollment. Nothing on the wire carries it, so the Receiver can't act on it. It's useful explanatory text, not something that needs normative structure.
Writing quality
Careful and precise, with the same strengths and weaknesses as the endorsement draft. The lifecycle table in Section 6.2 is the best part of the document and is exactly what an attester implementer needs. The honest statements in 5.1 and 10.3 about what the mechanism doesn't do are appreciated.
The terminology load is heavy. Thirteen defined terms, including Source Instance Identity, Instance Context, Instance Context Authority, Instance Context Identifier, Receiver Scope, Consumer Scope, and Consuming profile. Several sections can only be read with the definitions open in another tab. Most sentences carry two conditions and a cross-reference.
32 pages for one claim plus an optional token claim. The core, Sections 4 through 6, is about ten of them.
Background of the author
Karl McGuinness ([email protected]), Independent
- 0 published RFCs
- 16 active Internet-Drafts and 2 expired, including this one, the companion endorsement draft, and the AI agent instance draft. Very actively writing.
- Editor on ID-JAG, an adopted WG document.
Questions worth raising
- Should Section 7 be its own document? The instance claim and the token-level context have different audiences and different dependencies. Splitting them would let the claim move faster.
- Is per-Receiver scoping the right default? It costs ABCA's "attester doesn't learn the audience" property. For managed fleets where the attester is the organization's own MDM or workload platform, a single scope across Receivers might be the more sensible default.
- What happens to the AI agent instance draft? Two instance-identifier claims from one author should become one.
- Does refresh need instance identity at all? If refresh tokens stay key-bound, the check adds normative text without adding protection.
For the base mechanism this profiles, read Attestation-Based Client Authentication, Sections 10.3 and 10.6 in particular.