A single plan before the first code edit helps coding agents solve more bugs

The problem: effort that goes nowhere

Coding agents are AI systems that read a software project, try to fix a bug or add a feature, and run tests along the way. The paper opens with a familiar frustration: an agent can spend a lot of effort exploring a codebase and testing, and still hand back a patch that fails.

Existing ways to steer agents mid-run fall into two camps, according to the abstract. Some review the agent's progress at regular intervals. Others call in an advisor when a monitor notices odd behavior. The authors say frequent reviews are expensive, and that a lack of odd behavior does not prove the agent is heading the right way.

One intervention, at the moment of commitment

PAUSE, as the paper posted on arxiv.org describes it, uses a single planning step. The researchers observed that agents make their first edit to the actual source code at a median of 60% of the way through a run. By then they have explored the project, reproduced the bug and run tests.

PAUSE catches the agent's request to make that edit before it happens. A separate model, the Planner, reads the task and everything the agent has done so far, then writes one repair plan. The original agent, called the Executor, picks up again with that plan, keeping its memory of the run and its workspace.

The authors say this needs no trained monitor, no search across saved checkpoints, and no extra model call. That last property is what they mean by search-free: the method does not try many candidate paths and pick the best.

It works in two modes. Online, it steps in during a live run. Offline, it starts from a recorded stretch of an earlier run that ended in failure.

What the reported results say

The team tested on SWE-bench Verified and SWE-bench Multilingual, which are standard collections of real software-repair tasks. They used two Executors and three agent harnesses, the software frameworks that let a model use tools. In the headline setup, Qwen3-coder was the Executor and GPT-5.6 Sol was the Planner.

In that setup, online steering raised the resolution rate by 16.8% on Verified inside the OpenHands harness. In the SWE-agent harness, the Multilingual gain was 14.7%. The abstract does not say whether these are relative gains or percentage points.

The comparisons with other steering methods, all in SWE-agent:

• Against LivePlan, an advisor triggered by rules, PAUSE came out ahead by 3.2% on Verified and 3.7% on Multilingual, at similar Planner cost.
• Against SICA, which uses a periodic overseer, results were comparable, but PAUSE used roughly 11-15% of SICA's Planner cost.

Offline, PAUSE recovered 35.4% of eligible failed Verified tasks. Resuming from the recorded prefix used 33-41% fewer Executor tokens (the units of text a model processes, which drive cost) than starting over.

How far to trust it

This is a preprint, so it has not necessarily been through peer review. The numbers come from the authors' own abstract, and we have not seen independent replication. The results also depend on pairing a specific Executor with a strong Planner, so they may not carry over to every setup.

The idea is also an incremental one in a crowded area: the paper itself acknowledges that steering methods already exist. What is distinctive is the timing and the cost argument. One intervention at the point where the agent commits to a fix, rather than ongoing checking, is what the authors say makes it cheap.

For everyday users, the lesson travels without the software. Before an agent changes anything, ask it to say which files matter, what it thinks the bug is and how it will know it is fixed. Reviewing that plan takes seconds, and correcting a wrong start early is cheaper than unwinding it later.