An agent reruns the step that just failed because the transcript still points to it

A coding agent breaks one line and keeps editing it

SWE-agent is an autonomous coding agent that reads a bug report, edits files in a repository, and runs the tests. Its authors name a prominent failure of it plainly: the agent repeatedly edits the same snippet of code. The usual trigger is an errant edit that introduced a syntax error, a wrong indentation or an extra parenthesis, which the agent then keeps trying to fix.¹ Failed edits are not rare. Of 2942 SWE-bench task instances, 1185 of the runs, 51.7%, contain at least one failed edit, and the odds of recovery fall as those failed edits pile up.¹ These agents do not finish often: this one resolved 12.47% of the test tasks, against a prior non-interactive best of 3.8%.¹

The same pattern turns up wherever a model is put in a loop. In ReAct's error analysis of 50 runs on the HotpotQA question set, the authors single out one failure specific to it. The model keeps regenerating its previous thoughts and actions and cannot reason its way to a different next step. They file it under reasoning errors, 47% of ReAct's failures against 16% for plain chain-of-thought, though the repeated loop is only one part of that row.² AgentBench, which scores models as agents across a range of environments, keeps a tally of why a run ends. One reason it records is that the agent "begins to do repeated generations for many turns," and that category of unfinished run reaches as high as 82.5% of tasks in some environments.³ Outside the papers, a user filed an AutoGPT issue in April 2023 titled "Gets stuck in a loop." Its log shows the runner re-issuing the same Google query at three consecutive timestamps after it had already received results.⁴ That is one unreplicated report, not a rate, but the pattern is catalogued as a recognized failure of these runners.⁵

Underneath an agent is a model calling a harness in a loop

To see why the step comes back, take the agent apart. An agent is a language model given a way to act, and the model cannot act on its own. It writes text, and a program outside it does the running and reports back; the mechanics of one such tool call are their own lesson. Put that exchange on repeat and you have the reason-act loop. Four steps, one turn:

1. The model proposes an action

   Given the transcript so far, the model writes its next reasoning and the action it wants taken, as text.²

2. The harness runs it

   A program outside the model, the harness, parses that text and performs the action: it runs the command, follows the link, applies the edit.

3. The result goes back into the transcript

   Whatever came back, an output or an error message, is appended to the transcript as more text.

4. The model is called again

   With the transcript now one turn longer, the model is called to propose the next action, and the loop turns again.

One fact about the model in step one governs everything downstream. It is stateless: it keeps nothing between calls, so on every turn it re-reads the whole transcript from the top and produces the next action from that text alone. Its only record of what it has already tried is whatever the transcript holds. A model cannot keep a private note of a word it never wrote down, the same reason a chatbot loses a secret it promised to keep in a game of hangman.

The transcript keeps recommending the step that just failed

Now run the loop forward into the stuck state. Suppose the transcript still names the same goal and still shows the same action as the most reasonable next move. The model returns the most probable continuation of that text, so it returns that action again. The error the harness appended is evidence against the action, but it is weak evidence against a strong prior, and a model frequently continues on the prior instead of revising on the error.

How weak that evidence is has been measured. Huang and colleagues separate two settings.⁶ In intrinsic self-correction the model reviews its own answer with no outside check. Accuracy holds flat or slips: GPT-4 on the GSM8K math set went from 95.5 to 91.5 to 89.0 over two rounds of self-review. Hand the same procedure a correct-label oracle that decides when to stop, and accuracy climbs instead, GPT-3.5 on CommonSenseQA rising from 75.8 to 89.7.⁶ The finding is not that a model cannot revise. It is that a model cannot reliably judge whether its own reasoning was correct, so feedback it generates about itself is worth little while a reliable signal from outside is worth a great deal.⁶

Statelessness is not the only push toward the repeat. ReAct's own authors attribute part of their loop to greedy decoding, the habit of taking the single most probable token at each step, and suggest a different decoding procedure might address it.² That is the same force behind the token-level repetition loops an earlier lesson took apart, where a model is made likelier to repeat a phrase by having just repeated it. Some action-level looping shares that decoding-level cause. And the obvious knob does not reach it. Raising the sampling temperature adds randomness to the draw. It does not add a strategy for what to try next, so it can knock the agent off the exact repeat without giving it anywhere better to go.

Below the transcript and the harness, nothing else decides

Follow the chain down and it bottoms out quickly. The action appears because the transcript makes it the most probable continuation.² The transcript reads that way because the earlier turns, the failed one included, are still in it and still point at the goal. The model re-derives the action because that is what predicting the next token from this text yields, and the harness runs it because running what the model returns is the harness's one job.¹

No component in the base loop keeps a list of what was already tried, ranks the alternatives, or decides to explore. Nothing below that line changes the outcome: the loop is the default behavior of a stateless predictor reading a transcript while a harness executes what it says, and not a defect in one product built on that design.

What breaks the loop is a better signal or a harder stop

Because the cause sits in the transcript and the harness, the fixes that work reach for one of those two places. Reflexion adds a step after a failed trial.⁷ The agent writes a short reflection on what went wrong and stores it in a memory the next trial reads, so the transcript now carries an explicit record of the attempt and not just its failed output. On the AlfWorld task set, ReAct with Reflexion finished 130 of 134 tasks, well above plain ReAct, and on the HumanEval coding set it reached 91.0 pass@1 against an 80.1 GPT-4 baseline.⁷ The gain is not uniform: on MBPP the same method scored 77.1, below that baseline. What it isolates is the missing ingredient: a memory of past attempts.

SWE-agent's authors changed the harness instead. Recall that the repeated edits begin when an errant edit introduces a syntax error. They added a check to the edit action that applies a change only if it produces no major error, so the broken edit never enters the transcript to be repeated, and performance improves considerably.¹ LangGraph takes the bluntest route. Its recursion limit caps how many steps a graph runs in one execution, 1000 by default as of version 1.0.6 and 25 in earlier ones. It raises an error at the cap, noting it "is often due to an infinite loop."⁸ A cap is not a way out of the loop. It ends the run without solving the task, which makes it a way to bound the damage rather than fix the cause. A person watching supplies what the model cannot: the outside signal Huang and colleagues found to be the difference between self-correction that helps and self-correction that hurts.⁶

One caution sits over all of it. Not every repeated action is an unintended loop. Kapoor and colleagues note that repeating a step on purpose, sampling an answer several times and keeping the best, can match more elaborate agents at lower cost.⁹ A fix that suppresses all repetition can drop that useful strategy along with the failure. The test is whether the repeat is making progress, not whether it is a repeat. What is settled is the architecture, and that scaffolding of this kind helps: an explicit memory, a harness guardrail, and an outside judge each cut the looping their designers went after.⁷¹ What stays open is the layer beneath, why a model under-weights the error already in front of it, and whether it could be trained to correct itself reliably with no outside signal at all.⁶