Your AI Agent Has a Problem: It Can’t Stop Working!

And that’s more dangerous than you think

You hire a plumber to fix a leak. You come home to find the leak has already been fixed by someone else, but the plumber ripped out half your bathroom anyway.

That’s what coding agents are doing. Constantly.

A new paper from ETH Zurich just put hard numbers on it, and the results should change how every developer works with AI agents.

🧪 The Experiment

The researchers built something called FIXEDBENCH.

They took 200 real GitHub bug reports and applied the fix before giving them to the agent. The bug was already solved. The correct answer was to do nothing — submit an empty patch, move on.

Then they let five frontier AI models loose on those already-fixed issues: Claude Sonnet 4.6, GPT-5.4 Mini, Gemini 3 Pro, Qwen 3.5, and GPT-5.3 Codex. Each running inside its native agent harness — Claude Code, Codex, Gemini CLI, Qwen-Code.

The question:

Would the agents recognize that the code was fine and stop?

🔍 What They Found

They modified already-correct code 35 to 65% of the time.

Let that sink in. Given a codebase that needed zero changes, the best models still made unnecessary edits in more than one out of three attempts. The worst ones did it nearly two out of three times.

This isn’t a bug. The agents aren’t broken. They’re doing exactly what they were trained to do: produce a patch. The problem is that they were never taught that not producing a patch could also be the right answer.

The researchers call this action bias.

🧠 Why Agents Can’t Stop

Think of it like a new employee on their first week.

Their manager says “fix this bug” every single day. Never once does the manager say “check if it’s already fixed and if so, do nothing.”

After months of that, the employee develops a reflex: task arrives → find something to change → submit change. Even when there’s genuinely nothing to fix, they’ll reformat something, rename a variable, or add a comment. Because doing nothing feels like failing.

That’s exactly what’s happening with these models. Their training data is dominated by tasks that require a change. So they always make a change.

✅ The Fix Is One Sentence Long

The researchers tried four different ways of prompting the agents:

1. ISSUE — just hand them the bug report as-is (baseline)
2. EDIT — explicitly tell them to edit the codebase
3. REPRODUCE — tell them to reproduce the issue first, then fix it
4. ABSTAIN OR FIX — tell them to reproduce the issue first, and if it’s already fixed, say so and stop

The results:

A few things jump out here.

→ Telling the agent to “edit the codebase” made things significantly worse — it cut GPT-5.4 Mini’s correct abstention almost in half.

→ Telling the agent to reproduce the issue first, without also giving it permission to stop, was useless — and in GPT-5.4 Mini’s case, actually made it worse.

→ But adding one sentence — “if the issue is not present, report that and don’t make changes” — pushed GPT-5.4 Mini from 60.5% to 88.5%.

The agent already had the ability to recognize the bug was fixed. It just hadn’t been told that recognition was enough. That stopping counted as a win.

🤔 More Thinking Doesn’t Help

You might assume that if you just gave the model more time to think — more compute, higher reasoning effort — it would naturally figure out the right move.

The researchers tested this directly by varying GPT-5.4 Mini’s “thinking effort” from Low to Extra High.

The result? No meaningful difference. The correct abstention rate moved from 61.5% to 65.8% across all four effort levels — a change smaller than the statistical margin of error.

This is not a reasoning problem. Thinking harder doesn’t fix it.

It’s a framing problem. The model needs to be told what winning looks like.

⚡The Catch: You Can Overcorrect

There’s an uncomfortable twist.

When the researchers applied the “ABSTAIN OR FIX” prompt to code that was partially fixed — broken in a different way than the original bug — the agents over-abstained. They saw something was done and decided to stop, even though the code was still wrong.

So the prompt that fixes action bias introduces passivity bias on partially-broken code.

Prompt engineering traded one failure mode for another.

This is the unsolved problem the paper leaves open, and it’s an honest one. There’s no magic prompt that makes the agent perfectly calibrated in all scenarios. What the research does do is precisely define the failure modes so you can design around them.

🚀 What This Means for You

When you build agent pipelines:

Don’t just describe the task. Define what “done without doing anything” looks like. Every agent skill you write should have a clean exit path for “nothing to do here.” If it doesn’t, your agent will find something to do — and that something might quietly break your codebase.

When you write prompts for any agentic task:

The task framing implicitly tells the model what success looks like. “Fix this bug” frames success as producing a patch. “Check if this bug still exists, and fix it only if it does” frames success as correct diagnosis — whether or not a patch follows.

The concrete template from the paper, usable today:

First, reproduce the issue described above.
If the issue is not present (anymore), report that and don't make changes.
Otherwise fix the issue and verify the reproduction now fails.

When you review agent output:

Unnecessary activity in an agent trace is not neutral. It’s technical debt, and it compounds. An agent that makes a harmless-looking variable rename today creates a divergence that becomes a conflict tomorrow.

🌍 The Bigger Picture

This paper is about code agents, but the principle is universal.

Any AI agent — writing content, managing tasks, researching topics — has been trained on data dominated by “do the thing”. The scenarios where the right answer is “the thing is already done” or “the thing doesn’t need doing” are underrepresented in training.

The result is agents that feel compelled to act. That manufacturing works when there is none. That treat a task as incomplete until something has visibly changed.

You fix this not by making the model smarter, but by making the success criteria explicit.

Tell it that stopping is winning. That’s the whole lesson.

Paper: “Coding Agents Don’t Know When to Act” — Gloaguen et al., ETH Zurich / LogicStar.ai, May 2026

If this was useful to you and you want more, I recommend reading this article 👇

[embed]Telling Your AI “You’re an Expert ...” Is a Double-Edged Sword 🗡️ famzil.medium.com

See you in the next one 😉