> ## Documentation Index > Fetch the complete documentation index at: https://docs.reflections.ai/llms.txt > Use this file to discover all available pages before exploring further. > ## Agent Instructions > The OpenAPI document at /api-reference/openapi.yaml defines the target contract. Its x-reflections-availability field and each operation's availability notice identify supported test and live forms. Do not infer implementation from a schema or code sample. Live keys support account details, reads of the licenses the calling account holds as licensee or issued as talent (GET /v1/licenses?role=issuer), and GET /v1/generations?license=… for the state of outputs under such a license (summaries only: no prompt, reference, bytes or metadata). Live image checks, submissions and receipts are built but not activated: until activation, a live POST /v1/checks or /v1/generations returns 403 live_not_activated, which must not be retried. Discovery and JWKS are at the origin root (https://app.reflections.ai/.well-known/...), not under /v1. > Three rules hold everywhere: a decision is never an error (deny and escalate are 200 responses, and a live check still evaluating is a 202 with status checking); generate nothing for a named talent without an allow; deliver nothing until the generation is allow. > The sandbox accepts personal rk_test_ keys. Persist a separate Idempotency-Key and body for each logical /v1 POST; retry an unknown outcome with the same key and body. OAuth and Talent API MCP remain planned. # Decision semantics > The three decisions at the check, generation and session stages, escalation, binding to the request and output, and the honesty rule. This page specifies what `allow`, `deny` and `escalate` mean at each stage, how an escalation resolves or expires, how a decision is bound to one request and one output, and what a license server may claim to have checked. ## The three decisions | Decision | Meaning | | - | - | | `allow` | Proceed, and meet every obligation the decision carries. | | `deny` | Do not proceed. `reasons` say why; `remedy`, when present, says what would change it. | | `escalate` | Do not proceed yet. A person with authority decides. An unanswered escalation becomes `deny`. | **TLP-DEC-1.** A license server MUST return exactly one of `allow`, `deny` or `escalate` for every check and every generation, and for the check that starts a session. A session sample MUST be decided `allow` or `deny`. A decision MUST be returned as a successful response. An error means the request could not be evaluated, and MUST NOT be used to convey a decision. **TLP-DEC-2.** A platform MUST handle all three decisions. It MUST NOT treat an error, a timeout or a missing response as `allow`. **TLP-DEC-3.** A license server MUST state each `deny` and `escalate` with at least one reason, using the codes of the [reason code catalog](/api-reference/reason-codes) with the meanings given there. Each reason MUST carry its `stage` and a `sentence` in the license's own words, and the `term` it rests on as an [address](/standard/terminology#addresses) when it rests on one. ## Stages | Stage | Decisions | Before | The platform | | - | - | - | - | | `check` | `allow`, `deny`, `escalate` | Anything is generated | Generates only on `allow` | | `generation` | `allow`, `deny`, `escalate` | An output is delivered | Delivers only on `allow` | | `session` | `allow`, `deny` | Each sampled window of live output | Stops within one second on `deny` | ## At the check **TLP-DEC-4.** A platform MUST NOT generate a request that [TLP-DSC-10](/standard/discovery#talent-index) requires it to check, or that a check found to invoke a talent, unless it holds an `allow` for that request whose authorization has not expired and has generations left. It MUST run only the request the check decided, or under reuse a request the authorization covers ([TLP-DEC-8](#at-the-check), [TLP-DEC-26](#binding)), and only the model the authorization names. **TLP-DEC-5.** On `deny`, a platform MUST NOT generate. It SHOULD show its user `reasons[].sentence` as written. It MAY act on `remedy`. **TLP-DEC-6.** On `escalate`, a platform MUST NOT generate until the check resolves to `allow`. It learns the resolution from the `check.resolved` event or by reading the check. **TLP-DEC-7.** A license server MUST name, for each talent in a decision, the license, the license revision and the terms digest it relied on, or `null` for each when it relied on no license. **TLP-DEC-8.** An authorization MUST expire at most 15 minutes after it is issued. It MUST allow at most `max_generations` generations, which is the request's candidate count unless the platform asked for reuse. Reuse MUST NOT exceed 1,000 generations or a lifetime of `PT15M`. Under reuse, an authorization covers generations of the same use, talent, execution and end user, even when their inputs differ, and MUST cover no other. A license server MUST still decide each generation under reuse on its output. Generations under reuse carry no `candidate_index`. ## At the generation **TLP-DEC-9.** A platform MUST submit outputs as the `generation_check` obligation requires, before it delivers them. It MUST NOT deliver a submitted output until its generation is decided `allow`. On `deny`, it MUST NOT deliver the output, then or later. **TLP-DEC-10.** On `escalate`, the output is held for release. A platform MUST keep it private until the generation is released. It MAY show a preview before release only when the decision carries `draft_watermark`, and only with the mark. It learns the outcome from `generation.released`, `generation.denied` or `generation.expired`. **TLP-DEC-11.** A license server MUST decide a generation on the license's terms, term by term, and report each as a finding of `preserved`, `violated` or `unchecked`. A violated term MUST lead to `deny`. A rule the talent wrote that the license server could not read MUST be reported as `unchecked`, listed in `unchecked_terms`, and MUST NOT by itself prevent `allow`. A protected attribute, such as `identity.samePerson`, that the license server could not confirm on the output MUST lead to `deny` with `attribute_unverifiable`. **TLP-DEC-12.** A license server MUST decide a generation only for the talent covered by its check or, in a session, by the check that started the session, and MUST NOT match the output against any other talent. It MUST refuse a generation that names neither a check nor a session. ## In a session **TLP-DEC-13.** A license server MUST NOT escalate in a session. Anything that would escalate at a check MUST be `deny` in a session. A license that requires each output to be released by a person cannot cover a session, and the check that starts one MUST then be `deny` with `session_not_permitted`. **TLP-DEC-14.** A platform running a session MUST renew the session token at the interval the session states (`renew_every`) and MUST NOT produce output under an expired session token. It MUST submit samples at the session's `sampling` rate, and at least one audio sample for every 15 seconds of generated speech. On a `deny` sample or a `session.terminated` message, it MUST stop output within one second and end the session. **TLP-DEC-15.** A license server MUST fail the renewal of, and terminate, every session under a license that is revoked or suspended, pushing `session.terminated` on the session stream and as an event. ## Escalation An escalation has a `reason` and a `reviewer`. | `reason` | Stage | Raised when | | - | - | - | | `judgment` | check | A rule the talent wrote needs a person to apply it | | `unverifiable` | check | A protected attribute could not be confirmed from the request | | `evaluation_unavailable` | check | The evaluation could not finish | | `release_review` | generation | The license requires a person to release each output | `reviewer` names who may decide: `talent` (the talent, or a representative whose mandate holds `review_outputs`), `representative` (only such a representative) or `reflections` (the license server operator's own reviewers, for platform licenses). **TLP-DEC-16.** A license server MUST route each escalation only to a person with authority over the license: the talent, a representative whose mandate holds `review_outputs`, or, for a platform license, the license server operator's reviewers. It MUST accept a decision only from a party with that authority, and MUST record on the talent's audit record who decided: the party, the account and the name of the person who made the decision. **TLP-DEC-17.** An escalation's `expires_at` MUST be at most seven days (`P7D`) after it opens, or the license's `escalation_window` if that is shorter. Unless the platform cancels it or a revocation ends it ([TLP-RVK-2](/standard/revocation#what-the-license-server-does)), an escalated check MUST end with status `allowed` when the reviewer allows it, `denied` with `review_declined` when the reviewer declines it, or `denied` with `hold_expired` when `expires_at` passes unanswered. A held output MUST end with status `released` when the reviewer releases it, `denied` with `review_declined` when the reviewer declines it, `expired` with decision `deny` and `review_expired` when it is not released by `expires_at`, and `denied` with `license_revoked` when its license is revoked first. A check's status `expired` MUST mean only that an allowed check's authorization expired unused. **TLP-DEC-18.** When an escalated check resolves to `allow`, its authorization MUST cover exactly the escalated request, bound by the same request digest, or, when the check asked for `reuse`, the generations TLP-DEC-8 allows. A platform that changes any other part of the request MUST send a new check. **TLP-DEC-19.** A check sent with `on_escalate: "deny"` MUST NOT escalate. Where it would have escalated, the decision MUST be `deny` with `review_required` and a `retry_with_hold` remedy. Interactive products, such as chat and live voice, SHOULD send `on_escalate: "deny"`. ```mermaid theme={null} stateDiagram-v2 [*] --> allowed: allow [*] --> denied: deny [*] --> escalated: escalate escalated --> allowed: reviewer allows escalated --> denied: reviewer denies or expiry escalated --> cancelled: platform cancels allowed --> consumed: generations used allowed --> expired: authorization expires unused ``` ## When no license covers the use A talent's posture answers for uses that no license covers. Each posture rule may set `modality`, `kind`, `purpose` and `commercial`; an omitted field matches every value. **TLP-DEC-20.** A license server MUST apply the posture rule that matches the use and sets the most fields. When two matching rules set as many fields, `prohibited` MUST win. When no rule matches, the posture's `default` applies. **TLP-DEC-21.** When no license of the licensee covers the use, a license server MUST decide by the posture: | Declaration | Decision | | - | - | | `prohibited` | `deny` with `talent_prohibits`, term `talent:`, no remedy | | `license_required` | `deny` with `no_license` and a remedy of type `license_request` naming the talent. When the licensee holds a license that is narrower than the use, the reason names the field that fails and the remedy is `license_change` naming that license. | | `allowed` | `allow` with the matching rule's obligations, and `license`, `license_revision` and `terms_digest` set to `null` | **TLP-DEC-22.** A license server MUST NOT return `escalate` because no license covers a use. A missing license is `deny` with a remedy. **TLP-DEC-23.** A license MUST NOT widen a `prohibited` declaration. When the matching rule is `prohibited`, the decision is `deny` with `talent_prohibits` whatever licenses exist. **TLP-DEC-24.** When the inputs of a check invoke no protected talent, a license server MUST return `allow` with an empty `talent` list and no obligations. That decision states only that the inputs invoke no protected talent. It is not a license for any person an output shows. ## Several talent A license server MUST resolve a check's inputs even when the check names talent in `talent`. The request invokes every talent it names and every talent its inputs invoke. **TLP-DEC-25.** When a request invokes more than one talent, a license server MUST decide each talent separately and return the most restrictive decision: `deny` over `escalate` over `allow`. Each talent's own decision is in `talent[].decision`, and each reason names its `talent`. The obligations are the union of each talent's obligations. An escalated check resolves to `allow` only when every escalated talent's reviewer allows; any `deny` or expiry resolves it to `deny`, and the license server MUST then cancel the check's other open escalations. ## Binding **TLP-DEC-26.** A platform MUST send as a check's `inputs` the request the model will receive, in order: the user's prompt, system text, negative prompt, the platform's rewritten prompt, script, references, voice samples, masks and conversation context. After the check, it MUST NOT change the inputs except to add the instructions of a `generation_instructions` obligation. Under reuse, it MAY run later requests with other inputs, and MUST run under the authorization only requests of the same use, talent, execution and end user ([TLP-DEC-8](#at-the-check)). **TLP-DEC-27.** A license server MUST compute the check's `request_digest` as [Tokens](/standard/tokens#request-digest) specifies. Without reuse, an authorization MUST cover only requests with that digest. Under reuse, the digest remains that of the request the check decided, and the authorization covers what [TLP-DEC-8](#at-the-check) states. **TLP-DEC-28.** A license server MUST bind each generation to its check, its `candidate_index` (absent under reuse) and the SHA-256 of its artifact, and MUST put that digest in the generation's receipt. It MUST refuse: | Condition | Error | | - | - | | A second generation for the same check and candidate | `generation_already_submitted` | | Bytes that do not match the declared `sha256` | `artifact_digest_mismatch` | | A check whose decision is not `allow` | `check_not_allowed` | | A check whose `max_generations` is spent | `authorization_consumed` | | A check whose authorization has expired | `check_expired` | | A generation that names neither a check nor a session | `parameter_missing` | ## Honesty A license server states what it knows and how it knows it, and nothing more. **TLP-DEC-29.** A license server MUST set a generation's `assurance` to `observed` only when it received the output's bytes and checked them. A check's receipt MUST be `observed` only when the license server received the text and media of every input the decision relied on, and `attested` otherwise, such as when the platform sent text `withheld`. **TLP-DEC-30.** A license server MUST NOT claim to have inspected content it did not receive. When a platform withholds prompt text, rules that need the text MUST be checked on the output instead, or reported as `unchecked`. **TLP-DEC-31.** A license server MUST class every term of a license revision as `checked` or `recorded`, per stage, and MUST NOT present a recorded term as enforced. The model named in `execution` is always attested: recorded as the platform stated it. ## When the license server cannot answer **TLP-DEC-32.** When a platform cannot reach the license server, or receives a server error, for a request that [TLP-DSC-10](/standard/discovery#talent-index) requires it to check, it MUST NOT generate, except under an authorization it already holds that has not expired and has generations left. It MUST retry with the same `Idempotency-Key`. **TLP-DEC-33.** When a platform cannot reach the license server, or receives a server error, it MAY generate and deliver a request that TLP-DSC-10 does not require it to check: one that names no talent in `talent`, matches no entry in its current talent index, and has no `reference` or `voice_sample` input. ## Related The fields a use is described with, and when a license covers it. What an `allow` can require. The authorization a check returns, and the request digest. The same rules, explained with examples. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.