CuyFI: shipping a cross-chain yield agent at ETH Global in 36 hours

ETH Global Argentina runs 36 hours. That’s not a lot of time to build something that actually works — not just a demo that passes the judges’ 2-minute slot, but something where the actual cross-chain message goes through, the vault accepts the deposit, and the agent reads the transaction receipt without exploding.

We built CuyFI. A cross-chain AI yield agent. Users send stablecoins once via a Telegram bot, and an LLM agent figures out where the best yield is — even if it’s on a different chain — and moves the funds there automatically.

The stack

Hackathon timeline

What shipped vs. what didn’t

The LangChain tool definition

The agent’s tools are what made the natural-language → on-chain execution handoff work. Each tool has a strict typed schema — no hallucinated parameters.

@tool
def deposit_to_vault(
    vault_address: str,
    amount_usdc: float,
    chain: Literal["arbitrum", "polygon"],
    user_wallet: str,
) -> dict:
    """
    Deposit USDC into an ERC-4626 vault on the specified chain.
    Returns transaction hash and share amount received.
    Requires explicit user confirmation before calling.
    """
    # Privy signs the tx on behalf of the user's smart wallet
    tx = privy_client.sign_and_send(
        wallet=user_wallet,
        to=vault_address,
        data=encode_deposit(amount_usdc),
        chain_id=CHAIN_IDS[chain],
    )
    return {"tx_hash": tx.hash, "status": "pending"}

The Literal["arbitrum", "polygon"] constraint is load-bearing — without it the LLM picks arbitrary chain IDs.

Architecture

What I’d do differently

Diamond proxy was the wrong call for a hackathon. We spent 6 hours on the Diamond setup — 6 hours we could have used on the Avail integration. A simple UUPS proxy would have been fine.

Start with the demo path, add features backward. We built the full architecture first, then integrated the demo path. Should have been the reverse.

Budget the x402 micropayments in advance. 180 queries × $0.12 = $21.60 on a $20 budget. The fix — 5-minute yield data cache — should have been built Day 1.

The Telegram UX saved us. When contract deployment broke at hour 28, the working Telegram bot gave judges context. “This is what the user sees” is a powerful frame when the underlying tech is partially broken.

On LayerZero

DVN confirmation time on testnet: 12–15 minutes. Fine for real users, not great for live judging. We pre-ran bridge transactions to show completed receipts.

What CuyFI taught me about agent architecture

The experience that stuck with me most wasn’t the cross-chain engineering — it was how the LangChain agent handled ambiguity.

Users would send “put some money in yield” with no amount. The agent asked a clarifying question. The user replied “maybe $50?” — and the agent proceeded. That handoff between natural language and deterministic financial execution is where most AI DeFi projects fail.

The key: treat the Telegram conversation as stateful (agent remembered prior messages), and require explicit confirmation before any financial parameter. That confirmation step felt like friction in testing. In the live demo, it felt like trustworthiness.

CuyFI was a proof of concept. But it was a working one. That’s what hackathons are for.