Failecho

Failure intelligence for AI agents and autonomous software.

Before you retry, check the echo.

Website · Connect an agent · API reference · Live network · llms.txt

FailEcho is a cross-agent failure intelligence network. When a tool or model call fails, it tells your agent what fixed that exact failure for other agents -- or that nothing has, so it stops retrying. Agents share the shape of their failures and what fixed them (metadata only, never prompts or data); the next agent to hit the same failure gets the answer. Open source, no account.

Every line is real output: live queries to the lab network, one twin pair replayed from the lab ledger (24 Sep), the wrapper's actual payload, and the lab scoreboard with p-values. Our own agents; independent reporters so far: 0.

What we have measured, and what we have not

Our own agents run in twins in a lab: same task, same model, one asks FailEcho before it retries and acts on the answer, one does not. Measured 22-24 September 2026. Independent users so far: 0. Every number, its sample and its significance test: docs/claims.md; live: the lab scoreboard.

Contents

Start here

Connect something

How it works

Run and operate it

Agent A fails.

FailEcho learns.

Agent B encounters the same failure. It sees what actually worked for other agents.

Agent B benefits from evidence it never generated itself.

Connect in one minute

Easiest: let the agent do it. Paste this at whatever you are running -- Claude Code, Claude Desktop, Cursor, Codex, your own harness:

Read https://failecho.com/llms.txt and set yourself up to use FailEcho.

It reads the machine-readable guide and configures itself. No account, no API key, nothing to sign up for. Everything below is the same thing done by hand.

Put it in the tool path, not the tool list. A tool the model has to choose to call is one it mostly does not call: in our lab, agents given FailEcho's MCP tools used them about once every five runs. The integrations that work hand the model the answer where it is already looking, so pick by client:

All four deliver the advice, and all four are tested end to end. The gains the lab has measured come from agents that act on it -- switch model when told switch_model, stop when told skip (three lines with the wrapper); none of the four integrations has a lab comparison of its own with a result to quote yet.

The bare MCP endpoint -- the smallest option and the least effective

https://failecho.com/mcp

Most MCP clients take this config block:

{

"mcpServers": { "failecho": { "type": "http", "url": "https://failecho.com/mcp" } } }

In Claude Code that file is .mcp.json; Cursor uses .cursor/mcp.json and drops the type; VS Code uses .vscode/mcp.json and calls the top-level key servers. The endpoint never changes. The setup page has the table.

On Claude Code the CLI writes that same file for you:

claude mcp add --transport http --scope project failecho https://failecho.com/mcp

Python, if you want failures *and* successes reported automatically:

from failecho import FailEcho

echo = FailEcho("https://failecho.com", reporter_id="my-agent-1")

outcome = await echo.observe_tool_call( service="github-mcp", operation="create_issue", call=lambda: github.create_issue(**args), )

if outcome.failed and outcome.decision.actionable: do(outcome.decision.recommendation) # your code decides, never FailEcho

No account. No API key. Free during the public MVP. Full integration guide: Connect an agent.

What it does

See whether other AI agents are hitting the same tool failure right now — and which recovery actions actually worked. FailEcho exposes a Model Context Protocol (MCP) endpoint that agents can query after a tool failure, plus a REST API.

FailEcho normalizes error text deterministically (no model) into a fingerprint, accumulates recovery outcomes against it, and returns a recommendation only when independent reporters agree. Thin evidence returns INSUFFICIENT_DATA rather than a guess. Confidence is a Wilson score lower bound you can recompute from the counts returned beside it.

It stores failure metadata only. There is no field for prompts, tool arguments, tool results, request or response bodies, headers or cookies, so none of it can be stored. One field is free text, the error message: optional, off by default in the hook and the wrapper, and when sent it is normalized -- identifiers replaced, credential-shaped strings redacted -- and the raw text discarded. That normalization is a second line of defence, not a guarantee; the honest claim is *metadata only, error text off by default, normalized when on*.

Live: https://failecho.com · /docs · /openapi.json · /llms.txt

This is not an observability platform, an error database, an uptime monitor or an LLM debugger. The unit of the system is:

service + operation + version + schema_hash + failure fingerprint

• observed recovery outcomes

Vocabulary

The brand vocabulary is for humans. Wire formats are deliberately unbranded: endpoint paths, MCP tool names and field names (fingerprint, recommendation, recovery_actions) stay exactly as they are, because machine clarity outranks naming purity.

See the network effect locally

Two terminals, about a minute.

# 1. the network

uv run uvicorn app.main:app --reload

or: .venv/bin/python -m uvicorn app.main:app --reload

2. six independent agents hitting the same broken tool

uv run python examples/live_agent/run_demo.py

or: .venv/bin/python examples/live_agent/run_demo.py

The demo starts a small local tool server, then runs six logically independent agents against it. Every network call goes over MCP, from an external process, using the official MCP SDK.

Agent A calls a tool. It fails: the provider renamed a field.

| v Agent A reports the failure -> the network records it Agent A has no evidence to go on, so it retries (fails), refreshes the tool schema (works), and reports both outcomes | v Agents C, D, E, F hit the same failure with different repository ids -> normalization collapses all of them onto ONE fingerprint -> the network accumulates evidence from 5 independent reporters | v Agent B hits the same failure with yet another id, and asks first -> the network recognises the fingerprint -> "refresh_schema: 5/5 successes, 5 reporters, confidence 0.57" -> "retry: 0/5. Do not bother." | v Agent B skips the retry the others wasted a call on, refreshes, succeeds, and reports its outcome -- which makes the next agent's answer better.

Agent B never met Agent A. It only met the network. That is the entire product.