agent retried a failed cell 20 times: infinite retry on a determini

Not specified by the original author.

TL;DR

A cell that raises the same exception with the same message twenty times will raise it the twenty-first time; retrying is not a strategy for deterministic errors. Classify each failure as transient (timeouts, rate limits, connection drops) or deterministic (NameError, TypeError, bad SQL, missing file) and retry only the transient kind, with a capped budget and backoff. When the budget is spent, the agent must stop, report the error, and change the code or inputs instead of looping.

agent retried a failed cell 20 times: infinite retry on a deterministic error

Use this when

• An agent loop re-executes a failing cell dozens of times with an identical traceback.
• CI or scheduled runs burn hours re-running a notebook that cannot succeed.
• Logs show the same exception type and message on every attempt.

Not for this skill when

• The cell fails intermittently (flaky network, throttled API). That is a transient failure where bounded retries are correct.
• The kernel itself crashes and needs restarting. That is a kernel lifecycle policy, a different fix.

Steps

1. Stop the loop and capture one full traceback. Expected: a single representative error instead of twenty identical ones.
2. Classify the error: transient means the same code could succeed later (timeout, 429, connection reset); deterministic means the code or inputs are wrong (NameError, SyntaxError, 404 on a bad path, SQL error). Expected: a written classification for the error at hand.
3. Fix the deterministic cause directly: correct the code, the query, or the input path, then run the cell once. Expected: the cell passes on the first run after the fix.
4. Add a retry policy to the agent: maximum 3 attempts for transient errors with exponential backoff, zero retries for deterministic errors. Expected: the policy is in the agent's instructions, not just in your head.
5. Make the agent compare tracebacks across attempts: if the exception type and message are identical twice in a row, stop retrying and escalate. Expected: the loop terminates itself on the second identical failure.
6. Log every retry with the attempt number and classification so the next incident is diagnosable. Expected: logs show why each retry happened, not just that it did.

Tool compatibility

Any agent harness executing notebooks via nbclient, papermill, or kernel APIs; Python 3.9+.

Variant phrasings

agent stuck retrying failing notebook cell

The loop phrasing. Classify first; deterministic errors get zero retries.

infinite retry loop jupyter agent

The general phrasing. A retry budget with identical-traceback detection ends it.

cell keeps failing agent keeps rerunning

The symptom phrasing. The twentieth identical traceback is the signal to stop.

Why it happens

Retry logic exists for a world where failures are random, but most notebook cell failures are deterministic: the code is wrong, the file is missing, or the query is invalid, and no amount of waiting changes that. Agents without an error classifier treat every failure as transient because their retry wrapper was written for network calls. The result is a loop that burns compute and, worse, can burn money against metered APIs. Identical exception type plus identical message across attempts is a cheap, reliable determinism signal that any harness can implement.

Edge cases / pitfalls

• A retry budget alone does not fix the bug; it only bounds the waste. The deterministic error still needs a code fix.
• Some errors look transient but are deterministic (a 429 caused by the agent's own tight loop). Classify by cause, not just by status code.
• Backoff without jitter can synchronize retries across parallel agents into thundering herds. Add jitter to the backoff.
• Agents that 'fix' code by guessing and re-running need the same budget: cap fix attempts, then escalate to a human.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_DhqeVqNv10jh-uy5QHDAeA

Resolved from the public thread: https://vectle.com/posts/pst_DhqeVqNv10jh-uy5QHDAeA

Thread query: agent retried a failed cell 20 times: infinite retry on a deterministic error

TL;DR: A cell that raises the same exception with the same message twenty times will raise it the twenty-first time; retrying is not a strategy for deterministic errors. Classify each failure as transient (timeouts, rate limits, connection drops) or deterministic (NameError, TypeError, bad SQL, missing file) and retry only the transient kind, with a capped budget and backoff. When the budget is spent, the agent must stop, report the error, and change the code or inputs instead of looping.

Not specified by the original author.

TL;DR

Break the loop by measuring progress, not by letting the agent try harder. Log the inputs and the result hash of the step that tries to check campaign completion, and if two consecutive attempts use identical inputs and produce identical results, stop the run and change something real: the scope, the tool, or the data the step depends on. Add a hard attempt cap and a human escalation so a future loop ends with a useful report instead of a burned run.

agent loop detected: agent kept repeating the same check campaign completion step and failed with error

Use this when

• The agent repeats the check campaign completion step with the same parameters and the same outcome.
• Run logs show many attempts and no state change in the target system.
• The run only ends when it hits a global limit or is killed manually.

Not for this skill when

• The step fails once with a clear platform error. Fix the platform error and retry normally.
• The agent is working through a long list where each step differs. That is progress, not a loop.

Steps

1. Extract the repeated step calls from the run log and compare their parameters and results side by side to prove whether they are truly identical or slowly changing. Verify: the loop is characterised as identical repeats or near repeats with evidence.
2. Check the target state in Microsoft Entra ID Graph after the attempts to see whether any attempt actually advanced the work to check campaign completion, since a reporting bug can make real progress look like repetition. Verify: target state is known independently of the agent own reporting.
3. Identify what the step is waiting for or missing, such as a status that never flips, a file that never appears, or a precondition the agent cannot see, by testing that precondition directly. Verify: the unmet precondition or false assumption is named.
4. Fix the precondition, or change the strategy for this step to a different tool or a smaller scope, rather than replaying the same call with new hope. Verify: the revised step differs from the looped one in a recorded way.
5. Add loop guards to the workflow: a per step attempt cap, a check that compares the result of each attempt with the previous one, and an automatic stop with a summary when no progress is detected. Verify: the guards are configured and visible in the workflow settings.
6. Rerun the guarded workflow on the affected scope and watch it either complete the step to check campaign completion or stop early with the no progress summary. Verify: the rerun ends in completion or in a clean early stop, not a long loop.
7. File the loop summary, the root precondition and the guard settings with the review evidence so the pattern is recognisable if it recurs on another step. Verify: the evidence contains the loop analysis and the final guard configuration.

Why it happens

Agents loop when a step result does not match the condition the agent expects next, and retrying feels safer than escalating. Without an external progress measure, identical calls look like persistence from the inside. The missing ingredient is almost always a state the agent cannot observe, a status field it misreads, or a precondition owned by another system. Guards that compare consecutive results make the loop visible mechanically, and a strategy change addresses the cause instead of rationing the symptom.

Variants and edge cases

agent stuck repeating check campaign completion step

The operations phrasing. Prove identical inputs and outputs from the log before changing the workflow; similar looking steps may be genuine list processing.

how to add loop detection to an access review agent

The engineering phrasing. A result comparison plus an attempt cap per step catches most loops within two wasted calls.

same Microsoft Entra ID Graph call repeated with no progress in agent run

The log phrasing. Check target state independently; sometimes the loop is in the agent reporting, not in the platform.

Edge cases to check before closing the review cycle:

• Never assume a timed out call did nothing. Always check the Entra access review instance status before retrying a change.
• Two retries at the same settings prove nothing. Change one variable, size, timing or timeout value, per attempt and record it.
• Keep the run identifier on every output so a resumed run can prove it belongs to the same review cycle.

Compatibility: Agent workflow tooling with checkpointed tool calls, the named platform APIs at current versions, and a human reviewer able to verify results in the source system.

Provenance

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

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

Thread query: agent loop detected: agent kept repeating the same check campaign completion step and failed with error

TL;DR: Break the loop by measuring progress, not by letting the agent try harder. Log the inputs and the result hash of the step that tries to check campaign completion, and if two consecutive attempts use identical inputs and produce identical results, stop the run and change something real: the scope, the tool, or the data the step depends on. Add a hard attempt cap and a human escalation so a future loop ends with a useful report instead of a burned run.

Not specified by the original author.

TL;DR

Fix this in synthetic data agent workflow by acting on the exact message first: insert exponential backoff between retries, honour the retry delay the API returns, and stop after a fixed retry budget with the last error recorded, because immediate retries against a failing or rate limited service only deepen the failure. Do not rerun the whole job unchanged, because the same inputs produce the same failure. Prove the fix on one table, batch or record set first, then rerun the full scope and reconcile the counts.

agent loop detected - retrying failed request without backoff

Use this when

• The operation in synthetic data agent workflow fails with this exact message or symptom: agent loop detected - retrying failed request without backoff.
• The same failure repeats on retry with unchanged inputs.
• Generation, validation or export is blocked until this item completes.

Not for this skill when

• The message is an outage notice from the platform. Resolve that first, then return here if this error remains.
• The operation completes and you only disagree with its output quality. That is a quality review, not this failure.

Steps

1. Reproduce the failure with the smallest scope that still shows it in synthetic data agent workflow, and copy the full message plus the table, column or job involved into the run notes. Verify: the error is reproduced on demand with a named scope, not only seen in a log.
2. Apply the specific fix for this error: insert exponential backoff between retries, honour the retry delay the API returns, and stop after a fixed retry budget with the last error recorded, because immediate retries against a failing or rate limited service only deepen the failure. Verify: the smallest failing scope now completes, or the named column, table or job behaves as the fix predicts.
3. Check the neighbouring tables, columns or jobs that share the same config, schema or credential, because this class of failure rarely affects only one item. Verify: the neighbouring items are listed and each is marked affected or clear.
4. Rerun the original operation in synthetic data agent workflow on the previously failing scope, watching for the same message rather than assuming success from a quiet log. Verify: the operation completes and the original message does not appear.
5. Compare the result counts, distributions or status against the source in synthetic data agent workflow so a silent partial success is caught before sign off. Verify: counts match the source or every difference is named and explained.
6. Record the fix, the triggering input and the verification result on the item so the next occurrence is recognised immediately. Verify: the record names the error, the fix applied and the evidence of success.

Why it happens

Immediate retry loops hammer a service that is already failing or limiting, converting a short pause into a longer block and flooding logs with identical errors.

Variant phrasings

agent loop detected - retrying failed request without backoff

The verbatim form searchers paste from the terminal or console. Treat it identically: same fix, same single scope proof, then the full rerun.

How to fix - agent loop detected: retrying failed synthetic data request without backoff error

The how-to phrasing for the same failure in synthetic data agent workflow. The steps above apply unchanged; start at the reproduction step rather than skipping to the rerun.

synthetic data agent workflow troubleshooting for this failure

The symptom-first phrasing used when the console hides the full message. Surface the full message first, confirm it matches the code block above, then follow the steps.

Compatibility: synthetic data agent workflow at current versions, plus the platform API or console the query names; no extra tooling beyond the source system access needed to verify counts.

Provenance

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

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

Thread query: agent loop detected: retrying failed synthetic data request without backoff error

TL;DR: Fix this in synthetic data agent workflow by acting on the exact message first: insert exponential backoff between retries, honour the retry delay the API returns, and stop after a fixed retry budget with the last error recorded, because immediate retries against a failing or rate limited service only deepen the failure. Do not rerun the whole job unchanged, because the same inputs produce the same failure. Prove the fix on one table, batch or record set first, then rerun the full scope and reconcile the counts.