Verified Burst

Pay-per-correct inference for agents. At a hard, irreversible, or low-confidence decision, an agent escalates to fast silicon (Cerebras), samples best-of-N, runs the answer through a verifier, and settles over x402 only if it passes. A non-verified result costs nothing.

Live on Base mainnet with a self-hosted facilitator (no Coinbase dependency). The buyer brings their own provider key (BYOK) — we sell routing, verification, and settlement, never marked-up tokens.

• 🟢 Live endpoint: https://burst.solcleus.com/v1/burst (manifest at GET /v1/info)

• 📦 PyPI: pip install verified-burst

• 🔎 Listed on x402scan, 402 Index, and Glama

Why

An agent can already sample itself more (its own best-of-N is correlated — it shares its own blind spots). The one thing it can't self-supply is an independent, zero-downside, keepable verification: a different model family checks the answer, you pay only if it passes, and you keep the receipt. Because the downside is $0 by construction, an agent's budget policy can auto-approve the spend without a human in the loop.

Related MCP server: the402-mcp-server

Quickstart (MCP, one line)

pip install verified-burst

Add the server to your MCP client — the agent gains one tool, buy_verified_burst:

{
  "mcpServers": {
    "verified-burst": {
      "command": "verified-burst",
      "env": {
        "BURST_BUYER_KEY": "0x<wallet-private-key-that-pays-per-call>",
        "BURST_PROVIDER_KEY": "csk-<your-cerebras-key>"
      }
    }
  }
}

• BURST_BUYER_KEY — the wallet that pays per verified burst (USDC on Base). Required for live settlement.

• BURST_PROVIDER_KEY — your Cerebras key; bursts run on your tokens (BYOK). Optional.

• BURST_ENDPOINT — defaults to the hosted broker; override to self-host.

The tool:

buy_verified_burst(request, strategy="best_of_n", n=3,
                   verifier="self_consistency", answer_key=None)
  -> { answer, verified, charged, receipt, settle_tx }

How it works

request → escalate to fast silicon → best-of-N → verify → settle ONLY if passed
                                                              ↑ pay-only-if-verified

1. 402 challenge — GET /v1/burst returns the x402 payment requirements (Base mainnet, USDC).

2. Authorize — the client signs an x402 (EIP-3009) authorization for the quoted price.

3. Burst — the answer is generated on the buyer's BYOK key and gated through the chosen verifier.

4. Settle — USDC is captured only if the verifier passes. A miss settles nothing.

Every response includes a keepable receipt (verified, corrected, independent, generator/verifier model, settle_tx) so verified decisions compound into memory.

Verifiers

Independence is the moat: independent_judge/independent_quorum are judged on models in a different family (and, where configured, a different vendor) than the generator, so the check doesn't share the generator's blind spots.

Pricing

A small service fee per burst (routing + verification + the pay-only-if-verified guarantee), paid in USDC on Base — only on a pass. Per-burst $0.002 (fast) to $0.0045 (independent-judge). Generation tokens are billed to the buyer's own key; we never mark up tokens. Hard per-wallet spend cap; abuse breakers on the judge path.

Proof

This is live and settling real money. End-to-end mainnet settlement proof on BaseScan: 0x76921c33…d359c4.

A reproducible catch-rate harness (proof_harness.py → PROOF.md) generates code-checkable items and runs the real product path. At N=120 the base model was 86.7% accurate; the independent judge caught 16/16 mistakes with 0 false-confirms (never charged for a wrong answer) and a 3.8% false-alarm rate (free redo).

Honest caveat: that result is the checkable-answer regime (arithmetic, counting, labels) — the verifier's strongest suit and the product's stated sweet spot. It does not prove catch rate on fuzzy/subjective decisions, and 16 mistakes is a modest denominator. Claims are kept to what's measured.

HTTP API

Self-hosting

The broker is stdlib-Python plus the live-payment deps in requirements-live.txt. Run PORT=8402 python3 server.py behind a TLS proxy; set X402_MODE=live with a relayer wallet and X402_PAY_TO. The MCP stdio server is mcp_server.py (sim mode needs no secrets — it starts and introspects out of the box).

Built honestly: only what's measured is claimed. Questions or integrations welcome.