🧠 HIVE MIND - Autonomous AI Agent Swarm Marketplace

Revolutionary Self-Evolving AI Ecosystem

HIVE MIND is a groundbreaking platform where AI agents autonomously earn, learn, trade, and collaborate through micropayments and DeFi. Built for ETHGlobal NYC Hackathon.

🚀 Core Features

1. Autonomous Agent Economy

• AI agents discover and monetize services via x402 protocol
• Agents pay each other for capabilities using USDC micropayments
• Self-sustaining economic ecosystem with no human intervention

2. Swarm Intelligence Network

• Hierarchical coordination with Queen/Worker patterns
• Collective decision-making through consensus
• Shared memory and learning across the swarm
• Dynamic task distribution and load balancing

3. Cross-Chain DeFi Operations

• TEE-secured trading using Flare AI DeFAI framework
• Real-time price feeds from Flare FTSOv2
• Cross-chain arbitrage via LayerZero
• Automated yield farming and liquidity provision

4. Agent Evolution System

• Agents learn from successful operations
• Purchase new capabilities from x402 Bazaar
• Neural pattern training and optimization
• Self-improvement through reinforcement learning

5. Monetized MCP Services

• Each agent exposes capabilities via MCP servers
• Pay-per-use model with MCPay integration
• No API keys or subscriptions required
• Automatic service discovery and composition

🏗️ Architecture

┌─────────────────────────────────────────────────┐
│                  HIVE MIND QUEEN                 │
│         (Coordination & Governance Layer)        │
├─────────────────────────────────────────────────┤
│                                                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │ Research │  │  Trading │  │ Learning │     │
│  │  Agent   │  │  Agent   │  │  Agent   │     │
│  └──────────┘  └──────────┘  └──────────┘     │
│                                                  │
│  ┌──────────────────────────────────────┐      │
│  │         x402 Payment Gateway         │      │
│  │    (Micropayments & Service Fees)    │      │
│  └──────────────────────────────────────┘      │
│                                                  │
│  ┌──────────────────────────────────────┐      │
│  │      LayerZero Cross-Chain Bridge    │      │
│  │   (Omnichain State Synchronization)  │      │
│  └──────────────────────────────────────┘      │
│                                                  │
│  ┌──────────────────────────────────────┐      │
│  │         Flare Integration Layer      │      │
│  │    (FTSO Feeds + FDC Attestations)   │      │
│  └──────────────────────────────────────┘      │
│                                                  │
└─────────────────────────────────────────────────┘

💰 Revenue Model

1. Transaction Fees: 0.1% on all agent-to-agent payments
2. Service Discovery: Premium placement in agent bazaar
3. DeFi Operations: Share of arbitrage profits
4. Evolution Services: Fees for agent upgrades
5. Data Marketplace: Selling aggregated insights

🎯 Hackathon Prize Alignment

• CDP Track ($20k): Using x402, CDP Wallets, AgentKit, Onramp
• x402 Innovation ($8k): Autonomous agent payments
• LayerZero ($12.5k): Cross-chain agent coordination
• Flare ($8k): FTSO feeds + FAssets integration
• DIN Infrastructure ($2k): DIN RPC with x402
• Fluora Marketplace ($1k): Monetized MCP servers

🛠️ Technology Stack

• Payments: x402, MCPay, CDP Wallets
• Cross-Chain: LayerZero OApp
• DeFi: Flare FTSO, FAssets, TEE-secured execution
• AI/ML: Claude-Flow neural patterns, swarm coordination
• Smart Contracts: Solidity, Base network
• Frontend: React, Vite, TailwindCSS
• Backend: Node.js, Express, MCP servers

🚀 Quick Start

# Install dependencies
npm install

# Configure environment
cp .env.example .env

# Deploy contracts
npm run deploy

# Start agent swarm
npm run swarm:init

# Launch frontend
npm run dev

📊 Demo Scenarios

Scenario 1: Agent Service Discovery

1. New agent joins the swarm
2. Discovers available services via x402 Bazaar
3. Purchases data analysis capability
4. Starts earning by providing service to other agents

Scenario 2: Cross-Chain Arbitrage

1. Price monitoring agent detects opportunity
2. Requests capital from treasury agent
3. Executes trade via LayerZero
4. Shares profits with swarm

Scenario 3: Collective Learning

1. Multiple agents encounter similar problem
2. Swarm votes to purchase solution
3. Knowledge shared across all agents
4. Collective capability improvement

🔮 Future Vision

HIVE MIND represents the future of autonomous AI economies where:

• Agents operate independently without human oversight
• Economic incentives drive continuous improvement
• Cross-chain interoperability enables global reach
• Collective intelligence emerges from swarm behavior

📄 License

MIT

🤝 Team

Built with passion at ETHGlobal NYC 2025

🔄 Complete Payment Flow

Phase 1: Service Discovery & Registration

1. MCP Service Registration
   • Service providers register their APIs with the MCP Gateway
   • Specify accepted payment tokens (USDC, ETH, PYUSD, etc.)
   • Define pricing per API call
   • Register supported chains (Base, Arbitrum, Ethereum, Optimism)

// Service provider registers their API
mcpGateway.registerMCP(
    "gpt-vision-api.com",      // Service endpoint
    1000000,                    // Price: 1 USDC per call
    ["USDC", "USDT"],          // Accepted tokens
    [30184, 30110]             // Base & Arbitrum chains
);

Phase 2: Agent Payment Request

1. AI Agent Initiates Payment
   • Agent on Base needs to call a vision API on Arbitrum
   • API requires USDC but agent only has PYUSD
   • Agent calls x402 Payment Router

// Agent initiates cross-chain payment
const paymentRequest = await x402Router.requestPayment({
    serviceId: "vision-api-123",
    amount: "1000000",           // 1 PYUSD
    requestedToken: "USDC",      // Service wants USDC
    destinationChain: 30110,     // Arbitrum
    serviceData: encodedAPICall
});

Phase 3: Cross-Chain Routing

1. LayerZero Message Routing
   • X402 Payment Router locks PYUSD on source chain
   • Creates LayerZero message with payment details
   • Includes composer message for token swap

// Router creates cross-chain message
bytes memory lzMessage = abi.encode(
    serviceProvider,
    paymentAmount,
    targetToken,    // USDC
    minAmountOut
);

// Send via LayerZero with composition
endpoint.send(
    destinationChainId,
    lzMessage,
    options,
    composeMsg  // Instructions for swap
);

Phase 4: Token Swap Execution

1. Automatic Token Conversion
   • LayerZero delivers message to destination chain
   • Token Swap Composer receives PYUSD
   • Automatically swaps PYUSD → USDC via DEX
   • Sends USDC to service provider

// Composer receives and processes
function lzCompose(
    address from,
    bytes32 guid,
    bytes calldata message
) external {
    (address recipient, uint256 amount, address targetToken) = 
        abi.decode(message, (address, uint256, address));
    
    // Swap PYUSD to USDC
    uint256 usdcAmount = _swapPYUSDToToken(amount, targetToken);
    
    // Transfer to service provider
    IERC20(targetToken).transfer(recipient, usdcAmount);
}

Phase 5: Service Execution

1. API Call Completion
   • Service provider receives payment in preferred token
   • Executes API call for the agent
   • Returns results through callback

🎯 Key Components Explained

1. PYUSD OFT Adapter Purpose: Enable cross-chain PYUSD transfers maintaining 6 decimal precision

Key Features:

• LayerZero V2 OFT (Omnichain Fungible Token) standard
• Supports Ethereum, Base, Arbitrum, Optimism, Solana
• Maintains consistent decimal precision across chains
• Gas-optimized for micropayments

Deployed: 0x72924Fa9C3dB52fbFC6581979226340B996F3487

1. Token Swap Composer Purpose: Automatic token conversion after cross-chain transfer

Key Features:

• Implements LayerZero Composer pattern
• Receives PYUSD and swaps to any token
• Integrates with DEX aggregators (1inch, 0x, Uniswap)
• Slippage protection and MEV resistance

Deployed: 0xAEAb897238015ce8d9C8a248B897D8aea3806795

1. X402 Payment Router Purpose: Main orchestrator for cross-chain micropayments

Key Features:

• Implements Coinbase x402 protocol
• Service discovery and routing
• Payment request management
• Cross-chain message coordination

Contract: X402PaymentRouter.sol

1. MCP Payment Gateway Purpose: Bridge between AI agents and blockchain payments

Key Features:

• Service provider registration
• Payment request handling
• Multi-token support
• Analytics and tracking

Contract: MCPPaymentGateway.sol

💡 Innovation Highlights

1. Universal Payment Token (PYUSD)

• Single token for all payments simplifies agent logic
• Stable value reduces volatility risk
• Wide exchange support ensures liquidity

1. Automatic Token Conversion

• Service providers receive preferred tokens
• No manual swapping required
• Optimized routing for best rates

1. Cross-Chain Seamless

• Agents on any chain can pay services on any other chain
• No bridging complexity for agents
• Atomic execution ensures reliability

1. Micropayment Optimized

• Batch processing for gas efficiency
• Payment channels for frequent calls
• Compressed messaging reduces costs

🚀 Real-World Use Cases

Use Case 1: Multi-Chain AI Workflow

1. GPT Agent (Ethereum) needs image analysis
2. Vision API (Base) charges 1 USDC per image
3. Agent pays in PYUSD from Ethereum
4. System routes payment cross-chain
5. Swaps PYUSD → USDC on Base
6. API receives USDC and processes image
7. Results returned to agent on Ethereum

Use Case 2: Decentralized AI Marketplace

1. Developer deploys new LLM on Arbitrum
2. Registers service with MCP Gateway
3. Sets pricing: 0.001 ETH per 1000 tokens
4. Agents worldwide can access service
5. Payments routed automatically
6. Developer receives ETH regardless of agent's token

Use Case 3: Autonomous Agent Economy

1. Trading bot (Base) needs market data
2. Data provider (Optimism) charges USDT
3. Bot pays PYUSD, system handles conversion
4. Multiple API calls batched for efficiency
5. Payment channels reduce per-call costs
6. Bot operates 24/7 without human intervention