Mandate: Giving AI Agents a Memory for Your Money Rules

Built for **Total Recall — Tatum × Walrus, Consumer Finance Apps track.

Demo video (2:39): https://youtu.be/sRa2cWtP8ok ·

Code: https://github.com/fadillaoegi/mandate-walrusxtatum

AI agents are starting to pay for things on their own. With protocols like x402, an agent can call an API, get an HTTP 402 Payment Required, pay a few cents in USDC and receive the data, all without a human in the loop.

That is great until you hire your second agent, or restart the first one. Each agent starts from zero:

So you end up with two bad options: approve every purchase by hand, or let agents spend without any real control.

Mandate keeps the owner's spending rules and purchase history as memory on Walrus. Any agent you authorise with a delegate key reads the same memory, in any session. Agents pay with x402 on Sui, and Mandate independently checks each signed transaction's execution status through Tatum. A pending receipt reserves the purchase and budget until the chain result is known, so an unavailable read does not invite a duplicate payment.

In one sentence: your money rules, remembered by every agent you hire.

The dashboard walks through six steps (you can watch them in the video):

Every meaningful thing that happens is written as one immutable memory event with the Walrus Memory SDK ( @mysten-incubation/memwal ) against the Mainnet relayer:

Each memory is a readable sentence plus a small JSON payload, so it works both for semantic recall and for exact parsing:

[mandate:v1] Owner rejected $0.45 purchase of dh-market-deep-dive from DataHarbor: too expensive || {"kind":"owner_verdict",...} Enter fullscreen mode Exit fullscreen mode When a session starts, the agent recalls the namespace and rebuilds its knowledge by folding events in time order. Because Walrus memories are append-only, a correction is never an edit: it is a new event (for example a purchase_status: failed after the chain disagreed with a receipt).

In the recorded run, 13 memories were stored on Walrus Mainnet in namespace mandate-demo-run10.

Mandate uses Tatum as its source of truth for payments. After an agent pays, Mandate does not believe the merchant's X-PAYMENT-RESPONSE; it reads the transaction from Sui through Tatum's gRPC gateway and stores that execution status in memory. Audit receipts re-checks each remembered transaction's status against the chain; when a known chain result disagrees with memory, a correction event is written.

A practical lesson: the first JSON-RPC read path did not work in our environment, so we implemented a native gRPC adapter. Tatum's Mainnet and Testnet gRPC gateways worked in the recorded checks, with transaction reads around 50–260 ms. The reader sits behind a ChainReader port, keeping the application independent of the transport.

Payments use the x402 exact scheme on Sui ( @t2000/sui-x402 ): the merchant answers HTTP 402 with terms, the agent signs a gasless USDC transfer, and the merchant settles it. Before signing, Mandate's agent checks the merchant's terms against what the policy approved:

Anything else is refused before a signature exists. One challenge allows one payment, so replays are refused too.

In the recorded run, four x402 payments settled on Sui Testnet and each was verified through Tatum, for example Ht7Du4hHcm3e9DGA2bDMNttdjuPK3BedPFBYDM9aYdeE (the $0.15 purchase made right after the greedy 402 was refused).

"Learning" in Mandate is deliberately simple and explainable: it is deterministic policy over remembered events, not a model guessing.

The recorded dashboard comparison shows 14 purchase requests and 3 owner prompts. Its no-memory baseline evaluates each request with empty knowledge, which produces an owner prompt for each request; this is a policy comparison, not a separate live control experiment. Later sessions and the second agent use recalled events to decide without asking again. The current demo tasks are scripted and policy decisions are deterministic.

Clean Architecture in TypeScript: a pure domain (policy and memory events) behind ports ( MemoryStore, ChainReader, PaymentRail, DelegateAccess ), with adapters for Walrus Memory, Tatum gRPC, the x402 rail and a labelled demo merchant. Express API, React + Vite + Tailwind dashboard in a pixel style, PostgreSQL for app data only. 37 automated tests run without any keys ( npm install && npm test ).

A language model as the agent's planner (it may only suggest purchases; the policy still decides), more vendors, spending reports for the owner, and moving the payment rail to Mainnet once it is safe to do so.

Watch the demo: https://youtu.be/sRa2cWtP8ok Read the code: https://github.com/fadillaoegi/mandate-walrusxtatum On-chain evidence: Recorded verification and guided walkthrough

Built for Total Recall — Tatum × Walrus.