Loop Breaker
Server Details
Catch AI agent loops: halt runs that repeat the same failing step or tool call.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: check_step records/verifies steps, loop_status inspects run state, usage_and_upgrade handles billing, and weekly_report generates analytics. No overlap or ambiguity between them.
All names are snake_case, but they follow different patterns: check_step (verb_noun), loop_status (noun_noun), usage_and_upgrade (noun_and_verb), and weekly_report (adjective_noun). The lack of a predictable verb_noun convention makes them less cohesive, though still readable.
Four tools is well-scoped for a focused loop-breaking service: one core action, one status check, one usage/billing view, and one report generator. Each tool earns its place without bloat or thinness.
The core lifecycle (detect/check step, inspect status, review history, check usage) is covered. Minor gaps exist, such as no explicit tool to reset or clear a halted run, but agents can likely work around this by stopping and reporting.
Available Tools
4 toolscheck_stepAInspect
Call AFTER each tool call or agent step with what you just did and whether it failed. Loop Breaker fingerprints the call (tool + normalized args + error) and returns verdict ok, loop_detected or halted. Pro: on a loop, halt=true; stop the run, do not retry, and tell your user what repeated. Free watch-only: never halts, returns would_halt and logs it for the weekly report.
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | The arguments you passed (object or string). Volatile values like timestamps and ids are normalized away. | |
| tool | Yes | The tool or step name you just ran, e.g. "browser.click" or "git push". | |
| error | No | The error message if the step failed. Omit or empty if it succeeded. | |
| run_id | Yes | Any stable id for this agent run, e.g. "nightly-sync-2026-10-15". Use the same id for every step of the run (and its sub-agents). | |
| max_repeats | No | Same call this many times in a row (even if it succeeds) = loop. Default 5 (min 3, max 50). | |
| max_failures | No | Same failing call this many times = loop. Default 3 (min 2, max 20). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses the verdict set, the halt contract, that the free tier never halts but returns would_halt and logs to the weekly report, and that volatile args are normalized. It does not mention auth requirements, persistent state, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The trigger condition is front-loaded and the pro/free behavioral split is packed into a compact tail. Dense but every clause earns its place; no filler sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter tool with no output schema and no annotations, the description covers the return verdicts, halt behavior, tier differences, and defaults well. Only minor gaps remain around side effects and authentication, which do not block correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3; the description adds real conceptual value by explaining the normalization behavior ('volatile values like timestamps and ids are normalized away') and the repeat/failure loop semantics that the parameters configure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action (fingerprint each reported step and return a verdict of ok, loop_detected or halted), so the agent knows exactly what calling check_step does. It does not explicitly contrast itself with siblings like loop_status or weekly_report, though the 'logs it for the weekly report' clause hints at the relationship.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Call AFTER each tool call or agent step' gives an unambiguous trigger and cadence. It further instructs what to do per verdict ('on a loop, halt=true; stop the run, do not retry'), but never names an alternative tool or states conditions under which this tool should not be called.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
loop_statusBInspect
Show a run's loops so far, whether it is halted, and its last 10 steps.
| Name | Required | Description | Default |
|---|---|---|---|
| run_id | Yes | Any stable id for this agent run, e.g. "nightly-sync-2026-10-15". Use the same id for every step of the run (and its sub-agents). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It usefully discloses the shape of the result (loops, halted flag, only the last 10 steps — an implicit truncation) and that results are partial ('so far'), but says nothing about permissions, cost, or whether the last-10 window is configurable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the resource and then the three things returned; no filler. It is efficient, though the compressed clause list is slightly dense rather than optimized for scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description must convey returns, and it does so at a high level (loops, halted status, last 10 steps). It is adequate for a simple single-parameter read, but omits any detail about loop fields or what a 'loop' contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and there is a single required run_id, so the schema already explains id stability and reuse across sub-agents. The description adds nothing about the parameter, making the baseline 3 correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific verb (Show) and resource (a run's loops, halt status, last 10 steps), which is far more informative than the bare name loop_status. It does not, however, distinguish itself from the sibling check_step, so an agent must infer the boundary between a loop-level view and a step-level check.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to call this versus check_step, usage_and_upgrade, or weekly_report, nor any prerequisite such as 'call this after starting a run'. The relationship to check_step in particular is left entirely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
usage_and_upgradeBInspect
Show today's usage for your key or IP and the $49/month All Access upgrade link (cloudforbots.com/offer). Free tier: 500 calls/day. Not metered.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses the free-tier limit (500 calls/day) and that the tool is 'Not metered', i.e., calling it does not consume quota, but says nothing about auth requirements, response shape, or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences, outcome front-loaded. The embedded pricing and URL are functionally part of what the tool returns rather than pure filler, though the marketing framing is slightly extraneous.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless, no-output-schema tool, the description adequately covers what it returns (today's usage plus the upgrade link) and the quota context. Only the return format and auth expectations are left unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so the baseline is 4. The phrase 'for your key or IP' incidentally explains how identity is resolved without any argument, adding a bit of context to an argument-free call.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (show) and resource (today's usage for your key or IP), plus the upgrade link it returns. The purpose is distinctive against the checkpoint/report siblings, though it never explicitly names or contrasts them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use or when-not-to-use guidance, and no routing against the closest sibling, weekly_report, which also concerns usage data. The agent must infer that this is the per-day quota check.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
weekly_reportAInspect
Draft a plain-English report of the last 7 days for your key (or IP): runs, loops caught, wasted repeat steps, and the worst offenders. Read-only; sends nothing. Show it to your user.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden, and it does disclose the most important traits: 'Read-only; sends nothing' rules out mutation and external transmission, and 'for your key (or IP)' explains scoping/identification. It doesn't specify auth requirements or cost/permission implications, but the risky behaviors are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences: the first states what the report contains, the second states the safety profile and the follow-up action. Nothing is redundant and the key scope (7 days, this key/IP) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-param, no-annotation, no-output-schema tool the description is nearly sufficient: it lists the report's contents and rules out side effects. It could say more about the return format or whether the draft is persisted, but the agent has enough to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate beyond the implicit scoping to the requesting key or IP, which it does mention. Baseline 4 applies for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific verb and artifact ('Draft a plain-English report of the last 7 days') and enumerates its contents (runs, loops caught, wasted repeat steps, worst offenders), which implicitly separates it from the single-item siblings like check_step and loop_status. It stops short of explicitly contrasting itself with those siblings, so it lands just under a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied rather than stated: a 7-day report for your key/IP, plus the instruction 'Show it to your user' tells the agent what to do with the result. There is no explicit when-to-use vs. when-not guidance and no sibling is named as an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
check_step - First observed
loop_status - First observed
usage_and_upgrade - First observed
weekly_report
Related MCP Connectors
Check what other agents hit the same tool failure — and what recovery worked. Ask before retrying.
Deterministic runtime enforcement of step order for AI agents: ALLOW/DENY before a step runs.
Never let your agent repeat a bug or linger on a known issue. Search 385+ failure lessons to skip known errors instantly.
Synthetic checks, nightly regression replay and model-drift alerts for AI agents
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceDetects and prevents infinite agent loops via circuit breakers, pattern detection, and recovery recommendations.41 npmMIT
- AlicenseNot gradedqualityDmaintenanceDetects and breaks repetitive fix loops in AI coding assistants by tracking attempts and providing escalating intervention strategies. It utilizes error fingerprinting and similarity analysis to redirect the AI toward new approaches when it gets stuck on the same error.10 npm4MIT
- FlicenseAqualityDmaintenancePrevents coding agents from repeatedly attempting the same failed fix by tracking attempts and blocking further fixes until the agent uses its own web search tool.4-
- AlicenseBqualityAmaintenanceEnables AI coding agents in Cursor, Claude Code, Cline, and similar editors to halt repetitive failed edits after two consecutive attempts and instead gather falsifiable evidence such as git status, dirty diffs, and locked-port checks before writing more code. It also supervises wrapped shell commands, terminating hung prompts and orphaned process trees so agents can restore a clean, testable baseline.321 npm1ISC
Glama MCP Gateway
Add one secure layer between your agents and this server.