# agent loop detected rewriting the same compliance answer and failed to finish: how to fix it

An agent stuck rewriting the same compliance answer is looping because its completion check never fires. Add a similarity check against the previous draft and a max-rewrite cap, then escalate to a human when the cap hits. Loops end when the agent can recognize its own repetition.

```text
agent loop detected rewriting the same compliance answer and failed to finish
```

## When to use this skill
- An agent rewrites the same answer repeatedly
- Runs burn tokens with no progress on one answer

## When not to use this skill
- The agent writes different bad answers each time (a quality issue, not a loop)
- The loop is on tool calls rather than drafting (a different guard)

## Tool compatibility
Agent drafting loops with LLM rewrite steps.
Related area: agent frameworks and agent runtime tooling.
Cloud UIs change labels over time; if a button moved, search settings for the closest match.

## Before you start
- Sign in to the tool and keep one tab open so sessions stay clean
- Copy the exact error text and note the time it happened
- Set aside 15 to 20 minutes; most of these resolve in a single pass

## Quick diagnosis
Make sure this is the right skill before you invest the 15 minutes.
- If you are dealing with an agent rewrites the same answer repeatedly, start at step 1 below.
- If instead the agent writes different bad answers each time (a quality issue, not a loop), stop here; you need a different skill.
- If neither quite matches, compare your screen against the verbatim error block at the top; that block is exactly what this skill covers.

## Fix it in steps
### 1. Add a similarity guard

```
Before each rewrite, compare the new draft to the previous one and stop if they are nearly identical.
```
Expected: the agent detects it is going in circles.

### 2. Cap the rewrite count

```
Set a hard limit like three rewrites per answer.
```
Expected: the agent stops instead of looping forever.

### 3. Escalate on cap hit

```
When the cap triggers, flag the answer for human review with both drafts attached.
```
Expected: a human breaks the tie instead of the agent spinning.

### 4. Tighten the completion criteria

```
Make the done condition concrete, like all required points covered, instead of a vague quality bar.
```
Expected: the agent finishes instead of polishing endlessly.

## Confirm each step worked
Run through this checklist before moving on. If a check fails, redo that step instead of pushing ahead.
- Step 1 (add a similarity guard): Expected: the agent detects it is going in circles.
- Step 2 (cap the rewrite count): Expected: the agent stops instead of looping forever.
- Step 3 (escalate on cap hit): Expected: a human breaks the tie instead of the agent spinning.
- Step 4 (tighten the completion criteria): Expected: the agent finishes instead of polishing endlessly.

## Quick recap
1. Add a similarity guard
2. Cap the rewrite count
3. Escalate on cap hit
4. Tighten the completion criteria

## Still stuck?
Gather three things: the exact error text, the time it happened, and what changed just before it broke.
Check the vendor status page for an active incident. Then open a support ticket with those three things;
it cuts the back-and-forth in half. For agent runs, attach the last 50 lines of the agent log too,
since the loop or timeout signature in the log usually names the cause.

## Variant phrasings
### agent rewriting same answer loop
Similarity guard plus rewrite cap. If this matches what you saw, the steps above apply as written.

### compliance answer rewrite loop
Vague done criteria cause endless polishing. If this matches what you saw, the steps above apply as written.

## Why it happens
Rewrite loops happen when the agent judges its own output against a fuzzy standard and always finds it wanting. Without a similarity check or a cap, each pass looks like progress to the agent while changing almost nothing.

## Edge cases
- Set the similarity threshold loose enough to allow real improvements
- Log every rewrite so you can see the loop forming
- Human escalation should include the draft history, not just the last version

## Provenance

Resolved from the public thread: https://vectle.com/posts/pst_N8m8wo_LddLR8rVSrvUTkA