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

# Fallback chains

What may serve a lane when the model a decision named cannot.

## The question a chain has to answer

A fallback is the first thing this register holds that serves production traffic
without a decision having chosen it for that request. So the question is not
which model, but who said this model may ever answer for this lane.

The answer is a column. Every entry names the accepted decision it was
registered under, and every request a fallback serves carries that decision on
its [ledger row](../runtime/ledger.md). A fallback serve is still an
attributable serve.

## Registering one

```bash
npm run aperture:fallback:add -- --workload convexity/deep-research \
  --sku anthropic/claude-sonnet-5 --note "cross-vendor cover for the frontier tier"
```

The decision is not a flag. It is the workload's standing accepted decision,
read at the moment of registration, because that is what the chain exists to
back up.

`--position` puts an entry at a place in the chain; without it the entry goes on
the end. The runtime walks the chain in order and stops at the first model that
answers.

## Re-deciding a lane retires its chain

When a lane is re-decided, every fallback registered under the old decision
stops being emittable, and [`aperture:policy`](policy.md) refuses rather than
shipping them:

```
convexity/deep-research falls back to anthropic/claude-sonnet-5 under decision
154, and decision 161 is what stands. Re-register the chain under 161, or take
it out
```

That is deliberate, and it is the part worth arguing with. A chain assembled to
back up one model is not self-evidently the right chain to back up whatever
replaced it, and quietly carrying it over would be the register deciding
something nobody did. Re-registering is one command per entry.

## The refusals

| Refusal |
|---|
| The lane has no accepted decision, so there is nothing to back up |
| The sku is what the lane already serves, so the chain would repeat itself |
| The sku is from another market than the workload |
| The sku [cannot be named in a request](model-ids.md) |
| The sku is already in this chain |
| That place in the chain is held by another sku |

## Taking one out

```bash
npm run aperture:fallback:remove -- --workload convexity/deep-research \
  --sku anthropic/claude-sonnet-5 --reason "no longer cleared for this work"
```

The row is kept and dated rather than deleted. A fallback that served traffic
during an incident is part of what happened, and a row that vanished when
somebody tidied the chain would take that with it. A reason is required by the
database as well as by the command.

The remaining entries keep the positions they had; the emitter renumbers from
one when it writes the policy, so a gap here is not a gap there.

## What the runtime does with a chain

See [serving a lane](../runtime/serving.md). In short: it walks the chain only
when a provider cannot serve the request now, which means a transport failure, a
rate limit or the provider's own 5xx. A 4xx is the request being wrong, and
asking a second model the same wrong question spends money to be told the same
thing twice.

Every attempt is its own ledger row, so one request a fallback answered is two:
the primary's failure, worth no units, and the fallback's serve, worth one.

## What a chain costs, and why the engine does not say

Nothing. Not because a chain is free, but because its price is not knowable
before it runs.

A route's cost depends on how often the primary fails over, and that rate is
the one number no tape carries: it is a property of an incident, not of a
listing. So the engine prices the primary and reports the chain as a constraint
the decision was made under, and the brief says as much where a reader would
otherwise take the figure for the cost of the route.

That is a choice with a cost, so both sides are written down. What it buys is
that a lane carrying a chain is decidable at all, with every existing trigger
and comparison working unchanged. What it costs is a figure narrower than the
thing it sits beside, which is why the disclosure is part of the brief rather
than a footnote somebody may skip.

The alternative stays available and is the truer answer once there is enough
history: require an observed split from a prior window before a route is
decidable, which makes a route economically knowable only in its second
generation. Since [importing usage](usage-import.md) now attributes units to a
declared fallback rather than merely tolerating them, the reading that
alternative needs is being collected. The rule stays as written until somebody
wants the second generation more than the first.
Human Machine Shift+M