Review · November 10, 2026
"Agent DNS-OAuth Link: Using an Access Token as Proof the Agent Hasn't Been Disabled"
The problem it's solving
An agent at company A calls a service at company B. B wants to know two things: is this really agent01.a.example, and has company A disabled it since yesterday?
The draft only tackles the second question. Today, answering it across organizations means B's authorization server has to be configured to trust A's, through Identity Chaining or OpenID Federation. The draft argues that this pairwise setup doesn't scale for agents with many partners, so people fall back to long-lived API keys that survive the agent being turned off.
The proposal is to let the admin's existing "disable this client" button at their own IdP work as a kill switch everywhere, with no setup between the two organizations.
How it works
There are three pieces.
- A DNS TXT record. Company A publishes
_agent-oauth.agent01.a.examplecontaining an issuer, a client ID and an audience value. - A "link token". The agent gets a normal RFC 9068 JWT access token from its own AS using client credentials. The audience is a dedicated value that no resource server accepts. The token must carry no scopes, roles or permissions.
- A receiver check. B looks up the TXT record, fetches the issuer's metadata and JWKS, and verifies the token's signature, issuer, client ID, audience and age.
The token grants nothing. It is only evidence that A's AS issued a token to that client recently. If A disables the client, no new tokens are issued, and receivers reject the agent once the last token ages out. The recommended maximum age is 120 minutes, or 5 to 15 minutes for payments and production changes.
If a link record exists for a name, the token is mandatory. A receiver that has seen a record once should keep requiring the token even if a later DNS lookup fails.
So how does B know the caller's name in the first place? There are two modes:
- Channel mode. The name comes from somewhere else, such as mTLS with the agent name in the certificate, or a proprietary agent identity channel. The token rides inside that channel.
- Sender-constrained mode. The agent states its own name in a new
Agent-Link-NameHTTP header and presents a token bound with DPoP or mTLS. The name is trusted because the DNS record for that name points at the client the token was issued to.
How it fits with existing OAuth work
This is a small spec that adds one mechanism. It depends on about six OAuth RFCs (6749, 9068, 8414, 9449, 8705, 7517) plus the DNS underscore registry and HTTP Structured Fields.
It does create a new relationship between roles. In OAuth, an access token is presented to the resource server named in its audience. Here the token is deliberately presented to parties that are not the audience, and they are told to accept it anyway. The receiver is not a resource server, and the client has no registration with it.
That is an unusual use of an access token. The draft is effectively using the token endpoint as a liveness oracle for a client. The working group should decide whether that's a pattern it wants to endorse, or whether a purpose-built artifact would be cleaner.
Is it in charter? The token format and sender-constraining are OAuth. The DNS record and the agent naming model are not, and would need DNS review. The closest neighbors are in WIMSE (AIMS) and the HTTP Message Signatures work for automated clients. The draft positions itself against CIMD and the Workload Authorization Grant as complementary.
Does the mechanism earn its place?
The honest question is what the token adds over simpler options.
In sender-constrained mode, the whole chain of trust is DNS. The receiver trusts the TXT record, which points to an issuer, which vouches for a key. Company A could publish the agent's public key under its domain and sign requests with HTTP Message Signatures. Revocation is then deleting the key. That is fewer moving parts, with no AS involved at all.
In channel mode with mTLS, short-lived certificates give the same "stops working when disabled" property.
What the draft really offers is operational: the kill switch lives in the IdP admin console, where enterprise admins already manage app lifecycles in Okta or Entra. That is a real benefit. The draft should make that argument directly and compare itself to the key-in-DNS alternative.
Significant interoperability concerns
The token has no defined place in the request. The draft says the sender "presents the token with each call" and never says how. No header is named. In sender-constrained mode, Authorization: DPoP <token> is the obvious choice, but that slot is taken if the agent also has a real access token for B's API. Two independent implementations cannot interoperate on this draft today.
Channel mode is not a protocol. It requires that "the channel MUST bind the token to the authenticated sender name" with no description of how. Each agent identity system would do this differently.
"Refuse" is undefined. There's no status code, error code or challenge header. A sender can't tell a missing token from a stale one from a DNS failure.
"No change at any authorization server" is optimistic. The AS must issue RFC 9068 JWTs, must support a dedicated audience with no scopes, and must support DPoP or mTLS binding for client credentials. The draft itself allows azp, appid or cid as stand-ins for client_id, and admits that receivers may reach different results for the same token.
DNSSEC is only a SHOULD. In sender-constrained mode, a forged DNS answer lets an attacker fully impersonate the agent. The draft says this and still leaves DNSSEC optional.
Once-linked-always-linked is a SHOULD with receiver state. A new receiver, or one that lost its cache, accepts an unlinked call when the record is suppressed. Receivers will behave differently for the same agent.
There's a missing security consideration. The receiver fetches metadata from an issuer URL found in a DNS record for a name the caller chose. Any caller can point that at an internal address. That is a real attack vector (SSRF), and the draft doesn't mention it.
Revocation is slower than it sounds. Up to two hours by default, plus DNS and JWKS cache time.
Mechanisms that could be removed
- The
audfield in the DNS record. A single fixed audience value defined by the spec would remove a field and a comparison. - The alternate client claim allowance (
azp,appid,cid). It's a known source of divergent results. Requireclient_idor define a fixed mapping. - The sender's obligation to inspect its own token and "report the misconfiguration to the operator". That is implementation guidance.
- The receiver authorization policy section on wildcards. It is local policy and doesn't affect interoperability.
- Channel mode, unless a concrete binding is specified. As written it only describes the author's product.
Writing quality
The writing is good. It's 17 pages, clear, and uses BCP 14 language correctly. It has ABNF for the record, a proper IANA section, and stated goals and non-goals. The security section is short but candid about DNS weaknesses.
It is too short in the places that matter for interoperability. There is no example HTTP request, no example token, and no error handling. RFC 8705 and DNSSEC are listed as informative references even though normative text depends on them.
The implementation status section is telling. The one implementation is the author's commercial product. It uses a different record name and prefix than the draft, and does not implement sender-constrained mode. The HTTP-facing mode added in -01 has no running code.
Background of the author
Sriram Shankarlingam (HexaEight, India) is the sole author. HexaEight sells an agent identity runtime, and the draft's channel mode maps directly onto that product.
The Datatracker profile could not be fetched for this review, so RFC and draft counts are not confirmed. No other documents by this author appear in the local archive of OAuth, WIMSE, SCIM or DAWN drafts. That points to a new IETF author with this as a first draft, now on its second revision.
Questions for the working group
So what should the working group decide?
- Is presenting an access token to a party that is not its audience a pattern OAuth should standardize?
- Does this beat publishing a key in DNS and using HTTP Message Signatures, given both rest entirely on DNS?
- Where does the token go in the HTTP request, and how does it coexist with a real access token for the receiver?
- Should DNSSEC be a MUST for sender-constrained mode?
- Does the DNS-named agent model belong in OAuth, or alongside the agent identity work in WIMSE?