Robo DeFi Advisor

Robo DeFi Advisor is like a personal financial assistant for Web3 investing. Instead of learning how to use complex DeFi protocols, compare pools, or analyze risks, users can simply type what they want in plain English, and our system does the rest.

For example, a user can say: “I want to invest $1000 in the safest USDC pool that gives me at least 8% APY.”

Here’s what happens behind the scenes:

ASI:One understands the user’s request and turns it into structured instructions (amount, token, risk level, yield requirement).

A Discovery Agent fetches available pools from DeFi data sources like DeFiLlama and DexScreener.

A Risk Agent checks those pools against safety factors using MeTTa (e.g., audit status, liquidity, token history, volatility).

A Decision Agent compares all the options, verifies they match the user’s request, and picks the best ones.

The user gets back a clear answer in chat, such as: “The best option is the USDC/USDT pool on Surge DEX with 8.2% APY, verified audit, and $1.2M liquidity.”

Everything happens inside ASI chat — the user never has to open multiple dApps or figure out risk scores manually. Agents talk to each other securely on the Fetch Network, using DID identities and encrypted messages, so the results are trustworthy. Because the agent is also published in Agentverse, others in the ecosystem can discover and reuse it.

Our end goal is to make DeFi as simple as asking a friend for advice: you say what you want, the system finds it, checks risks, and (in future versions) even prepares the transaction for you to just sign.

I built Robo DeFi Advisor by combining the ASI stack with Web3 data sources and autonomous agents to make intent-driven DeFi investing possible.

ASI:One — handles natural language input from the user (e.g., “Invest $1000 in the safest pool”) and parses it into a structured intent object (amount, tokens, APY target, risk preferences).

uAgents — modular agents for each responsibility:

Discovery Agent queries DeFiLlama and DexScreener APIs to find candidate pools.

Risk Agent uses MeTTa knowledge graph + rules to filter and score pools based on audits, liquidity, token history, and volatility.

Decision Agent reconciles user constraints with pool/risk metrics and produces the final ranked recommendations.

Fetch Network — provides DID-based identities and encrypted messaging between agents, ensuring tamper-proof handoffs (e.g., Discovery → Risk Agent). This makes the system secure and trustworthy even when multiple agents run independently.

Agentverse — we listed the Advisory Agent so it can be discovered and reused by others in the ecosystem. This makes our project not just a standalone app, but a reusable building block. Currently on mailbox.

MeTTa — adds explainability and provenance. Instead of just giving a pool recommendation, the system can show why (e.g., “verified contract, $1.2M liquidity, 8.2% APY”).

Data Sources — DeFiLlama and DexScreener for pool/yield data, CoinGecko for prices, and Etherscan for token verification.

Hacky / Notable Bits

We used natural language → structured intent parsing with ASI:One to simulate “prompt-to-intent” without needing a separate NLP service.

Built lightweight agent-to-agent JSON messaging with signed DIDs to prove authenticity — ensuring no pool data can be spoofed in transit.

To speed things up during the hackathon, we cached DeFiLlama queries and pre-ranked some pools for demo reliability.