io.github.mission69b/t2000

t2000 is the infrastructure that powers Audric — conversational finance on Sui. The Audric consumer brand is exactly five products:

• 🪪 Audric Passport — the trust layer. Sign in with Google, non-custodial wallet on Sui in 3 seconds, every write taps to confirm, sponsored gas. Wraps every other product.
• 🧠 Audric Intelligence — the brain (the moat). Five systems orchestrate every money decision: Agent Harness (40 tools), Reasoning Engine (9 guards, 7 skill recipes), Silent Profile, Chain Memory, AdviceLog. Picks the tool, clears the guards, remembers what it told you.
• 💰 Audric Finance — manage your money on Sui. Save (NAVI lend, 3–8% APY), Credit (NAVI borrow, health factor), Swap (Cetus aggregator, 20+ DEXs), Charts (yield/health/portfolio viz). Every action taps to confirm via Passport.
• 💸 Audric Pay — the money primitive. Move money: free, global, instant (on Sui for now). Send USDC, receive via payment links/invoices/QR. No bank, no borders, no fees.
• 🛒 Audric Store — creator marketplace at audric.ai/username. Sell AI-generated music, art, ebooks in USDC. Coming soon.

Five t2000 packages give AI agents and developers everything they need to build the same thing.

const agent = await T2000.create({ pin: process.env.T2000_PIN });

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.swap({ from: 'SUI', to: 'USDC', amount: 10 });  // 20+ DEX routing
await agent.stakeVSui({ amount: 5 }); // liquid staking → vSUI (~3-5% APY)

Packages

Brand Architecture

suimpp.dev     → Protocol (Sui MPP standard, ecosystem, registry)
t2000.ai       → Infrastructure (CLI, SDK, MCP, engine, gateway)
audric.ai      → Consumer product (app, conversational banking)

All npm packages (@t2000/cli, @t2000/sdk, @t2000/mcp, @t2000/engine), the GitHub repo, and gateway domain stay as t2000. Audric is the consumer-facing brand.

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 pay https://api.example.com  # Pay for MPP-protected APIs

How it works

t2000 wraps financial primitives into a single interface:

Gas is invisible — self-funded SUI with sponsored fallback for bootstrap. Multi-step operations execute as single atomic PTBs.

Fees

SDK

import { T2000 } from '@t2000/sdk';

const agent = await T2000.create({ pin: process.env.T2000_PIN });

Full API reference: @t2000/sdk README

Engine — Audric Intelligence (the moat)

@t2000/engine powers Audric — the conversational finance agent. It implements Audric Intelligence, the 5-system moat that makes Audric a financial agent rather than a chatbot. Every action it triggers still waits on Audric Passport's tap-to-confirm.

It wraps the SDK in an LLM-driven loop with streaming, tool orchestration, and MCP integration.

import { QueryEngine, AnthropicProvider, getDefaultTools } from '@t2000/engine';

const engine = new QueryEngine({
  provider: new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY }),
  agent,
  tools: getDefaultTools(),
});

for await (const event of engine.submitMessage('What is my balance?')) {
  if (event.type === 'text_delta') process.stdout.write(event.text);
}

40 built-in tools (29 read, 11 write) with permission tiers, cost tracking, session management, and context window compaction. Includes a reasoning engine (adaptive thinking, guard runner, skill recipes) and a canvas system for interactive in-chat visualizations. Read tools use NAVI MCP and DefiLlama for market data, falling back to the SDK.

Full reference: @t2000/engine README

CLI

# Wallet
t2000 init                         Guided setup (wallet, AI, safeguards)
t2000 balance                      Check balance
t2000 send 10 USDC to 0x...       Send USDC
t2000 receive --amount 25          Generate payment request with QR
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 swap 10 SUI for USDC        Swap any token (20+ DEXs)
t2000 stake 5                      Stake SUI for vSUI (~3-5% APY)
t2000 unstake all                  Unstake vSUI back to SUI
t2000 health                       Health factor
t2000 rates                        Current APYs

# MPP Payments
t2000 pay https://api.example.com  Pay for API resource

# Contacts
t2000 contacts                     List saved contacts
t2000 contacts add <name> <addr>   Save a named contact

# Safeguards
t2000 config show                  View safeguard settings
t2000 config set maxPerTx 500      Set per-transaction 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

MCP Server

Connect Claude Desktop, Cursor, Windsurf, or any MCP client:

t2000 mcp install

Auto-configures Claude Desktop + Cursor. 40 tools mirroring the engine tool set. Safeguard enforced. See the MCP setup guide for details.

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.

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 40+ services (88 endpoints) — OpenAI, Anthropic, fal.ai, Brave, Lob, and more.

Full reference: @suimpp/mpp README

Agent Skills

npx skills add mission69b/t2000-skills

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

Full reference: Agent Skills README

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 operations
• Transaction simulation — dry-run before signing with Move abort code parsing
• Circuit breaker — gas station pauses if SUI price moves >20% in 1 hour

Repository structure

t2000/
├── packages/
│   ├── sdk/              @t2000/sdk — TypeScript SDK (core)
│   ├── engine/           @t2000/engine — Agent engine (QueryEngine, tools, MCP)
│   ├── cli/              @t2000/cli — Terminal bank account
│   ├── mcp/              @t2000/mcp — MCP server (Claude Desktop, Cursor, Windsurf)
│   └── contracts/        Move smart contracts (mpp-sui)
│
├── apps/
│   ├── web/              t2000.ai — developer/infra landing page + docs
│   ├── gateway/          MPP Gateway — proxied AI APIs (mpp.t2000.ai)
│   └── server/           Gas station + checkpoint indexer (api.t2000.ai)
│
├── t2000-skills/         Agent Skills for AI coding assistants
├── spec/                 Product specs, design system
└── .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
pnpm --filter @t2000/engine test
pnpm --filter @t2000/server test

Tech stack

License

MIT