Entelligence Model Router New

Frontier-model quality, routed at the cost of a cheaper model

Every message your team sends to Claude Code (or another agent harness) doesn't need a frontier model to answer it. Model Router sits in front of your coding agent traffic and sends each turn to the cheapest model that can handle it — a lightweight model for a simple edit, a mid-tier model for routine implementation work, and a frontier model (Claude Opus, GPT-5.5) only when the task actually needs it. When a cheaper model starts to struggle, Router detects it mid-session and escalates automatically — you never trade quality for savings.

Why not just always use the cheapest model?

Because "cheapest" and "good enough" aren't the same task-to-task. Force every request onto a discount model and you'll spend more time re-prompting and fixing bad output than you saved — force everything onto your best model and you're paying frontier prices for changelog entries. Router's job is deciding, per turn, which side of that line a given request falls on:

• Lower cost, same output quality. Router only downgrades when it predicts the cheaper model gets you to the same result. Critical, production-impacting work still gets routed to your top model.
• Nothing to change in how you work. Once connected, routing happens per request — you keep using Claude Code exactly as before.
• Full visibility into every decision. The dashboard shows which model handled every session and turn, and exactly how much you saved versus running everything on your top-tier model.

How routing works

Router makes a fresh decision on every turn, not just once per session:

1. Categorize the turn — is this planning, active execution, background/low-stakes work, or a simple instruction? Each category has a different cost/quality tradeoff worth making.
2. Predict the cheapest tier that clears the bar — starting from a workhorse-tier model and escalating only as needed, rather than defaulting to your most expensive model and hoping to downgrade later.
3. Watch for struggle in real time — repeated tool-call errors, a "stall score" that flags a session going in circles without obviously erroring, and context-pressure signals as the conversation grows. Any of these triggers an escalation mid-session.
4. Escalate up the ladder, then decay back down — a struggling session can ride all the way to a frontier model (Claude Opus or GPT-5.5) if the task demands it, and steps back down to a cheaper tier once turns are clean again, rather than staying pinned at the highest tier for the rest of the session.
5. Respect context windows — Router also checks that a candidate model's context window actually covers the conversation so far, escalating to a larger-context model when needed regardless of cost tier.

This is deliberately conservative by design: if the difficulty classifier or escalation judge can't confidently make a call, routing falls back to a safe default tier rather than guessing aggressively.

Router draws from a multi-provider catalog with live pricing and context-window data: Anthropic Claude, OpenAI GPT-5.5, DeepSeek, Moonshot/Kimi, plus Google Gemini and Alibaba Qwen models as broader cross-provider support rolls out.

A concrete example

A session opens with "fix the flaky test in payment_test.go" — a bounded, well-defined task. Router starts it on a cheap workhorse model. Three tool calls in, the model can't locate the right file and starts guessing at paths — the struggle detector catches the repeated tool errors and escalates to a mid-tier model. That model fixes it cleanly in two more turns. The next unrelated request in the same session ("now add a changelog entry") drops back down to the cheap tier, since it's a simple, low-risk task on its own.

Routing modes

Switch modes anytime from the Model Router dashboard, or turn routing off entirely for a session.

What you get in the dashboard

• Baseline spend vs. savings — what you would have spent running everything on your top model, next to what you actually spent.
• % of sessions auto-routed and a running savings total, with a savings-over-time chart.
• Model usage breakdown — where routed sessions actually went, model by model.
• Per-member and per-session views — drill into any session, and every turn within it, to see exactly which model handled it and why it escalated or didn't.
• A running credit balance with one-click top-ups and optional auto-recharge, so routing never runs out mid-sprint without warning.

Routing policy today is set globally for your org — Balanced or Eco, on or off — rather than per-project or per-repo. If your team needs different policies for different workstreams, talk to us.

Pricing

Model Router uses a pure gainshare model: you're billed 20% of the savings it generates versus your top-model baseline. If it doesn't beat that baseline in a given period, you pay nothing for routing. Routing draws down a prepaid credit balance — if it hits zero, routing stops rather than silently falling back to an unrouted (and undiscounted) direct call, so there are no surprise bills.

Integration options

• Hosted proxy (recommended) — point your existing setup at Entelligence's routing gateway. No provider keys to manage.
• Bring your own keys (BYOK) — connect your own AWS Bedrock, Google Gemini, or GCP Vertex credentials; Router optimizes routing across the models you already have access to.
• Bring your own cloud (BYOC) — run the router inside your own infrastructure. Available soon.

See Setup for the step-by-step for each option.