Get started

Routing

Source

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:

PieceDirection
`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

PageWhat it covers
Delivery targetsWhere a workload's decision gets applied
Emitting a configaperture:config, and the eight ways it refuses
Emitting a policyaperture:policy, the document a runtime loads
Signing without an operatoraperture:sign, the queue that answers an ask for an artifact
Collecting a signed artifactHow an organisation takes the bytes away, with its own key
Fallback chainsWhat may serve a lane when the decided model cannot
Rules within a laneDeclared per-request predicates, shadow first
Rollout and decision watchdogStanding-decision drift and shadow-to-canary ladder readiness
Multi-class unit profiles and compound pipelinesCross-layer Bill of Materials, x-vitna-run attribution, and two-tier spend optimization
Audit and procurement attestation packsSix-layer offline-verifiable vitna.audit-pack.v1 governance, pricing, and FinOps bundles
Rotating the sellerSeveral hosts of the same weights, under the decision that already stands
The runtimeThe process that applies a policy per request
Per-request routingDeterministic vitna-route per-request model and effort selection under a signed policy
The hosted routerThe design, the credential ladder it turns on, and what of it now runs
Running the hosted routerrouter:start and router:trail, multi-tenant serving under C1
Model idsWhy a registered sku can still be unnameable
Importing usageaperture:usage:import, windows and shares
Did the decision do what it saidWhat was predicted, against what the export observed
Connected accountsOAuth PKCE, and why no provider key is collected
Ruling from the consoleAccepting or refusing a proposal at /console, and the fifth role that may
Verifying a configChecking a file you were handed