LifeCare.ID® Developer Docs Public

Client-ID metadata documents: how the issuer admits an agent

Status: the policy on this page is ruled (D-AI3, 2026-11-05). The LifeCare.ID® issuer accepts client-ID metadata documents under these rules on the sandbox (live, AI-SANDBOX-CIMD), and production follows (gated, AI-PROD-CIMD). Every rule below describes what the issuer does, and this page says where each part is live.

An AI assistant that reaches a data source naming LifeCare.ID® as its authorization server has to say who it is before a person is asked anything. This page is the text the issuer will be built to, so that a developer, or the coding agent building for one, can read in advance what is admitted and what is refused. It is part of person-managed authorization: the person decides, on the LifeCare.ID® origin, and the client's identity is only the first question.

What a client-ID metadata document is

A client-ID metadata document (CIMD) is a JSON document published at an HTTPS URL. The client uses that URL as its client_id. The issuer fetches the document, reads the client's name and redirect URIs from it, and needs no registration call. The document is specified in an IETF Internet-Draft, draft-ietf-oauth-client-id-metadata-document (revision -03 when this page was written). It is a draft, not a final specification, and it can change.

The Model Context Protocol authorization specification, revision 2025-11-25, says authorization servers and MCP clients should support CIMD, and keeps dynamic client registration (RFC 7591) as an optional path for backward compatibility. Both ChatGPT apps and Claude connectors document support for CIMD (status: documented by each platform, not checked by this page).

A client reaches LifeCare.ID® now in one of two ways: a sandbox client created through the self-service routes, or a production client the operator provisions (From sandbox to production). CIMD is the third route on the sandbox, so that a stranger's assistant can connect with no prior step.

The fetch rules the issuer will apply

Status: ruled, live on the sandbox. When a request arrives with an HTTPS client_id, the issuer fetches the document and apply the draft's rules:

The terms every admitted client gets

Status: ruled (D-PL3, 2026-11-03), live on the sandbox. A client admitted through a CIMD has these terms, with no exception for a platform:

The ceiling: tier T0

Status: ruled, live on the sandbox. Every CIMD client is admitted at the lowest ceiling, T0 (D-AG6b): the same unreviewed, read-only, short-lived ceiling that Agent trust (developer access) gives a resolvable agent. A CIMD client is not on that ladder, because it has no registered DID or manifest. At T0:

What the issuer accepts and refuses

Status: ruled, live on the sandbox.

The issuer accepts The issuer refuses
An HTTPS document whose client_id equals its URL, answered with HTTP 200, no redirect, read within 5 kilobytes A redirect, any answer other than 200, an oversize document, a special-use address
An exact redirect-URI match, including the callback URLs a platform documents for its own client A localhost or loopback redirect in production
PKCE S256, no shared secret, the yes on the LifeCare.ID® origin, no refresh token A request with no resource, or with two data scopes
A document that allows none, private_key_jwt or both, and for private_key_jwt carries a jwks or a jwks_uri with an RSA, EC P-256 or Ed25519 public key (live on the sandbox) Any other method (client_secret_basic, client_secret_post, client_secret_jwt), a private key parameter in a key set, an assertion signed with none or an HMAC algorithm, a replayed jti
Any such client at the T0 ceiling, with its hostname and "not reviewed" on the consent page Anything above T0 from a client the operator has not admitted, until the trust list can vouch
A platform hostname the operator has named once A token presented by anyone but the client it was issued to

Authenticating with a key set

Status: ruled (D-AI3 as amended 2026-11-05); live on the sandbox. A client whose document allows private_key_jwt and carries a key set may prove itself at the token endpoint with a signed assertion (RFC 7523, RFC 7521 section 4.2) instead of sending no credential. Every other term on this page is unchanged: PKCE S256, exact redirect match, no refresh token, one data scope, the 1200-second token, the T0 ceiling.

A token request carries client_id, then what the document declares. A document that declares private_key_jwt (alone or beside none) requires client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer and client_assertion, as the client-ID metadata draft asks (section 5), and a request with no credential is refused. A document that allows only none sends nothing more. The document's declaration decides, not the request. The issuer verifies the assertion like this:

The issuer's discovery documents now list private_key_jwt in token_endpoint_auth_methods_supported, and the algorithms in token_endpoint_auth_signing_alg_values_supported, on the sandbox.

Naming a platform, and rising above T0

Status: ruled, live on the sandbox. The operator names a platform's hostname once, in the issuer setting LIFECAREID_CIMD_NAMED_PLATFORMS (a comma-separated list of hostnames, empty by default and empty on the sandbox). A client on a named hostname is shown to the person by that hostname without "not reviewed". Naming a platform adds no scope and raises no tier by itself (this page's reading of D-AI3). ChatGPT's own document (fetched 2026-11-05) lists none and private_key_jwt and carries a jwks_uri; the issuer admits it now, and naming chatgpt.com takes effect now. What the tier line on the consent page reads for a named platform is defined with the consent page's agent lines (AI-CONSENT-AGENT-LINES).

A client rises above T0 only through the operator, until the trust list (D-AT5) can vouch for it. The operator's runbook for naming a platform and lifting a client, with the log of each such decision, is written (2026-11-05); the first naming act follows the operator's word, and this page says when a platform is named. Until a voucher exists, the operator is the one route above T0. The tiers and the vouching idea are on Agent trust (developer access). Two further rungs, tested and withdrawn, are adopted (D-AT3) and arriving, and will be added to that page.

What is not offered

Status: ruled (D-AI3, D-AI12).

The handoff the client must support

Status: ruled (D-AI11). The sandbox redirects a registered client to /authorize on the LifeCare.ID® origin now. The consent page's agent lines (AI-CONSENT-AGENT-LINES) are live on the sandbox. The QR code and the device grant (AI-DEVICE-GRANT-NOTE) are planned, with the sandbox first. The person answers on the LifeCare.ID® origin, so the client has to get them there:

  1. A same-device link first, opened in the person's own browser.
  2. A QR code for another device when the person is on a different one.
  3. The device authorization grant (RFC 8628) where the client cannot host a redirect, as with voice.

The device page and the consent page say what is authorized and who asked, and say that an app or AI assistant is asking. The passkey ceremony carries user verification in production. The assistant never renders, proxies or answers the consent question, and never holds the person's key.

A minimal document

The values below are placeholders. Replace them with your own. The document must be served at the URL in client_id, over HTTPS, with no redirect.

{
  "client_id": "https://assistant.example/lifecare-client.json",
  "client_name": "Example assistant",
  "client_uri": "https://assistant.example",
  "redirect_uris": ["<the callback URL the platform documents>"],
  "grant_types": ["authorization_code"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none",
  "token_endpoint_auth_methods_supported": ["none"]
}

If your client is your own agent, the template in A template to copy is the document to write. If your client is a platform, read When the client is a platform first.

A template to copy

Status: the sandbox accepts a document like this one (live, AI-SANDBOX-CIMD); production follows, gated (AI-PROD-CIMD). The file is published, as strict JSON, at https://developers.lifecare.id/client-id-metadata.example.json. JSON has no comments, so each field is explained below.

This template is for a developer's own agent: a client that runs on the developer's own domain and receives its own callback. A person who uses ChatGPT or Claude is served by that platform's own document, described in the next section, and a developer's MCP server behind a platform needs no document of its own for it. Copy the file, replace every value that names assistant.example, and serve it at the address you put in client_id.

Field What to put there The rule the issuer will apply
client_id The HTTPS address the file is served at, exactly. Must be an HTTPS URL with a path, and must equal the document's own address byte for byte. Answered with HTTP 200 and no redirect.
client_name The name of your assistant, as a person would say it. Shown to the person with the hostname of client_id. A name does not stand in for the hostname.
client_uri The home page of the client, on the same origin as client_id. Read as information only.
redirect_uris Your own callback addresses, each over HTTPS and on your origin. Matched exactly, as a string. The sandbox also accepts an http loopback address (localhost, 127.0.0.1 or [::1]) and ignores the port; production accepts no localhost or loopback address.
token_endpoint_auth_method none, or private_key_jwt if the client signs an assertion. The client holds no shared secret. Any other value is refused.
token_endpoint_auth_methods_supported ["none"]. The draft (revision -03, section 4.1) asks a client to publish the array, and marks the singular field above as kept for older readers. The template carries both. The issuer reads both, and whichever is present allows only none and private_key_jwt.
jwks or jwks_uri (optional, needed for private_key_jwt) A JWK Set with your public keys inline, or an HTTPS address that serves it. Public parameters only. RSA (2048 bits or more, RS256), EC P-256 (ES256) or Ed25519 (EdDSA); kid on each key when there is more than one. At most 16 keys. A jwks_uri is fetched under the document's own rules with a limit of 16 kilobytes, within the same 6-second limit as the document, and is kept as long as the document. When an assertion names a kid the kept set lacks, the issuer fetches the set once more (at most once a minute per address), so a rotation does not wait for the cache. Carry one of jwks and jwks_uri, never both (the draft's rule); a document with both is refused. The inline set counts toward the document's 5 kilobytes.
grant_types ["authorization_code"]. The code flow with PKCE S256 is the one flow admitted. A client that will use the device grant adds urn:ietf:params:oauth:grant-type:device_code when that grant lands (The device grant).
response_types ["code"]. As for grant_types.
scope One data scope. The template uses daily. At the T0 ceiling, one data scope per token, with the resource the token is for.
contacts An address where the issuer's operator can reach the person who runs the client. Read as information only.

The issuer will read at most 5 kilobytes of the answer; the template is well under that. The published template allows none; a client that signs an assertion changes the two method fields and adds a key set, as the table says.

logo_uri is left out on purpose. The consent page shows no logo or badge for a client, because a picture next to a request reads as approval, and admission at T0 says only that the document passed the fetch rules (D-AI12).

When the client is a platform

Status: ruled (D-AI3, D-AI7, 2026-11-05), live on the sandbox. A client-ID metadata document identifies the OAuth client. When a person uses ChatGPT or Claude, the platform is the client and presents its own document, with its own redirect address. A developer writes no document for a platform's client. What the issuer will see from each platform, from the platform's own page, is:

These are the hostnames the operator may name under D-AI3 (Naming a platform, and rising above T0). Until the operator names one, the platform's client is admitted like any other, at T0 and "not reviewed". Both platforms can change an address, so check the page again before you rely on it.

Refusal errors

Status: defined by the sandbox implementation, live on the sandbox.

A refusal at /authorize is shown to the person as an error page with HTTP 400 and a JSON body, and is never a redirect: the redirect URI is the thing the issuer has not verified. A refusal at /token is invalid_client (HTTP 401) or the error named below, always an RFC 6749 section 5.2 error object (error and error_description and nothing else); the full table is on Authorization and tokens. A refusal that is about the network or the issuer's load and not about the document (the host did not resolve, the timeout, a refused or dropped connection, too many fetches) is HTTP 503 with temporarily_unavailable and Retry-After, so a client keeps its state and tries again. A certificate that fails verification is the client's to fix and stays 401 invalid_client. At /authorize, too many fetches is also HTTP 503 with Retry-After; the other document refusals there are HTTP 400. At /authorize the body is {"error": ..., "error_description": ..., "detail": ...}, and detail repeats the description. These are the exact error_description strings.

Status: live on the sandbox. At /token the body is {"error": ..., "error_description": ...} with no detail, and every 401 invalid_client carries WWW-Authenticate: Basic realm="lifecare.id" (RFC 6749 section 5.2).

When the client document is refused (error is invalid_client):

When the request breaks a term:

A client sends its client_id in the form body and no Authorization header. The issuer does not read a URL client_id from HTTP Basic, and a Basic header or a client_secret is refused with 401 invalid_client for a CIMD client, because it holds no shared secret. That answer carries WWW-Authenticate: Basic realm="lifecare.id" like every 401 from /token, as RFC 6749 section 5.2 asks, although Basic is not a method a CIMD client can use. The token answer names the audience: resource is in the success body beside access_token, token_type, expires_in and scope. Status: live on the sandbox.

Where this is going

The profile that specifies person-managed authorization carries this policy in its first draft, planned for 2026-12-01 (status: planned). The page for the authorization flow itself is Person-managed authorization, and the differences between the sandbox and production are on From sandbox to production.

Sources checked

Fetched on 2026-11-05, each answering HTTP 200:

The statements about what ChatGPT apps and Claude connectors support come from each platform's documentation and are unverified by this page [unverified]. Check them there before you rely on them.

For coding agents

If you are an agent building a client for a LifeCare.ID® issuer, follow these lines. They describe the ruled policy, and the sandbox page lists what is live.