> 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.
