Detect a Stuck Agent Loop

easyPROAgent Loop Control & PlanningAI AgentsAI Agents 1

Problem Statement

An agent stuck in a loop repeats the same action. Detect whether the last k actions in a trace are all identical, a simple no-progress guard.

Background

A cheap loop-guard fires when the most recent k actions are the same string. If the trace has fewer than k actions, it cannot yet be flagged.

Your Task

def is_stuck(actions, k):

Return True if the last k actions exist and are all equal, else False.

Input Format

actions (list of strings), k (int, >= 1).

Output Format

A boolean.

Sample

print(is_stuck(["a", "b", "b", "b"], 3))

Output:

True

Example

Input

print(is_stuck(["a", "b", "b", "b"], 3))

Output

True

Reasoning

Inputs: actions is the agent's trace in time order, oldest first, so the most recent action is the last entry. k is the window size: how many of the newest actions must repeat before the guard fires.
Is there a full window? The trace has $n = 4$ actions and $k = 3$ . Since $n \ge k$ , a window of the 3 newest actions exists, so a verdict is possible.
The window: the newest 3 actions are positions $2, 3, 4$ of the trace: "b", "b", "b". The oldest action "a" falls outside it and plays no part.
The test: the window holds exactly one distinct value, $\{\text{b}\}$ , so every action in it is the same. The output is True.
Notice: with $k = 4$ the window would include "a", giving two distinct values, so the answer would be False. And when $n < k$ there is no full window at all, which is also False rather than an error.

Constraints

Need at least k actions to flag (else False).
The last k must be identical.
k >= 1.

Learn this in

The Agent Loop & ReAct FoundationsAgent Engineering Study Plan Production: Observability, Benchmarks, Runtimes & Eval-Driven DevelopmentAgent Engineering Study Plan Multi-Agent Frameworks: AutoGen, CrewAI, OpenAI Agents SDK, Claude Agent SDKAgent Engineering Study Plan Specialized Agents: Computer Use & VoiceAgent Engineering Study Plan

More from AI Agents 1

Cheapest Cache TTL Meeting a Freshness SLAhard Bootstrap Confidence Interval Width for Eval Accuracymedium Route to the Cheapest Model Meeting Qualitymedium pass@k Estimatormedium Savings from a Semantic Cachemedium

Concept primerPREVIEW

1. Background Knowledge

In AI agent systems, an agent loop repeatedly selects an action based on the current state. A common failure mode is a stuck agent, where the agent repeats the same action indefinitely without making progress. This can happen due to poor planning, a degenerate policy, or a state that does not change after the action is executed.

A no-progress guard is a lightweight safety mechanism that monitors the agent’s recent behavior. By checking whether the last $k$ actions are identical, the system can detect a potential loop early and trigger a recovery strategy, such as resetting the state, selecting a random alternative action, or escalating to a higher-level planner. This guard is intentionally simple and cheap, making it suitable for real-time monitoring.

The problem reduces to a basic list inspection task: given a sequence of actions, determine if the final $k$ elements are all the same string. This is a common pattern in monitoring and logging systems where you need to detect repetitive behavior in a stream of events.

2. Algorithm Approach

The approach is a direct slice-and-compare strategy:

Boundary Check: First, verify that the list actions contains at least $k$ elements. If len(actions) < k, return False immediately because there are not enough actions to evaluate.
Extract Window: Use Python slicing to extract the last $k$ actions: actions[-k:].
Uniformity Check: Determine if all elements in this slice are identical. This can be done by:

Comparing each element to the first element of the slice.
Using set() to check if the slice contains only one unique value.
Using all() with a generator expression.

The most Pythonic and efficient method is to compare the slice to a list of repeated first elements or use set to check for uniqueness.

3. Step-by-Step Strategy

Validate Input Length:

Check if len(actions) < k.
If true, return False.

Extract the Last k Actions:

Create a variable window = actions[-k:].
This slice contains exactly $k$ elements, representing the most recent actions.

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results