What does DeFi need for its next milestone?

Original Title: DeFi's next milestone: What it'll take for agentic finance to work

Original Author: @Lemniscap

Translated by: Ismay, BlockBeats

 

Editor's Note: When the world of DeFi becomes so complex that even professional users struggle to keep up, how can we return control to ordinary people?

This article, from Lemniscap's research, systematically reviews the rise and real-world challenges of "agentic finance." From &milo and Meridian to SendAI and The Hive, these early products demonstrate how AI can become a new interface for on-chain interaction, while also exposing significant gaps in execution reliability, permission security, and verification mechanisms. The author points out that for DeFi to reach the next stage, the key is not smarter models, but a more trustworthy underlying structure—making every action by agents verifiable, traceable, and trustworthy.

This is not only a turning point in technological evolution, but also an experiment in trust reconstruction. As the article says: DeFi's next milestone is not greater scale, but trust in automation.

By 2025, DeFi will look completely different from its early days.

The data speaks for itself: institutional capital inflows exceed $10 billions per quarter, and the number of active protocols across dozens of chains surpasses 3,000. The total value locked (TVL) in DeFi protocols across the network reaches $160 billions in 2025, a 41% year-on-year increase; cumulative trading volume on DEXs and Perps is now counted in the "trillions."

As DeFi grows in scale, the possibilities expand, but complexity rises sharply. Most people simply cannot keep up with everything happening on-chain. If we want more people to seize these new opportunities, we must build tools that help users make the right decisions more easily—this is the direction for future development.

Meanwhile, AI is gradually integrating into daily life, and people are developing new habits around automation. This trend has given rise to "agentic finance"—where intelligent agents handle the navigation and execution of financial operations.

Even simple browser-based agents like Comet demonstrate the rapid evolution of such tools. When you execute a DeFi operation through a browser agent (as shown in the example shared by SendAI founder Yash), you can see the potential of agentic finance.

The vision is intuitive: you no longer need to search through dashboards or long threads on X; just tell the AI your goal, and it will automatically handle the subsequent steps for you.

Currently, two types of intelligent agents are emerging:

One type is Copilots, which guide users in making decisions across the DeFi world; the other is Quant Agents, which focus more on professional automated strategy execution, akin to "Autopilots."

Both are still in early stages and have flaws, but together they point to a new direction—a fundamentally different, AI-driven way to interact with DeFi.

Intelligent Agents as "Copilots"

You can think of these intelligent agents as your personal assistants. You no longer need to sift through charts or jump between different protocols; just ask in natural language, such as: "What are the hottest tokens right now?" or "Where are the highest yields?" The agent can answer directly and provide the next step—like a knowledgeable friend always at your side.

Take &milo as an example. Its copilot mode can assist you in making investment decisions, rebalancing assets, and gaining portfolio insights—helping you stay in control while saving you from tedious operations.

With natural language explanations and smart prompts, &milo helps users understand positions and compare yield opportunities without digging through various dashboards. It demonstrates how copilot-type agents are evolving from simple chat assistants into fully functional DeFi guides.

To observe how these agents perform in practice, we tried several newly released products and experienced their ability to handle real DeFi tasks firsthand.

The results show that these agents still have limitations. For example, they can successfully identify popular tokens but fail to execute buy operations smoothly; there were also two failed transactions with the system indicating "insufficient balance," even though the account had enough SOL to pay the fees.

Similar platforms like The Hive take a different approach—combining multiple DeFi agents into a "swarm" that can collaboratively complete complex tasks such as cross-chain operations, yield strategies, and liquidation defense, all coordinated through a simple chat interface. This network of specialized agents can execute multi-step on-chain operations via natural language commands.

We tested the same buy command with The Hive. The system did identify the popular token WEED, but returned an incorrect contract address when executing the purchase.

Overall, Milo demonstrates how portfolio management tools can be integrated into a smooth workflow, while The Hive explores how multiple specialized agents can work together. As intelligent agents become more capable, their division of labor is becoming more apparent.

For example, Meridian focuses on another user group—helping beginners take their first steps into DeFi. It adopts a mobile-first design with clear prompts, making basic operations like swapping, staking, or checking yields more accessible.

Meridian performs smoothly and quickly on these core tasks, and more importantly, it is very clear about its boundaries. When users ask it to perform operations beyond its scope, it explains the reason instead of blindly trying—this "honesty" makes it a reliable starting point for newcomers exploring the on-chain world.

Meridian founder Benedict explained:

"Meridian allows users to safely research and operate using natural language. We have made the agent's research function freely available to the public at meridian.app. Users who register for the Meridian mobile app can use the agent's swap, multi-swap, and portfolio purchase functions. Accounts are still in closed beta; interested users can contact @bqbrady on Twitter to apply for access."

Through our testing, we found that most AI agents focused on DeFi navigation are still mainly in the role of "teacher" or "assistant," helping users complete the most basic operations (such as swapping).

To reliably handle more complex processes—such as providing liquidity or managing leveraged positions—further improvements are still needed.

As Rishin Sharma, Head of AI at the Solana Foundation, pointed out:

"Large language models (LLMs) are prone to hallucinations when handling broad tasks and struggle to execute deterministic operations. Function call mechanisms like MCP may be better suited to translate 'action plans' into actual execution. While LLMs perform well in ideation and guidance, they are still weak in precise execution. For agentic finance to be truly reliable, we must go beyond LLMs and develop specific function call mechanisms, clear execution strategies, verifiability, and secure permission systems. In other words, today's agent execution layer is still underdeveloped—the AI 'brain' is smart enough, but it still lacks a robust 'body' to act."

Intelligent Agents as "Autopilots"

If "copilot-type" agents are more like mentors, then "quantitative-type" agents are more like autopilot systems. They can not only build strategies but also actually execute—monitoring the market in real time, testing trades, and acting automatically at machine speed, bringing complex DeFi strategies into "fully automated" mode.

A typical case taking shape comes from SendAI. It is not a quantitative agent itself, but a toolkit that enables others to create such agents. Its "Agent Kit" for Solana supports over 60 autonomous operations, including token swaps, new asset issuance, lending management, and can interact directly with major protocols like Jupiter, Metaplex, and Raydium.

In other words, it provides developers with a "track system" that allows them to connect decision models directly to on-chain execution.

SendAI founder Yash clearly summarized their vision:

"We believe that every AI agent will have its own wallet in the future. SendAI is building the tools and economic layer needed for this system, enabling these agents to perform any operation on Solana. We are building a platform that gives these agents contextual awareness and supports long-running, persistent, and asynchronous execution of complex tasks."

Meanwhile, other teams are trying to make this capability more accessible. Lomen curates strategies and allows users to "deploy with one click," lowering the threshold for enjoying quantitative automation without writing code.

For more advanced users who prefer custom systems, Unblinked provides an AI-driven strategy experimentation environment. It's like the Cursor of trading: users can sketch out their strategy ideas, run and optimize them in a safe sandbox, and then decide whether to commit real funds.

Some platforms choose to call on multiple agents to collaborate on tasks.

For example, Almanak combines "programming agents" and "backtesting agents": users describe strategies in natural language, AI automatically generates production-grade code, and runs over 10,000 Monte Carlo simulations for backtesting, ultimately producing a "battle-ready" strategy.

Finally, some teams focus on real-time market advantages.

Giza's ARMA agent actively reallocates funds among lending protocols to maximize stablecoin yields. Instead of letting funds sit in a single pool, ARMA continuously monitors interest rates, liquidity, and gas costs, dynamically moving assets. Its flagship agent has managed over $17 millions in funds, claiming yields 83% higher than static positions.

Overall, these quantitative agents greatly reduce time costs and allow ordinary users to access complex strategies previously reserved for professional quant teams. However, they also reveal the fragility of automation: when data is delayed, protocols pause, or the market experiences violent swings, agents can still "stumble."

In other words, they can indeed make you faster, but are far from "invincible."

Their Challenges

After spending some time with today's intelligent agents, you'll notice similar problems: sometimes they suggest actions that no longer exist, such as a liquidity pool that has long been closed; the data they rely on often lags behind the real on-chain state; if a multi-step plan fails midway, they don't self-adjust but repeatedly attempt the same action.

Permission management is also clumsy—users must either grant full access to their entire wallet or manually approve every minor operation. Testing is equally shallow, as simulation environments cannot realistically reproduce sudden liquidity changes or governance parameter adjustments on-chain.

One of the most serious issues is that these agents almost all operate as "black boxes."

Users cannot know what inputs the agent read, how it weighed options, whether it checked real-time status, or why it chose to execute a particular transaction. There are no signed, verifiable operation records, so it's impossible to check whether the "promised result" matches the "actual execution."

Users can only use the system while "babysitting" the automation process—not only inefficient, but also making performance hard to evaluate.

Without a mechanism to verify decisions and prove that actions truly follow established strategies, users can never distinguish a "reliable system" from "well-packaged marketing."

For larger-scale capital, DeFi platforms must shift from "trust us" to "please verify." This is also the key turning point for building "auditable, governable, and trustworthy" agentic finance infrastructure.

Infrastructure Gaps

The core issue is that current systems lack the basic tools to keep agents trustworthy, consistent, and secure at scale. To solve this, we need infrastructure that can verify agent behavior, confirm execution results, and enforce unified rules across all environments. Only then will people feel comfortable entrusting real funds to them.

However, most users don't actually care about the agent's "thought process"; they just want to confirm that the output is correct, verified, and within safe boundaries. In building trust, "verifiable reliability" is more important than "visibility."

This is the meaning of "Verifiable Reliability." Agents don't need to record every internal step, but should operate under clear strategies and reasonable checks: set spending limits, execution time windows, confirmation nodes before key actions, etc.

At the underlying level, these rules can be enforced by Trusted Execution Environments (TEE) or similar systems—proving that agents follow boundaries without exposing all details. The result: auditable outputs when needed, and operations that ordinary users can immediately trust.

This verification layer doesn't have to be "one-size-fits-all." Everyday scenarios can use lightweight security protections and standardized metrics; high-risk or institutional scenarios can require stronger proofs and formal verification. The key is—every layer of infrastructure should provide reliability that matches its risk level and is measurable.

Making Protocols Agent-Ready

The next step is to make protocols "agent-friendly."

Currently, most DeFi protocols are not designed for intelligent agents. They need to provide more stable and secure execution interfaces: preview operations, safe retries, and execution based on consistent data structures. Permission design should also be "scoped" rather than "fully open," allowing agents to act within clear boundaries instead of controlling the entire wallet.

Without these foundational elements, even the smartest agent frameworks will be tripped up by a fragile base. Once these foundations are in place, users will no longer need to manually monitor automation; development teams can spend less time debugging and more time innovating; execution results from different service providers can be comparable due to shared benchmarks—no longer just marketing slogans.

What Must Change

The solution is actually not complicated: make agents provable, and make protocols agent-ready. Add a strategy layer between agents and wallets, and require all execution processes to be traceable and verifiable, not "black box operations."

For example, Termina's SVM engine is built on this concept—it provides a true Solana runtime environment for AI agents, enabling them to model, decide, and learn based on on-chain data. Meanwhile, protocols should open up "dry-run" operation interfaces, clear error codes, safe retry mechanisms, consistency in core data structures (positions, fees, health), and session-based permission control.

When these features are implemented, users can be freed from "babysitting" agents; teams can reduce system failures; institutional investors can finally get the safety rails and verifiable proofs they need.

Realistic Timeline

In the next six months, "copilot-type" agents are expected to improve the fastest. More complete data pipelines will enhance their reliability in everyday scenarios.

Within a year, as testing standards improve, agents will be able to coordinate execution across protocols, with humans only needing to approve key steps. In the longer term, as infrastructure matures, intelligent agents may gradually blur into the default interaction layer for DeFi—not just a separate "tool," but the main way people interact with financial systems daily.

Conclusion

"Agentic Finance" is lowering the barrier to entry, making automation no longer the exclusive tool of experts. But for it to truly operate at scale, it needs a better "foundation": real-time data, safer permission mechanisms, stronger testing systems, and more transparent execution results.

Smarter AI alone cannot solve these problems. Real progress will come from improvements in the underlying structure.

DeFi's next milestone is not just growth in scale, but—trust in automation. And that day will only truly arrive when AI agents are no longer just "concept demos," but become truly reliable executors.