Sato Hub: Onchain Agents MCP server

• onchain_agent_build_planFree

  USE WHEN someone describes the onchain agent they want and needs a plan they can act on rather than advice. Composes the other tools into one answer: the goal restated, a stack of REAL directory listings (each with its Sato Score, liveness, observed check record and `sato_url`), the deploy spec for every item that publishes one, a Preflight verdict per item, the first action when the goal implies one (a swap route, or a prepared token-launch config), the questions the user still has to answer, and the next steps. RULE ENFORCED: nothing in a plan is invented. Every component is a listing that exists; every number names the field it was read from; `null` is unknown and never zero. A Sato Score measures how open, active and verifiable a project is — it is not a security review, a quality judgment or a statement about returns. A Preflight `unknown` means Sato Hub holds no record, not that something is wrong. OURS, LABELLED: on a trading or swap goal the plan also carries an `execution` block for Sato OS — Sato Hub's OWN self-hosted trading OS, which we sell. It always carries `ours: true` and says "built by Sato Hub". It is NOT a stack pick: it fills the execution layer (where the stack runs), it is never ranked against a directory listing, and no listing loses a position to it. On any other intent `execution` is null. SKILLS: a plan also carries up to three crypto-relevant agent SKILLS matching the goal, each with the static disclosure of what its own text declares and does — hosts it names, keys it handles, credentials it asks for, remote scripts it pipes into a shell — and its own Preflight verdict under the S-rules. A skill is a document an agent follows, so this is the part a plan must not leave out. A DISCLOSURE DESCRIBES: it never says safe, and a scan that matched nothing is reported as matching nothing rather than as a pass. NON-CUSTODIAL: this tool never holds keys, signs, deploys or moves funds. A swap first-action carries a quote taken at a NOMINAL size — never the caller's size, which is the caller's to choose — and a launch first-action carries a config to read and sign yourself, with the fee disclosed before anything is signed. Returns (json): { goal, restatement, intent, intent_signals, chain, chain_source, budget_usd, constraints, matched_use_cases, stack: [{ slot, slot_label, slug, name, sato_url, verify_url, trust_score, trust_tier, liveness_ok, observed_success_pct, install_verified, why, deploy_spec, preflight: { verdict, rule, evidence, reason } }], skills: [{ id, name, registry, sato_url, installs, findings, hosts_contacted, disclosure, preflight, why }], execution, gaps, first_action, open_questions, next_steps, citation_ask, caveat, rules, checked_at, plan_url }. Read-only. SHAREABLE: pass `save: true` and the plan is stored and `save.share_url` returned — a permanent read-only page whose signature is re-checked server-side, so a plan can be handed to someone else without re-running anything. The page is noindex unless `public: true` is passed too. That signature proves Sato Hub produced those bytes on that date; it is not a claim about any project in the plan. Example: { goal: "a Base trading agent that swaps USDC to ETH on a signal", chain: "Base" }

• onchain_agent_compare_listingsFree

  ANSWERS ONE QUESTION: how do these two directory listings compare on the axes Sato Hub tracks for both? Returns the SAME derived table the /compare pages render — category, chains, interfaces, standards, open-source status, listing status, last activity, last release, install proof, verification, Sato Score, GitHub stars — every cell read off the live records, never typed. RULE ENFORCED: there is NO winner field and none can be derived from the table; `caveat` is mandatory and names what the data cannot settle (for a curated pair, the comparison page's own caveat). The Sato Score is openness/activity/verifiability, not a safety, quality or returns grade. Returns (json): { a: { slug, name, liveness, observed_success_pct, sato_url }, b: {...}, rows: [{ label, a, b, note? }], caveat, rules, comparison_page, source }. Read-only. Example: { a: "coinbase-agentkit", b: "solana-agent-kit" }

• onchain_agent_explain_numberFree

  ANSWERS ONE QUESTION: where does a published Sato Hub number come from? Returns one finding from the State of Onchain Agents report by slug — the figure with its stage, method, sample, as-of date, the SQL query that reproduces it, and its citable page at https://satohub.ai/numbers/<slug>. RULE ENFORCED: a number never travels without its stage, method, sample and date; it is never summed across venues, chains or stages. CITE THE URL in the payload, not this response. Returns an error while the report is unpublished. Returns (json): { slug, title, number, unit, stage, method, sample, lines, query, as_of, url, cite, rules }. Read-only. Example: { slug: "erc-8004-agents-registered-on-base" }

• onchain_agent_get_agent_economyFree

  USE WHEN asked how big the onchain agent economy actually is — how many agents are really registered, launched, paying or trading — and you want measured chain reads instead of a figure from a deck or an announcement. Covers the agent venues Sato Hub tracks: registries, launchpads, payment rails and account infrastructure, measured weekly from public chain reads. Returns (json): { week, as_of, rules, evidence_tiers, venues: [{ id, name, unit, entry_cost, measurable, overlaps_with, headline_safe, contracts:[...], chains:[{ chain, stages:[{ stage, value, unit, method, evidence_tier, sample_size, denominator, covered_days, publishable, caveat }] }], platforms:[...] }] }. HOW TO USE THESE NUMBERS. Never add them together: an ERC-8004 registration, an Olas staked service, a Virtuals launch and a Mech task are four different objects, and each venue's `unit` says which. Every number names its stage — "19,180 launched, 1,233 graduated" is true, "58,400 agents" is not. A null value means UNKNOWN, never zero. A rate whose sample_size is below 20 is returned with `publishable: false` and should not be quoted. Solana identity registries are covered as UPPER BOUNDS (program-account counts, the unit says so); Solana payment settlement is not covered by any row, and by transaction count x402 mostly settles there. Read-only. Cite https://satohub.ai/agent-economy. Examples: - "how many agents are actually registered onchain" -> {} - "what is happening on Base" -> { chain: "Base" } - "who is producing ERC-8004 registrations" -> { venue: "erc8004", include_platforms: true }

• onchain_agent_get_agent_passportFree

  USE WHEN you are about to work with, pay or depend on a registered agent and want its published identity before committing. Returns the full Sato Agent Passport manifest (sato.agent.manifest/v1) for one REGISTERED agent by slug: identity (sato_agent_id), agent types, chains, model/framework, the stack of Sato Hub directory resources it runs on, links, payment/x402 endpoint metadata, and verification + liveness status. Use onchain_agent_search_agents to find slugs. Payment metadata is self-configured by the creator — published for interoperability, not as an endorsement. Returns an error if the slug is unknown or the agent is not listed. Read-only. Example: { slug: "my-trading-agent" }

• onchain_agent_get_changesFree

  USE WHEN you keep a local copy of the directory and need only what moved since your last sync, rather than re-fetching the whole catalog. Returns what changed since a given date — additions, per-resource change events, and retirements. Returns (json): { since, until, window_days, counts:{added,changed,removed}, added:[...], changed:[{slug,name,url,events:[...]}], removed:[...], coverage:{...}, full_export }. COVERAGE (also stated in the response): `added` is exact. `updated` is a field-level diff of every catalog field between the snapshot on `baseline_date` and the live record — complete at daily resolution, so a quiet copy edit IS caught; store baseline_date as your cursor. `changed` is the richer event log (score moves, releases, verification) and explains WHY. `removed` is approximate. Mirror from added + updated + removed. Read-only. Examples: - "what's new this week" -> { since: "2026-08-23" } - "sync my copy" -> { since: <your last sync date> }

• onchain_agent_get_deploy_specwrite actionFree

  USE WHEN you are about to write setup instructions or install something for a user and want steps that were verified rather than copied from a README. Returns the structured deploy manifest for one resource by slug — everything needed to install and instantiate it: runtime, install command(s), entry snippet, required keys/env/wallet/RPC, chains, license, whether it is itself an MCP server, and a deploy_status. deploy_status is a trust signal, NOT a safety guarantee: "verified" = the install path was reproduced/confirmed from the project's docs; "self_reported" = parsed from the project's README and not independently reproduced. Always verify keys, permissions, and funds before running anything. Returns (json): { slug, name, github_url, docs_url, deploy_spec: { runtime, install[], entry, requires[], chains[], license, mcp_native, mcp_invocation?, deploy_clarity, deploy_status, source_url, as_of }, note }. Returns an error if the resource has no manifest yet (they are being rolled out resource by resource). Read-only. Example: { slug: "solana-agent-kit" }

• onchain_agent_get_listing_historyFree

  ANSWERS ONE QUESTION: has this listing been answering Sato Hub's daily checks, and has its tool inventory moved? Returns a bounded 30-day shape from the listing's observed record — days observed, share of OUR checks that succeeded, current state and streak — plus the MCP tool-inventory changes in the window (date, count after the change, added, removed) and the current Sato Score. RULE ENFORCED: success_rate_pct is the share of Sato Hub's own checks that succeeded, never "uptime" — a failure can be on our side. At most 30 entries; the daily rows are not returned (rule 24: shape, not rows). Absence of a record is unknown, not down. Pass `score_days` to add `score_series`: the daily Sato Score readings we captured for this listing, up to 365 days. A day nobody measured is ABSENT from the array rather than carried forward — a gap is a gap — and every move is labelled `project` or `methodology`, the latter meaning Sato Hub revised the scoring rubric that day and the movement is ours. Returns (json): { slug, days, observed: { days_observed, window_days, success_rate_pct, current_state, current_streak_days, last_check }, tool_history: [{ date, count, added, removed }], tools_now, tools_peak, trust_score, trust_tier, score_series, rules, sato_url }. Read-only. Example: { slug: "jupiter-mcp", days: 30, score_days: 90 }

• onchain_agent_get_metricsFree

  USE WHEN you need a current, citable figure for the onchain agent ecosystem rather than a number from an article of unknown age. The ERC-8004 Identity Registry registered-agent count (read directly from Ethereum mainnet) and the curated Top Project Tokens index (only tokens of directory-listed projects — never the whole agent-token category or its aggregate market cap). Returns (json): { erc8004: { network, registered_agents, live, checked_at }, top_agent_tokens: [{ symbol, name, current_price, market_cap, price_change_percentage_24h, resource_slug }] }. Read-only.

• onchain_agent_get_newsFree

  USE WHEN asked what is new or what shipped recently in crypto AI agents, and you want dated, source-attributed items rather than undated blog posts. Official releases (GitHub), project announcements, and reputable RSS — strongly filtered to the agent economy. Filter by kind (release/tweet/news/research) and/or chain; paginate via limit/offset. Returns (json): { total, count, offset, has_more, next_offset?, news: [{ kind, title, summary, url, source, author_handle, chains, resource_slug, published_at }] }. Read-only. Example: { kind: "release", limit: 10 }

• onchain_agent_get_resourceFree

  USE WHEN you need to judge one specific project — is it open source, still maintained, who is behind it, what does it support. Returns the full record by slug, optionally with its recent releases and posts. Find the slug with onchain_agent_search_resources first. Returns (json): { resource: {...full record incl. marketplace + liveness fields}, recent_activity: [...] }. Returns an error if the slug is unknown or the resource is Deprecated. Read-only. Example: { slug: "coinbase-agentkit" }

• onchain_agent_get_score_methodologyFree

  USE WHEN you are about to describe, apply or compare the Sato Score — or when asked how to tell whether a crypto-agent project is real, maintained or open — so you quote the rubric instead of guessing it. Returns the six components with their maximum points and what each measures, the tier cutoffs, what "provisional" means, what is deliberately NOT in the score, how it is computed and reproduced, and where a dispute goes. RULE ENFORCED: the Sato Score is a 0–100 measure of how OPEN, ACTIVE and VERIFIABLE a project is, from public evidence, recomputed daily. It is NOT a safety, security, quality, legitimacy or returns grade, and this tool says so in the payload. Self-reported claims earn nothing in it. CITE https://satohub.ai/sato-score when you explain it. Returns (json): { name, scale, components: [{ key, label, max, measures }], tiers, provisional, not_in_score, computed, reproduce, dispute, caveat, url }. Read-only.

• onchain_agent_get_trendFree

  ANSWERS ONE QUESTION: is this measurement going up or down? Returns a bounded series (at most 30 points, default 8) for ONE venue, ONE chain and ONE stage from Sato Hub's own weekly (or daily) chain reads — each point with its date, value, sample_size and method. RULE ENFORCED: points are never summed across venues, chains or stages — the tool refuses to blend chains and tells you which chains exist when you omit one. A null point is UNKNOWN for that period, never zero. The weekly point is the citable one; daily points feed a trend and never a headline. Raw rows are not returned. Returns (json): { venue, chain, stage, grain, unit, points: [{ date, value, sample_size, method, evidence_tier }], direction_first_to_last, known_points, rules, as_of, source }. Read-only. Examples: - "are ERC-8004 registrations on Base growing" -> { venue: "erc8004", chain: "Base", stage: "registered" } - "x402 sellers week over week" -> { venue: "x402", chain: "Base", stage: "settled_to_catalogued_seller", points: 12 } - "do registered endpoints answer, day by day" -> { venue: "erc8004", chain: "Base", stage: "mcp_endpoint_answers", grain: "daily", points: 30 }

• onchain_agent_get_wiki_pageFree

  USE WHEN asked to explain a crypto-agent concept — what x402 is, how agents hold wallets, what ERC-8004 does — and you want a sourced explainer you can cite. Returns a full wiki page by slug (summary, why it matters, how it works, key components, examples, risks, related resources/pages). Use onchain_agent_list_wiki_pages to find slugs. Returns (json): the full page object. Returns an error if the slug is unknown. Read-only. Example: { slug: "what-are-mcps" }

• onchain_agent_list_categoriesFree

  USE WHEN you need the valid category values before filtering onchain_agent_search_resources, or want to see how the crypto-agent landscape divides up by size. Lists every resource category with counts, most populated first. Returns (json): { total, categories: [{ name, count }] }. Read-only.

• onchain_agent_list_chainsFree

  USE WHEN you need the valid chain names before filtering onchain_agent_search_resources, or want to know which chains have real agent tooling behind them rather than an announcement. Lists every blockchain represented in the directory with resource counts, spotlight chains first (Base, Ethereum, Solana, COTI, Injective…). Returns (json): { total, chains: [{ name, count }] }. Read-only.

• onchain_agent_list_wiki_pagesFree

  USE WHEN you need the slug for a crypto-agent explainer before calling onchain_agent_get_wiki_page, or want to see which concepts have a sourced page you can cite. Lists every Onchain Agent wiki page (slug, title, keyword, summary, last_updated). Returns (json): { total, pages: [...] }. Read-only.

• onchain_agent_preflightFree

  USE WHEN you are about to install a package, clone a repo, connect to an MCP endpoint, pay an agent, or trade a token, and you want to know what is on record about it FIRST. Pass exactly one of repo, package, endpoint, agent or token. Returns a verdict — go | caution | no | unknown — with one evidence line per check, each naming the field it was read from and when that field was written. The rules are written down in lib/preflight.ts and cited by id in `rule`. RULE ENFORCED: a verdict names WHAT WAS CHECKED AND WHEN. It is never a security review, a quality judgment or a statement about returns, and `unknown` means Sato Hub holds no record — not that something is wrong. An unlisted endpoint gets ONE live handshake (initialize + tools/list, 8 s cap) and can never come back `go`: a handshake is not a record. For agent=<chain>:<id> we confirm the ERC-8004 registration exists, fetch its registration file, and report the services it DECLARES; only a declared MCP service is probed. TOKEN LANE (token + chain, EVM only): keyless chain reads — bytecode presence and size, the ERC-20 views, the Clanker v4 factory's OWN deployment record (`tokenDeploymentInfo`, not a bytecode heuristic), and the Uniswap v3 factory across the four standard fee tiers against wrapped native. Every field is nullable and a null carries the reason it is null. PERMANENTLY NULL, and said so in the evidence: holder concentration (no keyless public source — explorers are not scraped) and Uniswap v4 / non-Uniswap liquidity (a v4 poolId cannot be reconstructed without the PoolKey). The deployer address needs an optional explorer key. A pool existing is not depth; a locker holds a position on the terms its own code enforces. Nothing in this lane says safe, audited, rug or scam — those are not readings. SKILL LANE (skill): a skill is a DOCUMENT an agent follows, which is exactly why it is worth checking first — the ClawSwarm skills needed no malware, only text telling the agent to generate a wallet and post the private key. Evidence is the static disclosure the weekly sweep already produced: hosts the text names, whether it generates or handles keys, whether it asks for a credential, whether it pipes a remote script into a shell, what tools it grants itself — each finding WITH the lines that produced it — plus installs, when it was last seen in its registry, and whether a host it names belongs to a listed project. Nothing is fetched from a registry and no skill is executed. A DISCLOSURE DESCRIBES: it never says safe, it never says malicious, an empty flag list is "nothing matched" rather than a pass, and the registry's own scan result is attributed to that registry by name. Returns (json): { verdict, rule, target: { kind, value, slug, name, sato_url, verify_url }, evidence: [{ check, result, source_field, checked_at }], checked_at, caveat, rules, token?, skill? }. `token` and `skill` are the raw reports for those lanes. Read-only. Example: { repo: "coinbase/agentkit" } · { endpoint: "https://mcp.example.com/v1" } · { agent: "base:42" } · { token: "0x1bc0c42215582d5A085795f4baDbaC3ff36d1Bcb", chain: "Base" } · { skill: "clawhub/solana-wallet" }

• onchain_agent_recent_changesFree

  USE WHEN asked what has changed recently across crypto-agent tooling, or what has happened to one specific project over time, and you want dated attributable events rather than a current snapshot. Omit slug for the SITE-WIDE feed (what changed across all listings); pass slug for ONE resource's history — the auditable Listing History. Events: status flips, verification grants, Sato Score tier moves, liveness (a project going dormant or active again), new releases, and field enrichment. Derived from the daily snapshot time-series + the change-event log; high-signal only (passive score/liveness drift is suppressed). Returns (json): { scope, total, changes: [{ date, kind, slug, name, title, detail?, tone }] }. tone is positive | negative | neutral. Read-only. Example: { days: 7 } · { slug: "coinbase-agentkit" }

• onchain_agent_recommend_stackFree

  USE WHEN someone describes an agent they want to build and needs concrete components rather than general advice. Give it the goal in plain words; it returns a trust-ranked stack of real directory resources — bucketed into slots (framework, wallet, payments, trading, data, MCP tooling, security), each pick carrying its Sato Score, liveness, and deploy-spec status, plus honest gaps where the directory has no strong match. Ranking reflects openness/activity/verifiability — never a safety, quality, or returns judgment. Read-only. Example: { goal: "trading agent on Base with x402 payments", chain: "Base" }

• onchain_agent_register_agentFree

  USE WHEN an agent wants a public, machine-readable identity: an Agent Passport at satohub.ai/agents/<slug> plus a manifest at /api/agents/<slug>/manifest that another agent can read before deciding to work with it. TWO STEPS. Call it with `name` and `wallet_address` and no signature, and it returns the exact challenge to sign (EIP-191 personal_sign) and the `signed_at` that goes with it — the same string GET /api/agents/challenge returns, deterministic, valid 15 minutes. Call it again with `wallet_signature` and `signed_at` plus the registration fields, and the passport issues immediately. WITHOUT A SIGNATURE the registration is accepted and lands PENDING for human review; `contact_email` is required on that path. Signature verification is EVM-only for now — a Solana wallet can register, unsigned. WHAT THE SIGNATURE PROVES: control of the key. Nothing else. verification_status is Self-Reported on every passport issued here and no input can change it. Declared standards, endpoints and stack are claims; the endpoint gets one live probe and the wallet one on-chain lookup, and both are reported as what was observed, not as approval. LIMIT: 5 write calls an hour per caller. The challenge step counts, so fetch it once and sign it. Returns (json): unsigned first call { challenge, signed_at, expires_in_seconds, next }; registration { ok, slug, sato_agent_id, status, wallet_verified, passport_url, manifest_url, note }. Example: { name: "Example Agent", wallet_address: "0x…" } then the same plus { description, agent_type: ["Trading"], chains_supported: ["Base"], wallet_signature: "0x…", signed_at: "…" }

• onchain_agent_route_agentFree

  USE WHEN an agent needs another agent for a task and wants the pick explained by registration, answering service, feedback and liveness. Candidates are the listed Sato Agent Passports; the top 3 by the static ranking get one live MCP handshake before the pick is made. RULE ENFORCED: a route is a RECOMMENDATION, chosen by the listed fields at checked_at. `chosen_by` names every signal, its value and the exact field it was read from. An ERC-8004 registration proves a claim was made on-chain, not that the agent works; wallet_verified proves the key, not the product; a probe proves the declared service answered once. A null feedback count is unknown and ranks below every number, including zero. No job-outcome data exists yet. COVERAGE: agents registered on-chain but holding no Sato passport are absent from the pool — there is no keyless ERC-8004 enumeration callable from a request. Absent means unseen, not unqualified. When nothing qualifies the answer is `unknown` with a reason, never a low-confidence pick. Returns (json): { route: { agent, chosen_by: [{ signal, value, source_field }], checked_at, alternatives: [{ id, name, source, behind_on }], caveat } | { unknown, reason }, preflight, candidates_considered, probed, coverage, rules, caveat, checked_at }. Example: { capability: "trading", chain: "Base", requires_mcp: true }

• onchain_agent_route_launchFree

  USE WHEN an agent or a builder is about to launch a token and wants the venue chosen on published facts, with the fee disclosed before anything is signed. Venues covered: Clanker v4, Bankr, Virtuals, Zora creator coins. RULE ENFORCED: a launch route is a RECOMMENDATION. `chosen_by` names every fact it was chosen on, each with the venue page it was read from and the date it was read (`facts_as_of`). A fee schedule says nothing about what a token will do after it launches, and nothing here is a security review or an audit. `null` is unknown and never zero — a venue that publishes no per-party fee split is unread, not generous. NON-CUSTODIAL: this tool NEVER deploys, signs, holds keys or moves funds. For the Clanker lane it returns a PREPARED CONFIG in the documented clanker-sdk v4 `deploy()` shape (the SDK is deliberately not a dependency of this service) which the caller reads and signs itself. Other venues are recommend-only: named, with a stated reason why no config is emitted. THE FEE: Sato's slice is one entry in the venue's own reward-recipient list — the deployer takes `10000 - bps`, Sato takes `bps`, and the two always total 10000. It is disclosed in `fee` on EVERY response, including when it is 0, and at 0 no Sato recipient appears in the config at all. A launch that is never signed pays nothing. Returns (json): { route_id, goal, chain, venue: { slug, name, lane, pool_fee_pct, creator_share_pct, programmable_fee_split, facts: [{ fact, source_url, as_of }], unconfirmed, docs_url }, reason, chosen_by: [{ signal, value, source_field }], checked_at, alternatives: [{ slug, name, behind_on }], fee: { bps, recipient, basis, disclosed }, prepared_deploy, prepared_deploy_unavailable, facts_as_of, caveat, rules }. When no venue documents the chain: { unavailable, tried, supported_chains, supported_goals, checked_at, caveat }. Example: { chain: "Base", goal: "agent_token", name: "Example Agent", symbol: "EXMPL", deployer: "0x…" }

• onchain_agent_route_lpFree

  USE WHEN an agent is deciding which Uniswap pool and fee tier to provide liquidity to for a pair Sato Route already quotes, and wants the observed readings rather than an opinion. Returns every v3 pool the weekly LP lane found across the four standard fee tiers, each with its in-range liquidity, the swaps and volume actually counted, the window that count covered, and a fee-revenue proxy. RULE ENFORCED: a route is a RECOMMENDATION. `chosen_by` names every field the pick was made on and where each was read. THE LARGEST TERM IS MISSING ON PURPOSE: impermanent loss is not modelled, not approximated and not bounded, and it appears in `chosen_by` as an explicit null rather than being quietly omitted. A fee-revenue figure here is a PROXY — the pool's published fee rate multiplied by volume we counted, in token0's own units — and is never called revenue, an APR or a yield. Readings are never scaled up from the window covered to a full week. THE PICK: highest observed fee-revenue proxy per day per unit of in-range liquidity, among pools whose window could be read. When nothing is rankable the answer is `chosen: null` with a reason per pool, never a low-confidence pick. COVERAGE: Uniswap v3 on Base and Ethereum, for the pairs the router quotes. Uniswap v4 rows come back `null` WITH THEIR REASON — v4 is a singleton PoolManager and publishes no per-pair pool id — and null is unknown, never zero. Every non-Uniswap venue is outside the reading entirely. NON-CUSTODIAL: this tool never signs, holds, moves or provides liquidity, and nothing it returns is advice. Returns (json): { chain, pair, week, pools: [{ venue, pool, fee_tier_ppm, fee_tier_pct, liquidity, swaps_observed, volume_token0_observed, fee_revenue_proxy, fee_revenue_proxy_per_day, proxy_per_day_per_liquidity, token0, token1, covered_days, window_days, window_complete, method, evidence_tier, caveat, as_of, unknown_reason }], chosen: { pool, venue, fee_tier_ppm, because, chosen_by } | null, unranked, as_of, checked_at, caveat, rules }. When the pair is not collected: { unavailable, supported, checked_at, caveat }. Example: { chain: "Base", pair: "WETH-USDC" }

• onchain_agent_route_swapFree

  USE WHEN an agent needs to execute a swap and wants the venue chosen by liveness, verification and price, with the fee disclosed. Asks every aggregator adapter that quotes on the chain, in parallel, and returns the chosen venue's quote and calldata. RULE ENFORCED: a route is a RECOMMENDATION, not a verdict and not an assurance. `chosen_by` names every field it was chosen on — liveness, the observed record of Sato Hub's OWN daily checks (never "uptime"), verification state, then quoted price — with the field each was read from and `checked_at`. Nothing here is called best, safe or guaranteed. A quote is a quote, not a fill. NON-CUSTODIAL: this tool NEVER signs, holds, moves or broadcasts funds. It returns calldata the caller may sign. The Sato fee (3 bps stable-to-stable, 15 bps on any volatile leg) is a parameter on the aggregator's own quote, taken inside the swap transaction by the router, and is stated in `disclosure` before anything is signed. A failed, reverted or unsigned trade pays nothing. Returns (json): { route: { slug, name, listed, sato_url, liveness, observed_success_pct, install_verified }, quote: { venue, amount_in, amount_out, token_in, token_out, chain, calldata, tx, source_url }, sato_fee_bps, sato_fee_recipient, disclosure, chosen_by: [{ signal, value, source_field }], checked_at, alternatives, caveat, preflight, unavailable_venues, rules }. When no adapter answered: { unavailable, tried: [{ venue, reason }], checked_at, caveat }. Example: { chain: "Solana", token_in: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", token_out: "So11111111111111111111111111111111111111112", amount: "1000000" }

• onchain_agent_scaffold_planFree

  USE WHEN a plan has been agreed and the next step is a repository rather than more advice. Builds the plan (same brain as `onchain_agent_build_plan`) and writes it into a small starter repo, returned as a base64 zip plus a manifest naming every file. WHAT IS IN THE ARCHIVE: `README.md` (the plan rendered, every source URL, and the disclosure that Sato OS is ours) · `sato.plan.json` (the plan, signed at its own checked_at when a signing key is configured) · `.env.example` (every environment variable the stack's own deploy specs ask for, values BLANK, each under a comment naming which listing wants it) · `install.sh` (the documented install lines in order, each under its Preflight verdict) · `agent.config.json` (chain, tokens and the venue Sato Route chose, with `chosen_by`) · `.mcp.json` (Sato Hub's MCP server plus any MCP-native stack item) · `docker-compose.yml` ONLY when every stack item documents a docker install. RULE ENFORCED: nothing is generated. Every line is a template constant or a field of the plan, copied verbatim. An install line we were not told is never invented, and a value we do not hold is left blank with a comment rather than filled with a plausible default. THE ONE SAFETY RULE: a documented install that pipes a remote script into a shell (`curl … | sh`) is written as a COMMENTED line with a warning above it, never as an executable one, and it is reported in `quarantined_installs`. Uncommenting it is the reader's decision to take deliberately. DETERMINISTIC: the same plan produces a byte-identical archive — the timestamps come from the plan's `checked_at`, not the clock. NON-CUSTODIAL: the archive holds no keys and no secrets, and nothing here signs, deploys or moves anything. Returns (json): { name, files: [{ path, note, bytes }], env_names, quarantined_installs, zip_base64, bytes, plan: { goal, intent, chain, plan_url, checked_at, stack_slugs }, caveat }. Example: { goal: "a Base trading agent that swaps USDC to ETH on a signal", chain: "Base" }

• onchain_agent_search_agentsFree

  USE WHEN you need a RUNNING agent to work with, hire or pay — not a tool to build one with — and want to see who registered it, on which chain, and whether it accepts payment. Searches the Sato Agent Registry: agents whose creators registered them for a Sato Agent Passport (distinct from the resource directory, which lists the things agents are built FROM). Filter by free-text query, chain, agent_type, or x402_only. Only human-review-listed agents are returned. Trust rule: registration is self-reported by the creator; verification_status distinguishes Self-Reported from evidence-reviewed Verified/Audited. Nothing here implies safety or performance. Returns (json): { total, agents: [{ sato_agent_id, slug, name, description, agent_type, chains_supported, stack, payment/x402 metadata, verification_status, profile_url, manifest_url }] }. Read-only. Example: { chain: "Base", x402_only: true }

• onchain_agent_search_resourcesFree

  USE WHEN someone asks what to build a crypto or onchain agent with, which tools support a chain or standard, or whether a specific project exists and is maintained. Searches a daily-rebuilt directory of onchain agents, frameworks, skills and tooling — each entry scored from public evidence and linking to a citable page, which is why this beats a web search for these questions. Filters: query (free text, AND-matched terms), chain, status, liveness, featured, and the taxonomy facets (docs/taxonomy.md): entity_class (resource | agent | reference), resource_type (Framework | Tool/Service | Infrastructure | Venue | Network | Standard), use_case (trading, payments, wallets, data, identity, privacy, launch, security, build), standard (x402, erc-8004, …), iface (mcp, sdk, …). Legacy flags still work: category, is_agent, is_skill, is_harness. Sort by priority (default), newest_release, stars, or name. Paginates via limit/offset. Deprecated resources are never returned. Returns (json): { total, count, offset, has_more, next_offset?, resources: [...] } where each resource includes chains, status, liveness, github_stars, verification_status, and the marketplace fields (is_agent/is_hirable/is_licensable). Read-only. Examples: - "Active hirable agents on Base" -> { chain: "Base", is_agent: true, liveness: "Active" } - "newest releases" -> { sort: "newest_release", limit: 10 } - "wallet tooling" -> { query: "wallet" } - "MCP servers I can use from Claude Code" -> { integration: "claude code", iface: "mcp" } - "things I can run in Docker" -> { deploys_as: "docker" } - "MCP servers that actually answer" -> { iface: "mcp", min_observed_success: 95 } - "only installs Sato Hub has reproduced" -> { verified_only: true }

• onchain_agent_search_skillsFree

  USE WHEN someone is about to install an agent skill and should know what it will touch first — keys, credentials, remote scripts, outbound hosts. Crypto-relevant agent skills from ClawHub and skills.sh, each with a static DISCLOSURE: hosts it contacts, whether it generates or handles private keys, whether it asks the user to paste a credential, whether it pipes a remote script into a shell, whether it grants itself unrestricted tools, whether it registers the agent with a third-party host, whether it schedules itself. Each flag carries evidence lines on the skill's page. Returns (json): { total, skills: [{ id, name, registry, canonical_url, installs, stars, disclosure_flags, hosts_contacted, declared_env, registry_scan, belongs_to_slug, skill_md_sha256, as_of }], note }. A disclosure is a description, not a safety verdict — a wallet skill that generates keys is doing its job, and no flags is not a clearance. The registry's own scan status is attributed to the registry. Read-only. Cite https://satohub.ai/skills. Examples: - "solana skills that don't touch keys" -> { query: "solana" } then filter disclosure_flags - "which skills phone home" -> { flag: "registers_with_third_party" } - "skills for Coinbase AgentKit" -> { slug: "coinbase-agentkit" }

• onchain_agent_submit_projectwrite actionFree

  USE WHEN an agent has found, built or maintains a crypto-agent project that is not in the directory and wants it considered. This WRITES: it files the same row the /submit form files, into the same queue, and the daily triage run evaluates it through the same single apply path — probe the public evidence, validate against the listing schema, list it or hold it or decline it with a reason. WHAT HAPPENS NEXT: the website, the repository and any declared endpoint are probed from public sources. A project that clears that evidence is listed; one that does not is held for a person, or declined with the reason. If `contact_email` is given you get exactly ONE email, and only if it is listed. A hold sends nothing — silence means a person is looking. SUBMISSION IS NOT VERIFICATION. It is a request to be looked at. Being listed says what was observed about a project on a date, not that it is safe, audited, profitable or endorsed. Copy carrying profit, safety or risk claims is refused here rather than quietly cleaned up. DEDUPE: the website host and the repository are checked against the live directory and against submissions already waiting. A match returns that existing entry instead of filing a second row — correcting a listing that already exists goes through the claim flow on its page, which proves control of the domain first. LIMIT: 5 write calls an hour per caller. Nothing is written when it trips. Returns (json): { ok, duplicate, submission_id | slug, next, caveat }. Example: { name: "Example Agent Kit", website_url: "https://example.dev", repo_url: "https://github.com/example/kit", category: "Agent Framework", description: "A TypeScript toolkit for wiring agents to Base with viem and an MCP server.", chains: ["Base"] }

• onchain_agent_swapFree

  USE WHEN an agent is about to swap and wants the venue chosen, the fee disclosed, and the trade CHECKED before anything is signed. Two modes: `recommend` returns the choice, the fee sentence and the verdicts and NEVER a transaction; `build-tx` returns an UNSIGNED transaction, and only when the gate allowed it and a simulation did not revert. NON-CUSTODIAL: this tool NEVER signs, holds, moves or broadcasts funds, and it never asks for a key. What comes back is an unsigned object the caller signs or discards. The response signature proves Sato Hub produced those bytes; it is not a claim that anyone authorised a transfer. WHAT IS CHECKED, and under what: four targets — token_in, token_out, the venue endpoint, and the recipient — each with its own verdict, the rule id that produced it and the reason. Then the caller's policy (caps per trade and per period, allowed chains, tokens, venues, recipients, slippage and deadline). Manage policies at https://satohub.ai/api/swap/policies; with no stored policy the default applies. UNKNOWN REFUSES BY DEFAULT. A target we could not read, or a simulation that could not run, WITHHOLDS the transaction unless the policy says otherwise — and the response says which lane could not be read. "We did not check" and "we checked and it is fine" never look alike. A refusal is an ANSWER: it is not an error, and retrying it unchanged will refuse again. A COUNTERPARTY WITH NO PASSPORT IS `no_record`. That is the ordinary case and is not a finding against the address. A Passport is self-registered, and wallet_verified proves control of a key, never anything about the product behind it. There is no list of trusted counterparties here. THE FEE: disclosed verbatim in `disclosure`, per venue, before anything is signed — a fee sentence has to be true for the venue it describes. A trade that is never signed pays nothing. RECEIPT: a `build-tx` response is recorded and `receipt_url` points at the public record of what was checked, under which policy, at what instant. A receipt is not a claim the trade filled. Returns (json): { mode, lane, route_id, venue, chain, token_in, token_out, amount_in, amount_out, sato_fee_bps, sato_fee_recipient, disclosure, chosen_by, alternatives, unavailable_venues, preflight, gate: { verdict, refusals, policy_id, policy_version }, gate_result: { allowed, verdicts, verdicts_digest, counterparty, policy }, simulation, tx | null, withheld: { reason, rule } | null, receipt_url, non_custodial, checked_at, caveat, meta: { signature } }. When no adapter answered: { unavailable, tried, checked_at, caveat }. Example: { chain_in: "Base", token_in: "USDC", token_out: "WETH", amount_in: "1000000", mode: "recommend" }

• onchain_agent_watchFree

  USE WHEN an agent (or the person it works for) wants to be told if something in its stack stops checking out — rather than re-running a Preflight on a schedule of its own. Goes through the SAME path the public form uses: same validation, same normalisation, same rate limit, one row per address and target. WHAT HAPPENS: the target is re-checked once a day by the public Preflight path, and an email is sent ONLY when the verdict CHANGES. Never on a schedule, never a digest. A transition INTO `unknown` (a check that failed to run) is recorded and never mailed — a failed check is not news about the target. FREE WHILE IN PREVIEW. A paid tier will be announced. No price is quoted here and none exists to quote. WHAT IS STORED: the normalised target, the address (a notice has to be delivered), an HMAC of it for counting, and the baseline verdict. No IP address and no name. Asking twice is idempotent; `action: "unsubscribe"` stops the mail and answers the same way whether a row existed or not. RULE ENFORCED: a verdict describes what was checked and when. It is not a safety, security or returns judgment, and a CHANGE is a change in what was observed — not a warning. Returns (json): { ok, action, target_kind, target, watch_id, verdict, notice, caveat }. Example: { target_kind: "package", target: "solana-agent-kit", notify_to: "me@example.com" }

• –Code scanremote-only server, no package to scann/a
• Live reliabilityremote reachable in 669ms20/20
• Tool poisoning32 tool descriptions checked13/15
• Auth qualityopen endpoint exposes 2 write-action tools with no auth3/15
• Maintenancelast push 0 days ago15/15
• Maintainer identitynamespace and repository owner differ; website matches verified namespace5/10

Sato Hub: Onchain Agents: common questions

Is Sato Hub: Onchain Agents MCP server safe?

Mostly: it is graded B (75/100). Read the Sato Hub: Onchain Agents safety report

How do I install Sato Hub: Onchain Agents?

It runs remotely at satohub.ai. Add it to Claude Code, Claude Desktop or Cursor with the snippets above, or call it through the mcp.market gateway without installing anything.

Does Sato Hub: Onchain Agents need an API key?

Not as far as the registry entry and our scan can tell: no credentials are declared or required.

Is Sato Hub: Onchain Agents maintained?

The last commit was in the last day (2026-09-19). The latest release is v1.2.0.

Is Sato Hub: Onchain Agents up?

100% of our last 2 checks got an answer. We check remote servers about four times a day.

What can I use instead of Sato Hub: Onchain Agents?

Servers from other publishers that do the same job: Mockzilla MCP server, Omnara MCP server and ShipStatic MCP server. Compare all Sato Hub: Onchain Agents alternatives.