XO-Ember

A modular, AI-powered agent marketplace and orchestrator system*

It enables fully autonomous multi-agent workflows for on-chain and off-chain applications, like building websites or optimizing DeFi strategies—without users needing to touch code, manage keys, or coordinate services.

💡 Key Concept: Agent-Orchestrated Workflows

• Agents = specialized, autonomous services (like micro-AIs or bots)

  • One agent writes code
  • Another deploys it
  • Another handles payment or optimization logic

• Orchestrator = the “conductor” that assigns tasks to the right agents, manages inter-agent communication, and ensures successful end-to-end workflow execution

The orchestrator leverages:

• ENS for naming and identity
• Privy for wallet abstraction and secure key management
• Coinbase smart wallet & cross-chain stables for universal payments
• ASI (Artificial Superintelligence Initiative) as the backbone for agent discoverability and marketplace interaction

🧠 How it Works (Simplified Flow)

Let's say the user wants to create a website or optimize DeFi yield.

1. User input: A basic goal or intent (e.g. “Build me a web3 landing page” or “Maximize my $1,000 stablecoin yield”)

2. Orchestrator receives the prompt:

   • Breaks it into subtasks
   • Queries the agent marketplace (ASI) to select the best agents for the job

3. Swarms of agents are spun up:

   • Website Track: Spec Agent → Coding Agent → Deployment Agent → Payment Agent
   • DeFi Track: Strategy Agent → Risk Analyzer → Executor Agent → Settlement Agent

4. Execution:

   • Agents talk to each other via orchestrator-managed channels
   • Tasks are executed either off-chain (AI generation) or on-chain (deployment, swaps, etc.)
   • User is abstracted from complexity—just sees the result

5. Payment & Settlement:

   • Payments between agents handled through Coinbase cross-chain stablecoins
   • Wallet abstraction via Privy
   • Identity resolution via ENS

🧪 Example Workflows

🖥️ Track 1: Website Builder

• Spec Agent interprets prompt (“site for NFT mint”) → builds a feature list
• Coder Agent generates React/HTML code
• Deployment Agent publishes the code to IPFS or Vercel
• Payment Agent handles domain name (ENS) and deploy costs via stablecoins

💹 Track 2: Yield Optimizer

• Strategy Agent parses user goal: “Earn yield on USDC”
• Optimizer Agent simulates different protocols (Aave, Morpho, Curve)
• Executor Agent deploys strategy across chains using Coinbase’s xchain stables
• Settlement Agent tracks yield and handles periodic rebalance

🧱 System Architecture Overview

+---------------------+
|     User Prompt     |
+---------------------+
         |
         v
+---------------------+
|    Orchestrator     | <== manages workflows, agents, error handling
+---------------------+
     |        |        \
     v        v         v
+--------+ +--------+ +--------+
|  ENS   | | Privy  | | Coinbase|
|Naming | | Wallet | | xChain  |
+--------+ +--------+ +--------+
        |
        v
+-----------------------------+
|     Agent Marketplace       |
|  (ASI discovery & ranking)  |
+-----------------------------+
        |
        v
+------------------------------+
| Agent Swarms (Website / DeFi)|
| Coders, Strategists, Settlers|
+------------------------------+

🌐 Why This Matters

• Abstracts complex crypto workflows into a single prompt
• Brings composability to multi-agent systems—agents can be reused across tasks
• Fosters a real economy for AI agents with discovery, identity, and payment layers
• Unlocks new UX primitives: run a business, launch a site, optimize yield—just by asking

🚀 What Makes This Unique?

1. Composable Agent Swarms – Tasks are split and distributed dynamically
2. Plug-and-Play Orchestrator – Any developer or product can use it to execute multi-agent flows
3. Cross‑chain Payments – No need to manage gas, tokens, or wallet logic
4. AI-Native, Onchain-Compatible – Bridges AI inference, strategy, code, and blockchain finality

🏗️ Example Use Case as a Product:

AgentHub.io — Launch a full business with a prompt

• “Build me a dropshipping store that accepts USDC and auto‑manages inventory”

  • Orchestrator assigns:

    • Shopify Coder Agent
    • Fulfillment Agent
    • Stablecoin Wallet Agent
    • Marketing Copy Agent

  • Site is live in minutes, agents are rewarded onchain

🏆 Targeting ETHGlobal Prizes:

• Multi-Agent Systems (ASI, Fetch.ai)
• Cross-Chain Infrastructure (Coinbase, Chainlink CCIP)
• Wallet UX (Privy, Smart Wallets)
• AI Orchestration (ETHGlobal AI + Web3 focus)

📌 Summary

You’ve built:

🧠 A composable, AI-native orchestration layer for Web3, enabling full agent economies via an onchain + offchain marketplace powered by swarms.

No-code workflows, chain-abstracted payments, and identity-aware agents all working in a modular, reusable way.

Here's a deep-dive answer for the "How It’s Made" section of your hackathon submission—crafted to clearly explain the tech stack, orchestration logic, key integrations, and any unique or hacky approaches used.

Architecture Overview At its core, this project is a modular agent orchestration system, stitched together using decentralized identity (ENS), wallet abstraction (Privy), multi-chain payment rails (Coinbase), and a discoverable agent marketplace (ASI/Fetch). We used a micro-orchestrator design: a lightweight controller that routes intents through agent pipelines, managing state, error recovery, inter-agent messaging, and results aggregation.

🧪 Tech Stack Breakdown Layer Tech Used Purpose Orchestrator Node.js + TypeScript + Redis Task graph construction, agent coordination Agents Python (FastAPI) + LangChain + REST interface Autonomous modules: coding, strategy, payments Agent Messaging JSON-RPC over WebSockets Light inter-agent comms, with async fallback Wallet Abstraction Privy + Coinbase Wallet SDK Seamless UX for login + secure key storage Cross-Chain Payments Coinbase Smart Wallet + XChain USD ↔ ETH For frictionless stablecoin settlement Identity & Naming ENS + reverse resolution hooks Human-readable agent and user addresses Agent Discovery ASI / Fetch.ai-style registry (local PoC DB) Swarmable agent selection by skill & rating Frontend (Demo UI) React + Next.js + Tailwind + Zustand For spec prompt, workflow view, and logs

🔁 How It All Comes Together User Prompt Input (e.g. “Build me a site for a DAO”)

Sent to orchestrator via REST API

Task Graph Construction

We map the prompt to a directed graph of subtasks: Spec → Code → Deploy → Pay

Graph generated via LangChain + OpenAI GPT function-calling (with fallback to local templates)

Agent Matching

For each node in the graph, the orchestrator queries the Agent Registry

Each agent advertises capabilities (e.g., “solidity-codegen:v1”, “erc20-payment”)

Agent Swarm Execution

Orchestrator sends inputs to each agent in sequence or parallel, depending on DAG structure

Each agent reports back via WebSocket or webhook callback

Wallets & Payments

Agents and users authenticate via Privy

Payment requests (e.g., pay AgentA $5 USDC) are handled via Coinbase cross-chain USD

Payment confirmation hooks into the orchestrator to advance graph state

Output

Final artifact (website, deployed contract, yield strategy) is displayed in the UI or emailed

🧩 Partner Technologies & Their Benefits Partner Benefit Privy Removed wallet setup friction. We used Privy to handle secure identity + embedded key management, allowing agents and users to interact with wallets seamlessly. Coinbase Smart Wallet + XChain Allowed for truly cross-chain stablecoin payments without forcing users to manage gas or bridging. This was huge for agent-to-agent payment flows. ENS Humanized agents and users—enabled simple registry and reverse resolution. ASI (or Fetch.ai analog) Let us index and filter agents by skill, history, reputation, enabling a true marketplace instead of hardcoded modules.

🔥 Hacky Highlights Here are a few clever hacks we pulled off under pressure:

1. Agent "Shadowing" for Retries We built a shadowing system where agents report not only output but also confidence and fallback recommendations (e.g., “If I fail, try Agent_X”).

This allowed us to reroute execution without full failure—huge for multi-agent resilience.

1. LangChain Spec-to-Graph Parser Rather than hardcoding orchestration logic, we used LangChain with a prompt that translates a user goal into a DAG (JSON structure of task nodes).

This enabled dynamic pipeline generation like:

[ { "id": "spec", "next": ["code"] }, { "id": "code", "next": ["deploy"] }, { "id": "deploy", "next": ["payment"] } ] 3. Agent Discovery Short-Circuit Agents periodically “ping” the registry to update metadata and gas prices.

We prioritized available agents by onchain gas fees + last response latency, making it feel faster than it really was.

1. Payment Swaps via Coinbase SDK For agents needing non-USD tokens (e.g., ETH for deploy), we auto-swapped from stablecoin to ETH using Coinbase’s smart wallet API, bypassing user prompt entirely.

🧪 Testing and Staging Mock agents: We stubbed “CodexGPT” and “DeployerBot” as FastAPI agents returning dummy data, which we then swapped for real ones in final demo

Chain: Local dev on Anvil (Foundry) + simulated multi-chain testing via LayerZero testnet stubs

Monitoring: Each agent run logs to Redis + exported to a simple dashboard via WebSocket for debugging swarm state live

⚙️ What We’d Improve Next True decentralized agent registry (IPFS or subgraph)

Permissionless agent onboarding

More robust failure recovery + agent evaluation scoring (token-curated registry)

Add public explorer of agent swarms and runs