Crypto has always had an automation story. Bots arbitraging price differences across exchanges, smart contracts executing logic without human sign-off, liquidation engines firing when collateral ratios slip. What’s changed in the past year is the actor at the other end of those transactions: increasingly, it’s an AI agent with a wallet.
This isn’t hype. It’s infrastructure. And it’s moving faster than most DeFi builders expected.
What an AI agent actually does on-chain
An AI agent, in the context most relevant here, is a software program that can reason about goals, take actions to pursue them, and loop through those actions without constant human input. Give one access to a wallet and an API, and it can do things like pay for compute resources, tip a content creator, settle a cross-border invoice, or rebalance a portfolio based on market signals.
The crypto component matters because existing payment rails were not built for machines. Bank accounts require identity verification designed for humans. Credit card networks flag unusual automated patterns. Stripe’s terms of service don’t cover agents making thousands of micro-transactions per hour.
Crypto wallets, by contrast, are just key pairs. Any software that holds a private key can sign a transaction. There’s no onboarding process, no human-in-the-loop requirement, no minimum transaction size that makes small payments economically impossible.
That combination, programmable agents plus permissionless wallets, is what’s starting to produce real activity.
The infrastructure layer being built right now
A cluster of protocols is forming specifically around agent payments. They share a few common design goals: low per-transaction costs, programmable spending rules, and ways for agents to authenticate themselves to counterparties.
Micropayment channels are one approach. Instead of settling every tiny payment on-chain (expensive, slow), agents open a channel, transact freely inside it, and settle the net amount when done. This is an old idea from the Lightning Network era, but implementations optimized for EVM chains and Solana are being actively deployed.
Spending policies address a different problem. A human authorizing an agent to “spend up to $50 on compute” needs confidence the agent won’t drain the wallet. Protocols like Safe’s module ecosystem and newer entrants are building constraint layers that let wallet owners set rules an agent must follow, enforced at the smart contract level rather than trusted to the agent itself.
Agent identity is the thornier problem. When an AI agent pays for a service, the counterparty often wants to know something about what it’s dealing with. Is this a known agent type? What permissions does it have? Who deployed it? Decentralized identity frameworks are being extended to handle machine credentials, with attestations stored on-chain and resolvable without a centralized registry.
Where actual volume is appearing
The clearest current signal is in AI compute markets. Networks that let buyers pay for GPU time in crypto have seen a measurable increase in the share of transactions originating from automated buyers. When a developer runs an agent that spins up inference jobs on demand, it typically pays for each job programmatically. That’s a structural shift in who the customer is.
Content and data markets are showing the same pattern. Protocols that let data providers sell access to training datasets or real-time feeds are handling an increasing proportion of purchases from automated pipelines rather than human researchers. The humans set up the pipeline once; the agent handles the ongoing procurement.
DeFi itself is also involved. Yield optimization agents, already common in the form of vaults that rebalance across protocols, are becoming more sophisticated. The newer generation doesn’t just follow fixed strategies; it evaluates conditions and adjusts. These aren’t traditional bots following hardcoded logic. They’re running inference on market state and acting on the output.
The risks this introduces
More autonomous agents transacting on-chain creates several categories of risk that the DeFi ecosystem hasn’t fully worked through.
One is concentration. If a small number of AI frameworks (certain agent platforms, certain wallet infrastructure providers) come to handle the majority of agent transactions, the system acquires new chokepoints. Those providers gain leverage over what agents can do and who they can pay.
Another is accountability. When an agent causes a loss, either through a bad trade, a security failure, or interaction with a malicious contract, figuring out who’s responsible is genuinely hard. The human who deployed it? The platform that provided the agent framework? The wallet infrastructure provider? Legal frameworks don’t have clean answers here, and the crypto-native governance mechanisms aren’t designed for this problem either.
Smart contract exploits targeting agent behavior are a specific concern. Agents that interact with contracts based on on-chain data can be manipulated if that data can be influenced. Price oracle manipulation has always been a DeFi attack vector; agents that act on oracle data and do so at machine speed and scale make that vector more significant.
What this means for how DeFi develops
The honest framing is that AI agents are becoming a new class of DeFi participant, and the protocols that recognize this earliest will shape what the category looks like.
That probably means a few things. Protocols will start optimizing transaction structures for machine consumption, not just human-readable interfaces. Gas efficiency matters differently when an agent is making ten thousand small payments rather than one large one. Authentication and credentialing infrastructure will become load-bearing, because agents need ways to establish trust with counterparties that don’t rely on social reputation built over time.
It also means that the “user” in user experience is increasingly not a human. The interfaces that matter are APIs, not UIs. The composability that DeFi has always talked about becomes more literal: agents gluing protocols together in ways their creators didn’t anticipate.
None of this makes DeFi simpler. It adds new attack surfaces, new coordination problems, and new questions about what the system is actually for. But it does represent a meaningful expansion of what on-chain finance can reach, and where transaction volume will come from as this technology matures.
The question isn’t whether AI agents will be significant DeFi participants. They already are. The question is whether the infrastructure being built now is good enough to handle the scale that’s coming.