Skip to main content
Glama

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.02

Why 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

save(), borrow(), repay(), withdraw() — four methods

No standard payment protocol

MPP client + gateway — pay per request with Sui USDC

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 command

Use 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 APIs

How 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

NAVI + Suilend (auto-selected)

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

t2000 rebalance — moves savings to highest APY in a single atomic PTB

Payments (MPP)

Pay for API resources with USDC

@t2000/mpp-sui + MPP Gateway

Safeguards

Per-tx and daily limits, agent lock

t2000 config show/set maxPerTx/maxDailySend, t2000 lock, t2000 unlock

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

@t2000/sdk

TypeScript SDK — core library

npm install @t2000/sdk

@t2000/cli

Terminal bank account + HTTP API

npm install -g @t2000/cli

@t2000/mcp

MCP server for Claude Desktop, Cursor, Windsurf

Included with CLI

@t2000/mpp-sui

MPP payment client (Sui USDC)

npm install @t2000/mpp-sui

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

agent.balance()

Available + savings + gas breakdown

agent.send({ to, amount })

Send USDC

agent.history()

Transaction log

Savings

agent.save({ amount })

Deposit USDC to savings, earn APY

agent.withdraw({ amount })

Withdraw from savings (always USDC)

agent.earnings()

Yield earned, daily rate

Credit

agent.borrow({ amount })

Borrow USDC against collateral

agent.repay({ amount })

Repay debt

agent.healthFactor()

Liquidation safety

Info

agent.rates()

Current APYs

agent.positions()

Open DeFi positions

Safeguards

agent.enforcer.getConfig()

Safeguard settings

agent.enforcer.set({ maxPerTx?, maxDailySend? })

Set limits

agent.enforcer.lock()

Lock agent (freeze all operations)

agent.enforcer.unlock(pin)

Unlock agent

agent.enforcer.check(amount)

Check if amount allowed

agent.enforcer.recordUsage(amount)

Record send for daily limit

agent.enforcer.isConfigured()

Whether safeguards are set up

Payments

agent.pay({ url, maxPrice })

Pay for MPP-protected API (auto 402 handling)

Contacts

agent.contacts.list()

List saved contacts

agent.contacts.add(name, address)

Add a contact

agent.contacts.remove(name)

Remove a contact

agent.contacts.get(name)

Get contact address

agent.contacts.resolve(nameOrAddress)

Resolve name → address

Investment

agent.investBuy({ asset, usdAmount })

Buy crypto asset with USD

agent.investSell({ asset, usdAmount })

Sell crypto asset back to USDC

agent.investEarn({ asset })

Deposit invested asset to lending for yield

agent.investUnearn({ asset })

Withdraw from lending, keep in portfolio

agent.investRebalance({ dryRun? })

Move earning positions to better-rate protocols

agent.getPortfolio()

Investment positions + P&L

Strategies

agent.investStrategy({ strategy, usdAmount })

Buy into a strategy (atomic PTB)

agent.rebalanceStrategy({ strategy })

Rebalance to target weights

agent.getStrategies()

List available strategies

Auto-Invest

agent.setupAutoInvest({ amount, frequency, strategy })

Schedule DCA

agent.runAutoInvest()

Execute pending purchases

Sentinel

agent.sentinelList()

Browse active sentinels

agent.sentinelAttack(id, prompt)

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 server

Every 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/send

Method

Endpoint

Description

GET

/v1/balance

Balance breakdown

GET

/v1/earnings

Yield summary

GET

/v1/rates

Current APYs

GET

/v1/health-factor

Health factor

POST

/v1/send

Send USDC

POST

/v1/save

Deposit to savings

POST

/v1/withdraw

Withdraw from savings

POST

/v1/borrow

Borrow USDC

POST

/v1/repay

Repay debt

GET

/v1/events

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.05

The 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 install

Architecture: 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-skills

Works with Claude Code, OpenAI Codex, GitHub Copilot, Cursor, VS Code, Amp, Goose, and 20+ more.

Skill

Trigger

t2000-check-balance

"check balance", "how much USDC do I have"

t2000-send

"send 10 USDC to..."

t2000-save

"deposit to savings", "earn yield"

t2000-withdraw

"withdraw from savings"

t2000-borrow

"borrow 40 USDC"

t2000-repay

"repay my loan"

t2000-exchange

"swap USDC to SUI", "exchange tokens"

t2000-pay

"call that paid API"

t2000-sentinel

"attack a sentinel", "earn bounties"

t2000-rebalance

"optimize yield", "rebalance savings"

t2000-contacts

"list contacts", "add contact"

t2000-invest

"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 tests

Testing

pnpm --filter @t2000/sdk test     # 469 tests
pnpm --filter @t2000/mpp-sui test
pnpm --filter @t2000/server test  # 10 tests

Integration 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, @mysten/sui

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

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/mission69b/t2000'

If you have feedback or need assistance with the MCP directory API, please join our Discord server