Routing that tunes itself on what actually works.
Instead of hand-tuning a routing config that's stale the day it ships, the operator shifts traffic toward the models that are cheaper and more reliable on your own verified outcomes — and records why it chose each route, on a receipt your auditor can check.
The operator decides where each request goes
Instead of branching code you maintain by hand, the operator reads one declarative strategy and picks the target: a single model, a weighted load-balance, an ordered fallback on specific status codes, or a conditional tree. Any target nests its own strategy, so the operator resolves routing trees that go as deep as your policy needs.
It reads the real dispatch context — data classification, business hours, scope — through a fixed operator set (all, any, classification_intersects, business_hours and more), so every route it takes is auditable. You set the bounds; you change how much it tunes, per domain, reversible in one click. Observe & Suggest is available now; assisted and autonomous tuning roll out per tenant as you grant them.
- Four strategy modes it operates. Single, fallback, load-balance and conditional — composable and nestable.
- It fails over before you see the spike. Retries and reroutes on 429 / 500 / 503 with backoff, in milliseconds — not the two weeks a manual fix takes.
- Every route is on the record. The rule it applied is data in the receipt, not logic hidden in your app.
It proves why it chose each route
Instead of asking you to trust the routing decision, the operator writes it into a chained receipt — so your auditor sees not just which model answered, but why the operator sent the request there.
The receipt records the route it resolved
The operator can't move traffic without writing the provider, model and the strategy that selected them into the dispatch receipt, chained like any other. Recompute the leaf to confirm the routing record hasn't been altered after the fact.
This is the same client-side verification shipped on the Trust portal. SHA-256 runs via Web Crypto. No Agentics call.
- •Recompute leaf
- •Chain integrity
- •Fold Merkle proof
- •Anchor memo == root
SHA-256 runs in your browser via Web Crypto. No Agentics call.
You set the bounds. It routes within them.
Instead of writing the routing logic, you declare the strategy — here, regulated data goes to one provider and everything else falls back — and the operator tunes the weights inside it on your verified outcomes.
{
"version": 2,
"strategy": {
"mode": "conditional",
"targets": [
{ "provider": "anthropic", "model": "claude-opus-4-8",
"when": { "classification_intersects": ["pii", "phi"] } },
{ "provider": "openai", "model": "gpt-4o", "when": "always",
"strategy": { "mode": "fallback", "on_status_codes": [429, 503],
"targets": [{ "provider": "azure-openai", "deployment": "gpt4o-eastus" }] } }
]
}
}Watch the operator route, and override by exception
Instead of editing config blind, you see the live routing tree the operator is running, review the changes it proposes, and dial its autonomy up or down per target before anything publishes.
Smart Routing console
The strategy the operator is running, as a tree — per-target conditions, the moves it proposes, and a validate-before-publish step you hold.
Open Smart Routing →