Build with HUSH.

Coming to npm · meanwhile run from source: github.com/bigrceo/hush/tree/main/packages

Give your agent a wallet that pays privately. The MCP server plugs HUSH into Claude, Cursor or Claude Code. Read-only tools work with no key; buying needs an agent key from the app.

claude mcp add hush --env HUSH_AGENT_KEY=hush_... -- npx -y hush-mcp

{ "mcpServers": { "hush": { "command": "npx", "args": ["-y", "hush-mcp"],
  "env": { "HUSH_AGENT_KEY": "hush_..." } } } }

Python. hush-agents has no dependencies: list the shop, buy within the leash, run the privacy check.

pip install "git+https://github.com/bigrceo/hush.git#subdirectory=packages/hush-py"

from hush_agents import HushClient
hush = HushClient()   # HUSH_AGENT_KEY
r = hush.buy("liquidity-check", "<mint>")
print(r["paid"]["signature"], r["result"]["data"])

Sell your own endpoint. hush-x402 is the same middleware this site runs, standalone: your secret, your RPC, your one-time addresses.

import { sell } from "hush-x402";

export const GET = sell(
  { secret: process.env.HUSH_SECRET!, rpcUrl: process.env.RPC_URL,
    price: "0.001", resource: "/api/forecast", seller: "forecast-lab" },
  async () => Response.json({ tomorrow: "sunny" }),
);

Every buy pays the seller's price plus a 1% facilitator fee and the Robinhood Chain gas for each transfer (reserved at an upper bound, the unused part is credited back). The facilitator fee stays in the HUSH pool, booked to the protocol fee account; half of it funds the $HUSH buyback & burn.

Holder tiers switch on once the token is live on Pons (NEXT_PUBLIC_TOKEN_ADDRESS set): on every buy HUSH then reads the agent owner's $HUSH balance on-chain (cached 60 s) and discounts the fee. ≥ 100k $HUSH: −10% · ≥ 1M: −25% · ≥ 5M: −50% · ≥ 10M: no facilitator fee. The buy response returns facilitatorFee and tier; the app shows your tier. A failed or refunded call never keeps the fee.

1. Open the app, connect MetaMask, Rabby or Coinbase Wallet, sign in. 2. Create an agent, copy its API key. 3. Fund it with ETH from your wallet. 4. Allowlist a seller and press Buy. The agent gets a 402, pays a one-time address, and the gate serves the answer.

curl -X POST https://<host>/api/agent/buy \
  -H "x-agent-key: hush_…" -H "content-type: application/json" \
  -d '{"listing":"market-brief"}'

Agents and x402 indexers can find every paid endpoint without reading the site. /.well-known/x402 is the JSON catalog: resource URL, input, price, network and privacy scheme for each Agent Shop and self-serve listing. /llms.txt is the same list in plain text for LLMs.

curl https://<your-domain>/.well-known/x402
curl https://<your-domain>/llms.txt

A call without payment gets 402 and an accepts array, x402 style. HUSH adds extra.legs: one stealth payTo per seller, derived from the gate secret and a fresh nonce, plus a signed quote.

{ "x402Version": 1, "accepts": [{
  "scheme": "exact", "network": "eip155:4663", "currency": "ETH",
  "asset": "native", "maxAmountRequired": "3000000",
  "extra": { "privacy": "stealth-one-time-payee", "quote": "eyJ2Ijox…",
    "legs": [{ "seller": "oracle.hush", "amount": "1000000", "payTo": "8sQ2…" }, …] } }] }

The client pays every leg in one transaction, then retries with X-PAYMENT: base64url({quote, signature}). The gate re-derives each address, reads the transaction over RPC, checks amounts, asset, expiry and replay, and serves.

Framework-agnostic: it wraps any (Request) => Response. Next.js route handlers, Hono, Workers, Bun.

import { hushGate } from "@hush/gate";

export const GET = hushGate({
  resource: "/api/forecast", price: "0.001", currency: "ETH", seller: "forecast-lab",
  secret: process.env.HUSH_SECRET!, rpcUrl: process.env.RPC_URL!,
  network: "eip155:4663",
  onReceipt: (r) => saveReceipt(r),
}, async () => Response.json(await forecast()));

Composite: pass legs: [{ seller, amount }, …] instead of price. Each leg is paid with its own ETH transfer; send one tx hash per leg in signatures.

Funds sit on the one-time address, which only the gate can sign for. If your handler throws or returns non-2xx, the gate refunds the payer (ETH) from the stealth key and answers 502 with the refund signature. Sellers sweep settled addresses on their own schedule.

Each agent gets a deposit address funded by its owner; deposits are swept into the shared HUSH pool and credited to the agent's balance in an internal ledger. Every buy is paid from a pool address, never from the agent's own, so the agent and the seller are not linked on-chain (deposits into HUSH, amounts and timing stay visible; the pool is custodial). Before any payment the server checks: kill switch (agent and owner-wide), allowlist, per-call cap, daily budget. The check runs twice, against the list price and against the seller's actual 402. Owners edit limits with a wallet-signed session (personal_sign).

A stdio MCP server ships in mcp/server.mjs. Tools: hush_shop, hush_buy, hush_wallet, hush_receipts.

{ "mcpServers": { "hush": { "command": "node", "args": ["/path/to/hush/mcp/server.mjs"],
  "env": { "HUSH_URL": "http://localhost:4048", "HUSH_AGENT_KEY": "hush_…" } } } }

Every verified call yields a receipt. Publicly only its commitment sha256(nonce|signature|payer) exists. Hush Score (0 to 1000) weighs success rate, latency and refund rate, and lists the epoch roots its receipts live in. Owners see full receipts of their own agents.

Private, but verifiable. Unsealed receipts are rolled into an epoch every hour: leaf = sha256("hush-leaf-v1:" + commitment), node = sha256(0x01 | left | right), an odd node carries up. The root is anchored on Robinhood Chain as calldata of a 0-value self-transaction signed by the publisher key (/api/publisher):

HUSH receipts root v1 <epoch> <root> <leafCount>

Owners download a proof per receipt from the app (GET /api/receipts/:nonce/proof): commitment, leaf, Merkle path, epoch, root and anchor tx. /verify recomputes the root in your browser, reads the memo from Robinhood Chain and checks the signer. No other receipt is revealed. Epoch roots are public at /api/epochs. This is hashing plus on-chain anchoring; there is no zero-knowledge proof involved.