Open because the decision can't be a black box.
If model routing becomes the control point, the decision format can't be a black box. So the way a decision is expressed, encoded, and replayed is open and MIT-licensed — and the managed host exists for operational convenience, not control.
The decision is open. The hosting is convenience.
Teams need to know what policy was executed, what changed, and why a model was accepted or rejected. So the decision format and the runtime that evaluates it are open: any backend can generate a policy_ir, send it with the call, and replay it. The managed host runs the parts that have to stay alive — and you can run them yourself.
The decision, inspectable
Everything you need to express, fingerprint, and re-run a model decision yourself. A policy_ir is fingerprinted to 301140696-1054914287 (version sigma-pol/v1) and evaluated filter → rank → select → fallback by any conformant interpreter.
- The policy_ir / flow_ir format and grammar
- Canonical encoding and content fingerprints
- Reference interpreter and conformance tests
- Presets, plus a self-host path on your own catalog
The hosting, handled
The operational surface you'd otherwise build and keep alive — already running. Bring your own provider keys; the host keeps the catalog current, routes to the cheapest model that passes, fails over when one degrades, and stores the trace. Priced per run, not per token.
- Provider modules, live catalog & pricing
- Key management, health checks, and failover
- Trace storage, replay, and history
- Priced per run, not per token
The whole way a decision is expressed and proven is open.
Not a thin SDK around a closed brain — the actual language, its canonical form, the hash that identifies it, and a runtime that anyone can re-run. These are the pieces that make a routing decision portable and auditable.
The languages policy_ir · flow_ir
The grammar for routing rules: filter the catalog, rank what's left, select the cheapest model that passes — built from predicates like ["cmp","bench_intelligence","ge",0.5] ("only models scoring ≥ 0.5 on intelligence"). flow_ir composes several policy-governed calls into one routed, replayable unit.
The proof encoding · fingerprints
One byte-exact encoding of every policy, so the same rule always serializes the same way — and a deterministic fingerprint for the exact logic that ran, two decimal lanes like 301140696-1054914287. Same logic, same fingerprint, anywhere it executes.
The runtime interpreter · conformance
A conformant interpreter that evaluates a policy filter → rank → select → fallback, plus a shared test suite so independent implementations agree on the same policy, inputs, and catalog. Run it yourself; reproduce any decision byte for byte.
Presets and a full self-host path are MIT-licensed on GitHub — copy a preset, adjust the floor and ceiling, and start with the grammar and dry-run endpoints (GET /x/fields, POST /x/rank) in the docs.
The grammar holds still. The world it routes over never does.
An open spec can be frozen and trusted. The execution layer can't — and that's exactly why the host is the product, not a lock-in tax.
A policy_ir means the same thing today and next year. A spec, a canonical encoding, and a fingerprint are what hold it still.
But the surface it routes over never stops shifting:
- provider modulesdrift as APIs version
- model cataloggains & drops models
- pricing datamoves
- bench_intelligencere-measured
- health checksflip
- fallback pathsre-order
- uptimenever done
Self-hosting the open layer is real and supported — the managed host just absorbs that moving surface so you don't run it. Maintenance is the product, not lock-in; the language you depend on stays open and replayable either way.
Why isn't it all hosted-and-closed?
Because the model decision layer is too important to hide. If your application depends on a routing policy, you should be able to inspect it, fingerprint it, replay it, and run it somewhere else. The managed host should be a convenience, not a trap.
Why pay if the core is open?
Because production routing isn't just policy logic. It's keeping provider APIs, model availability, prices, health checks, failover, retention, and uptime alive — every day. You can run all of that yourself for no per-run fee; the managed host just does it for you. The language stays portable either way, so paying is a convenience, never lock-in.
A policy should mean the same thing wherever it runs.
Canonical encoding, content fingerprints, a reference interpreter, and a shared conformance suite are what hold that equation together. It's also what makes a trace replayable and a routing decision auditable — on our host or your own.
Take the language. Let us run the host.
The decision language is open and MIT-licensed — fork it, self-host it, replay it. When you'd rather not operate provider modules, catalogs, failover, and uptime yourself, the managed host does it per run.
Weighing self-host vs managed comes down to who runs the upkeep — see the line items on pricing.