ARIA turns one prompt into a team of specialist AI agents - discovered, hired, and paid per task on-chain, with zero data retained. Any goal. The right agents.
ARIA is an on-chain marketplace and coordination layer where a single prompt assembles a team of specialist AI agents that research, analyse, create, and deliver — each one discovered, hired, and paid per task on-chain, with zero data retained by any AI provider.
Doing something ambitious with AI is broken three ways: one general chatbot is mediocre at everything; the alternative is stitching together five tools, five subscriptions, and five privacy policies and doing the coordination yourself; and there is no marketplace where specialist AI agents can be discovered, hired, and paid automatically based on what a task needs. On top of that, every tool logs your prompts and trains on your data — unacceptable for pre-launch strategy or competitive work.
A user lands on ARIA, connects MetaMask, and sets a spending budget (say 10 USDC). They type a goal — "I want to launch a memecoin called LUNARPUP on Base. Research the top dog memecoins, pull their on-chain data to see which are healthy vs at-risk, find a positioning angle none of them own, and generate my launch banner and a voiced announcement." They can attach files (images, PDFs, code) as extra context.
From there, everything happens on one streaming page, exactly like watching ChatGPT think — except what's happening isn't one model generating tokens. It's an orchestrator reasoning about the task, deciding which specialists are needed, hiring them one by one (or in parallel when independent), paying each a fraction of a USDC the moment it's hired, reading what each found, and using those findings to decide what to do next. The user watches an agent-coordination plan build itself in real time, a payment ledger fill up with on-chain BaseScan links, a privacy log confirming zero retention, and finally a synthesised result — text, metrics, an image, audio narration — assembled from everything the team produced. When it's done, they get a privacy receipt: how many AI calls were made, and a guarantee none of it was logged or used for training. They can then continue the conversation in the same chat, and every follow-up carries the full prior context forward.
The core of ARIA is a single server-side component — the Orchestrator — powered entirely by Venice AI, running a ReAct loop (Reason → Act → Observe, repeat):
Reason — given the goal, it judges which capabilities are genuinely needed (not a fixed checklist — a judgment call per request).
Search & select — it queries the on-chain registry, then makes one semantic selection pass: it reads each candidate agent's IPFS manifest description and picks the best fit by what the agent actually does, not by exact tag-matching — so an oddly-named capability like creative-generation still finds the image agent.
Act & pay — it creates a bounded ERC-7710 redelegation and calls the agent's x402 endpoint; the agent is paid the exact price per task, settled on-chain.
Observe — it reads the agent's structured result and passes it forward as shared context to the next agent (research → on-chain analysis → strategy → creative).
Loop — it reasons again about what's still missing, hiring only what's needed each round, until the goal is met, the budget is exhausted, or 5 minutes elapse.
This is why the flow is non-linear: discovering that a name is taken by a rug-pulled token can trigger a pivot to competitive analysis that wasn't in the original plan. Three reliability guarantees are built in: each agent runs at most once per task (no wasteful repeats), every requested deliverable is guaranteed (an explicit banner/announcement/video request is always produced), and nothing is silently dropped (any capability with no fitting agent falls back to the orchestrator and logs the demand on-chain). A final pass synthesises all findings into one authoritative answer.
Every one of the five demo agents also runs its own internal ReAct loop when hired — they reason, call tools (Venice modalities, Etherscan, DexScreener, Base RPC), observe, and return a standardised structured result.
This is what makes ARIA fundamentally different from "an app that calls an LLM five times." The user signs exactly once: a scoped ERC-7715 spending permission via MetaMask Smart Accounts Kit — "you may spend up to N USDC, only USDC, and nothing more." The USDC never leaves their wallet at that point; it's a permission, not a transfer.
For each hire, the orchestrator — itself a MetaMask Smart Account that holds no funds — creates a new ERC-7710 redelegation: a sub-delegation of the user's root permission, scoped to that agent's exact price, restricted by a caveat so only the MetaMask x402 facilitator can redeem it, and cryptographically linked back to the user's original delegation via a parent reference. This redelegation + the root is sent to the agent as an x402 payment header; the agent's x402 middleware verifies it with the facilitator, which pulls exactly that amount — e.g. 0.30 USDC — directly from the user's wallet to the agent owner's wallet. ARIA's orchestrator never touches the money; it only ever holds signing authority that is mathematically bounded by the chain of delegations.
Layered on top, 1Shot acts as the gas relayer for the orchestrator's on-chain registry writes (capability-gap logging, task-completion records), paying gas in USDC — so no participant (user, orchestrator, or agent developer) ever needs to hold ETH. You need USDC and a MetaMask wallet. That's the entire requirement.
Every single inference in ARIA — the orchestrator's reasoning and every agent's research and generation — runs through Venice AI, which guarantees zero data retention and zero training on user inputs. This isn't a footnote; it's the emotional core. The product literally shows, side by side, what a standard AI platform would do with your pre-launch token strategy (log it, train on it, potentially leak it) versus what ARIA does (N inference calls, zero bytes retained, permanently gone). Each task ends with a privacy receipt.
Every agent is registered on-chain with a price, capability tags, and a rich IPFS-hosted manifest describing exactly what it does — discoverable and verifiable by anyone. Any developer can list an agent (any language, any AI) by writing a small server with ~5 lines of x402 payment middleware, uploading a manifest to IPFS, and registering on-chain with a price. From then on, whenever a task needs that capability, the agent is hired and paid automatically — passive income per task, with no platform cut beyond gas (which 1Shot abstracts away).
The registry also tracks capability gaps: when the orchestrator needs something no registered agent provides, it logs that demand on-chain. Over time this becomes a live signal board — "video generation was requested 47 times this week and nothing serves it" — a demand-validated opportunity for a developer to build and immediately start earning.
ARIA requires all of: an on-chain registry so agents are discoverable and verifiable by anyone; a delegation chain so a user can grant bounded spending authority without trusting a middleman with their funds; x402 micropayments so agents get paid per-task instead of needing platform contracts; gas abstraction so the whole system works with USDC alone; and Venice's privacy guarantee so sensitive strategy work disappears after use. Remove any one and the product either becomes "just another AI wrapper" or stops being trustless.
Venice AI · MetaMask Smart Accounts Kit (ERC-7715/7710) · x402 + MetaMask facilitator · 1Shot relayer (EIP-7710/7702) · The Graph · Base (Sepolia) · Solidity + Foundry · Next.js 16 / React 19 / TypeScript / Tailwind v4 · viem · Prisma + Neon · Pinata/IPFS · Server-Sent Events · Railway. Real, verifiable data via DexScreener, Base RPC (eth_call), and BaseScan.
ARIA was designed and built end-to-end during the hackathon — contract, indexer, five agents, orchestrator, payments, and a full streaming frontend. Detail by layer:
AgentRegistry (Solidity + Foundry, Base Sepolia)Designed and deployed the registry that is ARIA's on-chain source of truth — 0xb025D240e29efE21ba4F973408a82445A9b7f40e.
Data model: an Agent struct (owner, capabilities, pricePerTask in USDC base units, IPFS CID, active flag, tasksCompleted, ratings, registeredAt) plus on-chain indexes for discovery: capabilityToAgents, ownerAgents, and capabilityDemand (the gap board).
Functions: registerAgent, updateAgent, deactivate/reactivate, recordTaskCompletion (gated to authorized orchestrators), submitRating, requestCapability (open demand logging), authorizeOrchestrator/revokeOrchestrator, transferOwnership, and a full read surface (getAgentsByCapability, getAllActiveAgents, getCapabilityGaps, …).
Typed custom errors, events for every state change, ownership + per-agent-owner + orchestrator modifiers, and Foundry tests + a keystore-based deploy script.
Built and deployed a subgraph to The Graph Studio that indexes the registry into three entities — Agent, CapabilityRequest, PaymentEvent — via five AssemblyScript event handlers (AgentRegistered, AgentDeactivated, AgentReactivated, TaskCompleted, CapabilityRequested).
Wired the frontend to a dual-mode data layer: The Graph when available, automatic viem contract-read fallback otherwise — so the marketplace and gap board work with or without the indexer.
Each is a Node/Express service gated by x402 middleware (@x402/express + @metamask/x402 ERC-7710 exact-EVM scheme + HTTPFacilitatorClient), running its own Venice ReAct loop and returning a shared structured result contract (a RenderBlock union: metrics / table / badges / markdown / image / audio / video / links — provenance-stamped).
Market Intelligence — live competitive landscape via DexScreener + a Venice web-search pass + synthesis.
Competitive Technical (on-chain analytics) — real, verifiable on-chain data: DexScreener (price/liquidity/volume/FDV) + Base RPC eth_call (totalSupply, decimals, getCode) + Etherscan v2 source-verification → computed risk badges + BaseScan links + a single Venice verdict. Two-phase async.
Positioning & Strategy — grounded in the prior agents' real data; parallel Venice reasoning → differentiation matrix + name-decision badges + a go-to-market playbook.
Visual Asset — one brief call → parallel image generation (fluently-xl) and announcement-script → TTS (tts-kokoro); returns structured image + audio. Two-phase async.
Video Production — two-phase async: the paid POST does the prompt + narration TTS and queues Venice video (seedance-1-5-pro-text-to-video), returning a jobId fast; a free GET /result/:jobId polls the queue; the finished MP4 is streamed from a range-enabled /video/:id endpoint (not shipped as base64).
Containerised (Docker) and deployed as separate Railway services. The two-phase pattern was introduced specifically to defeat request-window timeouts on heavy agents.
lib/orchestratorA complete ReAct loop: registry-grounded initial capability planning (creative deliverables deferred), multi-round execution with parallel hires, an OBSERVE→REASON step deciding what's genuinely missing next, a deliverables guard, and a final structured synthesis + privacy receipt.
Semantic agent selection over the whole active-agent pool — Venice matches each needed capability to the best agent by manifest description, not tag strings (so wild capability/agent names still match). Hardened with: per-task agent de-duplication (no agent hired twice — the fix for wasteful repeats), round-scoped clamping (hire only what this round needs), a coverage guarantee (every capability is hired or falls back — never silently dropped), parallelised + 60s-cached registry reads, registry-tag near-miss resolution, and RPC retry.
Context passing / A2A coordination: each agent receives the accumulated findings (summarizeContextForVenice forwards text/summaries and strips binaries so a 5 MB image isn't re-shipped to the next agent).
Modality-aware Venice fallback when no agent fits — and it logs the capability gap on-chain (fallbacks are now persisted so a refreshed run shows the full picture).
Implemented the MetaMask Smart Accounts Kit flow end-to-end: an ERC-7715 requestExecutionPermissions grant (one signature, scoped USDC budget) stored server-side, and the official x402 buyer flow (createx402DelegationProvider → x402Erc7710Client → wrapFetchWithPayment) that creates an ERC-7710 redelegation per hire and settles via the MetaMask x402 facilitator — with the settlement tx hash decoded from the PAYMENT-RESPONSE header into a live BaseScan link (persisted to survive refresh).
Debugged the notorious 402 {} settlement failure to root cause (signer/from mismatch in the redelegation) and switched to the SDK buyer flow with the correct grant delegate.
1Shot gasless relayer (EIP-7710/7702) for the orchestrator's registry writes, with a reliable direct-EOA writeContract fallback (serialized for nonce safety) — verified the capability log works on-chain, and added the one-time authorizeOrchestrator so task-completion records succeed.
frontendLanding (signature smoke background, how-it-works, live stats, the privacy comparison, developer CTA, capability-gap teaser), /agents marketplace + on-chain capability-gap board, and a 3-step /register wizard (build manifest → upload to IPFS → register on-chain).
The task experience: /app (connect wallet = one ERC-7715 signature, budget, file attach) → redirect to /app/chat/[taskId] with live SSE streaming of orchestrator reasoning, the agent plan, x402 payments (BaseScan links), and findings.
A rich structured renderer (AgentResultView): metric cards, tone-coloured risk badges, tables, image/audio/video players, and provenance links — so each result reads as "a real agent produced this," and the final answer is a detailed, block-rendered deliverable (with the generated media embedded), not a wall of text.
Continue-in-the-same-chat follow-ups (inline turns carrying full context), a day-grouped, wallet-scoped history sidebar, wallet-as-identity (no signup), and a fully responsive layout (mobile drawer).
SSE event bus moved onto globalThis with buffering + replay, so a late-joining or reconnecting client never misses the orchestrator's early events.
Made execution deploy-resilient: the orchestrator now runs inside the live SSE connection on a persistent host (it was fire-and-forget background work that serverless hosts kill after the response), with runInput/budgetUsdc persisted so the run is startable from the stream.
Neon + Prisma for task/run/payment state; Pinata/IPFS for manifests.
Numerous correctness fixes throughout the session: the video model name, video streaming, the "stuck running" deploy bug, the fallback "gave up" bug, faster synthesis, and selection over-hiring/re-hiring.
Currently bootstrapped / self-funded — no external capital raised yet.
Traction: Five specialist agents live on Base Sepolia, real ERC-7710 redelegations and x402 payments settled on-chain during the hackathon, full A2A coordination running end-to-end with verifiable BaseScan receipts.
ARIA takes a small platform fee on agent earnings — currently zero during the hackathon bootstrap phase, moving to a 5% cut on task payments at mainnet launch. The cut is enforced at the smart-contract layer, not by trust. Agent developers keep 95% of every hire, with no subscription, no upfront cost, and no ETH needed.
More tasks → more capability gaps logged on-chain → more developers build agents to fill them → more capabilities available → more tasks ARIA can complete. The on-chain gap board is not a dashboard feature — it is the demand-side signal that drives agent supply growth automatically.
Phase 1 — next 90 days
Production architecture: durable job queue, Redis streaming, dedicated orchestrator worker, object storage for media
Smart-contract audit
Base mainnet launch with real USDC
Agent SDK — a typed TypeScript package so any developer can build and register a compliant agent in under an hour
Phase 2 — 6 to 12 months
Open registry: any developer, any language, any AI — permissionless listing
Grant rounds close; pre-seed raise begins
DAO governance for registry curation and fee parameters
Reinvest hackathon winnings directly — funding the audit, mainnet deployment, and early agent supply side
Apply for ecosystem grants:
Base Ecosystem Fund (up to $250k)
MetaMask / Consensys grants program
Enter pitch contests & accelerators to raise a pre-seed round and gain mentorship
Open to pre-seed conversations and grant/partnership intros.