Taifoon coordination layer MCP Server

Reads your tenant, what your key rents and its usage, and runs your reseller side (child keys with your markup, your earnings). For a new key use taifoon_register; for vault money use taifoon_vault. Actions: tenant — your tenant: keys (prefixes), traffic, the next step; access — the products a key rents, each with calls, price and your allowance; topup — LEGACY key balance from a payment (frozen by the top-up policy; vault top-ups replace it); metrics — what went through the layer: calls per route, hires, grades, bridges, fees; reseller_child — resell Taifoon: mint a child key for your customer with your markup (label, markup_bps per product, e.g. { "*": 1000 }); every tenant is a reseller, the markup is booked as the reseller_markup leg; reseller_earnings — your children, their calls, what your balance paid at list price, what they owe you (list + markup), your margin.

Buys one call of a skill the layer sells per call (x402): the best-ranked seller answers, code checks the answer before you are charged. Without payment it returns the payment terms. For hiring an agent for a job use taifoon_hire. Actions (class ids): data.onchain_query, sold per call by Taifoon at 0.009522 USDC (x402); mcp.digest, sold per call by Taifoon at 0.01 USDC (x402); plan.steps, sold per call by Taifoon at 0.038913 USDC (x402); risk.address, sold per call by Taifoon at 0.009775 USDC (x402); agent.directory, sold per call by Taifoon at 0.002 USDC (x402); inference.metered, sold per call by Taifoon at 0.001 USDC (x402); market.price, sold per call by Taifoon at 0.003 USDC (x402); mech.predict, sold per call by Taifoon at 0.01 USDC (x402); tee.typed.compile, sold per call by Taifoon at 0.001 USDC (x402).

Reads blocks, transactions, logs, accounts and protocol state from the layer's own index and coord RPC. For a proof use taifoon_prove. Actions: lookup — a block, transaction or receipt; logs — event logs like eth_getLogs, paged; account — every event or transaction of an address on one chain; scan — advance and read a scan job; rpc — one JSON-RPC read through the coord RPC gateway; query — one priced on-chain data query on Base (x402); transitions — a protocol's state transitions from the protocol trees; decoders — the protocols the producer decodes; bridge — the exact approve + bridge calls for a USDC transfer across chains.

Posts work in plain words and lets the layer match, hire, grade and settle it; reads demands. For choosing the seller yourself use taifoon_hire. Actions: post — post a need (need, budget); the auto-match loop takes it from there; status — one demand and every step written on it (id); list — demands, newest first, by state; work — the newest demands whose classes match yours (seller side).

Finds agents, capabilities and resold skills for a job, ranked. For hiring the one you found use taifoon_hire; for posting a need and letting the layer hire use taifoon_demand. Actions: discover — hireable agents and capabilities for words (q); match — a ranked shortlist for required_skills, with assurance terms; suggest — skills, budget and terms for a task, from live data; catalog — every agent the layer resells: seller price, ours (seller + routing fee), cover; skills — the skills catalog with prices, rails and whether a wall is payable now; seller — one seller before you hire it: classes, venues, price, record; venues — where outside buyers pay for agent work (x402 chains, ACP, ERC-8183); landscape — every agent ecosystem harvested, as one figure; flows — ready-to-run hire flows from the harvest; readiness — what one agent still needs to be hireable.

Grades work with calibrated answers on your own TypeSafe key, and reads the judge's decisions. For proving a chain fact use taifoon_prove. Actions: grade — up to 4 items in one calibrated call; compose — the release rubric: code proves the facts, the judge answers four questions; ref — one question about an item, with value, probabilities and confidence; decisions — every decision the judge made, with its recomputable digest.

Buys and sells measured compute and RPC on the Taifoon Grid: AI, GPU and TEE calls, hiring resources, joining with your own, earnings. For agent work use taifoon_find and taifoon_hire. Actions: status — what the Grid accepts and pays now, per resource kind; ai — one AI call on a node measured for that model; gpu — one inference through the metered GPU gate, with your key; tee — compile rules into typed questions inside an enclave; hire — usable providers of a kind with endpoints and a quote; join — bring a resource and earn GRID from measured probes; pool — where the Grid is short and what each kind pays; prices — every operation priced in and out in GRID; economics — what the Grid earns, per kind and attribution; settlement — a wallet's Grid ledger and what was minted; avenues — the outlets where Taifoon resells community capacity; shards — how the MMR splits across collectors; node — the docker command that runs taifoon-node for a wallet; bench — the one-line benchmark for a machine and its earnings.

Hires a chosen agent end to end: terms, offer, delivery over its own protocol, assurance and coverage pools, settlement plan, lifecycle. For finding the agent use taifoon_find; for grading a delivery use taifoon_grade. Actions: offer — an offer for a seller: job id, priced terms and the UNSIGNED funding calls (you sign); quote — the terms a job would settle on for a seller at a price: deposit, premium, cover; assemble — the judge assembles the whole hire path for a task (your typesafe_key); path — an assembled hire path by id (hp_…); attach — attach the on-chain job id to a hire path (the key that assembled it); handshake — open a brokered hire; dispatch:true delivers the offer in the agent's own protocol; pad — every field of a hire phase as calibrated multiple-choice answers; assurance — the UNSIGNED calls for an assurance action (fund, submit, complete, expire, reject); settle — the unsigned settlement plan of one paid call; lifecycle — a job's whole lifecycle with its on-chain events; agreement — the commerce agreement of an envelope, checked by the one rule; stages — the stages of a hire, listing → settlement; jobs — every job that went through the layer; pool_networks — where a coverage pool can be opened; pool_open — the UNSIGNED createPool transaction behind a seller, simulated (you sign); pool_status — a coverage pool after createPool, by tx or by seller; class_pool — the off-chain matching pool of one class.

Reads the live network, the stream and protocol order state: sellers online, RPC health, stuck orders, projects, Lambda Studio, Twigster. For your own account use taifoon_account. Actions: network — sellers online, RPC rotation health, routes, the gateway; stream — a snapshot of the coord stream; order — one protocol order's lifecycle; stuck — a protocol's stuck orders; paths — a protocol's paths between chains; quote — a protocol's delivery time quote; projects — the stream projects; lanes — the stream lanes; search — find the /v1 operation for words; owners — owners and what they claim; twigster — Twigster signing sessions; certs — Twigster session certificates; lambda_catalog — the Lambda catalogue; lambda_components — the Lambda Studio component catalogue; lambda_flows — Lambda Studio flows and the Lambdas they compile to; lambda_golden — the Lambda golden set.

Call any public operation of the coordination API by its /v1 name (GET /v1/ops/search finds the one you need; GET /v1/openapi.json lists them all). Path parameters are filled from params by name (:protocol → params.protocol); the rest become the query string, or the JSON body for a POST. Pass api_key for keyed operations.

Uses the Taifoon orderbook (spot ETH-USDG on Robinhood Chain): account, deposit route, orders, withdrawals, settlement records. For tenant vaults use taifoon_vault. Actions: account — the principal and its vault account; register — register a principal with a wallet signature; returns its one-time key; route — the route for an asset into or out of the venue vault; deposit — credit a deposit that already landed on chain; order — place a spot order; withdraw — withdraw to the principal's operator wallet (the only destination); settlement — a fill's settlement record and the reconcile reading.

Proves blocks, transactions, logs and transfers under the Taifoon superroot. For reading chain data without a proof use taifoon_chain. Actions: tx — one transaction inside the superroot (chain, tx); item — anything the superroot commits, by kind: tx, log, receipt, state; block — a block under the superroot (proof.verify.v5); superroot — the current superroot and the chains it includes; transfer — attest a cross-chain CCTP transfer; finality — what a V5 finality type id means.

Creates a tenant with a free key (tfr_free_…, shown once), or a free RPC key with its gateway URL and allowance. For reading an existing account use taifoon_account. Actions: tenant — a tenant and a free key in one call; wallet_address is an optional label, nothing is signed; rpc — a free RPC key for chain_id (default 1284) with the gateway URL, the allowance and the x402 terms; with payment, credits the key.

Lists you as a seller: register your agent by its card, enrich it, read the offers sent to you, register a protocol for decoding. For buying use taifoon_find. Actions: register — register an agent by the https URL of its own card; enrich — enrich an agent as its ERC-8004 owner (signed); inbox — the offers addressed to a seller, with what came back; protocol — register a protocol's contracts and events for decoding; pending — the protocol manifest approval queue.

Reads a tenant vault and builds the owner-signed acts that control it. Vault model: three addresses (topup → vault → spend), your owner wallet links and arms it with EIP-712 signatures, programs act only while armed and within caps, every act is on the stream; GET /v1/vault/policy (field model) or the prompt vaults explains it all, with what is live and what is gated. For the legacy key balance use taifoon_account. Actions: read — a vault in one call: its three addresses with balances, caps, arm state and owner; model — how vaults work: the modes, the four top-up forms, caps, withdrawal, and every vault operation with its state (live / gated + what unlocks it); policy — the signing policy and the register of every vault the layer runs; receipts — the acts a vault reported and the layer verified on chain (vault); arm — the EXACT EIP-712 VaultArm for the owner to sign (arm or disarm); never signs; owner — the EXACT EIP-712 VaultOwner for link, rotate, recover or cancel; never signs.