vitna.ai/docs/routing/overview Machine view
Raw .md llms.txt
> Source: https://vitna.ai/docs/routing/overview
> Raw Markdown: https://vitna.ai/docs/routing/overview.md
> Corpus index: https://vitna.ai/llms.txt

# 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](../concepts/decision.md) 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`](config.md) | Out. The decision rendered as a loadable value, signed. |
| [`aperture:policy`](policy.md) | Out. The same decisions as a document a runtime executes, signed. |
| [`aperture:sign`](signing.md) | Out. The same artifacts, built and signed from a queue rather than at a prompt. |
| [`aperture:usage:import`](usage-import.md) | 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](console-composing.md).

## 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](../runtime/overview.md) 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](connected-accounts.md), 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](../api/v1/engine/artifacts.md) 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`](../api/v1/engine/usage.md) 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](router.md) 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](delivery.md) | Where a workload's decision gets applied |
| [Emitting a config](config.md) | `aperture:config`, and the eight ways it refuses |
| [Emitting a policy](policy.md) | `aperture:policy`, the document a runtime loads |
| [Signing without an operator](signing.md) | `aperture:sign`, the queue that answers an ask for an artifact |
| [Collecting a signed artifact](../api/v1/engine/artifacts.md) | How an organisation takes the bytes away, with its own key |
| [Fallback chains](fallbacks.md) | What may serve a lane when the decided model cannot |
| [Rules within a lane](rules.md) | Declared per-request predicates, shadow first |
| [Rollout and decision watchdog](watchdog.md) | Standing-decision drift and shadow-to-canary ladder readiness |
| [Multi-class unit profiles and compound pipelines](pipelines.md) | Cross-layer Bill of Materials, `x-vitna-run` attribution, and two-tier spend optimization |
| [Audit and procurement attestation packs](audit-packs.md) | Six-layer offline-verifiable `vitna.audit-pack.v1` governance, pricing, and FinOps bundles |
| [Rotating the seller](sellers.md) | Several hosts of the same weights, under the decision that already stands |
| [The runtime](../runtime/overview.md) | The process that applies a policy per request |
| [Per-request routing](../runtime/route.md) | Deterministic `vitna-route` per-request model and effort selection under a signed policy |
| [The hosted router](router.md) | The design, the credential ladder it turns on, and what of it now runs |
| [Running the hosted router](hosted.md) | `router:start` and `router:trail`, multi-tenant serving under C1 |
| [Model ids](model-ids.md) | Why a registered sku can still be unnameable |
| [Importing usage](usage-import.md) | `aperture:usage:import`, windows and shares |
| [Did the decision do what it said](outcome.md) | What was predicted, against what the export observed |
| [Connected accounts](connected-accounts.md) | OAuth PKCE, and why no provider key is collected |
| [Ruling from the console](console-ruling.md) | Accepting or refusing a proposal at /console, and the fifth role that may |
| [Verifying a config](verifying.md) | Checking a file you were handed |
Human Machine Shift+M