DelegateX

One permission. Infinite agents.

---

## Short Description

Autonomous wallet intelligence powered by MetaMask Smart Accounts. Grant one spending permission - AI agents plan, pay, and execute tasks while you sign once.

---

## Medium Description

DELEGATE is an autonomous agent platform for Web3 wallets. Users grant a single scoped permission via MetaMask Smart Accounts (ERC-7715) setting budget, allowed contracts, and expiry and then delegate natural-language tasks to AI agents that work independently.

DELEGATE’s orchestrator uses Venice AI to break tasks into subtasks, spawns specialized sub-agents with narrower ERC-7710 redelegations, and executes machine-to-machine payments through x402 and the 1Shot relayer. Agents fetch data, run inference, and execute on-chain actions without repeated wallet signatures.

Built for the MetaMask Smart Accounts Kit × 1Shot API × Venice AI Dev Cook Off.

---

### Overview

DELEGATE is autonomous wallet intelligence for Ethereum. It lets users grant one permission to their MetaMask Smart Account and delegate complex tasks to coordinated AI agents that plan, pay, and execute on their behalf.

Instead of signing every transaction an agent needs, users sign once defining exactly what DELEGATE can spend, which contracts it can interact with, and when the permission expires. From there, agents operate autonomously inside those guardrails.

---

### The Problem

AI agents in Web3 create a signature problem. Every data fetch, API call, swap, or rebalance requires a wallet popup. As agents become more capable and multi-step, the wallet turns into a notification machine - breaking flow and making autonomous workflows impractical.

Traditional token approvals are not enough. They grant broad token access without task scoping, time limits, or contract-level restrictions. Web3 needs a permission model built for autonomous agents, not manual transactions.

---

### The Solution

DELEGATE introduces a permission-first agent architecture:

1. Grant once - User sets a USDC spending limit, duration, and allowed contracts via ERC-7715 through MetaMask Smart Accounts Kit.

2. Delegate a task - User submits a natural-language prompt (e.g. “Research the top 3 DeFi yields on Ethereum and move $50 to the best one”).

3. Agents coordinate - DELEGATE’s orchestrator plans the task with Venice AI, spawns specialized sub-agents, and assigns each a narrower budget slice via ERC-7710 redelegation.

4. Agents pay and execute - Sub-agents pay for APIs and on-chain actions autonomously using x402 and the 1Shot permissionless relayer.

5. Result delivered - User receives a synthesized result. One permission grant. Zero task-level signatures.

---

### How It Works

Permission Layer (ERC-7715)

Permissions are scoped, time-limited, and revocable. Users define token, max spend per period, expiry, and allowed contract allowlists. MetaMask Smart Accounts enforce constraints on-chain.

Agent Orchestration (Venice AI)

Venice AI (Llama 3.3 70B) handles task planning, subtask decomposition, and result synthesis. Privacy-first inference - prompts are not stored or used for training.

Sub-Agent Coordination (ERC-7710)

Each sub-agent receives a redelegated permission slice. A Data Fetcher might get $1 for 5 minutes; an Executor might get $5. Smart contracts enforce that sub-agents cannot exceed their budget or interact with unapproved contracts.

Autonomous Payments (x402 + 1Shot)

When agents hit paywalled APIs, x402 handles HTTP-native machine payments. 1Shot relays ERC-7710 delegations on-chain without agents holding private keys. Every payment is verifiable and constrained by the user’s original permission.

On-Chain Enforcement (Solidity)

DelegateCore, SubAgentRegistry, and X402PaymentVerifier contracts manage permissions, sub-agent lifecycle, budget tracking, and payment verification on Ethereum.

---

### Key Features

- One-signature autonomy - Grant permission once; agents handle everything else

- Natural-language task delegation - Plain English prompts, complex multi-step execution

- Multi-agent orchestration - Parallel and sequential sub-agent coordination

- Real-time agent dashboard - Live feed of spawned agents, payments, and task progress

- Budget controls - Per-period spending limits with live budget meter

- Contract allowlists - Agents restricted to approved protocols and APIs

- Instant revocation - Users can revoke permissions at any time

- Task history & analytics - Spending charts, agent breakdowns, payment logs

- SIWE authentication - Secure wallet-based sessions

---

### Use Cases

| Use Case | Example Prompt | Outcome |

|----------|----------------|---------|

| DeFi Research & Execution | Research top yields and move funds to the best option | 4 agents, ~$0.05 cost, 1 signature |

| Portfolio Monitoring | Monitor positions and alert on >10% drops | Ongoing agents, 1 permission |

| Smart Batching | Find cheapest gas window and batch pending txs | 3 agents, minimal cost, 1 signature |

---

### Tech Stack

| Layer | Technology |

|-------|------------|

| Frontend | Next.js 14, Tailwind CSS, Framer Motion, GSAP |

| Wallet | MetaMask Smart Accounts Kit, wagmi, RainbowKit, SIWE |

| AI | Venice AI (Llama 3.3 70B) |

| Payments | x402 Protocol, 1Shot Permissionless Relayer |

| Blockchain | Ethereum, Solidity (OpenZeppelin) |

| Backend | Next.js API Routes, WebSocket server |

| Database | Supabase, Prisma |

Standards: ERC-7715 (permissions), ERC-7710 (redelegation), x402 (HTTP payments)

---

### Architecture

```

User (MetaMask Smart Account)

│

▼

ERC-7715 Permission Grant

│

▼

DELEGATE Orchestrator ──► Venice AI (task planning)

│

├──► Sub-Agent A (Data Fetcher) ──► x402 ──► 1Shot ──► DeFiLlama

├──► Sub-Agent B (Chain Analyzer) ──► x402 ──► 1Shot ──► RPC

├──► Sub-Agent C (Venice AI) ──► x402 ──► 1Shot ──► Inference

└──► Sub-Agent D (Executor) ──► x402 ──► 1Shot ──► Uniswap

│

▼

Result synthesized & delivered to user

```

Each sub-agent operates under ERC-7710 redelegation with enforced budget, expiry, and contract allowlists. The user’s original ERC-7715 permission is the only signature required.

---

### Why DELEGATE Matters

DELEGATE shows what becomes possible when wallet permissions, AI orchestration, and machine payments work together. Users keep control budget, contracts, expiry, revocation - while agents handle execution. It’s the foundation for autonomous wallet intelligence on Ethereum.

---

### Built For

MetaMask Smart Accounts Kit × 1Shot API × Venice AI Dev Cook Off

Progress During Hackathon

During the hackathon, we took DELEGATE from concept to a production-ready platform for autonomous wallet intelligence built for real community use on Ethereum.

---

### Week 1 - Foundation & On-Chain Core

We established the full stack architecture and shipped the on-chain permission system first.

- Designed and deployed DelegateCore, SubAgentRegistry, and X402PaymentVerifier smart contracts on Ethereum with budget enforcement, expiry checks, contract allowlists, and emergency pause controls

- Built the Prisma + Supabase data layer for users, permissions, tasks, sub-agents, payments, and spending analytics

- Implemented the design system and animation layer (GSAP + Framer Motion) to a production UI standard

- Shipped the full landing page - hero agent network visualization, problem/solution narrative, how-it-works flow, tech stack, use cases, and conversion CTAs

---

### Week 2 - Agent Engine & Integrations

We integrated the full sponsor stack and built the autonomous agent pipeline end to end.

- Integrated MetaMask Smart Accounts Kit with wagmi, RainbowKit, and SIWE for wallet auth and ERC-7715 permission grants

- Built the Venice AI orchestration layer for task planning, subtask decomposition, and result synthesis using Llama 3.3 70B

- Integrated 1Shot Permissionless Relayer for ERC-7710 delegation execution without agent-held keys

- Implemented x402 payment flows so agents pay for paywalled APIs and resources autonomously

- Shipped the agent orchestrator, planner, executor, and WebSocket server for real-time task progress streaming

---

### Week 3 - Product Surface & Community Readiness

We completed the full application experience and polished it for public launch.

- Built the main app /app) - permission panel, natural-language task input, live agent tree, payment feed, budget meter, and signatures counter

- Shipped the 4-step permission wizard with budget sliders, duration controls, contract allowlists, and MetaMask ERC-7715 confirmation

- Built the dashboard with task history, spending charts, active permission management, and one-click revoke

- Completed How It Works and Developer Docs for community onboarding and third-party integration

- Implemented full API layer - auth, permissions, tasks, agents, and x402 verification endpoints with Zod validation

- Ran end-to-end testing across permission grant → task delegation → multi-agent execution → payment relay → result delivery

- Recorded demo video and prepared submission materials for the Dev Cook Off

---

### What We Shipped

By the end of the hackathon, DELEGATE was a complete, community-ready product:

| Area | Delivered |

|------|-----------|

| Smart contracts | Permission grants, sub-agent spawning, budget enforcement, payment execution |

| Wallet integration | MetaMask Smart Accounts, ERC-7715 + ERC-7710, SIWE auth |

| AI orchestration | Venice-powered planning, parallel/sequential agent execution |

| Autonomous payments | x402 + 1Shot relay for machine-to-machine USDC payments |

| Real-time UX | WebSocket live feed, agent tree, budget meter, task results |

| User dashboard | History, analytics, permission management, spending charts |

| Developer docs | API reference, WebSocket events, contract integration guides |

| Production UI | Landing, app, dashboard, docs responsive, animated, polished |

---

### Impact

DELEGATE proves that Web3 wallets can support true agent autonomy without sacrificing user control. Community users grant one permission, delegate complex tasks in plain English, and watch specialized agents coordinate, pay, and execute with scoped budgets, contract allowlists, instant revocation, and full transparency in the dashboard.

The platform is ready for community adoption: connect wallet, grant permission, delegate tasks, and let agents work.

One permission. Infinite agents.