Self-Correcting Agent Loops in Production

Key facts, with sources

• METR found the length of tasks frontier AI agents can complete autonomously with 50 percent reliability has been doubling roughly every 7 months since 2019. (METR)
• Continuations of METR's time-horizon tracking show frontier models in 2026 completing tasks that take human experts around 12 hours at 50 percent reliability, up from about 50 minutes for early-2025 models. (AI Digest)
• About 88 percent of AI agent pilots never reach production, with integration, reliability, latency, and security named as the main blockers rather than model quality. (Institute of Project Management)
• Gartner predicts at least 15 percent of day-to-day work decisions will be made autonomously through agentic AI by 2028, up from 0 percent in 2024. (Gartner)
• The global AI agents market was valued at about $7.6 billion in 2025 and is projected to reach roughly $183 billion by 2033, a compound annual growth rate near 50 percent. (Azumo)

Anatomy of the loop

The loop has four beats: the model acts, an external verifier checks the output, the failure details become feedback, and the model retries with that feedback in context. The quality of the whole system lives in beat three. Feedback like "the output was wrong, try again" is worthless — the model will produce a cosmetic variation of the same mistake. Feedback like "field total_cents was a float, schema requires an integer; line 3 references an SKU that does not exist" gives the model something it can actually fix.

I structure the retry prompt so the original task, the failed output's specific errors, and an explicit instruction to return the full corrected result all appear. Partial fixes that reference the previous attempt tend to break downstream parsing.

Verification must be external and deterministic

Everything I trust as a verifier shares one property: it produces the same verdict every time for the same input. JSON schema validation, pytest runs, compiler output, referential checks against a database, business-rule assertions — these are gates. An LLM judging its own work shares the blind spots that produced the error, so it passes exactly the failures you most need to catch.

I do use model-based critique, but only as an additional filter in front of a deterministic gate, never as the sole gate, and never for anything with financial or destructive consequences. If a task has no deterministic way to verify success, that is a strong signal it is not ready for an autonomous loop at all.

A bounded retry loop with verifier feedback

Here is the skeleton I deploy. The verifier returns a pass flag plus human-readable failure details, and those details are injected verbatim into the retry. Note the escalation path: exhausting retries raises with the entire failure history attached, so the human picking it up sees what was tried and why it failed rather than starting cold.

import anthropic

MODEL = "REPLACE_WITH_LATEST_MODEL_ID"  # always point this at the latest model id

client = anthropic.Anthropic()

class EscalateToHuman(Exception):
    pass

def run_with_correction(task: str, verify, max_attempts: int = 3) -> str:
    feedback = None
    for attempt in range(1, max_attempts + 1):
        prompt = task if feedback is None else (
            f"{task}\n\nYour previous attempt failed verification:\n"
            f"{feedback}\n\nFix these exact issues and return the full corrected output."
        )
        response = client.messages.create(
            model=MODEL,
            max_tokens=2000,
            messages=[{"role": "user", "content": prompt}],
        )
        output = response.content[0].text
        ok, feedback = verify(output)  # deterministic: schema, tests, business rules
        if ok:
            return output
    raise EscalateToHuman(f"Gave up after {max_attempts} attempts: {feedback}")

Bound everything: attempts, tokens, wall clock

Unbounded loops are how agents burn budgets. I cap three dimensions independently: attempt count (typically two or three retries — returns diminish fast after that), cumulative tokens per task, and wall-clock time. Whichever trips first ends the loop and escalates.

Escalation is a first-class outcome, not an error state. The handoff object carries the task, every attempt, every verifier verdict, and the running cost. In practice a well-tuned loop resolves most failures on the first retry; tasks that need a third attempt usually indicate the task definition or the verifier needs work, and the escalation data is exactly what tells you which.

Failure modes that arrive with real traffic

Three patterns to watch. Oscillation: the model alternates between two wrong answers, fixing error A by reintroducing error B — detectable by diffing consecutive attempts and escalating early when the diff is cyclic. Verifier gaming: if your check is shallow, the model satisfies the letter of it while missing the intent, which is an argument for layered checks. Silent degradation: retries mask a regression after a prompt or model change, so the task still succeeds but at double the cost and latency.

That last one is why retry rate belongs on a dashboard. A rising first-attempt failure rate with a stable final success rate means your loop is quietly absorbing a quality drop you should be investigating.

When to hire senior help

Senior help matters most for the safety and reliability envelope, meaning sandboxing, permissions, rollback paths, and evaluation, which determines whether autonomy is an asset or a liability. If pilots keep failing on reliability rather than capability, an experienced agent engineer can usually diagnose whether the problem is tooling, prompts, or architecture within days. If your stack includes React Native + Python + AI, a senior engineer who owns the full product beats coordinating multiple juniors.

Bottom line

Dhairya Senjaliya ships AI — Autonomous Agents projects worldwide — book a scoping call to discuss your specific situation.

Common pitfalls to avoid

• ✕Ignoring compounding error rates; an agent that is 85 percent reliable per step succeeds only about 20 percent of the time across a 10-step workflow unless you add checkpoints and recovery
• ✕Granting write access to email, payments, or deletion without approval gates or sandboxing, turning a single hallucination into an irreversible action
• ✕Running long-lived loops with no budget cap, timeout, or kill switch, so a stuck agent burns tokens for hours before anyone notices
• ✕Evaluating on single runs when agent pass rates drop sharply under repeated-run consistency testing, making one good demo a misleading signal

Frequently asked questions

Sources

• METR
• AI Digest
• Institute of Project Management
• Gartner
• Azumo