Skip to main content
The Agent Wallet is @t2000/cli + @t2000/mcp + t2000-skills — one CLI, one MCP server, one skill set. It’s the command surface for the whole stack, not just a wallet:
  • Money (the core) — hold + send USDC/USDsui gasless, swap any Sui token, pay any API per call over x402 (t2 send · swap · pay)
  • Identity — register an Agent ID, claim a handle, look up the directory (t2 agent … · t2 agents)
  • Inference — Private Inference, including trustless receipt verification (t2 chat · models · verify)
The CLI is the human surface (t2 <verb>, everything --json-scriptable); the MCP server is the AI-client surface — the same money, identity, and inference capabilities as tools (raising spending limits stays CLI-only by design); skills are the orchestration playbooks both share.

​
Install

npm install -g @t2000/cli
Requires Node.js 18+. 
t2 init                              # plain Bech32 wallet, 0o600 perms
t2 init --import                     # restore from a suiprivkey1… secret
t2 fund                              # address + ANSI QR to fund the wallet
t2 status                            # health check (wallet, balances, limits, MCP, gateway)
t2 send 5 USDC alice.sui             # gasless USDC send
Every command supports --json for machine-parseable output and --key <path> for a non-default wallet file.

​
Commands

The core loop is four commands:
CommandWhat it does
t2 initCreate the wallet + a free on-chain Agent ID. --import brings an existing secret.
t2 fundThe wallet address + QR — send USDC to it and you’re live.
t2 send <amount> <asset> <recipient>Send USDC / USDsui (gasless) or SUI. Recipient: 0x…, SuiNS name, or @audric handle.
t2 pay <url>Pay an x402-protected API — 402 challenge → USDC payment → response, automatically.
Everything else — swap, history, limits, identity, MCP, skills — is on the CLI Command Reference.

​
Gasless

USDC + USDsui sends and x402 pay are gasless — the Sui foundation sponsors the protocol-level 0x2::balance::send_funds flow. SUI sends and Cetus swaps need gas; keep ~0.05 SUI on hand. Any Sui exchange or DEX will fund the gas balance.

​
Examples

# Fresh wallet → first send
t2 init && t2 fund
# (fund the wallet with USDC from any source)
t2 send 5 USDC alice.sui

# Move a wallet to another machine
t2 export                                    # prints suiprivkey1…
# on the new machine:
t2 init --import                             # interactive hidden-input prompt

# Discover an API service, then pay for it
t2 services search "image"
t2 pay https://mpp.t2000.ai/fal/fal-ai/flux/dev --data '{"prompt":"a sunset"}' --max-price 0.10

# Adjust the default spending limits ($25/tx · $100/day)
t2 limit set --per-tx 50 --daily 200
t2 send 100 USDC alice.sui                   # blocked
t2 send 100 USDC alice.sui --force           # explicit override

# JSON output for scripting
t2 balance --json | jq '.available'
t2 history --json --limit 5

​
Configuration

PathPurpose
~/.t2000/wallet.keyPlain JSON wallet — { version: 2, secret: "suiprivkey1…" }, 0o600 perms.
~/.t2000/config.jsonSpending limits + daily usage (seeded at t2 init: $25/tx · $100/day; t2 limit reset clears).
Env varEffect
T2000_RPC_URLLegacy alias of T2000_GRPC_URL — resolves a custom Sui gRPC base URL (JSON-RPC is retired).
T2000_GRPC_URLCustom Sui gRPC endpoint (defaults to fullnode.mainnet.sui.io). Used during gasless USDC/USDsui send + pay builds.
T2000_GATEWAY_URLOverride the x402 gateway URL for t2 services + t2 pay. Defaults to https://mpp.t2000.ai.

​
MCP Integration

The CLI ships with the t2000 MCP stdio server. t2 mcp install writes the right JSON config for every supported AI client on your machine.
ClientSetupConfig path
Claude Desktopt2 mcp install~/Library/Application Support/Claude/claude_desktop_config.json
Cursort2 mcp install~/.cursor/mcp.json
Windsurft2 mcp install~/.codeium/windsurf/mcp_config.json
Codex / Cline / Continue / any MCP clientManual JSON (below)client-specific
Manual config — paste into your client’s MCP config file: 
{
  "mcpServers": {
    "t2000": {
      "command": "t2",
      "args": ["mcp", "start"],
      "env": { "T2000_API_KEY": "sk-…" }
    }
  }
}
The t2 command must be on PATH — npm install -g @t2000/cli puts it there. The env block is only needed for the inference tools (t2000_chat / t2000_models) — every wallet tool works without it. Get a key per Authentication; after t2 mcp install, add the env block to the generated entry by hand.

​
MCP Tools

ToolTypeWhat it does
t2000_balancereadUSDC / USDsui / SUI holdings + gas reserve + USD totals.
t2000_addressreadWallet’s Sui address.
t2000_receivereadPayment request — address, Payment Kit sui:pay?… URI, optional amount / memo / label.
t2000_historyreadRecent on-chain activity with Suiscan digests.
t2000_servicesreadDiscover x402 services on mpp.t2000.ai. Call before t2000_pay.
t2000_agentsreadLook up registered on-chain Agent IDs in the directory.
t2000_sendwriteSend USDC / USDsui / SUI. asset is required. USDC + USDsui gasless. dryRun: true for previews.
t2000_swapwriteCetus Aggregator V3 swap. Requires SUI for gas.
t2000_paywritePay an x402-protected API. HTTP 402 → quote → USDC payment (gasless) → retry.
t2000_chatreadPrivate inference on Private Inference (OpenAI-compatible). Needs T2000_API_KEY in the server env.
t2000_modelsreadList Private Inference model catalog (id · privacy tier · pricing).
t2000_verifyreadVerify a confidential response by receipt id — signed receipt + trustless on-chain Sui anchor. No key required.
t2000_limitsettingsRead-only. Surface the user’s opt-in caps to the LLM. Setting / clearing flows through CLI (security boundary).
Every skill (below) is also auto-registered as a skill-<name> MCP prompt — one per SKILL.md, including the Sui ecosystem skills (SuiNS · Walrus · DeepBook · Sui gRPC).

​
Security

  • Wallet file is 0o600 — owner read/write only. stdio transport, keys never leave the machine.
  • Every write tool has a dryRun: true preview path.
  • Setting / clearing spending caps requires CLI terminal access (the t2000_limit tool is read-only).

​
Skills

Skills are markdown instruction files your agent reads on demand — decision frameworks, correct patterns, common mistakes. Install per-client: 
# Cursor
npx @t2000/cli skills install --target=cursor

# Claude Code
npx @t2000/cli skills install --target=claude-code

# Codex / Windsurf / agentskills.io
npx @t2000/cli skills install                # default --target=agents

# Vercel Skills CLI (auto-detects the agent)
npx skills add mission69b/t2000-skills

# Claude Code plugin marketplace
# /plugin marketplace add mission69b/t2000-skills
# /plugin install t2000-agent-wallet@t2000-skills
SkillWhat it teaches
t2000-setupEnd-to-end wallet bootstrap (t2 init + optional limits + MCP install). Read first when onboarding a new user.
t2000-check-balanceInspect USDC / USDsui / SUI before any write.
t2000-sendExplicit --asset, gasless USDC / USDsui, SUI sends that need gas.
t2000-receiveAddress share, ANSI QR, Payment Kit sui:pay?… URIs.
t2000-swapCetus Aggregator routing, --quote, slippage, swap-needs-SUI gotcha.
t2000-servicesDiscover x402 services before t2 pay.
t2000-payx402 402 → quote → pay → retry flow.
t2000-verifyVerify a confidential response — t2 verify <receipt> or verify.t2000.ai.
t2000-mcpWire the MCP server into Claude / Cursor / Windsurf.
sui-grpc · suins · deepbook · walrusSui ecosystem reads — chain state over gRPC, name resolution, order-book data, blob storage. Browse by project at agents.t2000.ai.
Each skill is also served as plain markdown at https://t2000.ai/skills/<slug> — curl it or open in a browser. The discovery manifest lives at /.well-known/agent-skills/index.json. Skills + MCP are complementary: skills give the agent context that doesn’t change often (workflows, patterns, gotchas). The MCP server gives it the tools that do change (live balances, fresh quotes, current chain state).

​
At a glance

SurfaceDetail
Wallet filePlain Bech32 JSON at ~/.t2000/wallet.key, 0o600 perms
Sendable assetsUSDC, USDsui, SUI (asset required on every send)
GaslessUSDC + USDsui via Sui foundation’s 0x2::balance::send_funds sponsor
Spending limitsOn by default ($25/tx · $100/day); t2 limit set to adjust; gates CLI and MCP writes
MCP toolsThe table above is canonical — read, write, and settings groups
SkillsOne markdown playbook per task, shipped as skill-<name> MCP prompts
FeesFree at the t2000 layer. Network gas + third-party protocol fees still apply.
The Agent Wallet is intentionally narrow — focused on USDC sends, swaps, and x402 API access. For programmatic access to the same surface, use @t2000/sdk.

​
Programmatic usage

For TypeScript programmatic access — building bots, server apps, or your own consumer surface — use @t2000/sdk: 
import { T2000 } from '@t2000/sdk';

const agent = await T2000.create();
const balance = await agent.balance();
await agent.send({ to: 'alice.sui', amount: 5, asset: 'USDC' });