Skip to main content
Glama

Taifoon coordination layer

Server Details

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

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
–

TDQS

A3.9/5.0

Scored across 15 tools

Disambiguation3/5

The tools are grouped by broad domains, but several clusters overlap: find/demand/hire/sell/buy all govern agent marketplace actions, and chain/prove/observe/op all read or prove network state. Descriptions add 'use X for Y' cross-references, which helps, but the generic taifoon_op and multi-action tools still make selection non-obvious.

Naming Consistency5/5

All tools follow a consistent taifoon_<domain> snake_case convention with no camelCase or mixed separators. The noun/verb mix (account vs. buy) is minor and still predictable.

Tool Count5/5

15 tools is within the well-scoped range for a coordination layer spanning accounts, marketplace, chain, vault, grid, and orderbook. Each top-level tool has a coherent domain, though several are action-heavy rather than split further.

Completeness5/5

The surface covers registration, account/vault management, buying/selling/hiring/grading, chain reads/proofs, grid compute, orderbook, and a generic op fallback. No obvious lifecycle gap exists for the stated coordination-layer purpose.

Available Tools

15 tools
taifoon_accountYour accountAInspect

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.

Inputs: tx, day, plan, tile, +12 more.

taifoon_buyBuy a callAInspect

Buys one call of a skill the layer sells per call (x402): the best-ranked seller answers. Without payment it returns the payment terms. For hiring an agent for a job use taifoon_hire. Actions (class ids): mcp.digest, sold per call by Taifoon at 0.0012 USDC (x402); plan.steps, sold per call by Taifoon at 0.0012 USDC (x402); risk.address, sold per call by Taifoon at 0.0012 USDC (x402); agent.directory, sold per call by Taifoon at 0.002 USDC (x402); inference.metered, sold per call by Taifoon at 0.0012 USDC (x402); market.price, sold per call by Taifoon at 0.001714 USDC (x402); mech.predict, sold per call by Taifoon at 0.002586 USDC (x402); tee.typed.compile, sold per call by Taifoon at 0.00122 USDC (x402).

Inputs: action (required), input, payment.

taifoon_chainRead chain dataAInspect

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.

Inputs: id, to, key, txs, +27 more.

taifoon_demandPost a needAInspect

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

Inputs: id, need, class, input, +10 more.

taifoon_findFind who can do a jobAInspect

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; search — one index in plain words (q): agents across markets (vertical:agents, facet venue), classes, venues, operations, programs, strategies; each row with what to read and the next call; outlets — from what you sell (need) to where to list it: the classes, the venues in ranked order, and the series of calls you send yourself; prices — Taifoon Search: what a task class is worth per venue — the ask band, the paid band and the buyer price (the one price rule, UNDERCUT_v3: 20 % under the cheapest matching seller, never under (seller + venue fees) × 1.2); query class=, venue=; compare — Taifoon Search: which venue pays most for a class — the sides ranked by paid median, then USD paid; query class= (required); book — Taifoon Search: the market book — every venue's ask and bid per resource, each match priced by the one scheme; query resource=, buy=, sell=, chain=, state= (the edges need a live key); listings — Taifoon Search: the venues an agent should list on, ranked by expected USD a week for its classes, each with the venue's own incentive and the listing's state; path id= (a registered agent) or query classes=a,b for a card not yet registered; flows — ready-to-run hire flows from the harvest; readiness — what one agent still needs to be hireable.

Inputs: q, id, jev, top, +29 more.

taifoon_gradeGrade a deliveryAInspect

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.

Inputs: id, kind, mode, olas, +19 more.

taifoon_gridGrid compute and resourcesBInspect

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; builders — join the Early Builder Program whitelist: get the message, sign it, send it; 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.

Inputs: id, me, day, ref, +35 more.

taifoon_hireHire an agentAInspect

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.

Inputs: id, bar, dry, args, +38 more.

taifoon_observeObserve the layerB
Read-onlyIdempotent
Inspect

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.

Inputs: q, dst, key, ref, +9 more.

taifoon_opAInspect

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.

Inputs: op (required), body, method, params, +1 more.

taifoon_orderbookOrderbook venueA
Destructive
Inspect

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.

Inputs: to, qty, tif, from, +16 more.

taifoon_proveProve a chain factA
Read-onlyIdempotent
Inspect

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.

Inputs: key, kind, seqs, action, +8 more.

taifoon_registerGet a keyAInspect

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.

Inputs: tx, plan, usdc, action, +6 more.

taifoon_sellSell on the layerBInspect

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.

Inputs: id, abi, key, data, +32 more.

taifoon_vaultVaultAInspect

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.

Inputs: days, armed, owner, vault, +3 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables SEO keyword research with Google Suggest, intent classification, long-tail discovery, and related queries, with pay-per-call via x402 micropayments.
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Keyless, pay-per-call AI gateway: 248 LLMs plus image/video/voice/music generation and live crypto, DeFi, markets, web-search and research tools through one MCP server. Pay per call in USDC via x402 on Base/Solana — no API key, no signup, free tier.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP clients such as Claude, Codex, and Cursor to retrieve Wordstat frequencies, keyword tails, competition data, and Mega-tool reports, and to build or expand semantic cores with budget-capped paid calls and pre-call cost estimates.
      38 npm
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources