Our agent just shipped a Uniswap v4 hook on Base

Earlier this month we connected Agent Wallet to aeon, one of the leading open frameworks for autonomous agents. Last week we wanted to test what the agent is actually capable of with some pocket money in Finance District’s Agent Wallet — not in a sandbox, not on a testnet, but with real money on Base mainnet.

The instruction was simple: buy the latest ETH market data from CoinMarketCap, fund a deployer address with just enough ETH for gas, then write and ship a Uniswap v4 hook that encodes the data it just bought. One dispatch. No babysitting.

Spoiler alert — it did all three. The hook is live on Base, the market data it paid for is sitting in the contract’s fee logic, and the full run — every step, every payment — is in a public GitHub Actions log.

Continue reading if you want to learn how the setup works, what happened during the run (including the part we didn’t plan), and why aeon and Agent Wallet complement each other so well.

If you followed the first post, you’ve seen the connection flow. Agent Wallet is a featured server in aeon’s MCP catalog, so there is nothing to build. Click Connect in the dashboard, sign in with your District Pass, and aeon stores the connection and refreshes it before every run. Your agent now has a non-custodial wallet across EVM chains, Solana, Bitcoin and Sui, with the private keys generated and used inside a secure enclave. The agent can submit a payment without ever seeing a key.

For this build we funded the wallet with pocket money. A few dollars of USDC to pay for data, and a little ETH for gas. That’s a design choice worth pausing on. You fund Finance District’s Agent Wallet with what you’re comfortable letting an agent spend — your exposure is a number you choose up front, before the agent does anything at all.

The one extra piece a contract deploy needs is a signing key. We created a brand new, empty account in MetaMask, and stored its private key as a repository secret on GitHub. That’s the deployer, and it’s deliberately disposable to keep things extra safe. It starts empty, and the agent’s job is to send it just enough ETH to ship one contract. Two wallets, two jobs: the Agent Wallet holds the money behind enclave custody, and the deployer is a throwaway nozzle that only ever touches gas. A key sitting in a repo secret should never be holding anything worth stealing.

The instruction itself is four lines of config in the repo. aeon runs everything from your own GitHub repository — skills, schedules, and the run itself, executed in GitHub Actions, so every step the agent takes is in a log you can read.

It paid for its own data. CoinMarketCap sells market data over x402, the payment protocol built for machines. No API key, no signup, no subscription — the agent authorized one cent in USDC through its wallet, and the data came back in the same request. This is the quiet headline of the whole demo: an agent with a wallet doesn’t need a human to open accounts for it. It just becomes a customer.

It refused a transfer we actually wanted. Here’s the part we didn’t script. We’d rehearsed this run a few times, and when the agent went to send the deployer its gas money, it stopped. It had read the wallet’s own transaction history, noticed the same transfer going out repeatedly, right next to a look-alike address that pattern-matched suspicious activity, and decided the whole thing resembled a drain. It declined to send, and told us why.

That was the agent being cautious, not a wallet feature — and it was annoying for video demo purposes, in the way a smoke alarm is annoying when you’re cooking. But it’s exactly the disposition you want in something that spends money: an agent that reads on-chain history before moving funds, and treats “this looks wrong” as a reason to stop. Underneath that caution sits the wallet’s actual guarantee — non-custodial custody with keys sealed in the enclave, funded only with what you chose to put in.

It shipped. With the deployer funded, the agent generated the hook around the exact numbers it had bought — ETH’s 24-hour move, −0.18%, rounded to −18 basis points and baked into the fee logic as an on-chain constant. It compiled, simulated the full deployment against a fork of Base, and only broadcast once the simulation passed. Then it initialized a pool, added liquidity, and ran the first swap, which emitted a fee of exactly 4800: the 3000 base fee plus the 1800 premium derived from the data it purchased. The number it bought is verifiably live in the contract.

Total cost of a working piece of on-chain infrastructure: one cent of data, a fraction of a dollar in gas, and a couple of dollars of Claude compute.

Agent Wallet and aeon solve opposite halves of the same problem.

aeon gives agents hands — skills, schedules, an MCP catalog of real tools, and a runtime that lives in your own repo where every action is logged and auditable. What it deliberately doesn’t solve is money: an open framework shouldn’t be in the business of holding your keys.

Agent Wallet gives agents money they can be trusted with. Multichain custody where the agent never touches a key, x402 payments for machine-to-machine commerce, and a funding model where your maximum exposure is set by you, in advance, not negotiated with a model at runtime.

Put together, the loop closes. An agent that can pay for data, fund its own operations, and ship the result, inside an allowance you control, on rails you can audit. That’s not a demo of what agents might do someday. It ran last week, and the receipts are on Base.

Everything in this post is reproducible: aeon is open source, the Agent Wallet connector is in its catalog, and the setup takes a few minutes. Create a District Pass, connect the wallet to your agent, and give it a job with a price tag. The setup docs cover the rest, and our Discord is there if you get stuck.

There’s a lot more agent-payments work coming from us in the next few weeks.

Financial autonomy for AI.