TaifoonTAIFOON
← ALL POSTS
EcosystemMay 10, 2026 · 7 min read

Frontier 2026: Intent in. V5 proof out.

Taifoon Team · Builders Programme
Frontier 2026: Intent in. V5 proof out.

Most cross-chain solvers ship as private MEV boxes. The infrastructure is there — Across, deBridge, Mayan, the whole nine — but the value flow is broken. The people who write the integrations don't own them. The routes that get adopted earn for whoever owns the SaaS, not whoever wrote the code. And every LLM agent everyone says will eat this market in a year — none of them have a solver they can actually call.

So that's what we built. And we built it MCP-native from day one.

> [Open the live deck](/deck/frontier) · [Download the PDF](/decks/taifoon-frontier-deck.pdf) · [MCP tool catalog](/os/intel#mcp-catalog) · [Watch the OS](/os/dispatch) · [Read the license](/legal/tsul)

The 16-slide pitch deck is hosted at [taifoon.io/deck/frontier](/deck/frontier) — open it in your browser, share the URL anywhere, or grab the [PDF](/decks/taifoon-frontier-deck.pdf) if you want a copy. Same artifact submitted to Colosseum.

What changed since the first draft of this post

I started writing this a week ago with the headline "we shipped the OS that turns solvers into a public good." Still true. But the more I dug into the [taifoon-mcp-server crate](https://github.com/taifoon-io/taifoon-solver/tree/main/rust/crates/taifoon-mcp-server), the more obvious it became that the wedge was sharper than that.

Five live MCP tools, callable over stdio JSON-RPC, are already shipping in the solver:

  • get_quote — ranked cross-chain route recommendations across 30 protocols. Sub-50-millisecond deterministic scoring.
  • explain_route — natural-language reasoning over those scores. Anthropic-backed.
  • get_route_stats — per-route fill rate, fee p50/p95, latency, per-protocol breakdown.
  • get_protocol_health — real-time health for any indexed bridge or intent protocol.
  • get_solver_leaderboard — top fillers by volume, fill count, latency. Reverse-mapped from on-chain events.

Public catalog and a runnable example live at [/os/intel#mcp-catalog](/os/intel#mcp-catalog).

Show, don't tell

The cleanest way to demonstrate "MCP-native" is to read [examples/intent-to-fill.ts](https://github.com/taifoon-io/taifoon-solver/blob/main/examples/intent-to-fill.ts) and run it. 270 lines of Apache 2.0 TypeScript. It spawns the MCP server as a subprocess and walks the full loop:

text
1natural-language intent
2  ↓
3taifoon-mcp::get_quote      (deterministic, <50ms, ranked across 30 protocols)
4  ↓
5taifoon-mcp::explain_route  (LLM-backed reasoning)
6  ↓
7UniversalOperator           (9-adapter on-chain fill)
8  ↓
9V5 proof blob               (cryptographic settlement attestation)
10  ↓
11BuildersRegistry            (49 bps donut, 70/20/10 split)

Run it locally:

sh
cargo build --release -p taifoon-mcp-server
export TAIFOON_DA_API=https://solver.taifoon.io
pnpm tsx examples/intent-to-fill.ts "1000 USDC ethereum → solana, fast"

Truncated output, in the order it streams to your terminal:

text
1▶ MCP server exposes 18 tools (5 intelligence-class)
2
3▶ get_quote — scoring across 30 protocols…
4  quote_id: q_0xab12…  (38ms)
5    #1  mayan_swift     fee=4.0bps   lat=8.0s   gas=$0.40  fill=98.1%
6    #2  debridge_dln    fee=6.5bps   lat=12.0s  gas=$0.55  fill=96.4%
7    #3  cctp            fee=0.0bps   lat=900s   gas=$0.82  fill=99.7%
8
9▶ explain_route — natural-language reasoning…
10  For a $1,000 USDC ETH→SOL transfer optimised for speed, mayan_swift is the
11  strongest pick: 4 bps fee, ~8s end-to-end, 98.1% 30-day fill rate, and Solana
12  settlement is native (not a wrapped representation).
13
14▶ executeRoute — handing off to UniversalOperator…
15▶ V5 proof blob — cryptographic settlement attestation
16▶ BuildersRegistry.recordRevenueTouch() — 49 bps split 70/20/10

Same wire from intent to V5 proof. The agent reasons in English. The OS responds with structured, deterministic data. The fill is provable. The donut routes to the contributor.

Why a Solana hackathon

Solana is the right place to ship this. Three reasons.

Native settlement. The existing Mayan Swift adapter routes Ethereum-to-Solana fills with real lamports landing on the destination wallet. We don't have to wrap, bridge, or fake it. The live demo at the 1:00 mark is exactly that flow.

The right audience. The judges who matter for a solver pitch — Drift, Altitude, Ellipsis Labs, the OpenBook crowd — have spent years thinking about how to make solver markets non-extractive. They don't want another extractive box. They want the rails.

The economics work. A 49 bps donut on a $1,000 fill is $4.90. Try doing that on Ethereum mainnet at $30 a transaction. Fair-code routing only becomes possible when the settlement layer is cheap.

The four product promises

The Taifoon Sustainable Use License (TSUL) and the on-chain donut combine into four promises:

  1. Co-ownership of every route you ship. When your adapter merges, your wallet becomes the perpetual recipient of 70% of a 49 bps donut on every settled call routed through it. On-chain, automatic, irrevocable for as long as your contribution stays merged.
  2. No upfront. No prize. No synthetic token. Performance only. Paid in whatever currency each upstream call settled in. No FX risk introduced by the platform. No vesting. No cliffs.
  3. On-chain enforcement, not lawyer-paper. TSUL rule four is enforced by BuildersRegistry.recordRevenueTouch() on devnet 36927. Strip the donut and the registry revokes the merge.
  4. The OS extends itself. Six self-extension loop edges generate fresh bounties from real revenue gaps. Anyone with a wallet can dispatch new work via [/os/submit-job](/os/submit-job).

The license posture

Three licenses, split deliberately. Each path picks the license that matches its job.

| Path | License | Why | |------|---------|-----| | [taifoon-solver](https://github.com/taifoon-io/taifoon-solver) | Apache 2.0 | Public Goods. Anyone can fork, embed, integrate. | | [taifoon-sdk](https://github.com/taifoon-io/taifoon-sdk) | Apache 2.0 | Maximum reach for the TypeScript client. | | [open-mamba](https://github.com/taifoon-io/open-mamba) | MIT | The task-bus engine should propagate. | | [taifoon-mamba](https://github.com/taifoon-io/taifoon-mamba) | TSUL | Pro dispatcher tier. Donut routes through it. | | taifoon-eco (private) — BuildersRegistry + adapter contracts | TSUL | The donut routing must be enforceable. | | [taifoon-design-system](https://github.com/taifoon-io/taifoon-design-system) | CC-BY-4.0 | Tokens, fonts, UI kit. Free to remix with attribution. |

Canonical TSUL: [github.com/taifoon-io/license](https://github.com/taifoon-io/license/blob/main/LICENSE.md). Single source of truth — every other repo references it.

Apache 2.0 on the solver core is what makes the submission Public-Goods eligible. TSUL on the platform contracts is what makes the donut enforceable. The license is a contract because the contract IS the license.

The 95-second demo

The recording is structured around eight beats. Live site, live MCP call in a terminal pane, live Solana fill.

text
10:00–0:35   homepage → /spinners → /proof    "56 chains. 127M blocks. V5 proofs."
20:35–0:55   /os/intel#mcp-catalog            "five live MCP tools. The agent is the customer."
30:55–1:18   live MCP call in iTerm pane      "1000 USDC eth → sol, fast." → ranked routes → LLM why
41:18–1:30   /builders/onboarding             "60 seconds. Wallet, devnet, faucet, fork, ship."
51:30–1:55   /builders/bounties → /legal/tsul "open routes under TSUL. Contract IS the license."
61:55–2:25   /os/dispatch                     "Brain pulses every 2s. Reviewer fleet running."
72:25–2:48   /os/submit-job                   "Anyone with a wallet dispatches work."
82:48–2:55   github.com/taifoon-io/taifoon-solver

When the judge clicks "Submit a job", the LiveBrain on /os/dispatch pulses on every dispatcher tick. Reviews-in-flight chips show which [open-mamba](https://github.com/taifoon-io/open-mamba) reviewer agents are running. Verdict pills (P/F/I) scroll as agents complete. Autonomous work, on screen, in real time.

The full cue sheet — recording mechanics, retake rules, three-tier fallback if the live MCP call dies on camera — is in [LOOM_RUNBOOK.md](https://github.com/taifoon-io/taifoon-solver/blob/main/LOOM_RUNBOOK.md).

What the deck shows

The full 16-slide pitch is hosted at [taifoon.io/deck/frontier](/deck/frontier) — the same PDF submitted to Colosseum, rendered inline in the browser, downloadable directly if you want a copy. Triple-click the URL, paste, share.

Slide order:

  1. The wedge — *Cross-chain intents, solved on Solana.*
  2. The problem — slow, trusted, inconsistent, Solana islanded.
  3. Where Solver sits — one product in a stack of seven (Pulse, Search, Proof, Intel, Solver, Spinners, OS).
  4. MCP-native — five live tools any LLM agent calls directly.
  5. 9-adapter fleet — Across, deBridge, Mayan, Lambda, Hyperlane, LiFi, Squid, CCIP, Stargate.
  6. V5 proof anchor — six layers, one SuperRoot, reproducible by any light client.
  7. Donut economics — 49 bps split 70/20/10 on every settled call.
  8. TSUL fair-code — four rules, on-chain enforcement, license IS the contract.

Slides 9 through 16 cover the live demo path, the repo posture, builder onboarding, and the close. Direct PDF: [taifoon.io/decks/taifoon-frontier-deck.pdf](/decks/taifoon-frontier-deck.pdf).

Where to look

  • Pick an open route — [taifoon.io/builders/bounties](/builders/bounties). Every card under TSUL.
  • Submit a route — [taifoon.io/os/submit-job](/os/submit-job). 72h triage SLA, no upfront.
  • Drive the OS from your own LLM — [taifoon.io/os/intel#mcp-catalog](/os/intel#mcp-catalog). Five live tools, runnable example.
  • Watch the OS — [taifoon.io/os/dispatch](/os/dispatch). Live Brain, reviewer fleet activity.
  • Read the license — [taifoon.io/legal/tsul](/legal/tsul). Four rules, plain English.

License or commercial questions: taifooon@proton.me.

Submission deadline: 23:59 May 11, 2026 UTC. I'll post the outcome and any accelerator-interview follow-up the moment Colosseum gets back.

NEWER →
How Taifoon Collects Block Headers Across 41 Chains