Fetch.ai uAgents: AI Agent Integration for Web3

Integration with Fetch.ai

Imagine your DeFi protocol requires automatic monitoring of liquidity in Uniswap V3 pools and rebalancing positions when ETH price changes by 5%. Manual execution causes a 15-minute delay, while an agent on Fetch.ai uAgents handles it in 20 seconds — 10x faster than traditional bots on AWS Lambda. Traditional solutions require trust in a central server, have a single point of failure, and high operational costs when scaling. Fetch.ai (now part of the ASI Alliance) eliminates these issues: each agent has a cryptographic identity, and interaction is decentralized via the Almanac registry. Our team of blockchain engineers has implemented agent systems for decentralized automation — if your product requires this approach, it's a working tool, not speculation. Contact us to discuss possibilities for your project.

Practical use cases: uAgents automate supply chains (buyer agent negotiates with supplier agent), DeFi (agent monitors on-chain conditions and executes strategy), IoT (agent manages a smart device and monetizes data).

How uAgents Work

Agent Structure

uAgent is a Python process with a built-in HTTP server, a crypto identity (secp256k1 keypair), and a message protocol.

from uagents import Agent, Context, Model

class PriceRequest(Model):
    token: str
    currency: str = "USD"

class PriceResponse(Model):
    token: str
    price: float
    timestamp: int

price_oracle = Agent(
    name="price-oracle",
    seed="your-deterministic-seed-phrase-here",
    port=8001,
    endpoint=["http://localhost:8001/submit"],
)

@price_oracle.on_message(model=PriceRequest, replies=PriceResponse)
async def handle_price_request(ctx: Context, sender: str, msg: PriceRequest):
    price = await get_price_from_coingecko(msg.token, msg.currency)
    await ctx.send(sender, PriceResponse(
        token=msg.token,
        price=price,
        timestamp=int(time.time())
    ))
    ctx.logger.info(f"Sent {msg.token} price {price} to {sender}")

Each agent has a unique address like agent1q... (Bech32-encoded public key). The address is deterministic from the seed — reproducible between deployments.

Almanac: Registration and Discovery

Almanac is an on-chain registry (Fetch.ai mainchain) for agents. An agent registers its endpoint and protocols in Almanac, paying a fee in FET. Other agents find required ones by querying Almanac.

from uagents.query import query
response = await query(
    destination="agent1qxxxxTargetAgentAddress",
    message=PriceRequest(token="ETH"),
    timeout=30,
)

This is a key difference from simple REST APIs: an agent doesn't know another agent's URL in advance — it finds it through a decentralized registry. The interaction protocol is verified by message signatures.

Protocols and Message Schemas

A protocol is a set of message types with a unique digest (SHA256 of the Pydantic schema). Two agents interact only if they use the same digest.

from uagents import Protocol

defi_protocol = Protocol(name="DeFiStrategy", version="1.0.0")

class ExecuteStrategy(Model):
    strategy_id: str
    params: dict
    max_slippage: float

class StrategyResult(Model):
    success: bool
    tx_hash: str | None
    error: str | None

@defi_protocol.on_message(model=ExecuteStrategy, replies=StrategyResult)
async def execute(ctx: Context, sender: str, msg: ExecuteStrategy):
    # execution logic ...

agent.include(defi_protocol)

How Fetch.ai Integrates with DeFi and Web3

Agent with On-Chain Interaction

from web3 import Web3
from uagents import Agent, Context

w3 = Web3(Web3.HTTPProvider("https://arbitrum-one.publicnode.com"))
agent = Agent(name="defi-executor", seed="...")

class ArbitrageOpportunity(Model):
    token_in: str
    token_out: str
    amount: float
    expected_profit: float

@agent.on_message(model=ArbitrageOpportunity)
async def execute_arbitrage(ctx: Context, sender: str, msg: ArbitrageOpportunity):
    if msg.expected_profit < MIN_PROFIT_THRESHOLD:
        ctx.logger.warning(f"Skipping low-profit opportunity: {msg.expected_profit}")
        return
    tx = build_arbitrage_tx(msg.token_in, msg.token_out, msg.amount)
    signed = w3.eth.account.sign_transaction(tx, PRIVATE_KEY)
    tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)
    ctx.logger.info(f"Executed arbitrage: {tx_hash.hex()}")

Periodic Tasks

@agent.on_interval(period=60.0)
async def monitor_positions(ctx: Context):
    positions = await fetch_open_positions(WALLET_ADDRESS)
    for pos in positions:
        if pos.health_factor < LIQUIDATION_THRESHOLD:
            await ctx.send(ALERT_AGENT_ADDRESS, LiquidationAlert(
                position_id=pos.id,
                health_factor=pos.health_factor
            ))

Why Fetch.ai for DeFi?

Autonomous agents solve tasks where human monitoring is inefficient: continuous on-chain analysis, automated conditional trades, decentralized data exchange. They reduce reaction latency to market events by four times compared to manual management. We have implemented projects where agents manage pool liquidity and optimize gas costs, saving up to 30% in fees. Want a similar result? Get a consultation — we will prepare an architecture for your case.

According to Fetch.ai documentation, Agentverse provides built-in monitoring. For high-load production, self-hosted offers more flexibility.

How Agent Development Works

The process includes five steps:

• Analytics (3–5 days). Define agent scope, protocols, and on-chain operations.
• Development (2–6 weeks). Write agent code with Web3/API integration.
• Testing. Simulate interaction in a local network with multiple agents.
• Deployment. Deploy on Agentverse or self-hosted with CI/CD.
• Monitoring. Set up logging and alerting (Grafana + Loki).

A typical project: 2 agents (monitoring + execution) with on-chain integration — 3–4 weeks. Our team with blockchain development experience has completed over 30 such projects. Contact us to evaluate your project — we will prepare a prototype within a week.

Practical Limitations

Throughput. uAgents are not a high-frequency system. A message via Almanac + HTTP has latency of 100–500 ms. Not suitable for HFT strategies. Suitable for monitoring and orchestration.

Message reliability. No built-in retry or delivery guarantees. Implement at the application level: timeout handling, acknowledge patterns.

FET for Almanac. Registration requires FET tokens (about 0.1 FET per registration). For production with dozens of agents, include this in the budget.

What Is Included in the Work

We deliver turnkey:

• Architectural documentation and agent interaction diagram
• Agent source code with comments
• Docker images and CI/CD pipeline
• Integration with on-chain smart contracts (EVM, Solana)
• Monitoring setup (Grafana + Loki) and alerting
• Training your team on the platform

Get a consultation on your project — we will prepare a prototype within a week.