An agent that stops paying for data it already learned was useless

Spend-Aware Agent is a research agent for Sui. You ask about the network, a validator set, a token, or a wallet. It buys the data per request, scores what the purchase actually added, and writes that verdict to Walrus Memory. The next time the question comes up, it skips the sources that did not deliver.

It is live at spend-aware-agent.vercel.app. The code is at github.com/AshThunder/spend-aware-agent. This is a project for the Total Recall hackathon (Tatum × Walrus Memory), on the Smart Agents for Real Life track.

Here is the demo, recorded on mainnet:

The gap

x402 makes it easy for an agent to pay for an API. It does not make the agent careful. A stateless agent pays the same seller again on the next run, including the seller that returned nothing useful. The missing piece is a memory of the purchase, not of the answer.

What one run does

1. Recall. Before spending, the agent reads Walrus Memory for this topic. If memory cannot be read, it refuses to spend instead of buying blind.
2. Plan. A source with no history is bought once, so the agent can learn it. A source whose average usefulness is under 0.25 is skipped, with the reason written out. A source that proved useful is bought only if the budget still covers it and the facts are not already in hand. Verdicts older than seven days are tested again.
3. Pay. Each source is an HTTP route that answers 402 Payment Required. The agent pays with the x402 exact scheme on Sui mainnet, in native USDC, through the Tentacle Pay facilitator. Payments under $0.01 have their gas sponsored, so the agent wallet holds USDC and no SUI.
4. Score. Usefulness is the share of required facts that this purchase added and cheaper purchases had not already covered. It is a number from 0 to 1, computed from the response, not from an LLM.
5. Remember. One evaluation per purchase is written to Walrus Memory on mainnet and linked from the site.

Each memory is one line of text:

[source-eval] source=alpha-wire topic=network paid_usd=0.008 usefulness=0.00 new_facts=0/5 redundant_with=- tx=<sui digest> at=2026-11-05T14:34:50.365Z run=<run id> 

How it uses Tatum and Walrus

Tatum. Every honest source reads its chain data through Tatum's Sui gRPC gateway (sui-mainnet-grpc.gateway.tatum.io): checkpoints, gas price, the epoch and validator set, balances, owned objects and coin metadata. Tatum's gateway speaks native gRPC, so the agent uses SuiGrpcClient from @mysten/sui over a gRPC transport with the x-api-key header, throttled to the plan's 3 requests per second with a retry on 429. The same client builds the x402 payment transactions and reads the wallet balances shown on the site.

Walrus Memory. The agent calls recall before every run and rememberBulk plus waitForRememberJobs after it. The site counts memories with listMemories from the Walrus Memory index, and links every memory to its blob.

How it learned over time

The site rebuilds each paid run from the memories it wrote. Green is money that bought new facts. Red is money spent on a source that added nothing. The dashed line is what buying every source would cost.

The first run on each topic explores, and pays for it. After that, the red is gone:

Across 19 paid runs, the agent spent $0.113. Buying every source each time would have cost $0.326. All of the waste, $0.055, happened on the four first runs, while it was still learning. Later runs wasted nothing.

The trust table on the site shows the same thing per source. Each square is one purchase, oldest first.

A measured run

The question was "How healthy is the Sui network right now?"

Chain Pulse returned the checkpoint, its age, total transactions, the reference gas price, and the epoch. Staking Scope and Chain Pulse Pro repeated facts the agent already had. Alpha Wire claims every topic and returns no verifiable data. It exists so the agent has something it should learn to refuse.

One of the first payments is this Sui transaction. The latest run, on Nov 9, recalled nine verdicts, skipped the three sources above, and paid $0.002 for Chain Pulse in this transaction. Its verdict is this Walrus blob.

See what memory changes, for free

The console has a plan preview. It reads memory and shows what this agent will buy next to what a fresh agent with no memory would buy. Nothing is paid.

For a network question, a fresh agent buys all four sources for up to $0.024. With its memory, the agent buys Chain Pulse for $0.002 and crosses out the rest.

Every memory, on mainnet

There are 26 memories in the agent's Walrus Memory namespace as of Nov 9. Each one links to its Walrus blob and to the Sui transaction that paid for the purchase it judges.

What is honest about the demo

The agent and the data sellers are both wallets in this project, so the USDC moves from one demo wallet to the other. The settlements are still real x402 payments on Sui mainnet. Scoring is deterministic on purpose: a judge can see why a source was kept or skipped. With the default Walrus Memory relayer, the relayer can see the evaluation text. Those evaluations contain source names, prices, and scores, not personal data. Older memories carry no run id, so the site groups them into runs by topic and time.

Try it

• Live: spend-aware-agent.vercel.app. The home page has the chart, the trust table and the proof table. The console has the free plan preview and real runs.
• Code: github.com/AshThunder/spend-aware-agent. pnpm test runs the learning-loop tests.