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.

Argument	Type	Description
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)

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "tx": {
      "type": "string",
      "description": "the hash of your transfer on that chain (actions: topup)"
    },
    "day": {
      "type": "string",
      "description": "YYYY-MM-DD (UTC) (actions: metrics)"
    },
    "plan": {
      "enum": [
        "builder-99",
        "team-199",
        "protocol-299"
      ],
      "type": "string",
      "description": "plan (actions: topup)"
    },
    "tile": {
      "enum": [
        "demand",
        "catalog",
        "pool",
        "rpc",
        "proof",
        "grade",
        "gpu",
        "bridge"
      ],
      "type": "string",
      "description": "tile (actions: tenant)"
    },
    "usdc": {
      "type": "integer",
      "maximum": 500,
      "minimum": 1,
      "description": "usdc (actions: topup)"
    },
    "view": {
      "enum": [
        "products",
        "package",
        "key",
        "usage",
        "reseller"
      ],
      "type": "string",
      "description": "view (actions: access)"
    },
    "label": {
      "type": "string",
      "description": "a label for the child key (your customer) (actions: reseller_child)"
    },
    "range": {
      "enum": [
        "1d",
        "7d",
        "30d",
        "90d"
      ],
      "type": "string",
      "description": "range (actions: tenant)"
    },
    "action": {
      "enum": [
        "tenant",
        "access",
        "topup",
        "metrics",
        "reseller_child",
        "reseller_earnings"
      ],
      "type": "string",
      "default": "tenant",
      "examples": [
        "tenant"
      ],
      "description": "what to do (default tenant): tenant | access | topup | metrics | reseller_child | reseller_earnings"
    },
    "params": {
      "type": "object",
      "description": "operation parameters, e.g. { \"vault\": \"vault:tenant:tenant-3\" } (actions: reseller_earnings)"
    },
    "series": {
      "type": "integer",
      "maximum": 90,
      "minimum": 1,
      "description": "series (actions: metrics)"
    },
    "window": {
      "enum": [
        "1d",
        "7d",
        "30d",
        "month"
      ],
      "type": "string",
      "description": "window (actions: access)"
    },
    "api_key": {
      "type": "string",
      "description": "api key (actions: tenant, access, topup, reseller_child, reseller_earnings)"
    },
    "chain_id": {
      "enum": [
        8453,
        42161,
        5042,
        143,
        4663
      ],
      "type": "integer",
      "description": "the pay chain; absent = Base (actions: topup)"
    },
    "signature": {
      "type": "string",
      "description": "personal_sign of the quoted message by the wallet that sent the transfer (actions: topup)"
    },
    "markup_bps": {
      "type": "object",
      "description": "your markup in basis points per product id, \"*\" for all, e.g. { \"*\": 1000, \"taifoon.rpc\": 2500 } (actions: reseller_child)"
    }
  },
  "additionalProperties": false
}

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

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

Input schema (JSON)

{
  "type": "object",
  "required": [
    "action"
  ],
  "properties": {
    "input": {
      "type": "object",
      "description": "the class input (each class lists its example in the action list)"
    },
    "action": {
      "enum": [
        "data.onchain_query",
        "mcp.digest",
        "plan.steps",
        "risk.address",
        "agent.directory",
        "inference.metered",
        "market.price",
        "mech.predict",
        "tee.typed.compile"
      ],
      "type": "string",
      "examples": [
        "data.onchain_query"
      ],
      "description": "the class to buy one call of"
    },
    "payment": {
      "type": "string",
      "description": "optional: the x402 PAYMENT-SIGNATURE header value (base64) for this wall's terms"
    }
  },
  "additionalProperties": false
}

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.

Argument	Type	Description
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)

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

Argument	Type	Description
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

taifoon_find

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.

read-only

Argument	Type	Description
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)

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.

Argument	Type	Description
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

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.

Argument	Type	Description
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

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.

Argument	Type	Description
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

taifoon_observe

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.

read-only

Argument	Type	Description
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)

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.

Argument	Type	Description
op*	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)

Input schema (JSON)

{
  "type": "object",
  "required": [
    "op"
  ],
  "properties": {
    "op": {
      "type": "string",
      "description": "the operation name, e.g. protocol/:protocol/stuck"
    },
    "body": {
      "type": "object",
      "description": "the JSON body of a POST"
    },
    "method": {
      "enum": [
        "GET",
        "POST"
      ],
      "type": "string",
      "description": "default GET"
    },
    "params": {
      "type": "object",
      "description": "path and query parameters by name"
    },
    "api_key": {
      "type": "string",
      "description": "your tfr_ key, for keyed operations (keyless reads need none)"
    }
  },
  "additionalProperties": false
}

taifoon_orderbook

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.

destructive

Argument	Type	Description
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)

taifoon_prove

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.

read-only

Argument	Type	Description
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)

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.

Argument	Type	Description
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)

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.

Argument	Type	Description
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

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.

Argument	Type	Description
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

Taifoon coordination layer

Try it

taifoon_account

Taifoon coordination layer

Try it

taifoon_account

Tools (15)