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

# Rotating the seller, not the model

A lane may name several hosts of the same weights and let a request go to the
cheapest one that is up, without a new decision, because nobody decided to serve
a different model.

This is the fifth rotation in [the router design](router.md), and the only one
that does not need a router. It runs in the runtime you already have.

## Why it moves under a decision that already stands

The other four rotations change what answers a request. A lane moving to another
sku, a rule promoting inside a lane, a canary widening, a fallback firing: each
of those is a different model doing the work, so each is a quality question and
each has a gate that ends in an accepted decision.

Rotating the seller holds the model constant. Nobody chose different weights, so
there is no quality question to re-ask, which is what lets the price be chased
under the decision that already named the model.

And the price is worth chasing. Vitna already mirrors what every seller of every
model charges into the endpoints snapshot, key-free. Those prices move on a much
shorter half-life than a model choice does, and a team applying decisions by hand
cannot follow them.

## The gate, which is not the price

`deepseek/deepseek-chat-v3-0324` was sold at four prices when the mirror last
ran:

| Seller | Declared | Input |
|---|---|---|
| DeepInfra | fp4 | 0.24 |
| SiliconFlow | fp8 | 0.25 |
| GMICloud | fp8 | 0.29 |
| Crusoe | bf16 | 0.50 |

The cheapest row is half the dearest and it is not the same artifact. The
snapshot's own attribution says why this cannot be waved through: every figure is
a seller's list price when the mirror ran and not what anybody paid, and
**quantization is declared by the seller and verified by nobody.**

So the gate is not "trust the declaration", which nobody can check. It is:

> A seller is reachable only where the workload named the quantization it is
> declaring.

The declaration has to match something a person wrote down. A workload that
never said fp4 was an acceptable way to serve its weights does not rotate to
fp4, however cheap it is, and a seller declaring nothing at all is excluded for
being uncheckable rather than for being bad.

## Turning it on

A workload names what it will accept:

```json
{ "allowsQuantizations": ["fp8", "bf16"] }
```

Then emit as usual. The lane comes out carrying its admissible sellers, cheapest
first, with the quantization each declared frozen into the document:

```bash
npm run aperture:policy -- --org convexity --out policy.json
```

**A workload that says nothing gets exactly the policy it gets today**, down to
the bytes. That is what keeps every runtime already deployed serving unchanged.

Three things are reported rather than silently done. A workload naming a
quantization no request can ask for refuses the whole file. A workload whose
model has one admissible seller is emitted **without** a seller set and told why,
because a one-entry list is a pin rather than a rotation and would stop the lane
using a second seller the day one appeared. And a lane with no OpenRouter name is
refused, because a seller is a host the substrate picks between and a direct
route has none.

## What the runtime sends

```json
{
  "model": "deepseek/deepseek-chat-v3-0324",
  "provider": {
    "order": ["siliconflow/fp8", "gmicloud/fp8", "crusoe/bf16"],
    "allow_fallbacks": false,
    "quantizations": ["fp8", "bf16"]
  }
}
```

The order is the emitter's, from the prices the record mirrored, so it is in the
signed artifact and the runtime consults no price while a request is waiting. A
price that moved after the policy was signed changes nothing until somebody
re-emits, which is the same staleness every other figure in a policy has.

`allow_fallbacks: false` is the field that matters most. Without it an exhausted
list is served from a host outside it, which is a silent substitution, and this
runtime refuses those everywhere else. With it, an exhausted list is an error the
caller sees.

Field names read from
[provider routing](https://openrouter.ai/docs/features/provider-routing),
retrieved 2026-08-31.

## What an older runtime does

It refuses the file, and that is the intended behaviour rather than a cost.

A lane carrying a seller set adds lines to the bytes the digest is taken over, so
a runtime that predates this recomputes a digest that does not match and declines
to load the policy, keeping whatever it had. A lane carrying none adds nothing,
so the same runtime keeps serving that policy exactly as before.

The alternatives were both worse. Bumping the canonical version would make old
runtimes refuse every policy, including ones they can execute perfectly. Putting
the set outside the hashed body would leave them serving happily while ignoring a
routing instruction, and would leave that instruction unsigned, which is the one
thing no part of this system does.

## What is not verified

**Whether the tags in the endpoints snapshot are the slugs `provider.order`
reads.** They come from OpenRouter's own endpoints API, on the `tag` field, and
they have the shape the routing documentation shows for variant slugs
(`deepinfra/turbo`, `google-vertex/us-east5`). Nothing here has confirmed the two
are one namespace, and no request has been made with one.

That gap is bounded rather than open. `quantizations` says the same gate again in
the vendor's own vocabulary, so it holds if the tags are wrong; and
`allow_fallbacks: false` means a wrong tag produces an error rather than a
request quietly served by a host nobody named. What would settle it is one real
request against a rotating lane, which is the first thing to do with this.

**Which host actually answered.** The chat completions response documents no
field naming it
([API overview](https://openrouter.ai/docs/api-reference/overview), retrieved
2026-08-31), so the ledger records the set a request was **permitted** to use and
not the one that served it. That is a real limit and it is why the row is named
`sellers` rather than `seller`.

Which host served is a fact OpenRouter keeps and this does not, and reading it
there is the same independent trail
[the hosted router](hosted.md) describes. A check somebody else keeps turns out
to be useful for a second reason.
Human Machine Shift+M