Bigger Agents Are Worse at Knowing When to Stop

New research on Agentic Abstention shows LLM agents keep tool-calling on impossible tasks. Bigger models are worse at stopping. The fix is context engineering, not scale.

TL;DR: A new UW paper defines Agentic Abstention, the problem of when a tool-using agent should stop acting instead of continuing to call tools on tasks that were never going to succeed. The counterintuitive finding: larger models are sometimes worse at timely abstention. The fix is CONVOLVE, a context engineering method that distills stopping rules from past trajectories. No fine-tuning needed.

Key takeaways:

Agents that never stop on impossible tasks waste tokens, API budget, and user trust. The paper evaluates 13 agent systems on 28K+ tasks across web, terminal, and QA settings.

Bigger models sometimes perform worse at timely abstention. Scale alone does not solve the stopping problem.

CONVOLVE, a context engineering method, improved timely recall from 26.7 to 57.4 on WebShop without updating model parameters.

The problem is sequential, not single-turn: the agent might need to interact with the environment before realizing the task is impossible.

Agent platform teams should score timely abstention as a first-class metric alongside task success.

The first time I watched an agent burn $12 on a task that was impossible from the start, I didn’t blame the agent.

I blamed myself. I had given it a search tool, a browser, and a terminal. Everything it needed to try. What I had not given it was a way to know when to stop. The agent searched a catalog for a product that did not exist. It searched again with different keywords. Then a third time. Then it started browsing categories, hoping the product would materialise. Twelve dollars and 47 tool calls later, it returned an apology.

The agent was not broken. It was doing exactly what we trained it to do: act until success or budget runs out. The missing piece was not a better model. It was a stopping policy.

This gap now has a name. A new paper from the University of Washington and Allen Institute for AI introduces Agentic Abstention, the problem of deciding when a tool-using agent should stop acting under uncertainty arXiv:2606.28733. And its central finding cuts against the dominant narrative in agent engineering: bigger models are not better at this.

What is agentic abstention?

A kitchen has two kinds of cooks.

The first reads the ticket once, starts cooking, and keeps plating until every item on the ticket is through the pass. If the order gets cancelled midway, they do not know. They are already on the third component.

The second watches the pass between every action. They check: is this ticket still active? Did the customer change the order? Should I stop what I am doing and pivot?

Many LLM agents are the first kind of cook. They get a task, they start acting, and they keep going until they either succeed or hit the interaction budget. They do not check whether the task is still feasible at each step. The paper calls this the difference between having a task policy (how to complete a task) and a stopping policy (when to stop trying).

Agentic abstention is a sequential decision problem. At every turn, the agent has three options: answer the user, act in the environment, or abstain. The need to abstain might only become clear after the agent has taken a few actions and discovered that the environment does not support the request. A product that is out of stock. A terminal command that fails because the required package is not installed. A search query that returns zero results matching the user’s constraint.

Standard LLM abstention is a single-turn decision: answer the question or say “I do not know.” Agentic abstention is harder because the agent must decide at every step, with partial information, and the cost of being wrong changes over time.

The catch: bigger models are worse at this

The paper evaluated 13 LLM-as-agent systems and 2 agent scaffolds on more than 28,000 tasks spanning three environments. WebShop (online shopping), Terminal-Bench (command-line operations), and Interactive QA (multi-turn question answering).

The headline result: some agents never abstain when they should. Others abstain only after many unnecessary interactions. The gap is especially large on tasks where the instruction appears feasible until the environment reveals otherwise.

A search for a product that does not exist looks just like a search for a product that happens to be out of stock, which looks just like a search for a product that the agent has not found yet. The agent cannot tell the difference without interacting. And once it realises the task is impossible, it has already spent turns, tokens, and user patience.

The result that cuts against the scale narrative: larger or more capable models sometimes perform worse at timely abstention.

This is not a clean monotonic relationship. The paper does not claim that every large model is worse than every small one. But across settings, increasing model scale did not reliably improve the agent’s ability to stop on time. In some cases, it made things worse.

Why? The authors suggest that larger models are better at generating plausible intermediate steps even when the overall task is impossible. They can construct a believable narrative of progress. “Let me try a different search strategy,” “let me check the related products section.” That keeps the tool call loop running. A smaller model runs out of ideas faster and stops sooner.

The insight flips the usual framing. When your agent is stuck in a tool-calling loop, the solution is not a bigger model. It is a stopping policy.

What does the data look like?

The paper measures abstention along two axes: whether the agent abstains at all, and whether it does so timely (within the first few turns after infeasibility becomes detectable).

On WebShop, most agents show reasonable overall abstention rates. They do eventually stop. But timely abstention is low across the board. Agents that eventually abstain are typically doing so after 5-10 unnecessary tool calls.

Setting	Model	AbsRec@1 (timely)	AbsRec@10 (overall)
WebShop	Llama-3.3-70B (baseline)	26.7	83.2
WebShop	Llama-3.3-70B + CONVOLVE	57.4	100.0
WebShop	GPT-4o	31.2	78.5
Terminal	Llama-3.3-70B (baseline)	22.1	71.4
Terminal	Llama-3.3-70B + CONVOLVE	39.8	85.7

The timely numbers are the ones that matter in production. An agent that eventually abstains after 8 unnecessary tool calls has already done the damage.

Why CONVOLVE works

CONVOLVE is the paper’s method for improving agentic abstention without fine-tuning. The mechanism is simpler than the acronym. AI Weekly described it as “the kind of number that, if it holds up, points at a fairly cheap intervention for teams that cannot fine-tune frontier models.”

Here is how it works in practice:

Collect trajectories. Run the agent on a set of tasks, including both solvable tasks and tasks designed to be impossible. Record the full interaction. Every tool call, every observation, every turn.
Label the stopping point. For each trajectory, mark the turn at which the environment first signals infeasibility. This is the point where a human observer would say “this task is not going to work.”
Distill into rules. Extract the patterns that distinguish stopping points from normal progress. These become a playbook written in natural language.
Inject into context. The playbook is appended to the agent’s system prompt on every task. No parameters are updated. No fine-tuning is needed.

The playbook looks something like:

When searching a catalog:
- If the first 3 queries return zero results with different phrasings, the product is likely not available. Stop searching.
- If a product page exists but all variants show "out of stock," do not check related products. The task is infeasible.
- If the environment returns an error for a required command, do not retry with the same flags. The approach is wrong.

On WebShop, CONVOLVE raised Llama-3.3-70B’s timely recall from 26.7 to 57.4. It raised overall recall from 83.2 to 100.0. The agent never missed an abstention. The Secondary Progress Metric (SPL), which measures the balance between completion and efficiency, went from 55.3 to 78.9.

The mechanism matters because it does not depend on model access. You cannot fine-tune GPT-4o. You cannot fine-tune Claude Sonnet. But you can inject a CONVOLVE playbook into their context on every task. The paper shows that stopping rules distilled from a smaller model transfer to larger models effectively. The useful signal is the rule, not the model that produced it.

What this means for agent builders

Agentic Abstention reframes a problem most teams have felt but not named.

When your agent runs a tool call 11 times before giving up, the instinct is to blame the model. Switch to a bigger one. Add more examples to the prompt. The paper suggests a different diagnosis: your agent lacks a stopping policy, not a better task policy.

The practical takeaway for teams running agents in production: score abstention as a first-class metric alongside task success. Track how many tool calls your agent makes on tasks it cannot complete. If the number is consistently above 3-4 per failed task, you have an abstention problem, not a model problem.

For teams running open-weight agents, CONVOLVE is directly applicable. Collect your agent’s failure trajectories, label the stopping point, distill into rules, inject into context. No fine-tuning, no infrastructure changes. A context engineering pass that takes an afternoon can double your timely recall.

For teams using frontier models through APIs, the same approach works. You cannot fine-tune. But the paper shows that stopping rules from one model transfer to another. Run the distillation on a local model, inject the playbook into your GPT-4o or Claude context. The gain is smaller but still present.

FAQ

What is Agentic Abstention? Agentic Abstention is the problem of deciding when a tool-using LLM agent should stop acting under uncertainty. Unlike standard LLM abstention (a single answer-or-abstain decision), it is a sequential problem. The agent might need to interact with the environment before realizing the task is impossible.

Are bigger models better at knowing when to stop? No. The paper found that larger or more capable models sometimes perform worse at timely abstention. Some agents never abstain when they should, while others do so only after many unnecessary tool calls.

What is CONVOLVE? CONVOLVE is a context engineering method that distills full interaction trajectories into reusable stopping rules. It improved Llama-3.3-70B’s timely recall from 26.7 to 57.4 on WebShop without updating any model parameters.

How is Agentic Abstention different from standard LLM abstention? Standard LLM abstention is evaluated as a single-turn decision. Answer the question or say “I do not know.” Agentic abstention is sequential: at every turn the agent can answer, act, or abstain, and the need to stop may only become clear after interacting with the environment.

What environments were tested? The paper evaluated 13 LLM-as-agent systems and 2 agent scaffolds on more than 28,000 tasks across web shopping (WebShop), terminal environments (Terminal-Bench), and question answering (Interactive QA).

Agents break in production and nobody talks about it. Why agents fail in real deployments. Tool loops, context drift, and silent failures.
How agents evaluate their own work: task completion and trajectory quality. Why task completion alone is not enough and trajectory quality needs its own metrics.
The 15 jobs of an agent harness. What an agent harness needs to handle. Including stopping conditions and budget management.
Your agent needs policy gates, not just prompts. Why policy-based guardrails outperform prompt instructions for controlling agent behavior.

This article was published on Agentic Up (https://agenticup.dev): practical guides for developers and founders building with AI agents. Reach me at [email protected]