Why AI Agents Can't Use DeFi (Yet)

The problem: DeFi speaks human, not machine

If you ask an AI agent to “swap 1,000 USDC for ETH on Uniswap,” the agent understands the intent perfectly. It can reason about the trade, evaluate whether the amount makes sense, and explain the risks. What it cannot do — without significant custom engineering — is actually execute the transaction.

The reason is deceptively simple: DeFi protocols were designed for humans. Every interface assumes a person with a browser, a wallet extension, and the ability to read a dashboard. The entire information architecture is optimized for visual consumption by people.

This creates three concrete problems for autonomous agents.

ABIs exist, but context doesn't

Yes, every smart contract has an ABI. An agent can technically read that swapExactTokensForTokens takes five parameters. But the ABI tells the agent nothing about what those parameters mean in practice. Which token addresses are valid? What fee tiers exist? What's the slippage tolerance a reasonable agent should set?

An ABI is a function signature, not a user manual. For a human developer, the gap is filled by experience and intuition. For an autonomous agent operating at machine speed, that gap is a wall.

Documentation is scattered and fragile

Protocol documentation lives in GitBooks, Notion pages, blog posts, PDFs, and governance forum threads. It's written in natural language for human developers. It may or may not reflect the current state of the contracts — protocol upgrades happen regularly and docs lag behind.

An agent can't reliably scrape a GitBook to figure out that Aave v3 on Arbitrum uses a different pool address than Aave v3 on Ethereum. This information needs to be structured, versioned, and machine-accessible.

Execution flows are protocol-specific

Every protocol has its own transaction flow. Swapping on Uniswap v3 requires constructing a path through specific fee tiers. Supplying on Aave requires an approval transaction followed by a supply call. Staking on Lido is a single call, but withdrawal involves an NFT-based queue.

There is no universal “swap” function. No standard “lend” interface. Each protocol is its own island. An agent that integrates with Uniswap has learned nothing about how to integrate with Curve.

ABIs tell you what functions exist. They don't tell you what they mean, when to call them, or what can go wrong.

What machine-readable DeFi actually looks like

The solution isn't another chatbot wrapper or a better dashboard. It's a structured data layer that sits between agents and protocols — translating the human-readable world of DeFi into something machines can consume programmatically.

Three capabilities are required.

Structured protocol specs

Every protocol needs a machine-readable specification that describes its capabilities. Not just the ABI — the full operational context. Think of it as an OpenAPI spec for DeFi: what actions the protocol supports, what parameters each action requires, what constraints those parameters have, and what the fee structure looks like.

These specs need to be standardized across protocols. A “swap” action on Uniswap and a “swap” action on Curve should share the same schema. This is what lets an agent reason about actions abstractly without needing protocol-specific logic.

Unified execution interface

Agents shouldn't need to know the difference between Uniswap's exactInputSingle and Curve's exchange. They should express intent and have an execution layer handle the protocol-specific encoding, gas estimation, and chain routing.

Risk and context metadata

Execution without context is dangerous. An agent needs to know not just how to supply liquidity to a pool, but whether it should. What's the current TVL? What's the historical yield? Is the protocol audited? Has it been exploited?

Machine-readable DeFi isn't a better UI. It's a new layer of infrastructure that lets agents interact with protocols the way APIs let applications interact with services.

How Axon makes DeFi agent-native

This is exactly what we're building at Axon. The core of the system is two components.

The Axon Protocol Spec format

We've created a standardized JSON schema for describing DeFi protocol capabilities. Each spec includes the protocol's identity, every available action with typed parameters and constraints, fee structures, risk metadata, and contract addresses across all supported chains.

The format is designed to be consumed by any AI agent framework — LangChain, CrewAI, AutoGen, or a raw LLM. An agent reads the spec and immediately understands what the protocol can do. No documentation scraping. No ABI guesswork.

We already have specs published for Uniswap v3, Aave v3, and more protocols — you can explore them on our specs page.

The execution gateway

Axon's execution gateway is an MCP-compatible API that translates agent intents into protocol-specific transactions. An agent calls a single tool and Axon handles the ABI encoding, chain routing, gas optimization, and transaction construction.

Because we're built on the Model Context Protocol, any MCP-compatible client — Claude Code, Cursor, or custom agent frameworks — can connect to Axon with a single command and immediately gain access to every supported DeFi protocol.