ShroudFi — The private agentic economy on Base

Why it matters

Human privacy tools don’t fit agents.

Existing stealth-address wallets were designed for occasional, human-initiated transfers. Autonomous agents break those assumptions on every axis.

High-frequency, on-chain

Agents transact constantly. Address reuse over hundreds of operations turns the ledger into a complete, queryable strategy log — clusterable in seconds with a single graph query.

Strategy is the asset

For a trading or yield agent, the edge is the on-chain behaviour. Leaking the transaction graph leaks the alpha to anyone watching — competitors, MEV searchers, dashboards.

No human in the loop

There’s no operator clicking “new address”. Privacy has to be programmatic, gasless, and free of UX friction — or it never gets used.

What agents do with ShroudFi

The agentic economy — on private rails.

x402 stealth payments unlock payment graphs that today don’t exist on-chain — because publishing them would burn the agent’s edge before the first call.

Agent-to-agent commerce

One agent calls another’s HTTP endpoint. The seller returns 402. The buyer signs USDC, the seller broadcasts the settlement into a fresh stealth address, the body unlocks. No shared identity, no routing graph.

Metered AI services

Sell inference, signals, scraped feeds, or compute per-call. Each customer pays into an unlinkable address; revenue lands at the operator’s sweep destination without exposing who-paid-whom.

Treasury & payroll

Disburse to contributors or sub-agents without publishing the payroll graph. Gasless ETH + ERC-20 sweeps mean destinations never need to pre-hold gas.

Universal agent surface

Three ways to wire it in.

Pick the surface that matches your stack. The cryptography is identical underneath — only the integration shape changes.

any TS / JS agent loop

TypeScript SDK

The most direct path. createShroudAgent wires identity, transport, scanning, and sweeps. Drop it into a viem / wagmi loop and call the four ops your agent needs.

Zero framework assumptions — works with any TS agent stack
Fully typed; ESM + CJS dual-build
Deterministic identity from a master seed (same meta-address across SDK / MCP / REST)

agent.tstypescript

import { createShroudAgent } from '@shroud-fi/agent-runtime'
import { payX402 } from '@shroud-fi/x402'

const agent = await createShroudAgent(({ chain: 'base' })
await agent.register()

// agent-to-agent payment via x402
const signal = await payX402(({
  agent, url: 'https://api.alpha.xyz/signal',
  maxPriceUsdcAtomic: 10_000n
})

Claude Code · Cursor · Windsurf · Zed

MCP server

Drop @shroud-fi/mcp-server into any MCP host. Your agent gains 9 tools — register / send / send_to_wallet / receive / sweep / balance / status / x402_pay / x402_serve — callable from inside the runtime.

Stdio for local install (one .mcp.json entry)
HTTP transport with EIP-191 challenge-response for shared infrastructure
Same identity resolution as SDK + REST — one master seed, one meta-address

.mcp.jsonjson

{
  "mcpServers": {
    "shroudfi": {
      "command": "node",
      "args": [
        "node_modules/@shroud-fi/mcp-server/dist/esm/bin/stdio.js"
      ],
      "env": {
        "SHROUDFI_PRIVATE_KEY_FILE": "/abs/path/agent-eoa.key",
        "SHROUDFI_CHAIN": "base",
        "SHROUDFI_RPC_URL": "https://base-mainnet.g.alchemy.com/v2/<key>",
        "SHROUDFI_MASTER_SEED_FILE": "/abs/path/master.seed"
      }
    }
  }
}

Python · Go · Rust · any language

REST API

Hit api.shroudfi.live — or self-host the Fastify app from apps/api. 7 v1 endpoints mirror the MCP tool set. OpenAPI 3.1 schema generates clients in any language; TypeScript + Python clients ship in-repo.

EIP-191 challenge-response auth (same flow as MCP HTTP)
Rate limits + log-privacy gates baked in
50-line Python sample agent in the repo

x402_buy.pypython

import httpx, os
from eth_account import Account
from eth_account.messages import encode_defunct

API = "https://api.shroudfi.live"
acct = Account.from_key(os.environ["AGENT_PK"])

ch = httpx.post(f"{API}/v1/auth/challenge",
    json={"wallet": acct.address}).json()
sig = acct.sign_message(
    encode_defunct(text=ch["message"])).signature.hex()

print(httpx.post(f"{API}/v1/x402-pay",
    headers={
      "x-shroudfi-wallet": acct.address,
      "x-shroudfi-nonce": ch["nonce"],
      "x-shroudfi-signature": "0x" + sig,
    },
    json={"url": "https://api.alpha.xyz/signal",
          "maxPriceUsdcAtomic": "10000"}).json())

Editor / runtime names are referenced for compatibility. ShroudFi is independent and works with any EVM agent stack.

The privacy layer for autonomous agents.