Model Routing for Coding Agents

What is it

Model routing for coding agents is a middleware layer that sits between your coding agent (Claude Code, Cursor, Codex CLI, Aider) and the underlying LLM providers (OpenAI, Anthropic, DeepSeek, Moonshot/Kimi, Google). Instead of hardcoding one model, the router inspects each request — task type, context size, cost budget, latency needs — and dispatches it to the cheapest or most capable model that fits. A refactor of a 50-file repo might go to Claude Sonnet; a quick regex fix goes to DeepSeek at 1/20th the cost.

The technical essence is a proxy with policy: request classification, provider abstraction, fallback chains, and token accounting. The business significance is bigger. Coding agents are now the single largest driver of LLM API spend for developers, and model quality/cost shifts monthly. Whoever owns the routing layer owns the switching cost, the telemetry, and the billing relationship. It is the "Stripe for tokens" position — unglamorous, but sticky.

Why now

Three forces converged in late 2025 and early 2026. First, model parity: DeepSeek-V3, Kimi K2, and Qwen have closed enough of the gap on coding benchmarks that "always use the frontier model" is now financially indefensible. A team running Cursor or Claude Code across 10 engineers can burn $2,000–$8,000/month on tokens; routing can cut that 60–80% with minimal quality loss.

Second, agent architecture changed. Coding agents now make dozens of tool calls per task — file reads, greps, test runs. Most of those calls are trivial and don't need a $15/M-token model. The old "one model per session" assumption broke.

Third, provider fragmentation. Every month a new cheap frontier-class model ships (GLM, MiniMax, Kimi K2 Thinking). Developers are exhausted by re-benchmarking and re-wiring. Open-source routers like this one — Go-based, per the tags — signal that the community is solving it bottom-up before vendors do. The timing is a classic "picks and shovels" window: the gold rush (agents) is loud, the tooling layer is quiet, and the incumbents haven't locked it down.

Market Evidence

The signal is early but clean: 2 independent sources (GitHub + Show HN), 2 total mentions, 100% growth rate, stage classified as nascent, trend score 67/100. That combination — high trend score on tiny absolute volume — is the signature of a term that just crossed from "someone's weekend project" into "other people are noticing."

Be honest about what this is: two data points is not a market. It is a leading indicator. The GitHub source tells you builders are shipping code; the Show HN source tells you the builder wants distribution and feedback. A 100% growth rate off a base of 1 is mathematically meaningless as a forecast, but it is meaningful as a direction — the term didn't exist in the dataset before, and now it appears in two independent channels within days.

Compare this to where "LLM gateway" was in early 2024: a handful of HN posts, then LiteLLM, then OpenRouter, then every cloud vendor shipped one. The pattern is well-worn. My position: this is real demand, not hype, because the underlying pain (token cost + model churn) is measurable in dollars. Hype terms have vibes; this one has invoices. The risk isn't that demand is fake — it's that you're too early and have to educate the market.

Who's Behind It

The named entities here are the model providers themselves — OpenAI (Codex), DeepSeek, Moonshot (Kimi) — plus the coding-agent vendors (Anthropic's Claude Code, Cursor, Cognition's Devin) and the open-source router community. The "whales" are OpenRouter (consumer/prosumer gateway, $80M+ raised trajectory), LiteLLM (open-source proxy with a commercial cloud), and Portkey (enterprise LLM gateway with guardrails). Any of them can extend into coding-agent routing tomorrow.

The competitive dynamic is a classic squeeze: model providers want you pinned to their API; agent vendors want you pinned to their subscription; infra vendors want the routing layer as a feature, not a company. The independent builder's only durable angle is coding-specific intelligence — knowing that a failing test loop needs a different model than a docstring generation — which general gateways treat as a black box. Watch Anthropic and OpenAI pricing moves closely; a 50% price cut on a coding tier would compress the entire routing value prop overnight.

TAM & Market Size

The buyer is the engineering team lead or platform engineer at a company with 5–500 engineers running coding agents daily. Bottom-up: GitHub has 100M+ developers; conservatively 2–3M use AI coding agents seriously today, growing 40–60% YoY. Of those, maybe 300K–500K are at companies that track token spend and would pay for a router.

Willingness to pay is high relative to the pain. If a team spends $3,000/month on tokens and you save 60%, that's $1,800/month saved. Charging $200–$500/month is an easy yes — a 10–25% take rate on savings. That's the pricing anchor: percentage-of-savings, not seats.

The scores given here — opportunity 0/100, demand 0/100 — reflect that the dataset has almost no volume yet, not that the market is empty. Treat them as "unmeasured," not "nonexistent." My estimate: a realistic serviceable market of $150M–$400M ARR within 24 months, with the first $10M captured by whoever ships the best coding-specific policy engine. Buyers will pay, but only after they see a savings dashboard. Lead with ROI proof, not features.

Competitive Landscape

Four tiers of competition. Tier 1: general LLM gateways — OpenRouter, LiteLLM, Portkey, Helicone. Strengths: mature, multi-provider, enterprise features. Weakness: they route by price/latency, not by coding task semantics. They don't know a "fix the failing test" call from a "write the migration" call.

Tier 2: agent vendors' built-in model pickers — Cursor's model selector, Claude Code's config. Strength: zero setup. Weakness: single-vendor lock, no cross-provider optimization, no team-level cost policy.

Tier 3: cloud vendor routers — AWS Bedrock, Azure AI Foundry, Google Vertex. Strength: procurement trust. Weakness: slow to add DeepSeek/Kimi, enterprise-only pricing.

Tier 4: open-source hobby routers like the one in this signal. Strength: fresh, Go-fast, community. Weakness: no SLA, no billing, no support.

The gap: a coding-aware, cost-optimizing router with team policy, savings analytics, and sub-50ms overhead. Big Tech will enter — AWS and Google already have the plumbing — but they'll lag on cheap Chinese models for compliance reasons. That gives an indie 12–18 months. Ship the policy engine and the savings dashboard before they notice.

Business Model

Recommendation: usage-based SaaS with a percentage-of-savings floor, not pure per-seat. Why: your value scales with their token spend, and per-seat pricing caps your upside on exactly the teams that need you most.

Pricing tiers:

• Free: 1M routed tokens/month, single user, community support. Acquisition funnel.
• Pro — $99/month: up to 10M tokens, 5 seats, savings dashboard, fallback chains. Target: 2–10 person startups.
• Team — $499/month: 100M tokens, unlimited seats, SSO, per-project budgets, audit logs. Target: 20–100 engineer orgs.
• Enterprise — custom, from $2,500/month: on-prem/VPC deployment, custom routing policies, SLA. Target: regulated industries.

The $99 tier is the wedge — cheap enough to expense without approval, valuable enough to prove ROI in week one. Team tier is where the real revenue lives.

12-month forecast (assuming 18-month sales cycle compression typical for dev tools):

• Conservative: 150 Pro + 15 Team = ~$22K MRR → $264K ARR
• Base: 600 Pro + 60 Team = ~$89K MRR → $1.07M ARR
• Optimistic: 2,000 Pro + 200 Team = ~$298K MRR → $3.6M ARR

CAC estimate: $150–$400 via content/SEO and dev community. Payback: 2–4 months on Pro, 1–2 months on Team. Healthy.

MVP Blueprint

Ship in 5–7 days. Cut everything that isn't routing + proof of savings.

Core features (only these):

1. OpenAI-compatible proxy endpoint (drop-in base_url swap).
2. Three providers wired: OpenAI, Anthropic, DeepSeek. Hardcode the adapters.
3. One routing policy: "cheap-first with escalation" — try DeepSeek, escalate to Claude Sonnet if the request contains stack traces or >8K context.
4. Token + cost logging per request, stored in SQLite.
5. A single-page dashboard: total spend, spend-without-router (calculated), savings in dollars and percent.

Tech stack: Go for the proxy (matches the signal's tag, fast, single binary, trivial to deploy). SQLite for logs — no Postgres until you have 50 users. A static HTML + htmx dashboard, no React. Deploy as a Docker image on Fly.io or Railway. Auth via API key, nothing more.

Fastest path to launch: open-source the proxy on GitHub (drives the Show HN audience that's already watching this term), gate the hosted dashboard behind $99/month. The OSS repo is your marketing; the hosted version is your business.

Explicitly do NOT build: multi-tenant billing, SSO, custom policy DSL, or a Slack integration in v1. Those are month-3 problems.

Commercial Opportunities

1. Coding-Agent Cost Optimizer (SaaS). Target: 10–100 engineer startups spending $2K+/month on agent tokens. Value prop: "Cut your Cursor/Claude Code bill 60% in 10 minutes." Expected revenue: $5K–$40K MRR within 6 months. Beats alternatives because it's the only product whose headline metric is a dollar figure on a dashboard.

2. Routing-as-API for agent builders (API). Target: teams building their own coding agents (startups, OSS maintainers). Sell the routing decision as a service — they POST a task description, you return the optimal model. Expected revenue: $2K–$15K MRR, usage-priced at $0.10 per 1K routing decisions. Beats LiteLLM because you sell decisions, not plumbing.

3. Enterprise model-governance layer (Service + SaaS). Target: banks, healthcare, defense contractors who can't send code to DeepSeek but want cost savings. Value prop: policy-enforced routing that keeps sensitive code on approved models. Expected revenue: $10K–$50K MRR per account. Beats cloud vendors because you support their cheap-model exceptions with audit trails.

Product Ideas

🥇 RouteWise — "Cut your coding-agent bill in half without changing your workflow." One-line value prop: drop-in proxy that routes each agent call to the cheapest model that can handle it. Target user: engineering leads at 10–100 person startups already paying for Cursor/Claude Code. Why now: token costs are the #1 complaint in dev communities, and no coding-specific router exists with a savings dashboard.

🥈 AgentLens — "See exactly where your agent tokens go." Observability-first play: per-task, per-file, per-model cost attribution with routing recommendations. Target user: platform engineers who need to justify AI spend to finance. Why now: as agent usage scales, "we spent $9K on tokens, on what?" becomes a board-level question. Routing is the natural upsell once they see the waste.

🥉 KimiBridge — "Use Kimi K2 and DeepSeek inside Claude Code, safely." Narrow wedge: a compliance-aware bridge that lets Western teams use cheap Chinese models with data-residency controls and output sanitization. Target user: cost-sensitive teams blocked by legal from direct DeepSeek access. Why now: the price gap (10–20x) is too large to ignore, and the compliance objection is the only thing stopping adoption.

SEO Opportunity

Search volume is nascent but compounding — terms like "LLM router," "model routing," and "coding agent cost" are climbing from near-zero. SEO difficulty: 0/100, meaning almost no established content owns these terms yet. That's a rare greenfield.

Target long-tail keywords: "route Claude Code to DeepSeek," "cheapest model for coding agents," "LLM gateway for Cursor," "reduce Cursor token cost," "coding agent model router."

Content strategy: publish benchmark-driven comparison posts ("DeepSeek vs Sonnet for refactoring: 200 real tasks, 12x cost difference") every two weeks. These rank fast, get shared on HN, and convert because the reader is already cost-motivated. Own the "X vs Y for coding" query space before the gateways write generic docs.

Risk Assessment

Risk 1 (tech): Providers ship native routing. OpenAI or Anthropic could add "auto-select model" to their APIs, collapsing your value prop. Mitigation: stay cross-provider — their incentive is to lock you in, not route you out.

Risk 2 (market): Token prices keep falling. If frontier models drop to DeepSeek prices, routing loses its raison d'être. Real but slow — a 10x price convergence would take 3+ years, and quality tiers will persist.

Risk 3 (execution): You're too early. Two mentions is a whisper. You may spend six months educating a market that isn't ready to buy. Mitigation: launch as OSS first, monetize the hosted layer only after 500+ GitHub stars.

Cheap validation: Ship the OSS proxy in a week. Post to Show HN and r/LocalLLaMA. If you get 200+ stars and 20+ "how do I pay for the hosted version" comments within 14 days, build. If you get polite interest and no payment intent, walk away. That's a $0, 7-day test.

Action Plan

Today: Write the README for the OSS proxy. Define the one routing policy (cheap-first with escalation). Set up a GitHub repo named something searchable like coding-agent-router.

Week 1: Ship the Go proxy with OpenAI/Anthropic/DeepSeek adapters and SQLite logging. Post to Show HN, r/LocalLLaMA, and the Cursor forum. Instrument a landing page with an email capture and a "notify me when hosted version launches" button.

Month 1: If you hit 200+ stars and 100+ emails, ship the hosted dashboard at $99/month. Onboard the first 10 paying users manually — white-glove their routing policies. Measure real savings per user; that number is your entire marketing.

Month 3: If MRR > $3K with <5% monthly churn, raise or double down on content SEO. If MRR < $1K, pivot to the enterprise governance angle (RouteWise #3) or shut it down. Do not grind on a dead signal.

Related Terms

LLM Gateway — the broader category this term lives inside; gateways handle auth, rate limits, and logging across providers, while model routing adds the decision layer on top. Expect these to merge.

Agent Observability — tracing and cost attribution for agent runs (Langfuse, Helicone). Natural upstream: you can't route well without seeing where tokens go.

Inference Cost Optimization — the umbrella trend (caching, quantization, batching, routing). Model routing is the highest-leverage, lowest-effort lever in that stack, which is exactly why it's emerging first.