Why AI Coding Agents Can't Stop Looping — And How to Fix It

When Your Coding Agent Gets Stuck in "Infinite Work" Mode

An OpenCode user recently raised a question that many developers have run into: after assigning a task to an AI agent, it starts relentlessly reading files, editing code, running commands, and looping back to re-check things — all while looking busy but never actually converging on "done." Eventually, the user had to hit Esc to interrupt it, then manually type "continue" — and strangely enough, the agent would then finish the task without issue.

This kind of behavior is surprisingly common for developers new to agentic coding, and it reveals the real limitations of current AI coding tools when it comes to autonomous execution. It's not a single bug — it's the combined result of model reasoning, tool-call loop design, and task description quality all working against each other.

Why Agents Get Stuck: The Root Causes

The Model's Sense of "Done"

At the core of every agent is a large language model that must decide, at each step, whether the task is complete. But models don't have a genuine sense of completion — they probabilistically select the next action based on context. When the task goal is vague or there's no clear verification criterion for success, the model tends toward "let me check one more time" or "let me confirm this again," falling into an overly cautious self-loop.

Different models vary significantly here. Those with stronger reasoning and better instruction-following know when to stop; weaker models tend to bounce back and forth between "read → edit → re-read" without a coherent sense of overall progress.

The Design of the Tool-Call Loop

An agent's execution is fundamentally a cycle of "think → call a tool → observe the result → think again" — commonly referred to as the agent loop or tool loop. If this loop lacks effective termination conditions, or if the model can't form a clear next step after observing tool output, it starts "spinning."

The behavior the user described — "reading more files, looping back to check things" — is a textbook example: the agent hasn't built a clear model of task state, so it re-evaluates everything from scratch on each observation instead of advancing toward a definite next step. The reason hitting Esc and typing "continue" works is likely that the interruption resets the context's attention focus, breaking the model out of its loop inertia.

The technical implementation of an agent loop is typically based on the ReAct (Reasoning + Acting) paradigm: the model outputs a "thought" segment, then decides which tool to call and with what parameters. The tool's return value is appended to the context, and the next round of reasoning begins. At the code level, this is a while loop whose termination condition is either a specific "I'm done" signal from the model or a hard step-count limit. The problem is that generating this termination signal depends on both prompt design and the model's own judgment — when neither is strong enough, the loop can run indefinitely. Tools like OpenCode, Cursor, and Claude Code all set step or token limits as a last-resort circuit breaker, but that's a failsafe, not a graceful exit.

Clarity of the Task Description

Vague task descriptions are breeding grounds for infinite loops. Without explicit acceptance criteria (what counts as "done"), without a defined scope of changes, and without decomposition into checkable sub-steps, the agent can only guess at the boundaries — and guessing tends to lead to repeated probing.

How to Reduce the Need for Constant Babysitting

Make Tasks "Verifiable"

Instead of saying "help me optimize this module," give the agent a concrete completion standard — for example: "Modify function Y in file X so it passes test case Z. Don't touch any other files." Give the agent a clear finish line, and it'll know when to stop. Verifiable goals (like passing a specific test or producing a specific output) are far more effective than abstract descriptions.

Break Tasks Down and Reduce Scope

Handing an agent a large, open-ended task all at once is a recipe for getting lost. Splitting it into smaller steps with clear boundaries — executed one at a time — both reduces the chance of a single loop spiraling out of control and makes it much easier for you to review and intervene at each stage.

Use Interruptions Deliberately

The user's discovery of "Esc + continue" is actually a valid human-in-the-loop technique. When you notice the agent starting to spin, proactively interrupt it and give more specific direction (e.g., "You've already read the files — now go ahead and make the change and run the tests"). This is often far more efficient than waiting for the agent to find its own way out. This isn't a failure — it's the normal rhythm of human-AI collaboration.

Choose a More Capable Model

When possible, using a model with stronger instruction-following and reasoning capabilities can significantly reduce the frequency of infinite loops. A model's ability to judge when a task is complete is the key variable that determines whether an agent knows when to stop.

This Is Normal for Agentic Coding — Not Your Fault

For developers new to agentic coding, an agent that won't stop doesn't mean you did something wrong. This is a widespread phenomenon at the current stage of the technology — autonomous agents still lack reliable progress awareness and termination judgment on long-horizon tasks.

Once you understand the causes, the response strategy becomes clear: use explicit task constraints to reduce ambiguity, use task decomposition to limit the blast radius of runaway loops, and use timely human intervention to break loop inertia. As model capabilities and agent frameworks continue to evolve, this kind of "infinite work" problem will gradually improve — but for now, developing a feel for the rhythm of human-agent collaboration remains a critical skill.

From a broader perspective, this issue is also tied to context window pollution. As an agent executes more steps, the context accumulates a growing volume of tool call records, file contents, and intermediate outputs. The density of useful information drops, and it becomes increasingly hard for the model to focus on what actually matters when making the next decision. This is another reason why manually interrupting and resuming sometimes works — a fresh conversation effectively clears some of the accumulated noise, letting the model reassess the task state with a cleaner view. Some agent frameworks (such as LangGraph) have introduced explicit state machine designs that replace pure model-driven judgment with structured task state tracking, attempting to address this problem at the architectural level.