Fetch.ai Integration

Fetch.ai Integration

Fetch.ai is not just another AI-token project. It's a specific technical stack: autonomous agents (uAgents), Agentverse (agent marketplace), ASI Alliance (union with SingularityNET and Ocean Protocol). If your product requires autonomous agents that interact with each other in an economic network — this is a real tool, not hype.

Practical context: uAgents are used for supply chain automation (buyer-agent negotiates with supplier-agent), DeFi (agent monitors on-chain conditions and executes strategy), IoT (agent manages smart device and monetizes data).

uAgents: Technical Model

Agent Structure

uAgent is a Python process with built-in HTTP server, crypto-identity (secp256k1 keypair) and messaging 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
price_oracle = Agent(
    name="price-oracle",
    seed="your-deterministic-seed-phrase-here",  # reproducible address
    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):
    # Fetch price from external API
    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 unique address like agent1q... (Bech32-encoded public key). Address is deterministic from seed — reproducible across deployments.

Almanac: Registration and Discovery

Almanac is on-chain (Fetch.ai mainchain) agent registry. Agent registers its endpoint and protocols in Almanac, paying small FET commission. Other agents find needed ones through Almanac query.

# Search for agents with specific protocol
from uagents.query import query
from uagents.envelope import Envelope

# Get agent endpoint from Almanac
response = await query(
    destination="agent1qxxxxTargetAgentAddress",
    message=PriceRequest(token="ETH"),
    timeout=30
)

This is key difference from simple REST API: agent doesn't know another agent's URL beforehand — it finds it via decentralized registry. Message protocol verified through signatures.

Protocols and Message Schemas

Protocol in Fetch.ai terms — set of message types with unique digest (SHA256 from Pydantic schema). Two agents can interact only if using same digest — this ensures compatibility.

from uagents import Protocol

# Define protocol explicitly
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):
    # strategy execution logic
    ...

agent.include(defi_protocol)

Integration 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
    
    # Build and send transaction
    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)  # every minute
async def monitor_positions(ctx: Context):
    positions = await fetch_open_positions(WALLET_ADDRESS)
    for pos in positions:
        if pos.health_factor < LIQUIDATION_THRESHOLD:
            # Send alert to another agent
            await ctx.send(ALERT_AGENT_ADDRESS, LiquidationAlert(
                position_id=pos.id,
                health_factor=pos.health_factor
            ))

Agentverse and Deployment

Agentverse is hosted platform for Fetch.ai agents. Alternative to self-hosted: agent lives in Fetch.ai cloud, pay for compute in FET.

For production: self-hosted agent in Docker, endpoint behind reverse proxy (nginx). Almanac registration happens at startup automatically if correct endpoint passed.

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install uagents web3
COPY agent.py .
CMD ["python", "agent.py"]

Practical Limitations

Throughput. uAgents is not high-frequency system. Message via Almanac + HTTP has 100-500ms latency. Not suitable for HFT strategies. For monitoring, position management, orchestration — sufficient.

Message reliability. No built-in retry and delivery guarantees at protocol level. Need to implement at application level: timeout handling, acknowledgment patterns.

FET for Almanac. Registering agent in Almanac requires FET tokens. For production system with dozens of agents — account for in budget.

Work Process

Analysis (3-5 days). Define agent scope: what each does, how they communicate, what on-chain operations they perform, need Almanac discovery or direct addressing.

Development (2-6 weeks). Create agents → integrate with Web3/backend API → test in local agent network → deploy on Agentverse or self-hosted.

Monitoring. Agents are autonomous — need centralized logging (ELK or Grafana + Loki) and alerting on anomalous behavior (agent stopped responding, unexpected transactions).

Typical project: 2 agents (monitoring + execution) with on-chain integration — 3-4 weeks.