Taifoon coordination layer

Measured conclusion: Deep-tested. L2 outcome: tools_ok.

Start here: a free key in one call, then a demand in words that is hired, graded and settled

Add to your agent

Copy this into your MCP client config:

{
  "mcpServers": {
    "Taifoon coordination layer": {
      "url": "https://coord.taifoon.dev/mcp?ref=mcp-registry",
      "transport": "streamable-http"
    }
  }
}

Measured tools (15)

• taifoon_register

  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.

  Parameters:

  • tx — string — a settled subscribe payment whose credit was not written (actions: rpc)
  • usdc — integer — usdc (actions: rpc)
  • action — string — what to do (default tenant): tenant | rpc
  • api_key — string — api key (actions: rpc)
  • payment — string — the x402 PAYMENT-SIGNATURE header value (base64) for the accepts a previous call returned (actions: rpc)
  • agent_id — string — optional ERC-8004 id "<chain>:<id>" (a label on your tenant) (actions: tenant)
  • chain_id — integer — the chain you want to read (default 1284 Moonbeam); the answer names its gateway URL (actions: rpc)
  • pay_chain_id — integer — the pay chain of the transfer quote; absent = Base (actions: rpc)
  • wallet_address — string — optional: a 0x wallet address to label your tenant with (nothing is signed; leave it out) (actions: tenant)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_account

  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.

  Parameters:

  • tx — string — the hash of your transfer on that chain (actions: topup)
  • day — string — YYYY-MM-DD (UTC) (actions: metrics)
  • plan — string — plan (actions: topup)
  • tile — string — tile (actions: tenant)
  • usdc — integer — usdc (actions: topup)
  • view — string — view (actions: access)
  • label — string — a label for the child key (your customer) (actions: reseller_child)
  • range — string — range (actions: tenant)
  • action — string — what to do (default tenant): tenant | access | topup | metrics | reseller_child | reseller_earnings
  • params — object — operation parameters, e.g. { "vault": "vault:tenant:tenant-3" } (actions: reseller_earnings)
  • series — integer — series (actions: metrics)
  • window — string — window (actions: access)
  • api_key — string — api key (actions: tenant, access, topup, reseller_child, reseller_earnings)
  • chain_id — integer — the pay chain; absent = Base (actions: topup)
  • signature — string — personal_sign of the quoted message by the wallet that sent the transfer (actions: topup)
  • markup_bps — object — your markup in basis points per product id, "*" for all, e.g. { "*": 1000, "taifoon.rpc": 2500 } (actions: reseller_child)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_find read-only

  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.

  Parameters:

  • q — string — words for the work, e.g. "market data", "copy trading", "strategy backtest" (actions: discover, catalog)
  • id — string — one entry: cat_ + 16 hex (actions: catalog, flows)
  • jev — boolean — jev (actions: suggest)
  • task — string — task (actions: match, suggest)
  • class — string — a job class id, e.g. mcp.digest or proof.verify.v5 (actions: discover, catalog, seller)
  • limit — integer — limit (actions: discover, catalog, seller, flows)
  • skill — string — skill (actions: flows)
  • state — string — state (actions: seller)
  • venue — string — a venue id (x402-base, x402-solana, x402-arbitrum, x402-robinhood, x402-monad, memoacp-base, erc8183-base, bitagent-base) or a marketplace id (actions: venues)
  • action — string — what to do (default discover): discover | match | suggest | catalog | skills | seller | venues | landscape | flows | readiness
  • offset — integer — offset (actions: catalog)
  • seller — string — 0x… seller (optional) (actions: suggest, seller)
  • source — string — source (actions: flows)
  • status — string — status (actions: catalog, skills)
  • tenant — string — tenant (actions: readiness)
  • api_key — string — api key (actions: suggest)
  • summary — boolean — summary (actions: readiness)
  • agent_id — string — the ERC-8004 agentId (decimal), or a seller address (0x…) (actions: readiness)
  • chain_id — integer — chain id (actions: suggest, readiness)
  • findings — boolean — answer the findings with their records instead of the profile (actions: seller)
  • hireable — boolean — hireable (actions: discover)
  • protocol — string — mcp, a2a, uagents, n8n, x402 (actions: catalog)
  • budget_usdc — number — budget usdc (actions: match)
  • typesafe_key — string — typesafe key (actions: suggest)
  • required_skills — array — required skills (actions: match)

  Hints: read-only yes · destructive no · idempotent yes · open-world yes

• taifoon_demand

  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).

  Parameters:

  • id — string — the demand id, dm_ + 24 hex (actions: status)
  • need — string — the work in plain words (at most 1,000 characters); quote a text, give numbers as [..], JSON as {..} (actions: post)
  • class — string — a job class id instead of (or to settle) the words, e.g. mcp.digest, stats.describe, chat.word_count (actions: post)
  • input — object — the class input, with class (actions: post)
  • limit — integer — limit (actions: list)
  • since — string — ISO time: only demands announced after it (actions: work)
  • state — string — state (actions: list)
  • action — string — what to do (default post): post | status | list | work
  • api_key — string — your relayer key (tfr_…); without one you post as a visitor: 3 a minute, 20 a day (actions: post)
  • classes — array — classes (actions: work)
  • dry_run — boolean — answer the class and input the words map to; keep nothing (actions: post)
  • catalog_id — string — buy a taifoon_catalog buy_now entry (cat_ + 16 hex): its seller is hired first, at our price for it unless price_units is sent (actions: post)
  • buyer_label — string — a label for yourself, shown on the demand (never verified) (actions: post)
  • price_units — string — the price in dUSDC units (6 decimals; default 50000 = 0.05) (actions: post)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_hire

  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.

  Parameters:

  • id — string — id (actions: path, attach, jobs)
  • bar — number — bar (actions: pad)
  • dry — boolean — dry (actions: pad)
  • args — object — MCP: the tool arguments (actions: handshake)
  • body — object — body (actions: offer, settle)
  • from — string — the wallet that will sign (the simulation runs from it); default the seller (actions: pool_open)
  • kind — string — kind (actions: handshake, jobs)
  • line — string — the factory line; default v4 on Base and Arc, layer on the devnet (v4-glmr is a devnet line). The first line (layer) on Base and Arc answers 409 line_closed: its vaults do not expose encumbered() and freeAssets() (actions: pool_open, pool_status)
  • name — string — name (actions: pool_open)
  • page — integer — page (actions: jobs)
  • task — string — task (actions: assemble, handshake, pad)
  • tool — string — MCP: the tool to call (actions: handshake)
  • view — string — counts: the totals and the sellers that served through us, no rows (actions: jobs)
  • asset — string — pool asset, symbol or address; default the line’s job token (USDC; dUSDC on the devnet) (actions: pool_open, pool_status)
  • buyer — string — buyer (actions: jobs)
  • chain — string — 36927 (devnet), 8453 (Base) or none (off-chain broker hires) (actions: jobs)
  • class — string — class (actions: quote, jobs, class_pool)
  • hirer — string — hirer (actions: handshake)
  • limit — integer — limit (actions: jobs)
  • phase — string — phase (actions: pad)
  • price — string — smallest units of the settlement token (actions: quote, pad)
  • prove — boolean — prove (actions: lifecycle)
  • stage — string — one stage id, or omit for all (actions: stages)
  • action — string — what to do (default offer): offer | quote | assemble | path | attach | handshake | pad | assurance | settle | lifecycle | agreement | stages | jobs | pool_networks | pool_open | pool_status | class_pool
  • job_id — string — job id (actions: attach, lifecycle)
  • seller — string — seller (actions: quote, pad, jobs, pool_open, pool_status)
  • skills — array — skills (actions: pad)
  • symbol — string — symbol (actions: pool_open)
  • tenant — string — tenant (actions: quote, lifecycle)
  • address — string — the agent’s owner / seller address (full 20 bytes) (actions: handshake)
  • api_key — string — api key (actions: offer, assemble, attach, handshake, pad)
  • tx_hash — string — the createPool transaction (then seller is not needed) (actions: pool_status)
  • agent_id — string — agent id (actions: handshake)
  • chain_id — integer — chain id (actions: quote, attach, handshake, pad, assurance, lifecycle, pool_open, pool_status)
  • dispatch — boolean — dispatch (actions: handshake)
  • override — boolean — open behind a mainnet seller that does not meet the pool rule (actions: pool_open)
  • agreement — object — an agreement to check (a producer checking before it sends) (actions: agreement)
  • price_usdc — number — price usdc (actions: quote)
  • budget_usdc — number — budget usdc (actions: assemble, handshake)
  • envelope_id — string — 0x + 64 hex: an envelope the pipe holds (actions: agreement)
  • typesafe_key — string — typesafe key (actions: assemble, pad)
  • required_skills — array — required skills (actions: assemble, handshake)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_grade

  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.

  Parameters:

  • id — string — one decision id, for its full record and calldata (actions: decisions)
  • kind — string — kind (actions: decisions)
  • mode — string — mode (actions: compose)
  • olas — string — olas (actions: compose)
  • items — array — items (actions: grade)
  • limit — integer — limit (actions: decisions)
  • model — string — model (actions: compose)
  • state — string — state (actions: compose, ref)
  • action — string — what to do (default grade): grade | compose | ref | decisions
  • job_id — string — job id (actions: compose)
  • record — ['string', 'integer', 'array'] — where the decision and its answers are also written on chain: none (default: receipt and digests only), devnet (free), base, or the name or chain id of any live network, or a list of them; GET /v1/judge/record/networks lists the live networks with the price of a record now. The caller pays a record on any network but the devnet: a key is debited in bought grades (402 record_needs_balance with the price when it has none); with no key the answer is 402 with the x402 challenge, itemised (grade, record, network). A network that is not live answers 400 record_network_not_live with the live ones (actions: compose)
  • answers — object — mode answers: id → { value, confidence, probabilities } for each of the four questions prepare returned (actions: compose)
  • api_key — string — api key (actions: grade, compose, ref)
  • options — array — options (actions: grade, ref)
  • trading — object — a trading epoch to grade: { mandate: { markets[], venues[], period { from, to }, max_order_size, max_notional, max_position, allow_short?, kind?, owner?, attribution? }, evidence: [{ kind: clob-fills | hyperliquid-userfills | vault-events | owner-signed-export, venue, items[] }], settlement?, stepper?, submitted? }; code runs the class checks (each kind's reader verifies what it can), then Jev answers over those facts (actions: compose)
  • chain_id — integer — chain id (actions: compose)
  • question — string — question (actions: grade, ref)
  • price_usdc — number — price usdc (actions: compose)
  • answered_by — string — answered by (actions: compose)
  • execution_id — string — execution id (actions: compose)
  • handshake_id — string — handshake id (actions: compose)
  • typesafe_key — string — typesafe key (actions: grade, compose, ref)
  • prepare_digest — string — prepare digest (actions: compose)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_prove read-only

  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.

  Parameters:

  • key — string — key (actions: item)
  • kind — string — kind (actions: item)
  • seqs — array — seqs (actions: item)
  • action — string — what to do (default tx): tx | item | block | superroot | transfer | finality
  • blocks — array — blocks (actions: item)
  • api_key — string — api key (actions: item)
  • tx_hash — string — tx hash (actions: tx, item, transfer)
  • type_id — integer — type id (actions: finality)
  • chain_id — integer — any chain the layer reads (GET /v1/rpc): 8453, 5042, 1, 56, 43114, 42161, 137, 10, 4663, 42220, 36927, 3692781, 2741, 196, 143, 100; another chain answers 404 chain_not_read (actions: tx, item, block, transfer)
  • protocol — string — protocol (actions: item)
  • log_index — integer — log index (actions: item)
  • block_number — integer — Block number on that chain (actions: block)

  Hints: read-only yes · destructive no · idempotent yes · open-world yes

• taifoon_chain

  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.

  Parameters:

  • id — string — block: latest | finalized | a number | a block hash; tx and receipt: the 32-byte transaction hash (actions: lookup, scan)
  • to — integer — to (actions: logs, account)
  • key — string — key (actions: transitions)
  • txs — boolean — block: add the transaction hashes (actions: lookup)
  • from — integer — from (actions: logs, account)
  • kind — string — kind (actions: lookup)
  • view — string — view (actions: account)
  • chain — ['integer', 'string'] — 8453 (Base); "base" works too (actions: query)
  • limit — integer — limit (actions: logs, account, scan, transitions)
  • speed — string — speed (actions: bridge)
  • action — string — what to do (default lookup): lookup | logs | account | scan | rpc | query | transitions | decoders | bridge
  • amount — string — amount (actions: bridge)
  • cursor — integer — cursor (actions: logs, account, scan)
  • method — string — method (actions: rpc)
  • params — array — params (actions: rpc, query)
  • sender — string — sender (actions: bridge)
  • topic0 — string — topic0 (actions: logs)
  • topic1 — string — topic1 (actions: logs)
  • topic2 — string — topic2 (actions: logs)
  • topic3 — string — topic3 (actions: logs)
  • address — string — address (actions: logs, account)
  • api_key — string — api key (actions: lookup, logs, account, scan, rpc, transitions)
  • payment — string — optional: the x402 PAYMENT-SIGNATURE header value (base64) for the terms an unpaid call returns (actions: query)
  • chain_id — integer — any chain the layer reads: 8453, 5042, 1, 56, 43114, 42161, 137, 10, 4663, 42220, 36927, 3692781, 2741, 196, 143, 100 (actions: lookup, logs, account, scan, rpc)
  • from_seq — integer — from seq (actions: transitions)
  • protocol — string — protocol (actions: transitions)
  • question — string — question (actions: query)
  • recipient — string — recipient (actions: bridge)
  • full_proof — boolean — add the multiproof itself (actions: lookup)
  • dst_chain_id — integer — dst chain id (actions: bridge)
  • src_chain_id — integer — src chain id (actions: bridge)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_vault

  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.

  Parameters:

  • days — integer — how long the arm lasts (default 7, at most 30) (actions: arm)
  • armed — boolean — true arms (default), false disarms (always honoured, no expiry rule) (actions: arm)
  • owner — string — the 0x wallet the act installs (link, rotate, recover); omitted for cancel (the current owner) (actions: owner)
  • vault — string — the tenant vault id, vault:tenant:<tenant> (e.g. vault:tenant:tenant-3) (actions: read, arm, owner)
  • action — string — what to do (default read): read | model | policy | receipts | arm | owner
  • params — object — operation parameters, e.g. { "vault": "vault:tenant:tenant-3" } (actions: policy, receipts)
  • api_key — string — your tfr_ key (actions: policy, receipts)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_orderbook destructive

  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.

  Parameters:

  • to — string — the operator wallet (actions: withdraw)
  • qty — string — qty (actions: order)
  • tif — string — tif (actions: order)
  • from — integer — origin chain id (4663 Robinhood Chain, 8453 Base, 42161 Arbitrum One, 1 Ethereum, 5042 Arc) (actions: route)
  • name — string — principal name: [a-z0-9_-], 1..64 (actions: register)
  • side — string — side (actions: order)
  • asset — string — USDG | ETH | WETH | tICP | TRN (actions: route, deposit, withdraw)
  • price — string — price (actions: order)
  • units — string — whole units as a decimal string, e.g. "1.25" (actions: deposit, withdraw)
  • action — string — what to do (default account): account | register | route | deposit | order | withdraw | settlement
  • amount — number — amount (actions: route)
  • market — string — ETH-USDG (actions: order)
  • account — string — the operator wallet the transfer came from (actions: deposit)
  • api_key — string — api key (actions: account, deposit, order, withdraw)
  • fill_id — string — fill id (actions: settlement)
  • tx_hash — string — the transfer transaction (0x… 32 bytes) (actions: deposit)
  • operator — string — the wallet (0x…) that signs; deposits come from it, withdrawals go to it (actions: register)
  • direction — string — direction (actions: route)
  • signature — string — EIP-191 signature over the message; omit to get the exact message to sign (actions: register)
  • signed_at — integer — unix seconds in the message (10-minute window) (actions: register)

  Hints: read-only no · destructive yes · idempotent no · open-world yes

• taifoon_grid

  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.

  Parameters:

  • id — string — status/release: the enclave id (enc_…) (actions: tee, avenues)
  • me — string — your libp2p peer id (base58) — returns your shard, config and command (actions: shards)
  • day — string — YYYYMMDD (UTC); default today (actions: economics)
  • ref — string — Optional: the 0x wallet that referred this resource. It earns a share of what the resource accrues (measured work only). Never the owner itself. (actions: join, node)
  • body — object — body (actions: gpu)
  • gpus — integer — number of cards (default 1) (actions: bench)
  • kind — string — kind (actions: hire, join, node)
  • lane — string — lane (actions: tee)
  • node — string — did:taifoon:z… of one node (actions: economics)
  • note — string — optional, ≤200 chars, stored with the intent (actions: hire)
  • pool — string — Leave it out: the pool is Taifoon's side and is derived on the server (the Taifoon founding pool, fee 0). Kept only for nodes from before 2026-10-11 that still send one; honoured on first registration only. (actions: join)
  • sell — boolean — kind=gpu: true lists the node for sale at the BROKER's market price for its reference class (the rig never names a price; the cheapest other venue, input and output apart, sets it); the node is checked (battery + fingerprint) and owned by your key (actions: join)
  • group — string — group (actions: prices)
  • hirer — string — optional 0x wallet; records the intent in the Grid ledger (actions: ai, hire)
  • hours — integer — hours (actions: tee, hire)
  • model — string — the model the node must serve (e.g. hypernova-60b, littlelamb) (actions: ai, gpu, join)
  • owner — string — 0x wallet address that earns the GRID points (actions: join, economics, node, bench)
  • rules — string — rules (actions: tee)
  • state — string — state (actions: prices)
  • units — integer — how many resources (default 1) (actions: hire)
  • action — string — what to do (default status): status | ai | gpu | tee | hire | join | pool | prices | economics | settlement | avenues | shards | node | bench
  • payout — string — Optional: grid (default, the full rate) or cash (USDC at the TSUL rate, 70 %) (actions: node)
  • prompt — string — your prompt (one user message) (actions: ai)
  • wallet — string — optional 0x wallet (actions: settlement)
  • api_key — string — api key (actions: gpu, tee, hire, join)
  • compose — string — provision/quote: an allowlisted compose id (taifoon-tee-seller) or its file’s sha256; absent = the first on the allowlist (actions: tee)
  • vram_gb — number — VRAM of one card in GB (0 or omitted = no GPU) (actions: bench)
  • chain_id — integer — settlement chain (default 8453, Base — where the assurance contract is live) (actions: ai, join)
  • endpoint — string — endpoint (actions: gpu, join, node)
  • provider — string — optional: a specific measured endpoint from the providers list (actions: ai)
  • resource — string — only avenues for this resource (actions: avenues)
  • reference — string — kind=gpu: the market class your price is checked against (default llama-3.1-8b) (actions: join)
  • collectors — integer — plan for this many collectors instead of the live swarm (actions: shards)
  • replication — integer — collectors per shard (default 2) (actions: shards)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_sell

  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.

  Parameters:

  • id — string — id (actions: protocol)
  • abi — array — abi (actions: protocol)
  • key — string — key (actions: protocol)
  • data — object — { card_url?, endpoints?: [{ url, kind: mcp|a2a|a2a-legacy|x402|webhook }], skills?: [tags], classes?: [class ids], name?, description? } (actions: enrich)
  • docs — string — docs (actions: protocol)
  • name — string — name (actions: protocol)
  • type — string — type (actions: protocol)
  • grade — boolean — also grade the manifest: code verified the facts, Jev answers the rubric over them; spends one of your grades (actions: protocol)
  • hirer — string — hirer (actions: inbox)
  • limit — integer — limit (actions: inbox)
  • nonce — string — nonce (actions: enrich)
  • state — string — state (actions: inbox)
  • action — string — what to do (default register): register | enrich | inbox | protocol | pending
  • author — string — author (actions: protocol)
  • events — array — events (actions: protocol)
  • sla_ms — integer — sla ms (actions: protocol)
  • states — array — states (actions: protocol)
  • status — string — status (actions: pending)
  • actions — array — actions (actions: protocol)
  • dry_run — boolean — dry run (actions: protocol)
  • expires — integer — expires (actions: enrich)
  • fee_bps — integer — fee bps (actions: protocol)
  • version — integer — version (actions: protocol)
  • agent_id — string — agent id (actions: register, enrich)
  • card_url — string — card url (actions: register)
  • chain_id — integer — chain id (actions: register, enrich)
  • finality — string — finality (actions: protocol)
  • identity — string — identity (actions: protocol)
  • provider — string — provider (actions: inbox)
  • contracts — object — chain id to list of 0x addresses (actions: protocol)
  • signature — string — signature (actions: enrich, protocol)
  • fill_topic — ['string', 'null'] — fill topic (actions: protocol)
  • transitions — array — transitions (actions: protocol)
  • source_topic — string — source topic (actions: protocol)
  • fill_selector — ['string', 'null'] — fill selector (actions: protocol)
  • supported_dst — array — supported dst (actions: protocol)

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_observe read-only

  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.

  Parameters:

  • q — string — words or a phrase (actions: search)
  • dst — string — destination chain id (actions: stuck, paths, quote)
  • key — string — path parameter :key (actions: order)
  • ref — string — path parameter :ref (actions: certs)
  • src — string — source chain id (actions: stuck, paths, quote)
  • kind — string — components of one kind (quote, route, settle, release, venue, market-making, agent-tool, payment, read, stream, abi) (actions: lambda_components)
  • chain — string — components serving one caip-2 chain (actions: lambda_components, lambda_golden)
  • limit — string — at most 500 (actions: stuck, search)
  • action — string — what to do (default network): network | stream | order | stuck | paths | quote | projects | lanes | search | owners | twigster | certs | lambda_catalog | lambda_components | lambda_flows | lambda_golden
  • native — string — 1: native only; 0: borrowed only (actions: lambda_components)
  • reason — string — one of the protocol’s reasons (see reasons[]) (actions: stuck)
  • api_key — string — your tfr_ key (optional for keyless reads) (actions: stream, order, stuck, paths, quote, projects, lanes, search, owners, twigster, certs, lambda_catalog, lambda_components, lambda_flows, lambda_golden)
  • protocol — string — path parameter :protocol (actions: order, stuck, paths, quote)

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• taifoon_buy

  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.01 USDC (x402); mcp.digest, sold per call by Taifoon at 0.01 USDC (x402); plan.steps, sold per call by Taifoon at 0.028333 USDC (x402); risk.address, sold per call by Taifoon at 0.01 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).

  Parameters:

  • action (required) — string — the class to buy one call of
  • input — object — the class input (each class lists its example in the action list)
  • payment — string — optional: the x402 PAYMENT-SIGNATURE header value (base64) for this wall's terms

  Hints: read-only no · destructive no · idempotent no · open-world yes

• taifoon_op

  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.

  Parameters:

  • op (required) — string — the operation name, e.g. protocol/:protocol/stuck
  • body — object — the JSON body of a POST
  • method — string — default GET
  • params — object — path and query parameters by name
  • api_key — string — your tfr_ key, for keyed operations (keyless reads need none)

  Hints: read-only no · destructive no · idempotent no · open-world yes

Publisher website

Measured by MCPYP probing. Untested fields are omitted, never estimated. Listing is always free; MCPYP never proxies calls or stores user tokens.