DEV Community: Joakim William Hauge

Preventing Recursive Tool Loops in LangChain Agents

Joakim William Hauge — Mon, 25 May 2026 13:47:52 +0000

One of the fastest ways for LangChain agents to become unstable in production is not model quality.

It’s recursive tool loops.

A workflow starts normally:

search
retrieve
summarize

Then suddenly:

the same tool gets called repeatedly
retries compound
context grows
token usage spikes
execution drifts indefinitely

The agent technically remains “alive.”

Operationally, it stopped making progress a long time ago.

This article shows a simple way to detect and interrupt recursive tool loops in LangChain agents using TypeScript.

The Problem

A basic agent workflow often looks harmless:

```ts id="jlwm4"
const result = await agentExecutor.invoke({
input: userPrompt
});




But production agents can drift into patterns like:



```txt id="0jlwm4"
search_documents
→ search_documents
→ search_documents
→ search_documents

or:

```txt id="1jlwm4"
search
→ summarize
→ retry
→ search
→ summarize
→ retry




This usually happens because:

* the model fails to converge
* tool outputs are ambiguous
* retries reinforce uncertainty
* the agent misinterprets partial progress

The result is:

## runaway execution.

# Why This Is Dangerous

Most AI workflows behave normally most of the time.
T
he problem comes from tail events:

* recursive retries
* unstable recovery behavior
* escalating context windows
* repeated tool invocation

A tiny percentage of unstable runs can consume a disproportionate amount of:

* inference cost
* latency
* compute
* operational attention

This is not just an observability issue.

It’s a runtime governance issue.

---

# Basic Strategy

We want to:

* track recent tool usage
* detect repetition patterns
* interrupt execution safely

before the workflow spirals.

The simplest version:



```txt id="2jlwm4"
“If the same tool is called too many times consecutively, stop execution.”

Simple.
Effective.
Easy to implement.

Step 1 — Track Tool History

We’ll maintain lightweight runtime state:

```ts id="3jlwm4"
type ExecutionState = {
toolHistory: string[];
};




Initialize it:



```ts id="4jlwm4"
const state: ExecutionState = {
  toolHistory: []
};

Step 2 — Detect Recursive Patterns

Now create a helper:

```ts id="5jlwm4"
function detectRecursiveLoop(
toolHistory: string[],
threshold = 3
): boolean {
if (toolHistory.length < threshold) {
return false;
}

const recent = toolHistory.slice(-threshold);

return recent.every(
tool => tool === recent[0]
);
}




This checks:



```txt id="6jlwm4"
Did the same tool run 3 times in a row?

Step 3 — Wrap Tool Execution

Now intercept tool calls:

```ts id="7jlwm4"
async function guardedToolCall(
toolName: string,
execute: () => Promise
) {
state.toolHistory.push(toolName);

if (detectRecursiveLoop(state.toolHistory)) {
throw new Error(
Recursive loop detected for tool: ${toolName}
);
}

return execute();
}




---

# Step 4 — Use Inside LangChain Tools

Example:



```ts id="8jlwm4"
const result = await guardedToolCall(
  "search_documents",
  async () => {
    return searchTool.invoke(query);
  }
);

That’s it.

Now your workflow can:

detect runaway repetition
interrupt unstable execution
prevent unnecessary cost escalation

Why Simple Detection Works Surprisingly Well

A lot of teams initially assume they need:

anomaly detection
reinforcement learning
advanced telemetry pipelines

But simple operational heuristics already eliminate many expensive failures.

Especially:

recursive retries
retry storms
repeated tool churn

You do not need perfect intelligence initially.

You need:

bounded execution.

Production Improvements

The minimal approach above works surprisingly well, but production systems usually add:

semantic similarity detection
token velocity monitoring
execution depth limits
tool-call budgets
runtime ceilings
timeout policies
adaptive thresholds

Example:

```txt id="9jlwm4"
search
→ search
→ search




is easy to detect.

More advanced loops look like:



```txt id="10jlwm4"
search
→ summarize
→ retry
→ search
→ summarize
→ retry

These require broader trajectory analysis.

The Distributed Systems Parallel

Distributed systems eventually evolved:

retry limits
circuit breakers
bounded failure domains
timeout controls

because unconstrained retries became dangerous at scale.

Autonomous agent systems are beginning to encounter similar operational realities.

As agents become:

more autonomous
more persistent
more deeply integrated

runtime governance becomes increasingly important.

Final Thoughts

Most teams focus heavily on:

prompts
model quality
orchestration frameworks

But production AI systems also need:

bounded execution
runtime constraints
operational safeguards
economic stability

Because eventually:
the challenge is not just building autonomous agents.

It is building governable autonomous agents.

How to Add Execution Budgets to OpenAI Agents SDK

Joakim William Hauge — Mon, 25 May 2026 12:03:39 +0000

One of the fastest ways for AI agents to become expensive in production is not model pricing.

It’s runaway execution.

A simple workflow starts retrying.
A tool loops recursively.
The agent keeps reasoning without converging.
Suddenly a single session burns 10–50x the expected cost.

Most teams discover this after deployment.

This article shows a very simple way to add:

execution budgets
runtime ceilings
step limits

to OpenAI Agents SDK workflows using TypeScript.

No complex infrastructure required.

The Problem

A basic agent loop often looks harmless:

```ts id="zjlwm4"
while (!taskComplete) {
const result = await agent.run();
}




But in production, autonomous systems can drift into:

* recursive retries
* repeated tool invocation
* escalating token usage
* unstable recovery behaviour

The workflow technically “works.”

Economically, it stopped making sense a long time ago.

---

# What We Want

We want simple runtime constraints like:



```ts id="8m4t2u"
{
  maxSteps: 15,
  maxRuntimeMs: 30000,
  maxEstimatedCostUsd: 1.50
}

If the workflow exceeds those boundaries:

execution stops
the system fails safely
costs remain bounded

Think of it as:

```txt id="1jlwm4"
circuit breakers for autonomous execution




---

# Basic Setup

Install the OpenAI SDK:



```bash id="jlwm4"
npm install openai

Then create a simple agent loop.

Step 1 — Track Runtime State

We’ll maintain a lightweight execution context:

```ts id="d8y2n4"
type ExecutionState = {
steps: number;
startedAt: number;
estimatedCostUsd: number;
};




Initialize it:



```ts id="r4m1kx"
const state: ExecutionState = {
  steps: 0,
  startedAt: Date.now(),
  estimatedCostUsd: 0
};

Step 2 — Define Budget Constraints

Now define simple execution ceilings:

```ts id="v9x2qa"
const LIMITS = {
maxSteps: 15,
maxRuntimeMs: 30_000,
maxEstimatedCostUsd: 1.5
};




These numbers do not need to be perfect initially.

The important thing is:



```txt id="jlwm4"
execution becomes bounded

Step 3 — Create a Budget Guard

Now we add a lightweight guard function:

```ts id="4d1mza"
function enforceBudget(state: ExecutionState) {
const runtimeMs = Date.now() - state.startedAt;

if (state.steps > LIMITS.maxSteps) {
throw new Error("Execution budget exceeded: max steps");
}

if (runtimeMs > LIMITS.maxRuntimeMs) {
throw new Error("Execution budget exceeded: runtime");
}

if (state.estimatedCostUsd > LIMITS.maxEstimatedCostUsd) {
throw new Error("Execution budget exceeded: cost");
}
}




This becomes your:

## runtime governance layer

---

# Step 4 — Wrap Agent Execution

Now wrap every execution cycle:



```ts id="z3cw1l"
while (true) {
  enforceBudget(state);

  const response = await agent.run({
    input: userPrompt
  });

  state.steps += 1;

  // Example rough estimation
  state.estimatedCostUsd += 0.08;

  if (response.done) {
    break;
  }
}

That’s it.

Now your workflow has:

bounded runtime
bounded execution depth
bounded economic exposure

Why This Matters

Most AI systems behave normally most of the time.

The problem comes from tail events:

recursive loops
retry storms
unstable tool chains
runaway context growth

Those edge cases are where infrastructure cost explodes.

Execution budgets help constrain the blast radius before instability compounds.

Production Improvements

The simple example above is intentionally minimal.

In production you’d likely also add:

token-based estimation
tool-call budgets
recursion detection
timeout policies
per-user limits
adaptive thresholds
execution tracing

But even basic runtime ceilings dramatically improve operational safety.

The Distributed Systems Parallel

Distributed systems eventually evolved:

timeouts
circuit breakers
bounded failure domains
retry limits

because unconstrained execution became dangerous at scale.

Autonomous AI systems are starting to encounter similar operational realities.

As agents become:

more autonomous
more persistent
more deeply integrated

runtime governance becomes increasingly important.

Final Thoughts

A lot of teams focus exclusively on:

prompts
reasoning quality
tool orchestration

But long-term production systems also need:

bounded execution
operational constraints
economic predictability

Because eventually:
the challenge is not just building autonomous systems.

It is building governable autonomous systems.