Get started

Rotating the seller, not the model

Source

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, 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:

SellerDeclaredInput
DeepInfrafp40.24
SiliconFlowfp80.25
GMICloudfp80.29
Crusoebf160.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, 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, 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 describes. A check somebody else keeps turns out to be useful for a second reason.