Sato Hub
Developer kit

Sato Kit

Prepare every onchain action, check it against your policy, then execute it by id.

Install the kit

What it guarantees

@satohub/kit sits on top of the libraries your agent already uses (viem, your signer, @x402/*) and splits every write into two steps: prepare, then execute.

  • *_prepare returns an intent_id with a one-sentence summary, the policy verdict, a simulation result and any fee disclosure. Nothing is signed.
  • execute(intent_id) takes only that handle, so the parameters cannot change between approval and signing. An id the kit did not mint, an expired id or one already executed is refused.
  • policy.json holds caps, allowlists and slippage limits. Unknown means refuse, and every refusal names its rule, limit and observed value. The network defaults to a fork; mainnet is an explicit opt-in.
  • Receipts are hash-chained sato.receipt/v1 lines, kept locally, private by default and exportable.
  • Every action declares its custody: whether it reads your key, whether the key leaves, and whether it can move funds on its own.
  • Templates and actions are re-run every night and the results are published on Sato Status.

Pre-flight, not enforcement

The kit’s policy check runs before anything is signed and explains why it refused. It does not hold your key. Enforcement lives in the signer: the same policy.json compiles into a CDP, Privy or Turnkey policy, and any rule a provider cannot express is listed as not compiled, never dropped. OWS’s policy engine or a Safe’s owners work the same way. That is the layer that stops a transaction.

What an agent can do with it

  • Chain reads and transaction simulation on the EVM chains it supports.
  • Swaps and bridges, venue-neutral. Sato Swap is the labelled default and its fee is disclosed on every response, including at zero; a quote with no Sato fee is returned alongside it, and venue: "direct" skips Sato, and its fee, entirely. Sato Route itself always carries its fee on the quote it returns. The schedule: Sato Route swaps cost 3 bps stable-to-stable, 15 bps between majors (a chain's native coin such as ETH or SOL, its wrapped form, or a stablecoin), 75 bps with any other token and 25 bps cross-chain (75 bps when either side is any other token), taken as a parameter on the aggregator's own quote inside the transaction you sign; a failed, reverted or unsigned trade pays nothing. A token launch carries a disclosed share of the creator's LP fee, stated as fee.bps on every launch response, including when it is 0. Sato OS charges 3 / 15 bps on its own spot swap rail and a 3 bps perp builder fee, with no cross-chain tier. Some venues keep a share or pay later, and every quote says which.
  • x402 payments: read what a resource asks to be paid and return a priced, policy-checked intent.
  • ERC-8004 agent lookup and registration.
  • Token approvals: list them, and prepare a revoke.
  • Safe proposals: EIP-712 typed data posted to the Safe Transaction Service; nothing moves until the owners execute.
  • Solana reads, transfers and swaps.

Ways in

  • A library, with subpath adapters for the Vercel AI SDK, AgentKit, the Claude Agent SDK, OpenAI Agents and LangChain, an elizaOS compatibility adapter, and a GOAT adapter that consumes an existing GOAT plugin with the kit’s guarantees.
  • A CLI: read, prepare, execute, doctor.
  • A local MCP server over stdio, with a small default tool profile and every action under --toolsets all.
  • A Skill for coding agents.
  • A hand-off to Sato OS, which can take a prepared intent for a person to approve.
  • create-sato-agent starts a project from a template with the kit already wired.

Honest limits

  • Not a framework or a reasoning loop, not a wallet, not a custodian, and not a replacement for viem or your signer.
  • It never holds funds and ships no keys. Once a key is in play, the kit enforces nothing.
  • execute does not send x402 payments; pay through your x402 client.
  • When a USD value cannot be read, a price cap refuses rather than guessing.
  • A passing simulation says what the chain answered at that block. It is not a promise.
  • Actions consumed through AgentKit still make AgentKit’s own analytics call; the kit neither blocks nor adds to it.

The action format is published as a draft: Onchain Action Descriptor.

Install

npm i @satohub/kit viem

CLI

# check your setup
npx @satohub/kit@0.1 doctor

# quote 5 USDC -> WETH on Base: read-only, no setup, nothing signed
npx @satohub/kit@0.1 read swap.quote --input '{"chain":"base","sell_token":"USDC","buy_token":"WETH","sell_amount":"5000000"}' --json

# prepare a swap for your address, then execute the intent with your signer
export SATO_RPC_URL_BASE=https://mainnet.base.org
npx @satohub/kit@0.1 prepare swap.prepare --input '{"chain":"base","sell_token":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","buy_token":"0x4200000000000000000000000000000000000006","sell_amount":"5000000","taker":"<your 0x address>"}' --json
npx @satohub/kit@0.1 execute --intent <intent_id> --json

Local MCP server (stdio)

claude mcp add sato-kit -- npx -y @satohub/kit@0.1 mcp
{
  "mcpServers": {
    "sato-kit": {
      "command": "npx",
      "args": [
        "-y",
        "@satohub/kit@0.1",
        "mcp"
      ]
    }
  }
}

Start from a template

npx create-sato-agent@0.1 "<your goal>" --framework plain-ts

Which templates and actions passed tonight’s checks: Sato Status. Every template: Agent templates. Repo: satohubai/sato-agent-templates. Source: packages/kit. Rules files for your coding agent live at Agent Instructions.