- Introduction — Reasoning Effort as a Cost Lever
- A Router That Picks the Effort for Each Step
- The Numbers, and How to Read Them
- The Honest Tradeoffs — Router Overhead and Under-Thinking
- Closing — A Deployable Idea Today
- References
Introduction — Reasoning Effort as a Cost Lever
Agents built on thinking LLMs reach high accuracy through long chain-of-thought reasoning, but they pay for it in inference cost. Many current models expose the reasoning level as a setting — high, medium, low — and the real question is how to pull that lever.
The observation in the Ares paper (a March 2026 preprint) is simple but sturdy: static strategies do not work well. Running every step at low degrades performance noticeably, and choosing levels at random preserves neither accuracy nor a meaningful cost cut. The truer picture: some steps — navigating a complex website structure — genuinely need high effort, while simpler ones — opening a target URL — are fine at low effort. Effort should be allocated per step, not per task.
A Router That Picks the Effort for Each Step
The core of Ares (Adaptive Reasoning Effort Selection) is a single lightweight router. At every step, it looks at the interaction history so far and predicts the lowest appropriate reasoning level for that step. The idea is to answer "is this step hard?" cheaply, up front, and turn on expensive thinking only when it is.
How is the router trained? The paper uses a data-generation pipeline to identify the minimum reasoning effort each step needs to succeed, then fine-tunes the router on those labels. The result is designed to be plug-and-play — not tied to one model, but dropped in front of an existing LLM.
Sketched conceptually, it runs like this.
Right before each LLM call:
1. Pass the interaction history so far to the router
2. The router predicts the minimum reasoning level for this step (high / medium / low)
3. Call the main model at that level
4. Append the tool result to the history and move to the next step
The point is that the router is much cheaper than the main model, and the decision is per step — effort rises and falls within a single task.
The Numbers, and How to Read Them
Start with what the paper reports. Across three benchmarks — TAU-Bench for tool-use agents, BrowseComp-Plus for deep-research agents, and WebArena for web agents — it cuts reasoning tokens by up to 52.7% versus always running at high, while reporting only minimal degradation in task success rate.
How to read that. Two caveats up front. First, these are author-reported numbers from a preprint, not independently verified. Second, "up to" is a ceiling: it varies by benchmark, and it is safer to read it as a best case than as an average across all conditions. Still, the direction is clear — most agent steps do not need maximum thinking.
The Honest Tradeoffs — Router Overhead and Under-Thinking
There is no free lunch. The honest costs of this approach:
- The router itself costs something. It runs on every step, so it has to be light enough not to eat the savings. If the router call costs more than the thinking tokens it saved, there is no point.
- Under-thinking risk. If the router misjudges a hard step as easy and picks too low a level, that step fails. And in an agent, one failed step often derails the whole trajectory or forces a retry — which can cost more than the thinking you saved. In practice, biasing the router slightly toward more thinking is usually the safer calibration.
- Distribution shift. The router is trained on a particular distribution of agents and tasks. Move it to an agent in a different domain and its judgments may drift. Re-measure whenever you transplant it.
- Measure the accuracy-cost curve yourself. There is no guarantee that "up to 52.7%" reproduces on your workload. Measure success rate and tokens together on your own tasks, and confirm for yourself that the savings justify any accuracy loss.
Closing — A Deployable Idea Today
What makes Ares appealing is not a specific router implementation but the principle: do not spend reasoning effort uniformly across a whole task; allocate it per step, only as much as each step needs. You can approximate this idea today without any trained router weights — set the level by step type (a simple lookup versus complex planning) with a heuristic, or add a fallback that only raises effort after a failure.
This is still a preprint, and the numbers are the authors' own. But the claim that making every step think at maximum is wasteful holds up both intuitively and on the invoice. If you run agents in production, that is reason enough to start treating reasoning effort as one more tunable lever.