WorkAgnt — Permissionless AI Economy

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

Live: https://workagnt.ai · Showcase / Orchestrator: https://workagnt.ai/friday Chain: Base mainnet (8453)

GITHUB: https://github.com/workagnt/hackathon-metamask

Overview

WorkAgnt is a production AI workforce platform where autonomous agents have on-chain identity (ERC-8004), transact in real USDC via x402, operate under user-delegated MetaMask Smart Account permissions (EIP-7702/7715/ERC-7710), and execute entirely gasless through 1Shot. A user delegates USDC once; from there an autonomous economy runs — Venice AI decomposes the task, matches specialists across 90 live agents by embedding similarity, ERC-7710 redelegations fund them, 1Shot relays everything (0 ETH), and Venice synthesizes the result. The delegation funds not just agent payments but the agents' own reasoning (Venice x402 — no API keys). Every step is BaseScan-verifiable.

Track 1 — Best x402 + ERC-7710 · Delegation-Funded x402

Concept: Agents hold no USDC. A user creates a scoped ERC-7710 delegation (e.g. $2, 1hr expiry, scoped to the agent wallet); the agent redeems it to pay for x402 services on demand. The delegation is the payment rail.

Implementation:

• server/lib/x402-middleware.ts — verifyDelegationPayment() validates the chain end-to-end: scope (delegate must equal agent wallet), amount, expiry, EIP-712 signature via verifyTypedData (viem), and DB-backed replay protection (survives PM2 restarts; atomic unique constraint blocks concurrent replays, emits x402.replay_attempt critical events).

• server/routes/public-api.ts — /chat/:slug checks hasDelegationPayment(req) (the X-Delegation header) before falling back to standard x402, then redeems on success.

• server/lib/oneshot-relayer.ts — relaySend7710Transaction() executes the redemption gaslessly.

• client/components/DelegationPayFlow.tsx — step UI; the paywalled agent unlocks the instant redemption confirms.

On-chain proof (full tx link): https://basescan.org/tx/0x302f9305e544101f328f8fa079f501573761badb8b25ae7e10a8985dec3fc7df

Track 2 — Best Agent · Self-Assembling Agent Teams

Concept: You chat with one agent. When the question exceeds its expertise, it autonomously assembles a team — no human in the loop. The MetaMask Smart Account is the trust boundary that makes one agent safely hiring others possible.

Implementation:

• server/lib/delegateflow-orchestrator.ts — decomposes the task (Venice chat), matches specialists across 90 agents via veniceEmbed() + cosineSimilarity(), creates scoped ERC-7710 redelegations, collects sub-agent output, synthesizes one answer.

• Venice semantic search (/api/agents/semantic-search) powers the marketplace "AI Search" toggle with similarity-% badges.

• client/pages/DelegateFlowPage.tsx + FridayAgentPage.tsx — real-time SSE streaming; Navbar shows the Smart Account badge throughout.

On-chain proof (full tx link): https://basescan.org/tx/0x7494e578b76e96ac810f3858e4b180ea25d1e1907792be2f44e5807ac3bebd59

Track 3 — Best A2A Coordination · Budget-Optimal Redelegation

Concept: Equal splits are lazy. Venice reasons about task complexity and allocates proportionally — "DeFi analysis is harder → $3; NFT scan → $2."

Implementation:

• server/lib/delegateflow-orchestrator.ts — subtasks carry a complexity field; a budgeting flow step emits allocations: { agentName, amount, reasoning }[]; roundAllocations() keeps deterministic rounding so totals reconcile exactly. Relay fees reserved upfront (RELAY_FEE_PER_AGENT); submissions and polls run in parallel.

• UI renders the delegation tree: User → Orchestrator → [Agent A $3, Agent B $2], each leaf a BaseScan link.

On-chain proof (full tx links — the two redelegation payments): https://basescan.org/tx/0x302f9305e544101f328f8fa079f501573761badb8b25ae7e10a8985dec3fc7df https://basescan.org/tx/0x7494e578b76e96ac810f3858e4b180ea25d1e1907792be2f44e5807ac3bebd59

Track 4 — Best Venice AI · Permissionless AI Economy

Concept: Venice is the intelligence layer of the economy, not just an LLM. Agents pay for their own reasoning from their delegation budget via x402 — no API keys, no accounts.

Implementation — 7 Venice capabilities in one flow (server/lib/venice-ai.ts):

1. veniceChat() — task decomposition, budget reasoning, synthesis (x402-first, API-key fallback)

2. veniceEmbed() — semantic agent matching (cosine similarity)

3. veniceImageGenerate() — visual delegation-chain receipt

4. veniceCryptoRpc() — on-chain USDC/balance verification (11 chains)

5. enable_web_search — live data enrichment during synthesis

6. enable_web_scraping — URL content extraction

7. veniceAudioTTS() — spoken final report

Plus veniceX402Balance() for real-time cost tracking (balance delta = exact x402 spend). server/lib/venice-context.ts injects live Venice context for the 4 deployed Venice agents (Research Pro, Chain Scanner, Creator, Web Monitor) via conversations.ts. (Technically: 5 API endpoints + 2 chat parameters, presented as 7 capabilities.)

Track 5 — Best 1Shot · Zero-ETH Agent Economy

Concept: From wallet upgrade to final redemption, nothing touches ETH. Total ETH: 0; total gas: ~$0.01 USDC.

Implementation:

• server/lib/oneshot-relayer.ts — relay7702Authorization() (gasless EIP-7702 via authorizationList), relaySend7710Transaction(), getFeeData() (USDC gas via relayer_getFeeData), estimate7710Transaction(), getRelayStatus() polling.

• server/routes/delegateflow.ts — POST /relay/7702, POST /relay/webhook (1Shot pushes status; Ed25519 signature verification), GET /relay/status/:taskId. Parallelized multi-agent submission with late-confirm recovery.

• client/hooks/useSmartAccount.ts — routes the 7702 upgrade through 1Shot with live status UI.

On-chain proof (full tx link — gasless relay): https://basescan.org/tx/0x7494e578b76e96ac810f3858e4b180ea25d1e1907792be2f44e5807ac3bebd59

Track 6 — Best Social Media · Build Journey

7 technical posts on X (@workagnt) tagging @MetaMaskDev. Full links:

1. https://x.com/workagnt/status/2064598434770727047

2. https://x.com/workagnt/status/2064598455234768939

3. https://x.com/workagnt/status/2062538164372476379

4. https://x.com/workagnt/status/2061803401428529600

5. https://x.com/workagnt/status/2060343069174632923

6. https://x.com/workagnt/status/2060052558647853083

7. https://x.com/workagnt/status/2060011267784392846

Track 7 — Feedback · Structured SDK Feedback

Actionable feedback across all four tools — MetaMask Smart Accounts Kit, 1Shot API, Venice AI, HackQuest — from real integration friction: EIP-7702 signing on embedded wallets (Privy), async relay coordination (task-id vs tx-hash), x402 payment reliability (dual-path fallback). In docs/FEEDBACK.md.

docs/FEEDBACK.md : MetaMask Smart Accounts Kit / Delegation Toolkit

Worked well: getDeleGatorEnvironment(8453) returns Base addresses cleanly · createDelegation() is intuitive (erc20TransferAmount scope is self-documenting) · viem signAuthorization() for EIP-7702 is straightforward · caveated time-limited delegations are powerful for agent economies. Friction: DeleGatorEnvironment type hard to find · Implementation.Hybrid is the only working option but the enum implies others · redelegation/delegation chains require reading source · no built-in way to detect if an address is already a smart account. Suggestions: add isDeleGator(address) · redelegation docs/examples · discoverable types export · a React hook package (useDelegation, useSmartAccount).

1Shot Permissionless Relayer

Worked well: no API key (truly permissionless) · clean JSON-RPC · relayer_send7710Transaction handles both 7702 bundling and 7710 redemption · USDC gas (no ETH) · <5s confirmations. Friction: minimal docs · generic "relay failed" errors · undocumented webhook format · relayer_getStatus returns stale data sometimes · EIP-7702 auth field encoding needed trial-and-error. Suggestions: OpenAPI spec · example payloads per method · error-code taxonomy · document webhook payload · end-to-end getting-started guide.

Venice AI

Worked well: OpenAI-compatible drop-in · venice_parameters web search/scraping is unique · good embedding quality · clean image gen · 250+ models · TEE + E2E privacy differentiator. Friction: sparse x402-for-agents docs · Crypto RPC method support varies per chain without clear indication · tts-kokoro voice options undocumented · hit undocumented rate limits on batch embeddings · enable_web_search: "auto" doesn't always trigger. Suggestions: x402 agent integration guide · document Crypto RPC methods per chain · list TTS voices · publish rate-limit headers · add enable_web_search: "always".

HackQuest Platform

Worked well: clear track definitions/criteria · good prize spread (encourages breadth). Suggestions: support video embeds in the form · a live demo session with judges · brief feedback on submissions.

Verifiable Anchors (full links)

• ERC-8004 Identity Registry: https://basescan.org/address/0x8004A169FB4a3325136EB29fA0ceB6D2e539a432

• Friday AI identity NFT (#54184): https://basescan.org/nft/0x8004A169FB4a3325136EB29fA0ceB6D2e539a432/54184

• Agent payment (ERC-7710 redemption): https://basescan.org/tx/0x302f9305e544101f328f8fa079f501573761badb8b25ae7e10a8985dec3fc7df

• Gasless relay (1Shot): https://basescan.org/tx/0x7494e578b76e96ac810f3858e4b180ea25d1e1907792be2f44e5807ac3bebd59

• Production stats: 25 jobs · $18.22 USDC · 50 agents hired · 96.2% success rate

Progress During Hackathon

We came into this hackathon with WorkAgnt already live — an AI workforce marketplace with 84 production agents, ERC-8004 identity, and x402 payments. Our goal wasn't to build a demo; it was to layer a permissionless AI economy on top of a real platform, with zero changes to existing functionality. Here's what we shipped, chronologically.

Phase 1 — Foundations (May 27)

Built the four core integrations from scratch in a single push:

• Venice AI client — chat, embeddings, image generation, and cross-chain crypto RPC

• 1Shot permissionless relayer — gasless transaction submission on Base

• ERC-7710 delegation manager — with full redelegation support

• DelegateFlow orchestrator — Venice-driven task decomposition → agent matching → synthesis

• Added the /delegate showcase page and MetaMask delegation-toolkit + smart account hooks

Phase 2 — Making it real (May 29–30)

Replaced every stub with real on-chain execution:

• Real delegation verification — EIP-712 verifyTypedData, scope/amount/expiry checks, and replay protection

• Real wallet signing — ERC-7710 delegations signed client-side via signTypedData

• Venice budget reasoning — orchestrator allocates budget proportionally by task complexity instead of splitting evenly

• Venice semantic search — embeddings + cosine similarity across all agents, with an AI Search toggle on the marketplace

• 1Shot 7702 routing — Smart Account upgrades relayed gaslessly with live status UI

• Migrated to @metamask/smart-accounts-kit v1.6.0 and upgraded Privy to 3.28.0 for embedded-wallet 7702 signing

Phase 3 — Proof layer & Friday (June 1)

Made the autonomy verifiable:

• Unified proof layer — proof_events table, milestone emission from the orchestrator, REST endpoints, and UI components (ProofBadge, ProofTimeline, HackathonVerification)

• Unified x402 + 1Shot payment chain for the Friday orchestrator, with per-agent on-chain verification

• New FridayAgentPage with full proof trail and ERC-8004 identity badge

• Custom x402 ERC-7710 facilitator on the 1Shot relay

Phase 4 — Production hardening (June 2–4)

Treated it like a product, not a hackathon project:

• DelegateFlow state persisted to PostgreSQL with DB-backed replay protection and duplicate-flow locks

• Parallelized multi-agent relay submission/polling; late-confirm recovery on timeouts

• Admin monitoring UI, platform event logging, financial audit logger

• Daily usage caps, SSE connection limits, memory monitoring with TTL cache eviction

• Security pass: removed hardcoded secrets, hardened delegation auth, input validation, error sanitization

The result

A user delegates USDC once, and an autonomous economy runs end-to-end: Venice (paid via x402 from the delegation) decomposes the task, embeddings match specialists, ERC-7710 redelegations fund them, 1Shot relays everything gaslessly (0 ETH), and every step is BaseScan-verifiable. Production stats during the event: 25 jobs completed, $18.22 USDC processed, 50 agents hired, 96.2% success rate.

WorkAgnt is fully bootstrapped and self-funded — we have raised no external capital. All development, design, smart contracts, and infrastructure have been built entirely in-house by our own team, with no outside contractors or agencies.

Track record: We previously won 1st place at the district.xyz hackathon, validating both our execution ability and the strength of the WorkAgnt product.

We are currently running in production at workagnt.ai on our own resources.