Wave Protocol

An onchain AI yield manager for stablecoins ! where you don't have to trust the AI, because the chain enforces it.

The problem

Letting an AI agent manage your money means handing a model your funds and hoping it behaves. Every "AI DeFi" product today is a trust exercise: the agent could misallocate, overreach, or drain you, and nothing stops it but good intentions. Wave replaces that trust with cryptography.

What it does

You deposit idle USDC and set a goal ("grow it safely," "best risk-adjusted yield," "keep it liquid"). A swarm of AI agents debates the best strategy, reaches consensus onchain, and deploys your capital — and the agents are physically incapable of acting outside that consensus or beyond the budget you granted.

The flow, end to end

1. Grant — you stay in control (MetaMask Smart Accounts + ERC-7715) You connect MetaMask and sign an ERC-7715 Advanced Permission — a spending cap delegated to the lead agent. You're not approving a contract or handing over keys; you're authorizing a bounded amount, and nothing more. The grant is gasless (a signature). Behind it, the agents are real MetaMask Smart Accounts (toMetaMaskSmartAccount, Hybrid).

2. Redelegation (ERC-7710) That single grant is redelegated over ERC-7710 to three independent agent smart accounts, each wrapped in a custom caveat that ties its authority to a specific debate session and outcome.

3. Debate — agents that pay to think (Venice AI + x402) Three lenses — Yield, Risk, Liquidity — reason in parallel on Venice AI, then critique each other across two rounds. Crucially, thinking isn't free:

• Every inference is gated by x402 (HTTP 402, Payment Required), settled onchain as a gasless EIP-3009 USDC transfer.

• In round two each agent places a conviction bet — the more confident it is, the more USDC it pays. Confidence is priced in real money; you can't bluff for free.

4. Collapse — the contract decides (custom ERC-7710 enforcer) Each agent commits a hash of its reasoning to our VeniceCollapseEnforcer, a Solidity caveat enforcer we wrote and deployed on Base. When the final hash lands, the contract itself collapses the "wavefunction" — selecting the highest-conviction winner, deterministically and onchain. We don't choose the winner; the enforcer does, and anyone can re-verify it.

5. Constrained execution — the trust guarantee The winning agent redeems its delegation through MetaMask's DelegationManager — but the enforcer only permits the collapse winner to redeem, only within your ERC-7715 budget, only to deploy the agreed strategy. A losing agent, or any attempt before consensus, reverts. This is constrained AI: the model can act, but only exactly how and how much the chain allows.

6. You own the yield (Compound V3) The capital is supplied to Compound V3 via supplyTo(you) — the position and all yield are credited to your address. The agents only chose the strategy; you keep it and can withdraw anytime.

Wave Market — strategies as tradeable assets

A proven strategy shouldn't die after one use. After a collapse, the owner can list the winning strategy on Wave Market:

• The listing is onchain and provenance-gated — you can only list a strategy that genuinely won a collapse.

• A buyer pays the creator directly over x402 (a real buyer→seller USDC sale), and the protocol re-executes the proven strategy for the buyer's own capital, into their own Compound position — no debate to re-run.

• Here x402 isn't paying for compute; it's the marketplace settlement rail. Creators earn on every copy.

Built-in transparency

Every debate, payment, and deployment is persisted and surfaced:

• The Ledger — every collapse, public and Basescan-linked.

• The Strategists — an agent leaderboard with win rates, conviction staked, and calibration (is an agent confident when it's actually right?).

• State of the Wave — protocol stats with live onchain TVL read straight from Compound.

• Your Positions — your live Compound balance, principal vs. value, and net yield.

• The Coordination Map — an A2A knowledge graph of who critiqued whom, which lens won, and which strategies got copied.

The standards, working together

• MetaMask Smart Accounts Kit — agents as Hybrid smart accounts; execution via the DelegationManager.

• ERC-7715 (Advanced Permissions) — the user's spending-cap grant.

• ERC-7710 — redelegation to agents + the custom caveat enforcer that gates everything.

• x402 — pay-per-inference, conviction bets, and marketplace settlement.

• Venice AI — private, uncensored multi-agent reasoning.

• Compound V3 — the live yield venue; the user owns the position.

• Base — everything is real and verifiable onchain.

Why it matters

Wave is a blueprint for agentic finance you can actually trust: autonomous agents that debate with real economic stake, coordinate agent-to-agent, reach verifiable onchain consensus, and operate inside cryptographic guardrails that make misbehavior impossible — not just discouraged. And by making winning strategies tradeable, it turns AI reasoning itself into a market.

We built Wave Protocol end-to-end during the hackathon — from contracts to a working, onchain demo across 9 pages. Highlights:

Smart contracts (written + deployed on Base Sepolia)

• VeniceCollapseEnforcer — a custom ERC-7710 caveat enforcer that receives agents' reasoning hashes, collapses the debate to the highest-conviction winner onchain, and gates redemption so only the winner can act.

• WaveStrategyVault — constrained execution layer; verifies onchain consensus, then supplies USDC to Compound V3 credited to the user (the user owns the position + yield).

• WaveMarket — copy-trading marketplace; re-executes a proven, provenance-checked strategy for a buyer.

• All three covered by no-mock fork tests against the live enforcer, Compound V3, and USDC (e.g. WaveMarket 7/7 passing).

MetaMask delegation stack (the core, working live)

• Integrated the Smart Accounts Kit: 3 agents as Hybrid smart accounts.

• ERC-7715 grant flow (requestExecutionPermissions) — the user signs a spending cap in MetaMask Flask.

• ERC-7710 redelegation of that grant to the agents, each scoped by our custom caveat.

• DelegationManager redeem by the collapse winner — got the full grant → redelegate → redeem path working live onchain (including auto-deploying the user's gator + agent smart accounts, and fixing an RPC read-after-write race that was reverting the redeem).

x402 (three uses)

• Built a self-hosted x402-gated inference gateway — agents pay per Venice inference via gasless EIP-3009 USDC, settled onchain.

• Conviction bets — round-2 price scales with agent confidence.

• Marketplace settlement — buyer → seller USDC over x402.

AI + execution

• 2-round A2A debate on Venice AI (Yield / Risk / Liquidity lenses) with peer critique and confidence revision; tuned for speed (~70s end-to-end).

• Compound V3 deployment via supplyTo, verified onchain (real cUSDC positions credited to users).

Frontend (9 pages, full design system)

• Live session runner (wave-interference canvas, debate floor, real-time SSE wave.log terminal with per-tx Basescan links, result card with an ERC-7710 delegation badge).

• Wave Market (list + buy with browser-side x402 signing), A2A Coordination Graph (force-directed knowledge graph), plus Ledger, Strategists leaderboard, live-onchain Stats, and Portfolio.

Backend / infra

• Next.js API (x402 gateway, session orchestration, SSE), Prisma + Neon for persistence, Redis (Upstash) pub/sub for live streaming, viem + Foundry for chain ops.

Verified end-to-end onchain: connect → ERC-7715 grant → ERC-7710 redelegation → 2-round x402-paid debate → onchain collapse → DelegationManager redeem → Compound V3 position owned by the user → list on Wave Market → copy-trade purchase — every step confirmed on Base Sepolia.

Not fundraising. Wave was built during the hackathon and is fully self-funded. Open to grants or pre-seed conversations if we take it past prototype.