SaaS Metrics
Show HN: Smart model routing directly in Claude, Codex and Cursor
Intelligently sends requests to the best model to serve them, reducing AI inference costs ('saved 40% on tokens') without sacrificing quality or velocity. It acts as an Anthropic/OpenAI endpoint for coding agents.
View Origin LinkProduct Positioning & Context
AI Executive Synthesis
Intelligently sends requests to the best model to serve them, reducing AI inference costs ('saved 40% on tokens') without sacrificing quality or velocity. It acts as an Anthropic/OpenAI endpoint for coding agents.
The Weave Router addresses a critical enterprise challenge: managing escalating LLM inference costs while maintaining performance for AI coding agents. By intelligently routing requests to cheaper, faster models for routine tasks and frontier models for complex ones, it delivers a tangible 40% cost reduction. This optimization is crucial for scaling AI-assisted development within organizations. Its positioning as an Anthropic/OpenAI endpoint simplifies integration, reducing developer friction. Offering both source-available (Elastic License 2.0) and hosted versions caters to diverse enterprise needs for control and convenience. This product capitalizes on the growing maturity of LLM ecosystems, where cost-aware routing and model orchestration are becoming essential infrastructure components for sustainable AI adoption and efficient resource utilization.
We built a model router that plugs into coding agents (e.g. Claude Code, Codex, Cursor, etc.) and intelligently sends requests to the best model to serve them. Here's a quick demo of running it locally: https://www.youtube.com/watch?v=isKhAyivtfM.At Weave, we write most of our code with AI, and it's been getting more expensive. This came to a head when Opus 4.7 was released and, thanks to its tokenizer changes, our costs shot up. We knew we didn't need Opus for everything but we didn't want to lose out on the intelligence for the cases where you really need it. So we decided to build a model router to handle this for us.The Weave Router acts as an Anthropic/OpenAI endpoint specifically for coding agents. It looks at every inference request and intelligently (more on that in a sec) decides what model to send it to, handling all the translations required along the way. So it can use faster/cheaper models (e.g. DeepSeek v4, GLM 5.2, Kimi K2.6) when possible, and frontier models (Opus 4.8 & GPT 5.5 (& Fable whenever it's back)) when necessary.How do we know what model to route to? We trained an RL model on tens of thousands (so far!) of agent traces. We reward the routing model when it selects an LLM that successfully completes the given task.Here's an example: if you ask the router to plan a complex change, it will (probably) route that request to Opus 4.8. Subagents exploring the codebase to gather context will be routed to more suitable models (e.g. DeepSeek V4 Flash). Then when you have the plan ready to implement, it will be (most likely) be handed to a quicker model (e.g. GLM 5.2) to carry it out.We've been using this internally for the last month or so. We've saved 40% on tokens vs. what we otherwise would have paid, with no noticeable differences in quality or velocity.The router is source-available under Elastic License 2.0, so you can self-host it. Or if you prefer, you can also use our hosted version: weaverouter.com.I'll be here to answer any questions you may have!
Related Ecosystem & Alternatives
Discover adjacent products, open-source repositories, and developer tools sharing similar technical architecture.
Deep-Dive FAQs
What is Smart model routing directly in Claude, Codex and Cursor?
Smart model routing directly in Claude, Codex and Cursor is analyzed by our AI as: Intelligently sends requests to the best model to serve them, reducing AI inference costs ('saved 40% on tokens') without sacrificing quality or velocity. It acts as an Anthropic/OpenAI endpoint for coding agents.. It focuses on The Weave Router addresses a critical enterprise challenge: managing escalating LLM inference costs while maintaining performance for AI coding age...
Where did Smart model routing directly in Claude, Codex and Cursor originate?
Data for Smart model routing directly in Claude, Codex and Cursor was aggregated directly from the Hacker News community ecosystem, representing raw developer and early-adopter sentiment.
When was Smart model routing directly in Claude, Codex and Cursor publicly launched?
The initial public indexing or launch date for Smart model routing directly in Claude, Codex and Cursor within our tracked developer communities was recorded on June 27, 2026.
How popular is Smart model routing directly in Claude, Codex and Cursor?
Smart model routing directly in Claude, Codex and Cursor has achieved measurable traction, logging over 187 traction score and facilitating 100 recorded discussions or engagements.
Which technical categories define Smart model routing directly in Claude, Codex and Cursor?
Based on metadata extraction, Smart model routing directly in Claude, Codex and Cursor is categorized under topics such as: model router, coding agents, Claude Code, Codex.
What are some commercial alternatives to Smart model routing directly in Claude, Codex and Cursor?
Our semantic intelligence engine identifies potential commercial alternatives in the SaaS space, such as Trump Accounts, which offers overlapping value propositions.
How does the creator describe Smart model routing directly in Claude, Codex and Cursor?
The original author or development team describes the product as follows: "We built a model router that plugs into coding agents (e.g. Claude Code, Codex, Cursor, etc.) and intelligently sends requests to the best model to serve them. Here's a quick demo of running it loc..."
Community Voice & Feedback
I generally believe the proxy route is best to understand any harness. I been building some thing similar.
There are so many of these projects to wrangle AIs I think we might need an AI to go through, analysing each and amalgamating the good bits.It makes me think of MakeFiles.Make is sufficiently bad that everyone who has used it has considered writing a better way to do it. A good percentage of those people have done so.On the other hand, make is also not so sufficiently bad that it cannot do its job. The choice becomes picking the thing that everyone has or one of the many many alternatives that proclaim their strengths and leave their weaknesses lurking to bite when they are least expected.No single replacement to make dominates, and make lives on. I wonder if AI management is on a similar path.
I ran into a problem at work recently: we are given access to a bunch of models up to a full Claude Opus 4.8, but a monthly budget of 100k tokens. We are also given access to Gemini 3.5 Flash & 3.1 Pro with a daily budget of 50M tokens, but no tool calling. I'd love to hook Claude Code (or Pi) into the Gemini model, but the lack of tool-calling makes it quite difficult. I've been planning out how an intelligent router might be able to use a token-efficient tool-calling model (including a small local open-weights model) to handle the basic tools like reading from the file system or interfacing with MCP servers such that context is gathered, but then send the built up context to the Gemini model where I have a nearly unlimited (for my use cases) token budget.Could your router handle this?
Looks interesting!Out of curiosity, how does it compare with vLLM Semantic Router?For reference:https://vllm-semantic-router.com/https://github.com/vllm-project/semantic-routervLLM Semantic Router: Signal Driven Decision Routing for Mixture-of-Modality Models, https://arxiv.org/abs/2603.04444https://github.com/vllm-project/semantic-routerFor instance, does it offer similar algorithms:- vllm-sr/auto: efficient, fast, balanced routing, similar in spirit to Fugu // Sakana Fugu — Multi-Agent System as a Model: https://sakana.ai/fugu/
- vllm-sr/fusion: panel-style multi-model reasoning and synthesis.
- vllm-sr/flow: router-native workflow orchestration
- vllm-sr/remom: multi-round reasoning over one or multiple models.FWIW, it does look good on https://routeworks.github.io/leaderboardRef.RouterArena: An Open Platform for Comprehensive Comparison of LLM Routers, https://arxiv.org/abs/2510.00202, https://github.com/RouteWorks/RouterArena
- vllm-sr/fusion: panel-style multi-model reasoning and synthesis.
- vllm-sr/flow: router-native workflow orchestration
- vllm-sr/remom: multi-round reasoning over one or multiple models.FWIW, it does look good on https://routeworks.github.io/leaderboardRef.RouterArena: An Open Platform for Comprehensive Comparison of LLM Routers, https://arxiv.org/abs/2510.00202, https://github.com/RouteWorks/RouterArena
I'm glad there are more attempts at solving model routing, as costs (at API rates) has really become an issue. Some feedback:1. Reiterate the cache issue from other comments already here. there is a lot of optimisation in harnesses around caching and a proxy model blows that up2. Coding agents are model aware - they already route code discovery to mini / flash models, planning to heavy models, workflow design to ultra, implementation to mid / high etc. They know when they're exploring, planning, implementing, reviewing etc. and which model class to select and when it fails.With a proxy you're breaking this control loop and feedback. It doesn't know, for ex. that it just attempted with deepseek v4 and it failed, lets try Opus?3. How are you going to RL improvements and prevent the router becoming stale? You only have access to your own internal prompts and ~thousands of samples.This is RL'd on one orgs codebase. There are going to be a lot of prompts you haven't seen before and have no insight to on how to route correctly, and you have no insight into users HF to improve your own model. Orgs aren't going to share their traces with you, so you need other sources to train on and improveThere are also new model releases every week that you need to keep up with - whats the story going to be here4. Publish evals by running terminalbench / deepswe bench. Show us the performance / cost / time chart vs the other agent and model sets. If you can show gains there, you have a very simple value prop to sell where you can charge for a % of the saved costs
This would not work in the way that shows any significant genuine benefit IMO. Caching and optimum routing of a single request are at odds with each other. Higher the distinct model count in a conversation, more cache misses you accept.Based on what OP said elsewhere in the discussion "threshold to switch to another model will be higher" means that essentially you reduce the workflow into two models at most. The two model primitive, one planner and one executor, is already sufficient for such a use case.For lower than 2 models, it's just a simple single model cache-preserving conversation which arguably doesn't need another layer. For larger than 2 models, you are likely paying a large aggregate cache penalty that negates most of the gains
It's rather hard to do at the proxy level with agentic coding, such as Claude Code or similar. These are long-chained sessions of tool use that heavily rely on prompt caching. Changing mid-flight is costly.It looks like much more context is required to decide on the best model (e.g., summarizing logs might use a cheap model, whereas you likely want Opus/Mythos/GPT 5.6 to debug multithreading logic). In an agentic system, a decision about the model may be embedded in the decision to orchestrate the model.
I auto tune my prompts to a locked model version based on production data used as evals with holdback data. I think the use case for this would be one off interactive prompts? For now I just run those all against an Opus 4.8 MAX and I'm sure I could downtune, although for interactive my opening prompt isn't always reflective of my overall goals for the multi turn session.I'm just trying to figure out why on the fly routing would beat testing and tuning and locking models and versions for each class of call, with evals and auto tunes running to explore more possible models for commonly run classes of prompt over time . . .
Man, I'm not so sure if I'd use something like this because the way I prompt already changes based upon what model I am using. I'm not convinced it would route to the right model based on my diction or whatever.
The thing I do not get with these routers is that you will have more cache misses (5min ttl). And if there is one thing i’ve learned; using the cache is crucial.How does this router translate to $$$ when developing?
Discovery Source
Hacker News Aggregated via automated community intelligence tracking.
Tech Stack Dependencies
No direct open-source NPM package mentions detected in the product documentation.
Media Tractions & Mentions
No mainstream media stories specifically mentioning this product name have been intercepted yet.
Deep Research & Science
No direct peer-reviewed scientific literature matched with this product's architecture.