The device grant: how an agent with no browser asks
Status: ruled (D-AI11, 2026-11-05). The LifeCare.ID® issuer will offer the device authorization grant (RFC 8628) for an agent that cannot host a redirect. This note comes first. The sandbox implementation follows the note, and production follows the sandbox, gated. Every line below describes what the issuer will do. The sandbox page lists what is live, and this page is updated when the sandbox implementation lands.
Some agents have no browser and no address a redirect can come back to: a voice assistant, a command-line agent, an agent on a device with no screen. The person still decides, on the LifeCare.ID® origin, as in person-managed authorization. The device grant lets the agent start the request and lets the person answer on a device of their own.
When it applies
The handoff has three routes, in this order (D-AI11):
- A same-device link, opened in the person's own browser.
- A QR code, when the person is on another device.
- The device grant, only where no redirect can be hosted.
An agent that can use the first or second route uses it. The device grant is the third route because it asks the person to carry a code between two devices, and a code carried by hand is the step a phisher imitates. The sections below say how the issuer will limit that.
The flow in plain terms
- The client asks the issuer for a device code and a user code. It sends its
client_idand the one scope it wants, with theresourcethe token is for, as for any request. - The issuer answers with
device_code(for the client only),user_code(short),verification_uri,verification_uri_complete(optional, the address with the code carried in it),expires_in(the lifetime in seconds) andinterval(the least number of seconds between polls; 5 when absent, RFC 8628 section 3.2). - The client shows the person the
verification_uriand theuser_code, even when it also offers the complete address. It never shows thedevice_code. - The person opens the verification address on their own device, and enters the code or follows the complete address.
- The person signs in with their passkey, or creates their LifeCare.ID®, on the LifeCare.ID® origin.
- The page shows what is authorized and who asked. The person says yes or no.
- Meanwhile the client polls the token endpoint, no faster than
interval. It receives a token bound to one resource after a yes. Before the answer it receivesauthorization_pendingand keeps polling at the same interval. Onslow_downit adds 5 seconds to its interval, for that poll and every later one (RFC 8628 section 3.5). Onaccess_denied(a no) orexpired_token(the code's life ended) it stops, and on any other error it stops.
What the verification page will show
Status: ruled, arriving with the sandbox implementation (planned). The page will show:
- The hostname of the client, taken from its client-ID metadata document, in the same asker line as the consent page ("An app or AI assistant is asking:
at "), and the words "Not reviewed by LifeCare.ID®" at the T0 ceiling (Client-ID metadata documents). - The one scope, in plain words, and the resource it is for.
- The tier line.
- A line asking the person to confirm that the code on the page is the code shown on the device that asked.
- The yes and the no. The yes is rendered on the LifeCare.ID® origin only, never by the client.
The mitigations, and what the issuer will do for each
RFC 8628 section 5 lists the ways the flow can be attacked, and two further rows below come from the issuer's own terms. For each, in plain words, with what the issuer will do (status: ruled, arriving with the sandbox implementation):
| The risk, and where it is named | What the issuer will do |
|---|---|
| A guessed user code (5.1): someone tries codes until one matches a waiting request. | Issue a user code with enough entropy for the one data scope it protects, give it a short life, limit the attempts per code and per source, and count a failed attempt against the request. |
| A guessed device code (5.2): someone guesses the secret the client polls with. | Issue a device code with high entropy, never shown to a person, and refuse a poll from any client but the one the code was issued to. |
| Remote phishing (5.4): someone talks the person into approving a request the person did not start. | Name the client and say an app or AI assistant is asking, ask the person to confirm the code matches the device in their hand, and warn that nobody legitimate asks a person to enter a code they did not request. |
| A code that lives too long (5.4): a code sent by message is useful to a phisher for as long as it lasts. | Keep the life of a user code short, and end the request on a no. |
| The complete address (3.3.1): the code is carried in the address, so the person types nothing. | Use it only to open the page on the person's own device, show the code on the page, and still ask for the yes. It is never a way around the question. |
| A client that is not what it says (5.3, 5.6): a device client cannot keep a secret, and the person cannot see who made the device. | Treat it as a public client with no secret (5.6), issue no token to a client other than the one that asked (5.2), and show its hostname from its document. For 5.3 the person's reading of that hostname is the remaining check. |
| Someone watching the screen (5.5): a person nearby finishes the request first. | The client shows the code only where the person is (5.5 asks a device to take its environment into account). The issuer's part is the confirmation on the page, which shows what is authorized and who asked, so a request the person did not start is visible as such. |
| A code spoken aloud (5.7): someone in earshot uses it. | Ask the client to speak the code only where only the person can hear it. The page still asks the person to confirm the code and still asks for the yes. |
| Polling too fast (beyond section 5; see 3.2 and 3.5): a client or an attacker loads the token endpoint. | Set the interval, answer a faster poll with a request to slow down, and limit polls per code. |
| A token that outlives the person's mind (beyond section 5, the issuer's own terms): a yes given once and forgotten. | Bind the token to one resource with the 1200-second life of every data token, issue no refresh token, and let the person revoke from their data-rights panel on the LifeCare.ID® origin. |
What an agent must never do
- Never read the code to the person as if it were the agent's own, or as though the agent were asking the person to prove who they are. The code names a request the agent made.
- Never ask the person to paste, type or read back a code that came from somewhere else.
- Never poll faster than the issuer tells you.
- Never show the device code, log it or send it on.
- Never hold the person's key, passkey, recovery link or any credential, and never answer the question for the person.
- Never start a request the person did not ask for.
What the sandbox implementation will need
This is the content of a future work row, with no date. A build row follows this note.
- A
device_authorization_endpoint(RFC 8628 section 4) in the RFC 8414 metadata the issuer already serves, andurn:ietf:params:oauth:grant-type:device_codein itsgrant_types_supported. - The verification page on the LifeCare.ID® origin, with the lines above.
- The code rules: the user code's alphabet, length and life, the device code's entropy, the attempt limits.
- The polling rules: the interval, the slow-down answer, the expiry answers.
- Tests for each mitigation in the table, and an update to this page and to For coding agents when it lands.
Sources checked
Fetched on 2026-11-05:
- RFC 8628, OAuth 2.0 Device Authorization Grant: https://www.rfc-editor.org/rfc/rfc8628.html (sections 3.2, 3.3, 3.5 and 5 read)
- Model Context Protocol, Authorization, revision 2025-11-25: https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization (the page names no device grant; it describes the authorization code flow with PKCE)
For coding agents
If you are an agent that cannot host a redirect, follow these lines. They describe the ruled policy, and the sandbox page lists what is live.
- Use the same-device link first, the QR code second, and the device grant only where no redirect can be hosted.
- Build with a registered client or a client-ID metadata document, as Client-ID metadata documents sets out.
- Ask for one data scope and one
resource. - Show the person the verification address and the user code. Never show the device code.
- Poll the token endpoint no faster than the interval you were given. When told to slow down (
slow_down), add 5 seconds to the interval and keep it. - Stop on a no, on an expired code, or when the person is gone.
- Never read a code as your own, never ask for a code from elsewhere, and never hold the person's key.
- After a yes, keep the receipt, use the token at its one resource, and tell the person they can revoke it in their data-rights panel on the LifeCare.ID® origin.