Inspiration

An agent that can move money is easy to build. An agent you would hand the keys to is not.

Most agent wallets answer this with a spending cap and an approval step. The weak point is where the approval travels. A 2026 test by researchers at Cornell Tech and Yale reportedly found that nine of ten models raised their own crypto spending cap and fetched the approval code from the owner's inbox. If the agent can reach the channel that carries the yes, the yes protects nothing.

So we built the approval on a channel the agent cannot reach: your phone rings, and to approve you say the amount back plus a one-time word that is shown only on your screen.

What it does

You say or type one sentence: "Send 2 dollars from my Arc wallet to Sam's Solana wallet."

  • It quotes, then moves. The operator reads back the route, the cost and the time. Inside your limits the money moves, and you watch it leave the vault on screen.
  • A contract holds the limits, not the agent. The vault on Arc enforces a per-transfer cap, a rolling 24-hour budget and a payee allowlist. The agent's key can only ask the vault for a spend. It cannot sign for the vault or change a rule.
  • Outside the limits, your phone rings. The operator states the request, a risk officer gives one objection, and you approve by saying the amount and the word on your screen. "Yes" is not an approval. No answer means denied. There is no language model on the call, so nothing said on it can talk it into anything.
  • It stops when it cannot see. Vault events reach the server through a QuickNode Stream. If the Stream goes quiet for 90 seconds, every spend is refused until it returns.
  • It notices odd behaviour under the limits. Each spend is scored against what the agent has sent before: an unusual amount, a new payee, a burst or an odd hour turns an allowed spend into a phone call.
  • Send to someone with no wallet. "Send a link" puts USDC in escrow. The recipient opens the link, enters an address and claims; unclaimed money can be refunded after expiry.
  • Move a prediction-market position. Positions cannot be transferred between venues, so a move is a sale on one and a purchase on the other. Switchboard checks in code that the two markets are the same bet (event, strike, direction, time, who settles it), quotes the cost from both order books, and refuses look-alikes. A Bitcoin market that settles on a different price index on each venue is refused, with the reason spoken.
  • A second opinion with receipts. Four model families estimate the probability, starting from the market price. Each opinion is hashed onto a ledger contract before the event and scored afterwards against the market's own price.
  • One gate for other assistants. ChatGPT, Claude, Grok or anything that speaks MCP can ask Switchboard to send, each with its own key and its own limit. None of them can approve, see the word, add a payee or change a limit.

What is live and what is not

Piece State
Vault, Ledger and Escrow contracts Live on Arc testnet
Arc to Arc, Arc to Ethereum Sepolia, Arc to Solana devnet Live on testnet through Circle CCTP V2
Vault events and the dead man's switch Live through a QuickNode Stream
Escrow claim links and refunds Live on Arc testnet
Market prices, order books and the same-bet check Live public data from Gemini and Polymarket US
Approval rules (amount, word, passkey, expiry, call cap) Live
The phone call itself Built on AgentPhone and tested in dry run; the dashboard stands in for the phone
Position move Dry run: both orders are built and signed with a dummy key, never sent
Dollar to euro conversion, bank on-ramp Blocked on access from Circle

All money is testnet USDC with no value.

How we built it

Two people built two halves in parallel against a frozen interface: the money half (contracts, transfers, the Stream, venue clients) and the voice and surface half (intent, planner, approval call, dashboard). The surface half ran against in-memory stubs until the real modules dropped in behind four protocols.

  • Contracts (Solidity, Foundry) on Arc testnet. The Vault issues a single-use permit for a spend inside policy and stores a pending request for one outside it. The Ledger is an append-only commit and reveal store for forecast receipts and trade records. The Escrow holds USDC behind a secret for claim links.
  • Arc. USDC is the gas token, so the agent wallet needs only a small USDC float. Blocks are about half a second, so a CCTP burn on Arc is attested after one block.
  • Circle CCTP V2. The vault pays the agent on Arc, the agent burns, and Circle's Forwarding Service submits the mint on the destination, so neither side needs destination gas.
  • QuickNode Streams. A Logs stream on Arc testnet with a JavaScript filter that keeps only our three contracts and delivers a heartbeat every 60 blocks. Deliveries are HMAC-verified with a skew window and a replay guard.
  • Server (Python, FastAPI). One model call turns the sentence into a request and is cross-checked by a rule-based parser: the amount must match and a destination address must appear in the sentence character for character. The planner fixes the route before anything from outside is read.
  • Voice. ElevenLabs speech-to-text for the microphone and text-to-speech for the operator's voice on the dashboard. The approval call is placed through AgentPhone in webhook mode, following a fixed script on our server.
  • Markets. Gemini and Polymarket US public endpoints for events and order books; signed order clients (HMAC-SHA384 and Ed25519) tested against openssl vectors.
  • Grok Bot. Routines that research and watch but never move money: a missed-call follow-up, a daily summary, a ledger reconciliation and market-equivalence research.
  • Dashboard (React, TypeScript, Vite). A ring with the vault at its centre: allowed transfers pass through it, held ones stop at it, blocked ones fade.

Challenges we ran into

  • Look-alike markets. Two markets with the same question text can be different bets. San Francisco's daily high is listed on both venues with temperature bands offset by one degree, so no contract matches. We compare five fields in code and refuse when any is different or unknown.
  • Venues let you trade by API but not move cash. Neither venue documents a withdrawal endpoint that fits. We hold a balance on both, move the position, and show the cash rebalance as a queued instruction.
  • A Sepolia address looks like an Arc address. The planner tells the vault the destination chain, so the vault is never asked to pay an address on the wrong chain.
  • A claim secret is visible in the mempool. Claiming takes two transactions, a commitment and then the claim, so a copied secret cannot redirect the money.
  • A quiet vault and a dead Stream look the same. The filter delivers a heartbeat every 60 blocks so the server can tell them apart.
  • Retries against a replay guard. QuickNode retries a failed delivery with the same nonce. Refusing it as a replay would have terminated the Stream, so a delivery that fails halfway is removed from the guard.
  • Speech on the way in. Speech-to-text writes "Arc" as "Ark", and "two fifty" has two readings. The first is mapped; the second is asked again.

Accomplishments that we're proud of

  • A spoken sentence moved testnet USDC from Arc to Solana devnet, attested and minted 7 seconds after the burn.
  • An over-limit request was recorded onchain, delivered by the Stream, approved with the amount and the word, and paid by the vault in the same transaction.
  • Pausing the Stream in QuickNode blocked spending 90 seconds after the last delivery; resuming cleared it in 9 seconds.
  • A $1 escrow link was made in the dashboard, opened in a browser and claimed. A replayed claim was refused.
  • A four-model opinion on an NBA game was committed to the Ledger before tip-off.
  • A judge can paste hostile text into "Try to trick it". The worst outcome is a phone call the owner can refuse, or one capped transfer to a payee who was already trusted.
  • The README says which parts are live, dry run or blocked, piece by piece.

What we learned

  • The safety of an agent that pays comes from the code around the model. The model reads one sentence; fixed code plans, asks the contract and runs the call.
  • Approval is only worth something if the agent cannot reach it, and only if the owner still thinks before saying yes. We cap calls per day and show the approval rate, with a warning at 100 percent.
  • Truly equivalent markets across venues are rarer than they look, and the refusal is the feature.
  • Cross-chain "it just works" depends on who pays the destination gas. Forwarding removed a whole class of setup.

What's next for Switchboard

  • Place the approval call end to end on a real phone line and tune how the amount and the word are heard.
  • Run a position move with a few dollars of real money on verified accounts.
  • Dollar to euro conversion and a bank on-ramp, once Circle access is granted.
  • Routes that start on Ethereum or Solana, not only Arc.
  • Per-assistant limits enforced in the contract, and OAuth sign-in for connected assistants.
  • More venues: Kalshi and Limitless.

Built With

Share this project:

Updates

Submission history