The right model for every prompt.
Easy prompt? Haiku handles it for pennies. Gnarly multi-file refactor? That's Fable 5 or GPT-5.5 territory. Model Maverick benchmarks frontier models every night and picks the best one for each request — measured, ranked under your rules, and auditable when someone asks why.
Get early access See how it works
Benchmarking Anthropic · OpenAI · Google · xAI — nightly
Different prompts, different models.
The best model isn't a brand decision you make once a year. It changes with the task, the difficulty — and last night's benchmark run.
"Categorize 4,000 support tickets by refund reason."
→ claude-haiku-4-5
Easy classification, huge volume. A frontier heavyweight here is burned money.
"Pull every party, date, and obligation out of this 80-page lease."
→ claude-sonnet-5
Mid-tier extraction with legal stakes — accuracy failures cost more than tokens do.
"Refactor billing across fourteen files without breaking the tests."
→ claude-fable-5
Top-tier code generation. This is the work frontier models exist for.
Routing everything to Sonnet today? Then you overpaid on the first and under-served the third.
Every codebase has a models.ts nobody wants to touch.
A model got picked in a sprint two quarters ago. It's still there. Here's what that costs you.
Launch-day benchmark scores aren't your workload
The charts in every model announcement — MMLU, coding evals, arena rankings — measure generic tests that models are tuned to ace. A model can top those charts and still be mediocre at the thing you actually ship: hard extraction from noisy documents, your codebase, your edge cases.
Models drift underneath you
Providers update models in place and retire them on their own schedule. Yesterday's right answer quietly becomes today's regression, and nothing in your codebase notices until users do.
Wrong defaults compound quietly
In one published postmortem, a provider-side format change tripped a schema check and ~90% of traffic silently escalated to the most expensive model in the chain. Per-call overspend looks fine — until you multiply it.
Measure. Constrain. Ask.
Nightly benchmarks on a private corpus
Every night, Maverick runs a versioned corpus — ten capabilities, five difficulty tiers — across every model and configuration it tracks. Golden answers never enter a prompt, so contamination can't inflate a score. Variance and grader disagreement subtract from quality, and every score is a weighted running average of recent nights — real changes show up fast, but one noisy night can't flip a ranking.
You set the guardrails
Tell Maverick which models your company allows and what you care about. A pool is an approved list — "HIPAA-approved models only," "the budget tier" — and weights say how much quality, cost, and speed matter for each kind of work. Recommendations never go outside the list, even when falling back to a second choice, and Maverick won't let you save rules that leave it nothing to pick.
Change one line
Put maverick/auto where a hardcoded model name used to
go. The SDK intercepts the call, gets the measured pick with its
ranked fallbacks, and executes through the client you already use —
and what happened flows back automatically. There is nothing else to
integrate and nothing to report. Agents get the same over MCP; the
REST API underneath stays open.
Ask Maverick, run it anywhere.
You wrote one line: maverick/auto. On every call, the SDK
inside your app asks, Maverick answers with the best model and ranked
fallbacks, and the call executes through your own providers — escalating
down the chain on failure, never outside your approved pool.
Pick your door. Change one line.
SDKs intercept inside your process — your prompts, traffic, and provider
keys never leave it. Platform teams plug Maverick into the gateway they
already run. Every door reduces to the same change:
maverick/auto where a hardcoded model used to be.
| You're running | Your door | What you change |
|---|---|---|
| Vercel AI SDK (TypeScript) | @modelmaverick/ai-sdk meta-provider |
model: maverick('auto') |
| OpenAI or Anthropic SDK | drop-in client wrapper | maverick/auto as the model |
| Rails + RubyLLM | modelmaverick gem |
an initializer + the alias |
| Python + LiteLLM | Maverick router strategy | router config |
| Go services | http.RoundTripper interceptor |
wrap the client |
| A gateway your platform team runs | gateway plugin (LiteLLM proxy first) | a few lines of config — app devs change nothing |
| Agents | MCP tools (recommend_model, …) |
a tool call |
| Anything else | the REST API | POST /v1/recommend, your dispatch |
One key or many: SDKs execute direct against each provider, or send the whole chain through a single OpenAI-compatible backend — OpenRouter first; Bedrock, Azure, and Vertex ride the same mechanism.
SDKs for TypeScript, Ruby, Go, and Python ship to design partners first — ask for early access.
Honest flags beat confident guesses.
You always get an answer. When the data behind it is thin — a brand-new model, an outage, a tight policy — Maverick says so, instead of refusing or pretending.
measured: false
A newly added model runs dense for several nights before its scores drive recommendations. Until then, thin data says so — it doesn't pretend.
clears_difficulty: false
If the best model your policy allows sits below the workload's estimated difficulty ceiling, you still get the pick — plus the risk, stated plainly.
constraints_met: false
When every allowed model violates a per-request preference, the best available returns anyway, with each violation named. Your inference always has a model to run on.
"Why did it pick Haiku over Opus?" answers itself.
Every recommendation persists a decision trace: the classification with its confidence, the pool and allowlist applied, every surviving model with its query-time score, and every excluded model with the reason it never competed. The dispute settles from stored data alone — no re-running, no guessing.
Prompts never touch disk. Each request is fingerprinted with a per-tenant keyed HMAC-SHA256 — one-way, exact-match, useless without your key — so the audit log can show how often an exact prompt arrived without ever holding the prompt.
survivors:
claude-haiku-4-5 91.2 ⌖ pick: within noise band,
cheaper column wins tie
claude-opus-4-8 92.0 mode=balanced: +0.8 quality
not worth 14× cost
excluded:
gpt-5.5 — not in pool "vertex-only"
gemini-3.1-flash — fails zero-retention constraint
mode: balanced · weights: q .6 / c .3 / l .1
matrix_version: 2026-07-01 · prompt: hmac_sha256:9f2c…Maverick recommends. You execute.
Maverick performs no inference and proxies no traffic. The SDKs intercept inside your process — prompts and provider keys stay with you — and the call executes on whatever stack you already run: Bedrock, Vertex AI, OpenRouter, LiteLLM, or direct provider SDKs.
The ranked list is your escalation path
The first entry is the pick; the rest are your backups, in order — already filtered to your approved models. So when a bad output forces you to retry on a bigger model, you can't accidentally step outside compliance.
Validation your gateway can run
Every capability ships a machine-readable check spec — schema validation, rule scans — so your gateway can verify output and decide to escalate without a human in the loop.
The loop closes itself
What actually happened — successes, parse failures, escalations — flows back automatically as a side effect of using the SDK. Nothing to report, no endpoint to remember. Opt out and it's genuinely off.
→ Agents included: recommend_model, get_policy, and
list_models ship as MCP tools over HTTP and stdio.
Read the full mechanics.
Asked and answered.
What is Model Maverick?
Model Maverick is a model recommendation engine for LLM workloads. It continuously benchmarks frontier models against a private task corpus, folds the graded results into a capability matrix, and answers one question over REST or MCP: which model should run this workload — ranked, policy-aware, and auditable.
Is Model Maverick a gateway or router? Does it run inference?
No. Maverick recommends; your application executes. You keep whatever you already use — Bedrock, Vertex AI, OpenRouter, LiteLLM, or direct provider SDKs — and call Maverick for the decision. That makes it a complement to gateways, not a replacement, and it means zero inference lock-in.
How does it plug into my stack?
Usually by changing one line. SDKs for TypeScript, Ruby, Go, and Python hook the client you already use — Vercel AI SDK, OpenAI, Anthropic, RubyLLM, LiteLLM — so you set the model to maverick/auto and you're integrated: the SDK asks, executes the pick in your process, escalates on failure, and reports back automatically. Platform teams add a gateway plugin instead; agents call the MCP tools; and the REST API (POST /v1/recommend) stays open underneath for everything else.
What happens if Maverick is down?
Your calls keep working — the SDKs fail open by design. If Maverick is unreachable, they fall back to the last known-good chain for that workload, then to your configured default model, then to whatever model your code named. An outage on our side can pause learning; it can never block your traffic. And privacy mode "off" is a kill switch that never calls Maverick at all.
Do I need API keys for every provider?
No. Keep your own provider keys and the SDK executes direct — or point it at one OpenAI-compatible execution backend and the entire fallback chain runs through a single key, using per-model aliases the engine supplies with every recommendation. OpenRouter is the first supported backend; Bedrock, Azure, and Vertex aliases use the same mechanism. Either way the recommendation logic is identical, and telemetry records which endpoint actually executed.
How are models benchmarked?
Nightly. A private, versioned corpus of 200+ tasks spans ten capabilities and five difficulty tiers. Golden answers never enter a prompt, which blocks contamination. Deterministic and reference graders do most of the scoring; a cross-family LLM judge covers rubric dimensions. Variance and grader disagreement subtract from quality, and scores are smoothed as a weighted running average — recent nights count most — so rankings react to real changes fast, but one noisy night can't flip them.
Can it stop a feature from losing money on model costs?
Yes — that's the cost guardrail. Every route in your product earns something per call, and max_cost_per_run caps what a single model call may cost, so a free-tier feature can never be routed to a model that costs more than the feature earns. Set per request, a violation comes back flagged instead of failing; set tenant-wide, it's a hard wall — and Maverick refuses to save a configuration that would leave zero usable models.
Which providers and models are covered?
At launch: Anthropic, OpenAI, Google, and xAI — roughly 10 to 14 model columns, where a column is a (provider, model, endpoint, settings) tuple, so the same model with thinking enabled is measured separately. DeepSeek, Groq, and Together are on the roadmap, with self-hosted models (Ollama, vLLM) planned for the enterprise release.
What happens to my prompts?
Prompts are never stored by default. Each request is fingerprinted with a per-tenant keyed HMAC-SHA256 hash — one-way and exact-match only. The SDKs make this a one-word setting with three privacy modes: prompt (default), declared (only capability and difficulty labels leave your process), and off (never call Maverick at all). Optional debug capture is off by default, time-boxed, encrypted, access-logged, and hard-deleted at expiry.
What is the MCP server for?
Agents. Maverick exposes recommend_model, get_policy, and list_models as MCP tools over HTTP or stdio — the same services, auth, and audit trail as the REST API. A coding agent or Claude Code session can ask which model should run a subtask before spawning it.
When can I use it?
Model Maverick is in early access. The engine is built and benchmarking nightly; we are onboarding design partners now. Request early access and tell us what you are routing — teams with real workloads to route get priority.
Route on measurement, not vibes.
The engine is built and benchmarking nightly. Tenant #1 is us — we route our own products through it. Tenant #2 could be you.
Request early access