AgentRules.org
RulesStacksClientsAuditorPrunerSelf-HealRFCsBenchmarkCLICI/CDAuthorsSubmit
This specification is maintained by the AgentRules Working Group. Have enhancements or want to claim maintainership?Submit Specification →
backendcritical PriorityID: langchain-agent-recursion-limit

LangChain & LangGraph State Machine recursion_limit Cost Runaway Guardrails

Production safety guardrail for autonomous AI agent architectures. Mandates setting explicit recursion_limit bounds (max 25-50 iterations) in LangGraph / LangChain execution configurations, prevents infinite self-correction loops when tools fail repeatedly, and enforces hard timeout cancellations.

Prohibited Anti-Pattern: AI runs LangGraph or LangChain agent workflows without recursion_limit or timeouts, causing agents in decision deadlocks to loop endlessly and rack up thousands in API costs.

Export Ready-to-Drop Configuration

Select format below to copy code or download file directly.

---
description: LangChain & LangGraph State Machine recursion_limit Cost Runaway Guardrails - Production safety guardrail for autonomous AI agent architectures. Mandates setting explicit recursion_limit bounds (max 25-50 iterations) in LangGraph / LangChain execution configurations, prevents infinite self-correction loops when tools fail repeatedly, and enforces hard timeout cancellations.
globs: **/agents/**/*.py, **/workflows/**/*.py, **/graph.py
alwaysApply: true
verified_by: "agentrules.org"
license: "CC-BY-4.0"
source: "https://agentrules.org/rules/langchain-agent-recursion-limit"
---

# LangChain & LangGraph State Machine recursion_limit Cost Runaway Guardrails

> **Severity**: CRITICAL | **Category**: backend
> **Anti-Pattern Warning**: AI runs LangGraph or LangChain agent workflows without recursion_limit or timeouts, causing agents in decision deadlocks to loop endlessly and rack up thousands in API costs.

## System Constraints
You are an AI Agent Systems and Cost Governance Architect. NEVER execute LangGraph or LangChain agents using app.invoke(inputs) without specifying an explicit recursion_limit in RunnableConfig. An agent that enters a reasoning loop or encounters persistent tool errors will execute indefinitely, exhausting LLM token budgets.

## Strict Guidelines
- MUST pass config={'recursion_limit': 25} to every app.invoke() or app.astream() call.
- MUST handle GraphRecursionError gracefully, returning structured fallback responses instead of crashing.
- MUST configure asyncio.timeout(60) or request timeouts on agent execution threads.
- MUST track agent tool call repetitions; if a tool is called with identical arguments 3 times consecutively, break execution immediately.
- SHOULD log total tokens consumed and step execution counts to OpenTelemetry spans.

## Bad vs Good Implementations
### Bounding Agent Iteration Depth and Catching GraphRecursionError

#### Bad Antipattern (AI Common Hallucination)
> **Why it fails**: Without a recursion limit, an agent that fails to satisfy a goal will loop between tool calls and prompts hundreds of times, generating thousands of dollars in LLM API bills.
```python
# FATAL: Unbounded agent execution prone to infinite loops
from my_agent import graph

# If model enters circular reasoning, loops indefinitely until API credit runs out!
result = graph.invoke({"messages": [("user", "Fix this bug")]})
```

#### Production Standard (Correct)
> **Standard**: Sets an explicit ceiling on agent reasoning loops (25 steps) and an outer 45-second timeout, catching GraphRecursionError to provide a courteous fallback instead of crashing.
```python
import asyncio
from langgraph.errors import GraphRecursionError
from my_agent import graph

async def run_agent_safely(user_prompt: str):
    # 1. Hard bound on recursion steps
    config = {"recursion_limit": 25, "configurable": {"thread_id": "sess_1"}}
    
    try:
        # 2. Hard timeout ceiling (e.g. 45 seconds)
        async with asyncio.timeout(45):
            result = await graph.ainvoke(
                {"messages": [("user", user_prompt)]},
                config=config
            )
            return result["messages"][-1].content
    except GraphRecursionError:
        # 3. Graceful fallback when maximum reasoning steps are exhausted
        logger.warning("Agent reached recursion limit of 25 steps without convergence")
        return "I encountered complex conflicting requirements and stopped to prevent loops. Please clarify your prompt."
    except TimeoutError:
        return "Execution timed out after 45 seconds."
```
Recommended MCP Servers (mcp-serverlist.com)

Equip agent with system tools to verify code for this stack.

AI Agent Token & Recursion Budget MCP
Monitors active agent step counts, token expenditures, and intercepts runaway loops.
Recommended Agent Skills (askills.dev)

Ready-to-use executable skill functions tailored to this stack.

askills: Agent Recursion Guard
Wraps LangGraph and LangChain agent pipelines with recursion limits and timeout handlers.
Architectural Specification & Invariant Rationale

Architectural Invariant Design: LangChain & LangGraph State Machine recursion_limit Cost Runaway Guardrails

LangChain & LangGraph State Machine recursion_limit Cost Runaway Guardrails defines an industrial-grade behavioral standard for backend engineering. Production safety guardrail for autonomous AI agent architectures. Mandates setting explicit recursion_limit bounds (max 25-50 iterations) in LangGraph / LangChain execution configurations, prevents infinite self-correction loops when tools fail repeatedly, and enforces hard timeout cancellations. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: AI runs LangGraph or LangChain agent workflows without recursion_limit or timeouts, causing agents in decision deadlocks to loop endlessly and rack up thousands in API costs. Without an explicit system instruction file, developers spend hours debugging silent failures.
Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure ModeAI Symptom (The Anti-Pattern)SeverityProduction Impact & Remedy
AI Hallucination & Deprecation DriftAI runs LangGraph or LangChain agent workflows without recursion_limit or timeouts, causing agents in decision deadlocks to loop endlessly and rack up thousands in API costs.Critical
Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production.
Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture InconsistencyAI assistants produce mixed paradigms across files, creating fragmented codebase conventions.Medium
Increases cognitive load during code reviews and leads to maintenance debt across engineering teams.
Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.
Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

1

MUST pass config={'recursion_limit'

MUST pass config={'recursion_limit': 25} to every app.invoke() or app.astream() call.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
2

MUST handle GraphRecursionError gracefully, returning structured fallback responses instead of crashing.

MUST handle GraphRecursionError gracefully, returning structured fallback responses instead of crashing.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
3

MUST configure asyncio.timeout(60) or request timeouts on agent execution threads.

MUST configure asyncio.timeout(60) or request timeouts on agent execution threads.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
4

MUST track agent tool call repetitions

MUST track agent tool call repetitions; if a tool is called with identical arguments 3 times consecutively, break execution immediately.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
5

SHOULD log total tokens consumed and step execution counts to OpenTelemetry spans.

SHOULD log total tokens consumed and step execution counts to OpenTelemetry spans.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
Technical Questions & Answers

Frequently Asked Technical Questions

Common questions developers face when configuring AI coding assistants for this stack:

Q:Why is LangChain & LangGraph State Machine recursion_limit Cost Runaway Guardrails critical for AI coding assistants?

Production safety guardrail for autonomous AI agent architectures. Mandates setting explicit recursion_limit bounds (max 25-50 iterations) in LangGraph / LangChain execution configurations, prevents infinite self-correction loops when tools fail repeatedly, and enforces hard timeout cancellations. Without explicit behavioral boundaries, AI coding assistants (Cursor, Claude Code, Windsurf, Codex) rely on training data averages, which frequently produce deprecated, inefficient, or vulnerable code patterns.

Q:How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (AI runs LangGraph or LangChain agent workflows without recursion_limit or timeouts, causing agents in decision deadlocks to loop endlessly and rack up thousands in API costs.) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q:Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q:Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

Open Specification · CC BY 4.0·Free for Personal, Team & Commercial In-Repo Use

Citation & Open Source Attribution Guidelines

This specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You are completely free to adapt and share this rule in your workspace. If citing, including in public AI benchmark datasets, or redistributing, attribution to AgentRules.org is required.

Related BACKEND Rules

View all rules →
backend
42

Fastify 5 Schema Compilers & Encapsulation Production Standard

Fastify relies on lexical encapsulation contexts to sandbox decorators, hooks, and compiled validation/serialization schemas without memory leaks or cross-tenant bleed. In Fastify 5, misuse of global compilers or failing to encapsulate plugin boundaries causes compiled `fast-json-stringify` serializers and Ajv validators to either crash on duplicate IDs, leak private data across sibling scopes, or bypass JIT compilation optimizations. Production services must enforce strict encapsulation hierarchies and type-safe schema compilation across every routing subtree.

backend
68

Bun Embedded SQLite WAL Mode & Transaction Synchronization Standard

Production database standard for bun:sqlite. Mandates enabling Write-Ahead Logging (PRAGMA journal_mode = WAL), busy timeouts, and using db.transaction() for atomic operations without lock starvation.

backend
68

Drizzle ORM Batch API & Interactive Transaction Isolation Standard

Production database standard for Drizzle ORM (PostgreSQL & MySQL). Mandates using db.batch() over HTTP drivers to prevent round-trip waterfalls, explicit db.transaction() with serializable/read-committed isolation, and strictly avoids unawaited query promises.

1 Rule in Stack

LangChain