Open decision language. Managed execution layer.
The language is yours. The upkeep is ours. The way a model decision is expressed, encoded, and replayed is open and MIT-licensed — the work of keeping it routing in production is what the managed host does for you. New here? unhardcoded is a runtime LLM policy layer — you send a policy with your OpenAI-compatible call, and it routes to the cheapest model that passes your rules, over your own provider keys.
One layer is a specification. The other is an operation.
The decision language is a small, hashable thing: any backend can generate a policy_ir, send it with the call, validate it against the grammar, and run it through a conformant interpreter. Keeping it routing to the cheapest model that passes — over live provider catalogs, real keys, and current pricing — is a service. We open the first and operate the second.
The decision language
Everything you need to express and run a model decision deterministically. A policy_ir is validated against the grammar, fingerprinted to 301140696-1054914287 (version sigma-pol/v1), and evaluated filter → rank → select → fallback by any conformant interpreter.
- The policy_ir and flow_ir language and grammar
- Canonical encoding and content fingerprints
- Reference interpreter and conformance tests
- Presets you can copy and adapt
- A self-host path with your own catalog
The execution layer
The host you'd otherwise build and operate yourself — already running. Bring your own provider keys; we keep the catalog current, route every call to the cheapest model that passes, fail over when one degrades, and write the trace. Priced per run, not per token.
- Provider modules and live catalog & pricing data
- Key management and OAuth
- Replayable traces, history, failover, and uptime
- 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.
policy_ir
The language for routing rules. A policy filters the catalog, ranks what's left, and selects the cheapest model that passes — built from predicates like ["cmp","bench_intelligence","ge",0.5], meaning "only models scoring ≥ 0.5 on intelligence."
flow_ir
The language for multi-step workflows: chain several model calls — each governed by its own policy — into one routed, replayable unit.
Canonical encoding
One stable, byte-exact representation of every policy and workflow, so the same rule always serializes the same way — the precondition for a meaningful fingerprint.
Fingerprints
A deterministic identifier for the exact decision logic that ran — two decimal lanes like 301140696-1054914287. Same logic, same fingerprint, anywhere it executes.
Reference interpreter
A conformant runtime that evaluates a policy filter → rank → select → fallback. Run it yourself to reproduce any decision, byte for byte.
Conformance tests
A shared test suite so independent implementations produce identical results for the same policy, inputs, and catalog. No "works on our host only."
Presets
Reusable policies for common routing patterns — copy one, adjust the quality floor and price ceiling, and ship it.
Self-host path
Run the whole layer yourself, against your own provider catalog and keys. No per-run fee — you operate the upkeep instead.
All MIT-licensed and on GitHub. Start with the grammar, presets, and dry-run endpoints (GET /x/fields, POST /x/rank) in the docs.
The managed host is everything around the core that has to stay alive.
The open language is a fixed point. Production routing is not — it's a continuous obligation to keep providers, catalogs, prices, and uptime working. That operation is the managed host, priced per run.
Provider modules & live catalog
A connector per provider, kept current as APIs version and models are added or dropped — so a policy always routes over a real, present catalog.
Pricing & benchmarks
Live price data and re-measured bench_intelligence scores, so your quality floors and price ceilings keep meaning what they meant.
Keys & OAuth
Your provider keys, managed and encrypted, with OAuth where providers support it. Your accounts stay yours; tokens are never resold.
Failover & health checks
Continuous health probes and fallback paths that re-order the moment a provider degrades — so one bad provider doesn't become an outage.
Traces, history & storage
Every decision recorded, replayable, and retained — storage that fills and is managed for you, with the history windows each plan includes.
Uptime, team controls & support
Roles, SSO, audit exports — and the plain, continuous obligation of keeping all of the above running, on call.
This is the part that changes every day. Models are added, APIs change, prices move, providers fail, benchmarks get re-measured, fallback paths need tuning. You can run it yourself; the managed host exists so you don't have to.
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.