Are We Building the Perfect Finance Infrastructure for Machines?

Cannes this year felt different. Across EthCC, the annual Ethereum Community Event that gathers the developer community in France, the conversations had a new gravity to them. Less "when mass adoption?" and more "what if we've been asking the wrong question?" After a week of panels, demos, and late-night debates along the Croisette, one idea crystallized that I haven't been able to shake: 

"What if crypto was never really meant for humans in the first place?" 🤔

Let me be more precise. What if the financial infrastructure we've been painstakingly building for the last decade, blockchains, smart contracts, DeFi protocols, token standards, ERCs, is not the clumsy precursor to a mainstream human banking alternative, but rather the perfect financial operating system for AI agents and autonomous machines?

The Uncomfortable UX Truth

We've been telling ourselves a story for years: once the UX improves, normies will flock to DeFi. Better wallets. Simpler onboarding. Account abstraction. One more EIP and we're there.

But take an honest look at what interacting with a DeFi protocol actually looks like. Here's a real transaction on Etherscan, a fairly routine swap on Uniswap V3:

Function: multicall(uint256 deadline, bytes[] data)
 
// Decoded parameters:
deadline: 1743609612
data[0]: 0x04e45aaf
    tokenIn:  0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
    tokenOut: 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
    fee:      3000
    recipient: 0x3fC9...a7B2
    amountIn: 1500000000000000000
    amountOutMinimum: 3842691027
    sqrtPriceLimitX96: 0

Now be honest with yourself. Can you read that? Can your mother? Can anyone who isn't a Solidity developer decode what's happening here at a glance? You're looking at hexadecimal addresses, raw wei values with eighteen decimals, encoded function selectors, and parameters that require you to know the Uniswap V3 router ABI by heart to interpret.

This isn't a bug. It's how the system works. And here's the revelation: this is perfectly legible to a machine.

We didn't build a bad bank. We built a pristine API for autonomous economic agents — and then spent a decade wondering why retail couldn't use it.

The Accidental Machine Economy

Think about what blockchain actually provides:

• Permissionless access - no KYC, no bank account, no human identity required.
• Programmable money through smart contracts.
• Atomic, deterministic transactions that either execute completely or revert entirely.
• A global state machine running 24/7, with no business hours and no holidays.
• Composability between protocols, any contract can call any other contract.

Now ask yourself: who benefits most from these properties? A person trying to pay for coffee? Or an autonomous software agent that needs to execute complex multi-step financial operations across protocols, around the clock, without ever picking up a phone to call a bank?

The answer is obvious once you see it.

What humans struggle with

Humans need interfaces. We need friendly dashboards, readable numbers, confirmations in our language, customer support when things go wrong. We need to understand why a transaction costs what it costs. We need round numbers, not 3842691027 representing $3,842.69 in USDC's six-decimal format.

What machines excel at

Machines parse calldata natively. They don't need a "Confirm Swap" button — they construct the transaction bytes, sign it, and broadcast. They read contract ABIs the way we read menus. They can evaluate gas prices, slippage parameters, and routing paths across fifty DEXs in the time it takes you to unlock MetaMask.

The Infrastructure Is Already Here

What struck me in Cannes is how rapidly the "Agent Economy" has shifted from theoretical to operational. This isn't a 2030 roadmap anymore. The pieces are falling into place right now.

Ethereum's EIP-7702 lets standard accounts act as smart contracts for individual transactions, meaning an agent can receive scoped, temporary permissions without ever touching a user's master keys. ERC-8004 is creating on-chain identity and reputation systems specifically designed for non-human actors: NFT-based IDs, verifiable feedback loops, and pluggable proof systems. Meanwhile, Coinbase's x402 protocol enables native machine-to-machine payments over HTTP, allowing software to pay software as naturally as a browser requests a webpage.

MoonPay launched non-custodial wallets specifically for AI agents earlier this year. Alchemy demonstrated a flow where an agent creates its own wallet, receives an HTTP 402 payment challenge, and automatically tops up using USDC on Base, all without human input. The agent starts with a dollar and buys compute on demand. Software paying software to continue a workflow. That's a fundamentally new thing.

The Paradox of Mass Adoption

Here's the uncomfortable realization I kept coming back to during the week: maybe the path to crypto going mainstream doesn't run through making blockchain simple enough for your grandmother. Maybe it runs through making blockchain invisible to her entirely,  because an agent is doing all the on-chain work on her behalf.

Think about how most people interact with the internet's infrastructure. Nobody manually resolves DNS queries. Nobody hand-crafts TCP packets. Nobody reads HTTP headers for fun. These protocols are incredibly complex, deliberately so, because they were designed for machines to operate and for humans to benefit from the results. You just type a URL and a webpage appears.

Crypto could follow the same trajectory. The blockchain becomes the backend settlement layer. AI agents become the middleware. And the human just says: "Move my savings into something that earns 5% and is relatively safe." The agent handles the rest, finding the optimal yield across Aave, Compound, and Morpho, managing the gas, rebalancing weekly, and reporting back in plain language.

Nobody asks their grandmother to write SQL queries. Why are we asking her to approve raw calldata?

Agent-Native Finance

If we accept this framing, the implications for what we should be building are profound. Instead of yet another "simplified DeFi dashboard," we should be building agent-native financial rail,  protocols optimized for machine readability, composability, and autonomous execution.

This means:

• Standardized intent formats that agents can parse and execute.
• Reputation systems where agents build verifiable track records on-chain, and other agents (or humans) can audit their performance history before delegating capital.
• Payment protocols where machines can negotiate, settle, and reconcile without ever surfacing a transaction hash to a human eye.

Some of this already exists. Intent-based architectures like UniswapX separate what a user wants from how it gets executed, a design that practically screams "let an agent handle this." Solver networks compete to fulfill intents optimally, turning execution into a market rather than a manual task.

But we need to go further. We need:

• Agent identity standards that are as robust as human KYC (but designed for software actors).
• Escrow and insurance mechanisms designed for autonomous counterparties.
• Governance frameworks where delegated AI voters can participate in DAO decisions with transparent reasoning chains.

The Risk Landscape

I don't want to sugarcoat this. Giving autonomous software access to real financial instruments is genuinely dangerous. The attack surface is vast: prompt injection attacks that manipulate an agent's behavior, key management vulnerabilities in agentic wallets, adversarial environments where malicious agents exploit naive ones.

Security researchers have demonstrated that language-model-based agents can be hijacked through data they consume , an attacker plants malicious instructions in a public data feed, the agent reads it as market analysis, and the embedded payload overrides the agent's core instructions. In a financial context, this could mean unauthorized transfers, wash trading, or liquidity drain.

The solutions are emerging but immature:

• Hardware-isolated execution environments.
• Session keys with hard spending caps.
• Kill switches.
• Formal verification of agent strategies.

The rule of thumb I heard repeated in Cannes was blunt, never give an agent more than you can afford to lose today. Start with ten percent of your stack. If the agent hallucinates a non-existent arbitrage opportunity, you want it to burn its allowance, not your savings.

A New Mental Model

Walking along the Croisette after the final day of EthCC, watching the sun set over the Mediterranean, I found myself reframing the entire crypto narrative in my head. We've spent a decade asking: "How do we get billions of humans onto the blockchain?" Maybe the better question is: "How do we get billions of agents onto the blockchain, working on behalf of those humans?"

ETHCC9 Cannes 2026 - The Boulevard de la Croisette 

The infrastructure is not broken. It's just not for us,  not directly. It's for our agents. The hexadecimal addresses, the encoded calldata, the raw wei values, the ABI-encoded function signatures , these are features, not bugs. They're the machine-readable API of a global, permissionless financial system.

Crypto's path to mainstream adoption might not look like a beautifully designed mobile app that replaces your bank. It might look like you never knowing your agent just executed seventeen cross-chain swaps, bridged assets across three Layer 2s, and optimized your yield, all while you were sleeping. You just see: "Your portfolio earned 0.3% this week."

We didn't build a bad bank. We built a pristine financial operating system for the machine economy. And the machines are finally ready to use it.

Conclusion

This isn't a declaration. It's an invitation to sit with the question and rethink our foundations.

If crypto and Web3 truly are the financial backbone of an agent-driven world, then many of the debates we’ve been having, about wallet UX, confusing gas fees, or seed phrases as a dealbreaker, are aimed at the wrong user. They’re not irrelevant, but they matter in the way optimizing a server’s terminal font does: a nice refinement, not the breakthrough that brings in the next billion participants.

But if we're wrong,  if this is just another narrative rotation, a convenient reframe to avoid admitting that the UX problem is real and unsolved, then we risk building an incredibly sophisticated financial system that serves neither humans nor machines well. An infrastructure admired by engineers and ignored by everyone else.

The honest answer is: I don't know yet. Nobody does. But I think the question itself is worth more than most of the answers circulating right now.

The only question left is whether we're building it with intention, or we are stumbling into it by accident.