WalletOS

A private banker for the 99%. Talk to your money in natural language - where AI agents move, save, automate, and invest it all under your financial goals and control.

Comment

Inspiration

The wealthiest 1% don't stress about money the way the rest of us do. They have CFOs, wealth managers, and private bankers who proactively move, protect, and grow their money. The other 99% get a balance screen, a transfer button, and "good luck figuring out the rest."

We went to a networking event in San Francisco focused on the agentic economy - companies building the next wave of programmable money, agent-to-agent payments, and financial infrastructure. Walking out, one question stuck with us: if AI agents can now reason and act through financial tools, why does the gap between how rich people and everyone else manage money still exist?

Underbanked users, people living paycheck to paycheck, families sending remittances home, they pay the most in fees, receive the least in advice, and have no one proactively managing their financial lives. Not because the knowledge doesn't exist. Because the help was never accessible.

We built WalletOS to change that

What it does

WalletOS is a private banker for the 99% — an agentic financial copilot that lets anyone talk to their money in plain English, and then actually moves it under rules they define.

You say: "I get paid $2k on the 1st. Send money home to my mom every month, keep rent safe, and invest the rest low-risk — I'm a 3 out of 10 on risk."

WalletOS:

Parses your intent using Claude, extracting goals, amounts, cadence, and risk tolerance. Executes a real on-chain USDC transfer on Base Sepolia — verifiable live on a block explorer — so your family gets paid. Locks a rent-safe bucket so you can't accidentally overdraw rent money. Routes the remainder to the right sub-agent based on your risk score: a Stable-Invest agent for low-risk profiles (1–3), Balanced for mid-range (4–6), Growth for high-risk tolerance (7–10). Explains every decision back to you in plain English — building financial literacy as it works. Say "actually I need $200 back" and it pulls from the right bucket and confirms. Every action is auditable, every tool call is logged, and nothing moves without your stated policy allowing it.

Core features:

Conversational portfolio management — set goals by talking Automated recurring rules — send $50 on the 1st, protect 3 months of rent Agent marketplace — specialized sub-agents (Stable-Invest, Savings, Bill-Pay) you connect, gated by risk score Realtime portfolio events — Redis pub/sub keeps every bucket update live in the UI

How we built it

The architecture has three layers that fit together cleanly:

Reasoning layer — Claude with MCP-style tools

Claude never touches the wallet directly. It only ever acts through six explicit, auditable tools: get_balance, send_payment, set_policy, create_automation, route_to_agent, explain_decision. Each tool handler enforces a spending policy, writes a transaction record, and publishes a realtime event. We run a full Claude tool-use loop: send message + tool definitions → Claude returns a tool_use block → dispatch → return tool_result → repeat → stream final explanation.

This design was deliberate. Jailing Claude inside tool contracts means every money action is reviewable, and the policy layer is the only gatekeeper between "Claude thinks" and "money moves."

Money rail — Coinbase CDP Wallet API on Base Sepolia

We use CDP's server-wallet API to create a named, persistent wallet (demo-banker) programmatically. Funding is fully automated via cdp.evm.requestFaucet() — no website, no captcha, no manual step. Transfers go through account.transfer({ to, amount, token: "usdc", network: "base-sepolia" }) and return a real transaction hash verifiable on sepolia.basescan.org.

Base Sepolia is one config flip (base-sepolia → base) from production mainnet. The architecture is production-ready.

Realtime state — Redis (Upstash) + SSE

Every tool action publishes to a Redis pub/sub channel (channel:events:demo). A GET /api/events SSE endpoint bridges those events to the frontend so the portfolio panel updates live — no polling, no stale state.

Frontend — Next.js 15 App Router + Tailwind + shadcn/ui

Three panels: Chat (the conversational agent), Automations (rule builder), and Agent Marketplace (connect sub-agents by risk tier). The frontend consumes the five API routes (/api/chat, /api/balance, /api/payment/send, /api/agent/route, /api/events) built against a strict JSON contract so both teammates could build in parallel.

Agent marketplace — Fetch AI uAgents

Specialized sub-agents exposed as Fetch AI uAgents, each addressable by a DID. When Claude calls route_to_agent, it selects the right agent based on risk score, sends the funds, and gets back a confirmation event. This is the backbone of the "agentic economy" vision — money routing itself between AI agents without human intermediation.

Challenges we ran into

The CDP Sandbox trap. Coinbase has two completely different products that look similar on the surface: the Payments Sandbox (simulated fiat flows, no real chain) and the CDP Wallet API (real EVM wallets on public testnets). We spent real time figuring out why our faucet calls were failing before realizing we had the wrong product's API key entirely. The confusion cost us time we didn't have at a 24-hour hackathon.

Phone verification on the CDP portal gave us an intermittent "please try again in a few minutes, your funds are safe" error while trying to enable wallet signing. We planned a viem fallback (raw EVM signing with Sepolia USDC), built it out, and then CDP started working — leaving us with two implementations to reconcile.

Making Claude not just talk, but act. The hardest design challenge was constraining Claude's reasoning to operate only through tools — no raw wallet access, no ad-hoc decisions. Getting the tool-use loop right (streaming, multi-turn, policy enforcement before dispatch) required several iterations before money started moving reliably from a chat message.

Agent-to-agent payments with Fetch AI introduced a second runtime (Python microservice) that needed to stay in sync with the Node.js backend over HTTP. Keeping the event schema consistent across two runtimes under time pressure was messy.

"Is this crypto?" We had to find the right framing. Saying "blockchain" in a social-impact pitch risks losing the audience before you've made the point. The reframe: programmable money on testnet — the blockchain is the engine, not the product. We don't pitch Base Sepolia; we pitch "your family gets paid every month without you remembering to send it."

Accomplishments that we're proud of

A real on-chain USDC transfer triggered by a single chat message, verifiable on a public block explorer — not a mock, not a simulation, an actual Base Sepolia transaction hash. Claude reasoning about financial goals and executing multi-step plans through a fully auditable tool layer — policy enforcement, transaction logging, event publishing — all from natural language input. Programmatic testnet wallet funding via requestFaucet — zero manual steps, zero website faucets, zero captchas. The wallet is live the moment you run npx tsx scripts/setup-wallet.ts. The risk-score routing system that maps user-expressed risk tolerance (1–10, in plain English) to the right sub-agent tier — making a concept usually reserved for wealth management onboarding accessible to anyone who can say "I'm a 3 out of 10." A production-ready architecture that is one config line from mainnet. We built for testnet on purpose, but nothing in the codebase assumes it stays there.

What we learned

Programmable money is genuinely new. Traditional banks won't give AI agents API access to move funds autonomously. Blockchain rails — even testnet ones — let you wire up an agent that actually controls money. That's not a crypto pitch; it's an architectural fact that makes the whole product possible.

Tool contracts are the right abstraction for agentic finance. The MCP-style tool layer isn't just good engineering hygiene — it's the only design that's safe for money. Every action being explicit, logged, and policy-gated means you can audit what the agent did and why. Trusting a raw LLM with wallet access would be reckless; trusting a constrained tool dispatcher is defensible.

Financial framing matters more than technical framing. "Base Sepolia USDC transfer" means nothing to a judge evaluating social impact. "Your mom gets paid every month without you remembering to send it" means everything. We learned to build the technical story after the human story is clear.

Two runtimes under time pressure is one too many. The Fetch AI Python microservice was the right architectural call for agent-to-agent payments, but the cross-language event schema synchronization added friction at exactly the wrong moment.

What's next for WalletOS

Mainnet. One line of config separates the demo from production. The real question isn't technical — it's regulatory. We'd pursue partnership with an MSB-licensed operator to handle the compliance layer while WalletOS stays the reasoning and automation stack.

Voice-first interface with Deepgram. "Send money home" should be a sentence you speak, not type. Deepgram's real-time STT/TTS would make WalletOS fully accessible to users who are uncomfortable with financial apps — the exact population most underserved by current tools.

Recurring automations via Orkes Conductor. The automation rules exist in the data model today; making them durable, retryable, and observable at scale needs a proper workflow engine. Orkes lets us define "send $50 on the 1st" as a workflow that survives restarts and failures.

A real Fetch AI agent marketplace. Today we have one Stable-Invest agent stub. The long-term vision is an open marketplace of financial sub-agents — savings optimizers, bill negotiators, remittance routers — each addressable by DID, each transacting autonomously under user-set policies. Agent-to-agent payments on Base with Fetch AI as the coordination layer.

Eval and trust scoring with Arize. As the agent makes more consequential decisions, understanding why it routed a certain way becomes critical for user trust and regulatory defensibility. Arize gives us the observability layer to trace every decision back to the model's reasoning — and to catch drift before it becomes a problem.

Multilingual and low-bandwidth support. The users WalletOS is built for don't all live in San Francisco. SMS-first or USSD-first interfaces, multilingual Claude prompts, and offline-capable transaction queueing are the path to the actual 99%.

Built With

Share this project:

Updates