IQ Routing bets agent costs drop when the router sees the whole trajectory

A new tool called IQ Routing launched on Product Hunt this week with a deceptively simple pitch: trajectory-aware LLM routing that cuts agent cost. The core idea is that instead of choosing a model for each individual call inside an agent loop, a router watches the whole trajectory of the agent’s reasoning and picks models accordingly. That shift in granularity, from per-step to per-trajectory, is the genuinely interesting part of the launch. Most routing systems today optimize a single inference call. IQ Routing is betting that the cost problem in agents is not the individual call, it is the accumulation of calls across a multi-step task.

The routing problem is not new. Companies like Martian, NotDiamond, and OpenRouter have built businesses on the premise that different LLMs excel at different tasks, and that a smart dispatcher can send each prompt to the cheapest model that will handle it correctly. Those systems typically look at the prompt, the model’s historical performance on similar prompts, and a cost-quality tradeoff. They make a decision, the call happens, and the router moves on. That works fine for single-shot generation. It breaks down for agents, where a single task can involve dozens of sequential calls, each dependent on the previous one’s output.

IQ Routing’s trajectory-aware approach treats the agent’s entire reasoning path as the unit of analysis. The router does not just ask “which model should answer this prompt?” It asks “given where this agent has been, what it has tried, and what it has produced so far, which model should handle the next step?” That is a meaningfully different optimization problem. A model that is excellent at drafting a plan may be terrible at executing a tool call. A cheap model that works fine for the first three steps of a task may produce a subtly wrong intermediate result that derails the entire trajectory. Per-step routing cannot see that failure coming. Trajectory-aware routing can, in principle, intervene before the agent commits to a costly wrong path.

The cost angle is the hook. Agent workloads are expensive in ways that single-turn inference is not. Every tool call, every retry, every failed attempt burns tokens. A multi-step agent task that involves ten LLM calls at a few cents each adds up fast, and when the agent fails and retries, the cost compounds. The Product Hunt listing frames the value proposition around cutting that cost, which suggests the target customer is someone running agents at scale, not a developer experimenting with a single chatbot. The economics of agent deployment are still brutal for many teams, and anything that credibly reduces spend per completed task gets attention.

The technical claim deserves scrutiny. Trajectory-aware routing requires the router to have visibility into the agent’s state, which means it needs to be integrated into the agent loop itself, not bolted on as a proxy in front of an API. That is a harder integration than a simple gateway. It also requires the router to maintain a model of what “good” looks like for a trajectory, which is task-dependent. Routing for a code-generation agent is not the same as routing for a customer-support agent. The tool will live or die on how well it adapts to the specific agent framework and task domain of each customer.

There is a deeper question about whether trajectory-aware routing is even the right abstraction. An alternative approach is to make the agent itself smarter about when to escalate. Some agent frameworks already let a developer specify a fallback model if the primary model fails a validation check. That is a crude form of trajectory awareness, but it is built into the agent logic rather than externalized into a router. IQ Routing is betting that a dedicated, external router can do this better than hand-coded fallback logic, because it can learn patterns across many runs and many tasks. That is a plausible bet. Whether it holds depends on the quality of the telemetry the router collects and the quality of the training data it uses to learn routing policies.

The business model question is also worth watching. Routing tools typically charge either a per-call fee or a flat subscription. The per-call fee model has an inherent tension: the router makes money on volume, but its value proposition is reducing volume by sending calls to cheaper models. IQ Routing will need to resolve that tension, either by charging on savings or by pricing on a per-agent-seat basis. The listing does not specify pricing details, which is common for early-stage launches, but it is the first thing enterprise buyers will ask about.

The timing of the launch is notable. Agent frameworks like LangChain, CrewAI, and OpenAI’s own AgentKit have made it easy to build multi-step agents, but the cost of running those agents at scale is still the main barrier to production deployment. Every vendor in the agent stack is looking for ways to cut inference spend. Model distillation, caching, and speculative decoding all attack the problem from the model side. Routing attacks it from the orchestration side. IQ Routing is entering a crowded field, but the trajectory-aware angle gives it a distinct position.

The skeptical view is that trajectory-aware routing is a nice idea that will be absorbed by the platforms. OpenAI, Anthropic, and Google all control the models and the APIs, and they have every incentive to build routing into their own platforms. If OpenAI decides that trajectory-aware routing should be a native feature of its Agents API, a standalone tool like IQ Routing has a hard road ahead. The counterargument is that enterprises want model diversity, not lock-in to a single vendor’s routing logic. A neutral router that works across OpenAI, Anthropic, Google, and open-weight models has a reason to exist, as long as it can prove savings.

For AI builders, the practical takeaway is that routing is moving up the stack. The next wave of cost optimization will not come from picking the right model for a single prompt. It will come from managing the entire lifecycle of an agent’s work. IQ Routing is an early signal of that shift. The tool itself may or may not succeed, but the trajectory-aware approach is likely to become a standard feature of agent infrastructure within a year. Teams building agents today should start thinking about how they will measure cost per completed task, not cost per call, because that is the metric the next generation of routing tools will optimize.

The launch is small, the company is early, and the claims are unproven. But the direction is right. Agent cost is the bottleneck, and the industry is only beginning to build tools that attack it at the right level of abstraction. IQ Routing is one of the first to name the problem correctly: the unit of cost in an agent is the trajectory, not the call.