Provides tools for AI agents to interact with the Sui blockchain to manage a non-custodial bank account, enabling USDC transfers, yield-earning savings via lending protocols, collateralized borrowing, and automated investment strategies.
Your agent can hold money, earn yield, borrow against savings, exchange currencies, and pay for APIs — all in one CLI command. No human in the loop.
// Load existing wallet
const agent = await T2000.create({ pin: process.env.T2000_PIN });
// Or create a new one
const { agent } = await T2000.init({ pin: 'my-secret' });
await agent.send({ to: '0x...', amount: 50 });
await agent.save({ amount: 100 }); // earn ~2–8% APY (auto-selects best rate)
await agent.borrow({ amount: 20 }); // borrow against savings
await agent.repay({ amount: 20 }); // repay debt
await agent.withdraw({ amount: 50 }); // always returns USDC
await agent.investBuy({ asset: 'SUI', usdAmount: 100 }); // invest $100 in SUI (or BTC, ETH, GOLD)
await agent.investSell({ asset: 'SUI', usdAmount: 'all' }); // sell all SUI
await agent.investEarn({ asset: 'SUI' }); // deposit to lending for yield
await agent.investUnearn({ asset: 'SUI' }); // withdraw from lending
await agent.investRebalance(); // move earning to better-rate protocol
await agent.investStrategy({ strategy: 'bluechip', usdAmount: 200 }); // atomic PTB
await agent.setupAutoInvest({ amount: 50, frequency: 'weekly', strategy: 'bluechip' });See it work
❯ t2000 init
Step 1 of 3 — Create wallet
Creating agent wallet...
✓ Keypair generated
✓ Network Sui mainnet
✓ Gas sponsorship enabled
✓ Checking ✓ Savings ✓ Credit ✓ Exchange ✓ Investment
🎉 Bank account created
Address: 0x8b3e...d412
Step 2 of 3 — Connect AI platforms
✓ Claude Desktop configured
✓ Cursor configured
Step 3 of 3 — Set safeguards
✓ Safeguards configured
✓ You're all set
Restart Claude Desktop / Cursor and ask: "What's my t2000 balance?"
❯ t2000 balance
Available: $85.00 (checking — spendable)
Savings: $80.00 (earning 4.86% APY)
Investment: $5.02 (+0.4%)
──────────────────────────────────────
Total: $170.02Why t2000?
AI agents need money. They need to pay for APIs, receive payments, hold funds, and eventually — fund themselves. But today, giving an agent a wallet means teaching it about gas tokens, transaction signing, RPC endpoints, and DeFi protocols.
t2000 makes all of that invisible.
Problem | t2000 Solution |
Agents can't hold money | Non-custodial bank account in one line of code |
Gas tokens are confusing | Auto-managed — agent never sees SUI |
Idle funds lose value | Automatic yield via NAVI + Suilend (~2–8% APY) |
DeFi is complex |
|
No standard payment protocol | |
No standard wallet interface | SDK + CLI + HTTP API for any language |
Getting Started
npm install -g @t2000/cli # Install
t2000 init # Wallet + MCP + safeguards — one commandUse the CLI directly or connect your AI via MCP:
t2000 balance # Check balance
t2000 send 10 USDC to 0x... # Send USDC
t2000 save all # Earn yield on idle funds
t2000 invest buy 100 SUI # Invest $100 in SUI
t2000 exchange 5 USDC SUI # Currency exchange via Cetus DEX
t2000 pay https://api.example.com # Pay for MPP-protected APIsHow it works
t2000 wraps six DeFi primitives into a single interface that any AI agent can use:
Feature | What it does | How |
Checking | Send and receive USDC | Direct Sui transfers |
Savings | Earn ~2–8% APY on idle funds | |
Credit | Borrow USDC against savings | NAVI + Suilend collateralized loans |
Exchange | Swap between any supported tokens | Cetus DEX CLMM pools |
Investment | Buy/sell SUI, BTC, ETH, GOLD with cost-basis P&L | Cetus DEX (spot swaps) |
Investment Yield | Earn yield on invested assets via lending | NAVI + Suilend (auto-selected best rate, auto-rebalance) |
Strategies | Themed allocations (bluechip, all-weather, safe-haven, layer1, sui-heavy) — single atomic PTB | Agent orchestration + Cetus |
Auto-Invest | Dollar-cost averaging (daily/weekly/monthly DCA) | Agent scheduling |
Yield Optimizer | Auto-rebalance across 4 stablecoins |
|
Payments (MPP) | Pay for API resources with USDC | |
Safeguards | Per-tx and daily limits, agent lock |
|
MCP | AI agent banking — natural language | Claude Desktop, Cursor, Windsurf via @t2000/mcp |
Gas is invisible. t2000 handles it automatically: self-funded SUI → auto-topup ($1 USDC → SUI when low) → sponsored fallback for bootstrapping.
All multi-step operations (save with auto-convert, withdraw with auto-swap, rebalance) execute as single atomic Programmable Transaction Blocks (PTBs). If any step fails, the entire transaction reverts — no funds left in intermediate states.
Fees
Operation | Fee | Notes |
Save | 0.1% | Protocol fee on deposit |
Borrow | 0.05% | Protocol fee on loan |
Exchange | Free | Cetus pool fees only; used internally by rebalance/auto-convert |
Withdraw | Free | |
Repay | Free | |
Send | Free | |
Pay (MPP) | Free | Agent pays the API price, no t2000 surcharge |
The self-funding loop
At ~$2,000 supplied, yield from savings offsets typical AI compute costs — the agent becomes self-funding.
Supplied | APY | Monthly Yield | Covers |
$100 | ~8% | $0.67 | — |
$500 | ~8% | $3.33 | Light agent ($3/mo) |
$2,000 | ~8% | $13.33 | Medium agent ($15/mo) |
$10,000 | ~8% | $66.67 | Heavy agent |
Packages
Package | Description | Install |
TypeScript SDK — core library |
| |
Terminal bank account + HTTP API |
| |
MCP server for Claude Desktop, Cursor, Windsurf | Included with CLI | |
MPP payment client (Sui USDC) |
|
SDK
import { T2000 } from '@t2000/sdk';
const agent = await T2000.create({ pin: process.env.T2000_PIN });
// or: const agent = T2000.fromPrivateKey('suiprivkey1q...');Category | Method | Description |
Wallet |
| Available + savings + gas breakdown |
| Send USDC | |
| Transaction log | |
Savings |
| Deposit USDC to savings, earn APY |
| Withdraw from savings (always USDC) | |
| Yield earned, daily rate | |
Credit |
| Borrow USDC against collateral |
| Repay debt | |
| Liquidation safety | |
Info |
| Current APYs |
| Open DeFi positions | |
Safeguards |
| Safeguard settings |
| Set limits | |
| Lock agent (freeze all operations) | |
| Unlock agent | |
| Check if amount allowed | |
| Record send for daily limit | |
| Whether safeguards are set up | |
Payments |
| Pay for MPP-protected API (auto 402 handling) |
Contacts |
| List saved contacts |
| Add a contact | |
| Remove a contact | |
| Get contact address | |
| Resolve name → address | |
Investment |
| Buy crypto asset with USD |
| Sell crypto asset back to USDC | |
| Deposit invested asset to lending for yield | |
| Withdraw from lending, keep in portfolio | |
| Move earning positions to better-rate protocols | |
| Investment positions + P&L | |
Strategies |
| Buy into a strategy (atomic PTB) |
| Rebalance to target weights | |
| List available strategies | |
Auto-Invest |
| Schedule DCA |
| Execute pending purchases | |
Sentinel |
| Browse active sentinels |
| Full attack flow |
Full API reference → @t2000/sdk README
CLI
# Wallet
t2000 init Guided setup (wallet, AI, safeguards)
t2000 balance Check balance
t2000 send 10 USDC to 0x... Send USDC
t2000 history Transaction history
# Savings & DeFi
t2000 save 50 Earn yield (best rate)
t2000 withdraw 25 Withdraw savings (always USDC)
t2000 borrow 10 Borrow USDC against collateral
t2000 repay 10 Repay debt
t2000 rebalance Optimize yield across stablecoins
t2000 exchange 5 USDC SUI Exchange tokens via Cetus DEX
t2000 invest buy 100 SUI Invest $100 in SUI (or BTC, ETH, GOLD)
t2000 invest sell all SUI Sell entire SUI position
t2000 invest earn SUI Deposit SUI to lending for yield
t2000 invest unearn SUI Withdraw from lending, keep invested
t2000 invest rebalance Move earning to better-rate protocol
t2000 invest strategy buy layer1 200 Buy into a strategy (1 atomic tx)
t2000 invest strategy list List available strategies
t2000 invest auto setup 50 weekly bluechip Set up DCA
t2000 invest auto run Execute pending DCA
t2000 portfolio Investment portfolio + P&L
t2000 earnings Yield earned
t2000 health Health factor
t2000 rates Current APYs
# MPP Payments
t2000 pay https://api.example.com Pay for API resource
# Earn (directory)
t2000 earn Show all earning opportunities
# Sentinel (earn bounties)
t2000 sentinel list Browse active sentinels
t2000 sentinel attack <id> "..." Attack a sentinel (costs SUI)
t2000 sentinel info <id> Sentinel details
# Contacts
t2000 contacts List saved contacts
t2000 contacts add <name> <addr> Save a named contact
t2000 contacts remove <name> Remove a contact
# Safeguards
t2000 config show View safeguard settings
t2000 config set maxPerTx 500 Set per-transaction limit
t2000 config set maxDailySend 1000 Set daily send limit
t2000 lock Lock agent (freeze all operations)
t2000 unlock Unlock agent (requires PIN)
# HTTP API (for non-TypeScript agents)
t2000 serve --port 3001 Start HTTP API serverEvery command supports --json for structured output and --yes to skip confirmations.
Full command reference → @t2000/cli README
HTTP API
For agents written in Python, Go, Rust, or any language:
t2000 serve --port 3001
# ✓ Auth token: t2k_a1b2c3d4e5f6...curl -H "Authorization: Bearer t2k_..." http://localhost:3001/v1/balance
curl -X POST -H "Authorization: Bearer t2k_..." \
-d '{"to":"0x...","amount":10}' \
http://localhost:3001/v1/sendMethod | Endpoint | Description |
GET |
| Balance breakdown |
GET |
| Yield summary |
GET |
| Current APYs |
GET |
| Health factor |
POST |
| Send USDC |
POST |
| Deposit to savings |
POST |
| Withdraw from savings |
POST |
| Borrow USDC |
POST |
| Repay debt |
GET |
| SSE stream (yield, balance changes) |
MPP Payments
t2000 supports MPP (Machine Payments Protocol) for paid APIs. When a server returns 402 Payment Required, t2000 automatically pays with Sui USDC and retries — no API keys, no subscriptions, no human approval.
const result = await agent.pay({
url: 'https://mpp.t2000.ai/openai/v1/chat/completions',
body: { model: 'gpt-4o', messages: [{ role: 'user', content: 'Hello' }] },
maxPrice: 0.05,
});t2000 pay "https://mpp.t2000.ai/openai/v1/chat/completions" \
--data '{"model":"gpt-4o","messages":[{"role":"user","content":"Hello"}]}' \
--max-price 0.05The MPP Gateway proxies OpenAI, Anthropic, fal.ai, and Firecrawl — all payable with Sui USDC.
Full reference → @t2000/mpp-sui README
MCP Server
Connect Claude Desktop, Cursor, Windsurf, or any MCP client to your t2000 agent:
t2000 mcp installArchitecture: User → MCP Client (Claude/Cursor/Windsurf) → @t2000/mcp → @t2000/sdk → Sui
Auto-configures Claude Desktop + Cursor. 35 tools · 20 prompts · stdio transport · safeguard enforced. See the MCP setup guide for full instructions.
Agent Skills
Install one package and your AI agent gains financial capabilities:
npx skills add mission69b/t2000-skillsWorks with Claude Code, OpenAI Codex, GitHub Copilot, Cursor, VS Code, Amp, Goose, and 20+ more.
Skill | Trigger |
| "check balance", "how much USDC do I have" |
| "send 10 USDC to..." |
| "deposit to savings", "earn yield" |
| "withdraw from savings" |
| "borrow 40 USDC" |
| "repay my loan" |
| "swap USDC to SUI", "exchange tokens" |
| "call that paid API" |
| "attack a sentinel", "earn bounties" |
| "optimize yield", "rebalance savings" |
| "list contacts", "add contact" |
| "invest in SUI", "buy BTC", "portfolio" |
Full reference → Agent Skills README
Comparison
Feature | Coinbase Agent Kit | t2000 |
Chain | Base only | Sui |
Send / receive | ✓ | ✓ |
Earn yield on savings | — | ✓ NAVI + Suilend (~2–8% APY) |
Borrow / credit line | — | ✓ Borrow against savings + investment collateral |
Exchange / Token swap | ✓ Base tokens | ✓ Cetus DEX (any pair + rebalance) |
Investment (spot) | — | ✓ SUI, BTC, ETH, GOLD with cost-basis P&L |
Yield on investments | — | ✓ Earn lending APY on holdings while keeping price exposure |
Borrow against investments | — | ✓ Deposited investments count as collateral for credit |
Margin trading | — | 🔜 Coming soon — leveraged positions on SUI, BTC, ETH, GOLD |
Strategies + DCA | — | ✓ Atomic PTB multi-asset buys, dollar-cost averaging |
MPP client | ✓ Base / Solana | ✓ Sui · OpenAI, Anthropic, fal, Firecrawl |
Agent Skills | ✓ | ✓ |
Gas abstraction | ✓ Gasless (Base) | ✓ Auto-topup (Sui) |
DeFi composability | — | ✓ Atomic PTB multi-step |
Health factor protection | — | ✓ On-chain enforcement |
Yield Optimizer | — | ✓ Auto-rebalance across 4 stablecoins |
Agent Safeguards | — | ✓ Per-tx + daily limits + lock |
MCP Server | — | ✓ 35 tools + 20 AI advisor prompts |
Security
Non-custodial — keys live on the agent's machine, never transmitted
Encrypted storage — AES-256-GCM with PIN-derived key (scrypt)
Bearer auth — HTTP API requires token generated at startup
Rate limiting — 10 req/s default prevents runaway drain
Risk guards — health factor checks block risky withdrawals/borrows
Transaction simulation — dry-run before signing with Move abort code parsing
Circuit breaker — gas station pauses if SUI price moves >20% in 1 hour
Replay protection — on-chain nonce enforcement via Sui Payment Kit
Repository structure
t2000/
├── packages/
│ ├── sdk/ @t2000/sdk — TypeScript SDK (core)
│ ├── cli/ @t2000/cli — Terminal bank account
│ ├── mcp/ @t2000/mcp — MCP server (Claude Desktop, Cursor, Windsurf)
│ └── mpp-sui/ @t2000/mpp-sui — MPP payment client
│
├── apps/
│ ├── gateway/ MPP Gateway — proxied AI APIs (mpp.t2000.ai)
│ ├── server/ Gas station + checkpoint indexer
│ └── web/ Landing page + docs (Next.js)
│
├── t2000-skills/ Agent Skills for AI coding assistants
├── infra/ AWS ECS deployment scripts
└── .github/workflows/ CI/CD (lint → typecheck → test → deploy)Development
git clone https://github.com/mission69b/t2000 && cd t2000
pnpm install
pnpm build
pnpm typecheck # TypeScript across all packages
pnpm lint # ESLint
pnpm test # All unit testsTesting
pnpm --filter @t2000/sdk test # 469 tests
pnpm --filter @t2000/mpp-sui test
pnpm --filter @t2000/server test # 10 testsIntegration tests run real transactions on Sui mainnet and require a funded wallet. See each package README for details.
Tech stack
Layer | Technology |
Chain | Sui (mainnet) |
Contracts | Move (treasury, admin, fee collection) |
SDK | TypeScript, |
CLI | Commander.js, Hono (HTTP API) |
DeFi | NAVI + Suilend (lending), Cetus CLMM (swaps) |
Web | Next.js 16, Tailwind CSS v4, React 19 |
Infra | AWS ECS Fargate |
CI/CD | GitHub Actions |
License
MIT