# Snapback (remote · api.snapback.sh)

Diagnose why an AI agent failed and get the verified fix instantly. Free, no token.

- Trust score: 64/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-29

## Components

- remote · `api.snapback.sh`: 64/100 (this document), [markdown](https://verifymcp.io/servers/ra1labsworkx-wq-snapback/api.md), [page](https://verifymcp.io/servers/ra1labsworkx-wq-snapback/api)

## Channel facts

- Endpoint: `https://api.snapback.sh/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.8.2`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-29.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 23 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 73/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3076 tokens (~133/item across 23 items; 23 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 87/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 61% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 23 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 23 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 40/100
  - Spec-recency check failed: implements MCP spec 2025-03-26; the latest is 2026-07-28.

## Install

### How do I install the Snapback MCP server?

Snapback is a hosted endpoint at https://api.snapback.sh/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ra1labsworkx-wq-snapback 'https://api.snapback.sh/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "ra1labsworkx-wq-snapback": {
      "url": "https://api.snapback.sh/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ra1labsworkx-wq-snapback": {
      "type": "http",
      "url": "https://api.snapback.sh/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ra1labsworkx-wq-snapback]
url = "https://api.snapback.sh/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ra1labsworkx-wq-snapback": {
      "type": "remote",
      "url": "https://api.snapback.sh/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ra1labsworkx-wq-snapback --url 'https://api.snapback.sh/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ra1labsworkx-wq-snapback:
    url: "https://api.snapback.sh/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "ra1labsworkx-wq-snapback": {
      "Transport": "http",
      "Url": "https://api.snapback.sh/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ra1labsworkx-wq-snapback -t streamable-http -u 'https://api.snapback.sh/mcp'
```

### Other

```json
{
  "mcpServers": {
    "ra1labsworkx-wq-snapback": {
      "type": "http",
      "url": "https://api.snapback.sh/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-28 (score 64, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-26 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-25 (score 62, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-22 (score 61, 0)

- [functional improvement] Stability: unverified → 0.03

### 2026-09-21 (score 61)

First indexed and scored.

## MCP tools (23)

### `diagnose_trace` (~106 tokens)

Diagnose why an AI agent run failed. Returns a structured verdict (failure_class, failed_at_step, root_cause, fix_suggestion, confidence). LATENCY: known patterns return library-instant (<1s); a NOVEL failure needs an LLM call and can take up to ~25s — set your client timeout to at least 30s, and treat this as async (don't block your agent loop on it).

Input parameters:

- `trace` (object, required): OTel-shaped agent trace

### `diagnose_batch` (~92 tokens)

Diagnose SEVERAL traces in one call (up to 20). Each trace is metered like a separate diagnose_trace. Returns a verdicts array (per-trace, order preserved); a bad trace in the batch is isolated and doesn't fail the rest. Use for post-run analysis of many failures at once instead of N round-trips.

Input parameters:

- `traces` (array, required): array of trace objects (max 20)

### `get_verdict` (~42 tokens)

Fetch a previously produced verdict by its id or by trace_id (your org only).

Input parameters:

- `trace_id` (string)
- `verdict_id` (string)

### `preflight` (~114 tokens)

BEFORE running: get known failure patterns for a given agent setup so you can avoid them. Returns a ranked list of {failure_class, root_cause, fix_suggestion} from Snapback's library. Call this before executing a plan and self-correct.

Input parameters:

- `agent_stack` (string): e.g. openclaw, langchain (optional)
- `limit` (integer): max cards (default 10)
- `tags` (array): task facets, e.g. [tool_calling, retrieval] (optional)

### `submit_feedback` (~176 tokens)

Tell Snapback whether a verdict was correct (correct=true/false), with an optional free-text note (did the fix work? what was wrong?). ONE rating per verdict — call it AFTER you act on a verdict and see the outcome. Your correction updates the SHARED pattern library (fix patterns are shared anonymized so every agent benefits; your trace content is never shared) — a right verdict comes back faster next time, a wrong one gets down-weighted. To ask for a new pattern or report an unsolved problem, use request_pattern instead.

Input parameters:

- `correct` (boolean, required): true if the diagnosis was right, false if not
- `note` (string): optional free-text: what worked, what was wrong, or any detail that would help us improve this verdict
- `verdict_id` (string, required): the verdict you're rating

### `get_request_status` (~66 tokens)

Check what happened to a pattern you requested (from request_pattern's request_id). Returns pending / approved / rejected / in_library so you can see if your suggestion was actioned — the feedback loop isn't a black box. Free, no token.

Input parameters:

- `request_id` (string, required)

### `my_usage` (~67 tokens)

See YOUR current usage + remaining allowance so you can self-govern spend: snapbacks (diagnoses) used/cap/remaining, guard checks used/cap/remaining, estimated spend, % used, and when it resets. Call it periodically to avoid surprises. Token-scoped, free.

### `my_impact` (~55 tokens)

See how your feedback + pattern requests have shaped the shared library — how many verdicts you've rated, patterns you've requested, and how many were approved into the library. Turns your input into visible collaboration. Token-scoped to you.

### `what_others_did` (~242 tokens)

THE CROWD: for a failure_class (or pass the family/error and we'll map it), see what OTHER agents did about the same failure and whether it worked — anonymized, aggregated across everyone. Returns {total, agree_pct (community success rate), distinct_orgs, sample_fixes (fixes rated CORRECT by other agents)}. Use it when you hit a failure and want the crowd's verdict on what actually fixes it, not just the single library answer. Free, no token. Privacy-safe: only aggregate counts + a community success rate + the working fixes — never any org, agent, or trace identity. Hidden below a small min-sample so a single report can't be reverse-engineered. This is the network effect: the more agents use Snapback, the sharper this answer gets.

Input parameters:

- `error` (string): optional: an error string — we'll diagnose it to find the failure_class, then return the crowd outcomes for it
- `failure_class` (string): the failure_class to look up (e.g. 'unhandled_tool_error', 'loop_repeated_tool_call'); or pass 'error' and we map it

### `report_outcome` (~174 tokens)

Report the outcome of an auto-applied fix (the self-heal interceptor calls this after it gate-applied a fix and retried). Pass failure_class, family, fix, confidence, action_class, and succeeded (did the retry work?). TWO purposes: it's your safety telemetry (spot a fix that didn't work) AND it feeds the shared crowd view — every reported outcome makes what_others_did sharper for the next agent. Token-scoped (so we know it's your org), free.

Input parameters:

- `action_class` (string): retry | refetch | config
- `confidence` (number)
- `failure_class` (string, required)
- `family` (string)
- `fix` (string): the fix that was auto-applied
- `succeeded` (boolean, required): did the single retry after the fix succeed?

### `recommend_failover` (~191 tokens)

Should you RETRY the same target, SWITCH provider, FALL BACK to another chain, or STOP? Pass the error + your configured topology (current_chain, available_chains, and/or current_provider, available_providers) and get deterministic routing advice with the reason — so a flaky Solana RPC doesn't get retried 5x when you should switch to Base. Free, no token, no LLM. Reads only what you tell it (no network calls).

Input parameters:

- `available_chains` (array): fallback chains you can use (e.g. ['base','arbitrum'])
- `available_providers` (array): backup providers on the same chain
- `current_chain` (string): the chain you're on (e.g. 'solana')
- `current_provider` (string): the RPC/provider you're using (e.g. 'helius')
- `error` (string, required): the error you hit

### `cascade_root` (~130 tokens)

Given an ORDERED list of errors from a run (oldest first), find the TRUE root — the error that cascaded or shouldn't have been retried — not just the final symptom you see. E.g. a 429 that got retried and triggered a downstream 401: the root is the 429, not the 401. Each error can be a string or {error, retried, action}. Free, no token, no LLM.

Input parameters:

- `errors` (array, required): ordered list (oldest first) of error strings or {error, retried:bool, action} objects

### `suggest_budget_recovery` (~152 tokens)

Approaching a token/context/cost budget mid-run? Pass your counters and get the LEAST-DISRUPTIVE recovery ranked: truncate context | switch to a cheaper model | batch steps | wrap up — scored by speed gained, accuracy lost, cost saved. Turns budget_guard's 'you're at 94%' into 'here's what to do about it'. Free, no token, no LLM.

Input parameters:

- `context_used` (number)
- `context_window` (number)
- `cost_budget_usd` (number)
- `cost_used_usd` (number)
- `recent_actions` (array)
- `token_budget` (number)
- `tokens_used` (number)

### `request_pattern` (~160 tokens)

Leave us a message: ask us to add a failure pattern to the library, or report a problem we couldn't diagnose well. Use this when diagnose_trace didn't have a good answer, when you keep hitting a failure we don't classify, or when you want a specific kind of problem supported. It goes straight to our roadmap/backlog. Free — no token needed.

Input parameters:

- `context` (object): optional: the trace/error you couldn't get diagnosed (redacted server-side)
- `kind` (string): 'pattern_request' | 'problem' | 'message' (default 'message')
- `message` (string, required): what you'd like added, or the problem we couldn't solve — be specific
- `verdict_id` (string): optional: the verdict this relates to

### `detect_loop` (~130 tokens)

MID-RUN loop check (fast, no LLM, free). Send your recent steps DURING a run; get back whether you're stuck repeating a tool call and a concrete next move. Call this every few steps to catch a loop BEFORE you burn your step budget — don't wait for a postmortem. Non-blocking advice, not a verdict.

Input parameters:

- `steps` (array, required): your recent steps (last ~5-10), each with an action/tool and optionally inputs — same step shape as diagnose_trace
- `threshold` (integer): how many identical consecutive calls = a loop (default 3)

### `session_start` (~82 tokens)

Open a LIVE mid-run session so Snapback can watch your run step-by-step and warn you in real time (loop / token / cost / context) - the always-on guardian mode. Returns a session_id. Free, no token. Call session_step as you run, session_end when done.

Input parameters:

- `agent_id` (string): optional label for your agent/run

### `session_step` (~151 tokens)

Report ONE step of a live run and get back any warnings immediately (loop detected / budget breach). Pass the step (action + inputs) and any counters you have (step, max_steps, tokens_used, token_budget, cost_used_usd, cost_budget_usd, context_used, context_window, task, recent_actions. context_window). Warnings are advisory - act on them to self-correct mid-run. Free.

Input parameters:

- `counters` (object): running counters (tokens/cost/context/max_steps)
- `loop_threshold` (integer): identical calls that count as a loop (default 3)
- `session_id` (string, required)
- `step` (object, required): the step: action/tool + inputs

### `session_end` (~42 tokens)

Close a live session and get a short run summary (total steps, duration). Frees the session. Free, no token.

Input parameters:

- `session_id` (string, required)

### `agent_memory` (~98 tokens)

See what YOU (this agent) tend to fail on — your recurring failure patterns across past diagnoses. Returns your top failure classes with counts and what share of your failures each is (e.g. 'loop_repeated_tool_call: 12 times, 40%'). Call it before a run to know what to guard against. Token-scoped to your own agent. Free.

Input parameters:

- `limit` (integer): top N patterns (default 5)

### `budget_guard` (~226 tokens)

Live MID-RUN budget check (fast, no LLM). Send whatever counters you have and get an advisory on context %, token burn, cost burn, step budget, and off-task drift - with concrete suggested_actions and the projected cost of NOT acting. Call it every few steps to catch a runaway BEFORE you hit a limit. Advisory only (never blocks). Params: step, max_steps, tokens_used, token_budget, cost_used_usd, cost_budget_usd, context_used, context_window.

Input parameters:

- `context_used` (number)
- `context_window` (number)
- `cost_budget_usd` (number)
- `cost_used_usd` (number)
- `format` (string): 'summary' adds a one-line relayable answer (for chat/Telegram agents); 'summary_only' returns just that line. Default full.
- `max_steps` (integer)
- `recent_actions` (array)
- `step` (integer)
- `task` (string)
- `token_budget` (number)
- `tokens_used` (number)

### `convert_trace` (~137 tokens)

Turn your raw logs into a Snapback trace so you don't hand-craft JSON. Pass 'source' = a list of log/step entries, or an object with a spans/steps/messages/events/logs array (OTel spans, OpenAI/LangChain message lists, or generic {tool,input,output} arrays all work). Returns {trace} ready to pass straight to diagnose_trace. Free, no token.

Input parameters:

- `hint` (string): optional: the framework/format, e.g. 'otel', 'openai'
- `source` (required): your logs: a list, or an object wrapping a spans/steps/messages array

### `search_docs` (~101 tokens)

Search Snapback's documentation for how to use it — how to format a trace, what each tool does, the failure taxonomy, auth, pricing, and errors. Free and needs no token. Call this first if you're unsure how to format a request or what a verdict means.

Input parameters:

- `limit` (integer): max sections to return (default 3)
- `query` (string, required): what you want to know, e.g. 'how to format a trace'

### `diagnose_infra_error` (~342 tokens)

Diagnose a cryptic AGENT-INFRASTRUCTURE error — payments (x402/EIP-3009), Solana on-chain (ATA, blockhash, compute), MCP protocol, RPC/providers, EVM & Solana wallets, library of VERIFIED fixes the base model often gets wrong. Pass the error text (and optional context). Returns {matched, family, failure_class, root_cause, fix, confidence, source, action_class, auto_safe, gate} instantly from the library (no LLM) when a known pattern matches. Free and no token. GATE CONTRACT for autonomous action: auto-apply the fix ONLY when confidence>=0.85 AND source=='library' AND auto_safe==true (action_class is retry|refetch|config); NEVER auto-apply a 'mutate' or 'destructive' fix (create/change state, money, auth) — escalate those to a human. gate.auto_apply_ok gives you the verdict. Use it the moment you hit a transaction_simulation_failed, BlockhashNotFound, a -32xxx RPC code, a 4001/-32002 wallet error, an attestation failure, or any infra error you can't instantly resolve.

Input parameters:

- `action` (string): optional: the tool/operation that failed
- `context` (string): optional: what you were doing (e.g. 'paying via x402 on solana')
- `error` (string, required): the exact error text/message you hit
- `format` (string): 'summary' adds a one-line relayable answer (for chat/Telegram agents); 'summary_only' returns just that line. Default full.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ra1labsworkx-wq-snapback/api#diagnostics

## Score history

- 2026-09-29: 64
- 2026-09-28: 64
- 2026-09-27: 63
- 2026-09-26: 63
- 2026-09-25: 62
- 2026-09-24: 62
- 2026-09-23: 61
- 2026-09-22: 61
- 2026-09-21: 61

## Common questions

### What is the Snapback MCP server?

Snapback is an MCP server listed in the public MCP registry as io.github.ra1labsworkx-wq/snapback. Diagnose why an AI agent failed and get the verified fix instantly. Free, no token. This page covers its hosted endpoint (https://api.snapback.sh/mcp).

### Is the Snapback MCP server safe to use?

Snapback scores 64 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Snapback MCP server expose?

Snapback exposes 23 tools: diagnose_trace, diagnose_batch, get_verdict, preflight, submit_feedback, and 18 more. Their descriptions and schemas cost roughly 3,076 tokens of context every time the server is loaded.

### Does the Snapback MCP server require authentication?

No. We connected to Snapback without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Snapback MCP server still maintained?

Snapback is still listed as active in the MCP registry. We last reached this channel on 29 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://api.snapback.sh/mcp
- Repository: https://github.com/ra1labsworkx-wq/snapback-selfheal
- Changelog RSS feed: https://verifymcp.io/servers/ra1labsworkx-wq-snapback/api.xml
- Changelog JSON feed: https://verifymcp.io/servers/ra1labsworkx-wq-snapback/api.json
- HTML version of this page: https://verifymcp.io/servers/ra1labsworkx-wq-snapback/api