How do you prevent an agent from entering an infinite loop?

You prevent an AI agent from entering an infinite loop by giving its execution clear limits and checking whether each step is making meaningful progress.

The safest approach is to combine several controls rather than rely on a single rule.

1. Define explicit stopping conditions

The agent should know when execution must end.

Examples include:

• the goal has been achieved
• required information is unavailable
• human approval is needed
• continuing is not permitted
• no valid next action exists

Without explicit stopping rules, the agent may continue taking actions even when there is nothing useful left to do.

2. Set a maximum number of steps

A hard step limit prevents an agent from running indefinitely.

For example:

Maximum steps: 20

If the agent reaches that limit without completing the task, the execution stops or escalates.

This acts as a final safety boundary even if other loop-detection logic fails.

The next article, “What is a maximum-step limit in an agent?”, covers this control in more detail.

3. Limit retries

Failures should not trigger unlimited retries.

For example:

API call failed → Retry up to 3 times → Use fallback or stop

Retry limits are especially important for:

• unavailable APIs
• authentication failures
• timeouts
• repeated tool errors

The agent should record retry counts in state so it knows when the limit has been reached.

4. Detect repeated actions

The system can track recent actions and identify when the agent is repeating the same behavior.

For example:

• check inventory
• check inventory
• check inventory
• check inventory

If the inputs and results are effectively unchanged, repeating the same action is unlikely to make progress.

The system can then stop, choose another strategy, or escalate.

5. Detect lack of progress

Not all loops repeat the exact same action.

An agent may take different actions while still failing to get closer to the goal.

A useful control is to ask whether recent steps produced meaningful new information or completed any pending work.

For example:

Goal: Identify the cause of an error.

If ten steps produce no new evidence and the uncertainty remains unchanged, the agent may be stuck even though the actions are different.

6. Track completed work in state

Good state management helps prevent the agent from forgetting what it has already done.

For example:

• source A checked
• source B checked
• authentication already retried
• user already asked for missing ID

The next decision can use this information to avoid repeating completed work.

7. Use time, cost, or resource limits

Execution can also be bounded by limits such as:

• maximum runtime
• maximum tool calls
• token budget
• cost budget
• API quota

These limits prevent a poorly behaving agent from consuming unlimited resources.

8. Escalate when the agent is stuck

Stopping does not always need to mean abandoning the task.

When repeated attempts fail, the agent may:

• ask the user for missing information
• request human review
• use an approved fallback
• return a partial result with the blocking issue

This is often better than continuing an unproductive loop.

Example

Suppose an agent is trying to retrieve an unavailable customer record.

A safe execution might be:

1. Query the primary system.
2. Receive a timeout.
3. Retry once.
4. Receive another timeout.
5. Try an approved fallback source.
6. Fallback also fails.
7. Stop and report that the required data could not be retrieved.

An unsafe agent might simply continue retrying the first tool forever.

Use multiple safeguards together

A robust agent might combine:

• clear completion criteria
• stopping conditions
• a maximum-step limit
• retry limits
• repeated-action detection
• no-progress detection
• resource budgets
• escalation paths

Each mechanism protects against a different type of loop.

In short

To prevent an AI agent from entering an infinite loop, bound its execution and monitor whether it is actually making progress.

Clear stopping conditions, step and retry limits, state tracking, repetition detection, progress checks, and escalation rules help ensure the agent stops or changes strategy instead of continuing indefinitely.