Routing
How an accepted decision becomes a value a machine loads, and how the record finds out whether the change actually took.
The gap this closes
A decision produces a brief. A brief is a document, so somebody has to read it and then go and change a value somewhere else, and that second step is where a decision quietly fails to happen.
Until now aperture:accept moved exactly one column, the proposal's status, and said plainly why it moved no others: whether traffic actually moved is not something Vitna can see.
Two pieces close it from both ends:
| Piece | Direction |
|---|---|
| `aperture:config` | Out. The decision rendered as a loadable value, signed. |
| `aperture:policy` | Out. The same decisions as a document a runtime executes, signed. |
| `aperture:sign` | Out. The same artifacts, built and signed from a queue rather than at a prompt. |
| `aperture:usage:import` | Back. What the consumer's own export says actually served the work. |
The register those decisions are made from can be composed at /console as well as at a prompt: see Composing the register.
Two ways out, one record
A config is for a consumer that already reads its model ids from somewhere: a gateway, a variable, an existing platform. A policy is for one that does not, and would otherwise have nowhere to put a decision at all.
They are emitted from the same accepted decisions and a test asserts they agree, so which one an organisation consumes is a question about its infrastructure rather than about what Vitna decided.
What the router is not
Worth being exact, because "router" invites the opposite assumption.
Nothing here reaches a provider or moves a token. Vitna emits a file. A person reads the diff and applies it.
One key exists, and it is not a provider key. An org can connect its OpenRouter account, which grants Vitna a key OpenRouter minted and that org can revoke at source. No provider credential is involved, and nothing Vitna runs calls a provider with it: the runtime a customer operates reaches providers with the operator's own keys, from the operator's own environment, and never sees this one. See Connected accounts, which is exact about what sealing that key buys and what it does not.
No runtime fetches its policy from Vitna. That is deliberate and it is a boundary, not an omission: a consumer fetching its routing from Vitna at request time would have made Vitna a dependency of its own uptime. A runtime loads its policy from local disk at boot, which is what keeps that true even when Vitna's software is in the request path. An organisation does collect its signed policy between deployments, with its own key or as a download from the console, and no endpoint serves a config. Corrected 2026-09-13: this said no endpoint serves either file.
Nothing fetches usage either. A person exports it from the console or database they already have, and the export arrives as a file with a source_ref on it, exactly as a measurement does. A runtime's operator can also schedule a push of its closed days to `POST /api/v1/usage` with an org key, which Vitna receives and never requests.
So the loop is closed by a person at both ends, on purpose. What changes is that the record can now state what it told a workload to run and what the workload was observed running, rather than holding an intent and waiting.
And a hosted one is frozen, not operated. Every sentence above describes what runs. The hosted router works through what it would take for Vitna to operate one without ever holding a provider key. Its software was built on 2026-08-31 on the owner's instruction and frozen on 2026-09-09; it is not installed on Vitna's box, and no phase is scheduled to operate it. Corrected 2026-09-13: this said none of it was built. It is published because a custody design that nobody outside can read is a custody design nobody outside can refuse.
The pieces
| Page | What it covers |
|---|---|
| Delivery targets | Where a workload's decision gets applied |
| Emitting a config | aperture:config, and the eight ways it refuses |
| Emitting a policy | aperture:policy, the document a runtime loads |
| Signing without an operator | aperture:sign, the queue that answers an ask for an artifact |
| Collecting a signed artifact | How an organisation takes the bytes away, with its own key |
| Fallback chains | What may serve a lane when the decided model cannot |
| Rules within a lane | Declared per-request predicates, shadow first |
| Rollout and decision watchdog | Standing-decision drift and shadow-to-canary ladder readiness |
| Multi-class unit profiles and compound pipelines | Cross-layer Bill of Materials, x-vitna-run attribution, and two-tier spend optimization |
| Audit and procurement attestation packs | Six-layer offline-verifiable vitna.audit-pack.v1 governance, pricing, and FinOps bundles |
| Rotating the seller | Several hosts of the same weights, under the decision that already stands |
| The runtime | The process that applies a policy per request |
| Per-request routing | Deterministic vitna-route per-request model and effort selection under a signed policy |
| The hosted router | The design, the credential ladder it turns on, and what of it now runs |
| Running the hosted router | router:start and router:trail, multi-tenant serving under C1 |
| Model ids | Why a registered sku can still be unnameable |
| Importing usage | aperture:usage:import, windows and shares |
| Did the decision do what it said | What was predicted, against what the export observed |
| Connected accounts | OAuth PKCE, and why no provider key is collected |
| Ruling from the console | Accepting or refusing a proposal at /console, and the fifth role that may |
| Verifying a config | Checking a file you were handed |
