The cheapest way to run an agent is to not run the expensive model most of the time. Small language models are fast and nearly free; a frontier model is neither. So the standard advice is a router or a cascade: look at the incoming task, guess how hard it is, and send the easy ones to the small model and the hard ones to the big one. We've written about that machinery, and for a single API call it's the right instinct.

It's the wrong instinct for an agent, and the reason is a category error about where difficulty lives.

Competence is a property of the step, not the task#

A router treats "hard" as a label you can stick on a task before it starts. But an agent doesn't do a task; it does a trajectory — dozens or hundreds of steps, each a small decision. And a model's competence is not flat across that trajectory. A small model can handle thirty steps of a refactor and then hit the one step — a subtle race condition, an underspecified requirement — that it simply cannot get right.

Whole-task routing has no good move here. Send the whole trajectory to the small model and it fails on step thirty-one. Send the whole thing to the frontier model and you've paid frontier prices for the thirty steps a 3B model would have nailed. The unit of the decision is wrong. The real question isn't "which model should do this task" — it's "at this point in this run, should a bigger model take the wheel?"

The obvious fix doesn't work#

The tempting answer is to let the agent tell you. Ask the small model how confident it is; escalate when it hesitates. This fails, and 2026 produced an unusually clean stack of evidence that it fails.

Start with the base capability. AbstentionBench (NeurIPS 2025) evaluated whether models know when not to answer — across twenty datasets of unanswerable, underspecified, and false-premise questions. The finding was blunt: abstention is an unsolved problem, model scale barely moves it, and reasoning fine-tuning — the thing we do to make models better at hard problems — actively degrades it. Models will verbalize a confidence level without doing any real reasoning about their own uncertainty. The number they give you is a fluent guess, not a measurement.

Now put that model in an agent loop. HiL-Bench, from Scale, did exactly that: it took SWE and SQL tasks the best agents solve about 89% of the time, then quietly removed or obscured a few necessary details and handed the agent a tool it could use to ask for the missing information. Performance fell to 24%. The agents did not, mostly, ask. They "overconfidently guessed and wrote incorrect solutions," and on the occasions they did ask, the questions were rarely targeted or necessary. HiL-Bench's own taxonomy of the failure is the whole story in one line: overconfident wrong beliefs with no gap detection.

An agent is least able to tell that it's stuck at exactly the moment it is most stuck.

That's the trap. The signal you most want to read — "I'm out of my depth here" — is the signal the model is structurally worst at producing, because the same overconfidence that causes the error suppresses the doubt that would flag it.

Put the judge outside the model#

If the agent can't be the narrator of its own competence, the escalation trigger has to come from somewhere else. This is the actual insight, and R2V Agent is the cleanest 2026 instance of it. The architecture is deliberately un-clever: a small distilled policy runs the steps, and a separate, lightweight process verifier scores each candidate action — is this step likely correct, given where the trajectory has been? A calibrated router reads that verifier score plus a few trajectory features, estimates the residual risk of failure at this step, and escalates to the teacher LLM only when the risk crosses a threshold.

Because the verifier is external to the policy, it isn't taken in by the policy's overconfidence. Because it scores one step rather than solving the task, it's cheap. And the results are the argument: R2V reaches 93.3% on TerminalBench while calling the large model on only 33.9% of steps; it lifts a TextWorld task from 64.6% on the small model alone to 98.2% by escalating 41.7% of the time — at roughly half the large-model cost of a heuristic router matched to the same quality. On HumanEval+ it escalates on 0.60% of steps and still hits 94.3%, because most coding steps genuinely never needed the big model.

What this changes about how you build#

The practical reframing is small and load-bearing. "When should my agent ask for help" is not a prompting problem. You will not solve it with a better "say 'I don't know' when unsure" line in the system prompt — AbstentionBench is the receipt that such prompts help at the margin and don't touch the underlying inability to reason about uncertainty. It's an instrumentation problem: you stand up a cheap, calibrated judge next to the agent and let it pull the cord.

And "help" is a routing target, not a fixed recipient. The same detector that decides to escalate to a frontier model is the one that decides to escalate to a human in the loop — HiL-Bench's Ask-F1 and R2V's verifier are measuring the same latent quantity, should I proceed alone here, and pointing the answer at a different responder. The encouraging coda from HiL-Bench is that this judgment is trainable: RL on a shaped help-seeking reward improved both a 32B model's questions and its pass rate, and the gains transferred across domains.

So the escalation decision graduates into a first-class component with its own objective and its own evals — sitting beside the agent, watching it work, ready to say not this one, get help. Which is the honest arrangement, because the one thing we've now measured repeatedly is that the agent can't reliably say it about itself.