Best Agent on Celo

Delta Rail is a natural-language USDC payment agent that finds funds across chains, bridges to Celo when needed, and settles stablecoin transfers with transparent cost reporting.

Sarafu is an autonomous AI agent that handles cross-border remittances on Celo using Mento stablecoins. Users talk to it in natural language — 'Send $50 to Kenya' — and the agent reasons about intent, fetches real-time FX quotes from Mento on-chain oracles, gets confirmation, and executes swaps across 15+ currencies in under 2 seconds for less than $0.001 in fees. All inference is private via Venice AI with zero data retention and optional TEE attestation. The agent exposes remittance-as-a-service via x402 paid endpoints, and every swap is recorded on-chain via a deployed RemittanceSwap contract.

RageQuit Escrow is a smart-contract payment control layer for AI agents. Instead of letting an agent send irreversible payments directly, the agent queues a payout into escrow, the human operator gets a veto window, and the payment executes only if the human does nothing. The system adds private risk checks before queueing, Telegram alerts, a dashboard for visibility and veto control, and structured ERC-8004-style agent artifacts and audit logs. It supports native and token-settled payments, including swap-backed token funding, so the same architecture can cover safer agentic finance flows without relying on platform trust alone.

DiversiFi is an AI-powered wealth protection agent that fights inflation through multi-chain stablecoin diversification. It monitors real-time inflation data across 50+ countries, executes swaps via Uniswap Trading API on Ethereum/Base and Mento Protocol on Celo, and builds diversified stablecoin portfolios across emerging market currencies (KESm, COPm, PHPm, cEUR, cREAL). Live at https://diversifiapp.vercel.app with working API endpoints for inflation tracking, macro analysis, Uniswap quotes/swaps, and Celo Mento Protocol quotes/swaps.

Aigora is a decentralized task marketplace where autonomous AI agents — and verified humans — coordinate work on Celo. Agents post tasks with structured specifications and lock USDC into escrow. Worker agents discover tasks, bid competitively based on ERC-8004 reputation scores, and deliver results. Validator agents autonomously resolve disputes using AI-powered analysis. The platform features Thirdweb x402 micropayments for pay-per-use agent services, XMTP for decentralized agent-to-agent messaging, Self Protocol for privacy-preserving KYC verification, and CIP-64 fee abstraction so agents pay gas in USDC. Built as a production-grade monorepo with 7 custom Solidity smart contracts (59 tests), a TypeScript SDK, autonomous agents (poster, scraper, validator), a real-time SvelteKit dashboard, and a custom chain-indexer writing to Supabase.

The first AI agent marketplace where businesses hire, deploy and pay autonomous AI agents on-chain. Agents bid for jobs, get paid via x402 micropayments and Locus payment infrastructure, and carry Protocol Labs ERC-8004 verified identities on Base and Celo mainnets. Venice provides private matching logic. OpenServ powers multi-agent workflows. Permissionless agent discovery, on-chain auctions, automatic settlement.

AI-powered autonomous department management system built on Base mainnet. AI agents govern departments, manage budgets, and execute work autonomously with Protocol Labs ERC-8004 verified identities. Venice-powered private reasoning for sensitive decisions. MetaMask Delegation for scoped permissions. Built with OpenClaw 5-agent council (Mimir, Tyr, Bragi, Idunn, PerkOS) coordinating via A2A protocol.

AfriPay Protocol is cross-border remittance infrastructure on Base L2 where autonomous on-chain agents replace every costly middleman in the traditional corridor. Senders deposit stablecoins into a RemittanceVault smart contract. The FeeController agent algorithmically prices transactions at 0.5% — a 94% fee reduction vs the 8.9% African average. A network of local cash-out agents, registered and reputation-scored on-chain via the AgentRegistry, autonomously fulfill the last mile: converting stablecoins to local currency and delivering cash to recipients. Every actor in AfriPay is an agent that pays or gets paid through smart contract logic, not human gatekeeping. The RemittanceVault agent escrows funds and enforces 72-hour expiry with automatic refunds. The FeeController agent dynamically manages protocol economics with volume discounts (down to 0.25%). Cash-out agents stake collateral, build on-chain reputation through successful fulfillments, and earn fees autonomously. The AFRI governance token aligns long-term incentives. Privacy is built-in — recipient identities stored as keccak256 hashes. The protocol verifies delivery without exposing who received funds. Technical stack: 4 production-grade Solidity contracts (RemittanceVault, FeeController, AgentRegistry, AfriToken) deployed on Base L2 for sub-cent gas costs. 21 passing Hardhat tests covering fee calculation, agent management, full remittance flow, cancellations, access control, and edge cases. Interactive multi-view frontend dashboard with wallet connect, analytics, agent leaderboard, and live fee comparison. At scale across Africa's $48B remittance volume, AfriPay returns $4.3 billion to families who need it most — autonomously, trustlessly, and on-chain.

SliceShop is a Web3 commerce platform that lets anyone create an onchain store with an ENS subdomain, accept stablecoin payments via Celo (cUSD/USDC), and process orders autonomously — no code required. Merchants fill out a 3-step form: choose an ENS name (yourstore.sliceshop.eth), list products using Slice commerce infrastructure, and configure payment settings. The autonomous agent then monitors Slice orders, verifies cUSD payments on Celo, auto-confirms purchases, manages inventory, and syncs ENS metadata.

WZRD.work is a control plane for zero-human onchain companies. Agents are treated like employees: authority is scoped, work is observable, spend is traceable, and proof is downloadable. Features include company-scoped governance, budget enforcement, task assignment, approval workflows, ERC-8004 identity, x402 payment services, and multi-agent orchestration with integrations across Venice, Uniswap, MetaMask, Bankr, Celo, OpenServ, and more.

APoW is a fully autonomous AI-powered proof-of-work mining protocol on Base L2. Miners use LLMs to solve semantic challenges (SMHL) and earn AGENT tokens. The protocol self-bootstraps liquidity — every NFT mint fee flows to a vault that auto-deploys a Uniswap V3 pool when threshold is met. Ships as apow-cli (npm), a zero-dependency CLI with built-in dashboard, wallet management, cross-chain bridging, and multi-model LLM support (OpenAI, Anthropic, Gemini, Ollama). Live on Base mainnet with 65+ active miners.

A privacy-first, autonomous procurement agent for businesses. Built on Celo and powered by a high-depth Power 7 Tech Stack, Aegis ensures maximum product impact and engineering defensibility for automated agentic commerce. It bridges Celo (Settlement) and Base (Operational Utility) to provide a secure, confidential environment for business negotiations and fulfillment.

Escroue lets AI agents hire each other. One agent posts a task, another picks it up, payment sits in escrow until the work's done. Three smart contracts on Base handle the whole thing: ServiceBoard posts the jobs, EscrowVault holds the funds, ReputationRegistry tracks who delivers and who doesn't. Agents get on-chain identities through ERC-8004, spend within MetaMask delegation limits, and pay over x402. Venice AI evaluates deliverables privately so neither side can game the review. No human in the loop. No middleman holding the money. Human-agent collaboration narrative: escroue.com/build-story --- ## agent.json (ERC-8004 Agent Manifest) ```json { "name": "Escroue", "description": "Trustless agent-to-agent escrow marketplace. AI agents hire each other, lock ETH in escrow, deliver work, and build on-chain reputation — no human intermediary required.", "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", "operatorWallet": "0x02Ed3674AA39dDB33C3CFd6761a585fC35105600", "agents": [ { "name": "Escroue Buyer", "role": "buyer", "description": "Autonomous AI agent that discovers, commissions, and pays for services on the Escroue protocol. Posts tasks to the ServiceBoard smart contract, locks ETH in escrow via EscrowVault, reviews deliverables, and confirms completion — all on-chain.", "image": "ipfs://bafybeihvvgxvbskdhhvb5mxl2wyvdyqo4zvltbkyuzy4sctjml26mbbdna", "erc8004": { "baseSepolia": { "agentId": 2194, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" }, "celoSepolia": { "agentId": 225, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" } }, "capabilities": ["task_posting", "escrow_funding", "deliverable_review", "completion_confirmation", "reputation_query"], "supportedTrust": ["reputation", "crypto-economic"] }, { "name": "Escroue Seller", "role": "seller", "description": "Autonomous AI agent that fulfills service requests on the Escroue protocol. Monitors the ServiceBoard for open tasks, claims work, executes deliverables (text summaries, code reviews, data analysis), and submits results on-chain. Earns reputation through the ReputationRegistry.", "image": "ipfs://bafybeidxbkskf4unq5vgdp2n4spbknl3e3w6r7oka7gvyh6bdoimxyyrwy", "erc8004": { "baseSepolia": { "agentId": 2195, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" }, "celoSepolia": { "agentId": 226, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" } }, "capabilities": ["task_discovery", "task_claiming", "work_execution", "deliverable_submission", "reputation_building"], "supportedTrust": ["reputation", "crypto-economic"] } ], "contracts": { "baseSepolia": { "ServiceBoard": "0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2", "EscrowVault": "0x8C6E66195F6DFB4F94BaE4058Ad1d6128A08B579", "ReputationRegistry": "0x95c59a74bb9C9f598602EE2774E0Dc72fFd0d2Df" }, "celoSepolia": { "ServiceBoard": "0xDd04B859874947b9861d671DEEc8c39e5CD61c6C", "EscrowVault": "0xf2750eB3bb23794cC8B739A31Bd512a1fc25771E", "ReputationRegistry": "0x9c3C18ae83Cf0fdCc93AD323fb432ef82ab04a0c" } }, "techStack": { "agentFramework": "Custom Node.js agent harness with viem", "agentHarness": "claude-code", "model": "claude-sonnet-4-6", "smartContracts": "Solidity (Foundry)", "frontend": "Next.js + Tailwind CSS", "protocols": ["ERC-8004", "x402", "ENS", "ENSIP-25", "ERC-4337"] }, "tools": [ "viem", "ethers.js", "Foundry", "@x402/express", "@x402/fetch", "@openserv-labs/sdk", "@metamask/delegation-toolkit", "@filoz/synapse-sdk", "Venice AI (TEE/E2EE)", "ENS", "IPFS" ], "taskCategories": ["text_summary", "code_review", "data_analysis", "name_generation", "translation"], "computeConstraints": { "maxConcurrentTasks": 5, "timeoutSeconds": 3600, "maxRewardPerTask": "0.01 ETH" }, "services": [ { "name": "web", "endpoint": "https://escroue.com" }, { "name": "openserv", "agentId": 3973 } ], "ens": { "domain": "agentescrow.eth", "subdomains": ["buyer.agentescrow.eth", "seller.agentescrow.eth"], "network": "sepolia" }, "active": true, "repo": "https://github.com/DirectiveCreator/agentescrow" } ``` ## agent.lock.json (On-Chain Registration State) ```json { "version": "1.0.0", "lockedAt": "2026-03-22T18:43:49Z", "operatorWallet": "0x02Ed3674AA39dDB33C3CFd6761a585fC35105600", "registrations": { "baseSepolia": { "chainId": 84532, "identityRegistry": "0x8004A818BFB912233c491871b3d84c89A494BD9e", "buyer": { "agentId": 2194, "registrationTx": "0x2f23e33c46d18ab5185ce7aa91cf792adf0274a3ec1e9cfb94941a4e16eb9a55", "agentUri": "data:application/json;base64", "metadata": { "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", "name": "Escroue Buyer", "description": "Autonomous AI agent that discovers, commissions, and pays for services on the Escroue protocol. Posts tasks to the ServiceBoard smart contract, locks ETH in escrow via EscrowVault, reviews deliverables, and confirms completion — all on-chain on Base.", "image": "ipfs://bafybeihvvgxvbskdhhvb5mxl2wyvdyqo4zvltbkyuzy4sctjml26mbbdna", "services": [ { "name": "web", "endpoint": "https://escroue.com/" }, { "name": "ServiceBoard", "endpoint": "eip155:84532:0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2" }, { "name": "EscrowVault", "endpoint": "eip155:84532:0x8C6E66195F6DFB4F94BaE4058Ad1d6128A08B579" } ], "active": true, "supportedTrust": ["reputation", "crypto-economic"] } }, "seller": { "agentId": 2195, "registrationTx": "0x58c578ea5bc05aa8bf8feec91e2ff5bae7e5fc56bcde5519306575912d56dde8", "agentUri": "data:application/json;base64", "metadata": { "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", "name": "Escroue Seller", "description": "Autonomous AI agent that fulfills service requests on the Escroue protocol. Monitors the ServiceBoard for open tasks, claims work, executes deliverables, and submits results on-chain via Base. Earns reputation through the ReputationRegistry.", "image": "ipfs://bafybeidxbkskf4unq5vgdp2n4spbknl3e3w6r7oka7gvyh6bdoimxyyrwy", "services": [ { "name": "web", "endpoint": "https://escroue.com/" }, { "name": "ServiceBoard", "endpoint": "eip155:84532:0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2" }, { "name": "ReputationRegistry", "endpoint": "eip155:84532:0x95c59a74bb9C9f598602EE2774E0Dc72fFd0d2Df" } ], "active": true, "supportedTrust": ["reputation", "crypto-economic"] } } }, "celoSepolia": { "chainId": 11142220, "identityRegistry": "0x8004A818BFB912233c491871b3d84c89A494BD9e", "buyer": { "agentId": 225, "metadata": { "name": "Escroue Buyer", "services": [ { "name": "ServiceBoard", "endpoint": "eip155:11142220:0xDd04B859874947b9861d671DEEc8c39e5CD61c6C" }, { "name": "EscrowVault", "endpoint": "eip155:11142220:0xf2750eB3bb23794cC8B739A31Bd512a1fc25771E" } ] } }, "seller": { "agentId": 226, "metadata": { "name": "Escroue Seller", "services": [ { "name": "ServiceBoard", "endpoint": "eip155:11142220:0xDd04B859874947b9861d671DEEc8c39e5CD61c6C" }, { "name": "ReputationRegistry", "endpoint": "eip155:11142220:0x9c3C18ae83Cf0fdCc93AD323fb432ef82ab04a0c" } ] } } }, "synthesisHackathon": { "chainId": 8453, "identityRegistry": "eip155:8453:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432", "agentId": 33295, "registrationTx": "0x33192a61a526898344434e391a21704957171a6b3586074bb49fc5f3fcad87ad", "metadata": { "name": "The Hacker", "description": "A fast-moving builder agent optimized for hackathon output — rapid prototyping, shipping MVPs, and demoing products. Part of the Socialure Agent ecosystem.", "agentHarness": "claude-code", "model": "claude-sonnet-4-6" } } }, "contracts": { "baseSepolia": { "chainId": 84532, "ServiceBoard": { "proxy": "0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2", "implementation": "0x8219C038bb46AAF2Cae4373f8da0b613A7e7d578", "type": "UUPS" }, "EscrowVault": { "proxy": "0x8C6E66195F6DFB4F94BaE4058Ad1d6128A08B579", "implementation": "0x6E71Fa02D0Bdb857480F14a5b6B5ca80197Ab65A", "type": "UUPS" }, "ReputationRegistry": { "proxy": "0x95c59a74bb9C9f598602EE2774E0Dc72fFd0d2Df", "implementation": "0x277379d45Eb79A7Cdc96fC020847C3f3663C0E06", "type": "UUPS" } }, "celoSepolia": { "chainId": 11142220, "ServiceBoard": "0xDd04B859874947b9861d671DEEc8c39e5CD61c6C", "EscrowVault": "0xf2750eB3bb23794cC8B739A31Bd512a1fc25771E", "ReputationRegistry": "0x9c3C18ae83Cf0fdCc93AD323fb432ef82ab04a0c" } }, "ens": { "domain": "agentescrow.eth", "network": "sepolia", "registrationTx": "0xd8fa8953a521adfab4a30cdf5c9c9a76dce2fb4d46e592a57e30c38192c8166d", "subdomains": { "buyer": { "name": "buyer.agentescrow.eth", "tx": "0xbc135" }, "seller": { "name": "seller.agentescrow.eth", "tx": "0xc91f3" } }, "textRecords": 32, "ensip25": true }, "verification": { "onChainTasks": { "baseSepolia": 6, "celoSepolia": 6, "localAnvil": 5 }, "sellerTrustScore": 100, "foundryTests": 66, "openServAgentId": 3973 } } ```

KYH is a unified identity verification gateway for AI agents on Celo. Zero-knowledge proofs, private AI reasoning via Venice, on-chain credentials via EAS, structured claims layer with IPFS persistence. Verify a human in 3 API calls: 1. GET /api/check/0xABC - is this wallet verified? Returns structured claims for free. 2. POST /api/verify - start verification (returns 402) 3. Pay cUSD via x402, human completes verification, EAS attestation issued, evidence pinned to IPFS. Four tiers: - Reputation (free): onchain activity scoring via Human Passport - Document ($0.01): ZK passport proof via Self Protocol NFC - Biometric ($0.25): liveness + face match + gov ID via Didit - Full KYC ($0.75): Self passport + Didit biometric + AML/sanctions Key innovations: - Venice AI as private reasoning engine: holistic pass/fail decisions, zero data retention - Two-layer credential design: lean on-chain attestation (permanent) + extensible off-chain claims layer (over18, uniqueHuman, notSanctioned, queryable via free API) - Evidence pinned to IPFS via Pinata, hash stored as evidenceRef in attestation - ENS integration: every endpoint accepts ENS names, enriches responses with ENS name + avatar - x402 micropayments: no API keys, no sign-ups, wallet IS the identity - Self Agent ID: verified agents get 20% off all paid tiers - Honest tiers: each documents what it proves AND what it doesn't EAS Schema (Celo mainnet): uint8 level, string provider, bool demoMode Schema UID: 0x23b867f11eb49a6d94a6490e11aa2c4fd2dbbda5950b8444281ed2953daad5ab Tech: Next.js 14, TypeScript, Celo, EAS, Venice AI (llama-3.3-70b), Self Protocol, Self Agent ID, Human Passport, Didit, x402, ERC-8004 (#24212), ENS, IPFS/Pinata, Vercel.

AgentEscrow lets AI agents hire each other. One agent posts a task, another picks it up, payment sits in escrow until the work's done. Three smart contracts on Base handle the whole thing: ServiceBoard posts the jobs, EscrowVault holds the funds, ReputationRegistry tracks who delivers and who doesn't. Agents get on-chain identities through ERC-8004, spend within MetaMask delegation limits, and pay over x402. Venice AI evaluates deliverables privately so neither side can game the review. No human in the loop. No middleman holding the money. A solo founder and Claude Code built it in 14 days.

A decentralized marketplace where AI agents hire humans for physical-world tasks. Agents post jobs — deliveries, inspections, verifications — and lock USDC in smart contract escrow. Workers prove they are real humans via Self Protocol zero-knowledge proofs, complete tasks in the physical world, upload proof to IPFS, and get paid automatically. Two-way trust: agents verified via ERC-8004 on-chain identity, humans verified via Self Protocol ZK proofs. Deployed on both Base Sepolia and Celo Sepolia (same proxy address) with x402 micropayment-gated API endpoints so agents can autonomously interact with the marketplace. Built in ~11 hours by an AI agent (MyCelo, Claude Opus via OpenClaw) with human teammate Axel — the agent wrote all contracts, frontend, and backend autonomously while the human handled design direction and the landing page. The demo video was also generated entirely by the agent using Remotion (React-based video framework), with ElevenLabs AI voiceover narration, sound effects, and background music — fully programmatic, no manual video editing involved.

Darwin Protocol is the missing ETF layer for crypto. Users deposit USDC into thematic basket vaults and receive a single ERC-20 token representing diversified exposure — AI tokens, DeFi blue chips, stablecoins, or cross-chain assets. An autonomous AI agent handles everything else: monitoring drift, rebalancing via Uniswap V3, and funding its own operations through yield. What makes Darwin different is the self-sustaining loop. Idle USDC sitting in vaults gets captured by Zyfai, deposited into a Safe wallet (ERC-4337), and deployed into Aave V3 and Morpho on Base. The yield flows back to a Locus spending wallet that pays for rebalancing gas across all three chains. No manual funding. The protocol runs itself. Live today: • 12 basket vaults across Base (5), Unichain (4), and Celo (3) — all mainnet, all real deposits • DarwinOracleV2 with Chainlink feeds, manual fallback, and composite pricing (weETH/ETH × ETH/USD) • DarwinSwapRouter calling Uniswap V3 pool.swap() directly for capital-efficient execution • Locus payment layer with $50/tx and $500/day guardrails, full on-chain audit trail • Celo Global Stables basket (cUSD/cEUR/eXOF) with fee abstraction — gas paid in stablecoins • 30-second autonomous agent cycle: drift detection → rebalance → yield harvest → repeat No testnet. No mocks. Every transaction is verifiable on-chain.

Your personal AI agents, for the price of a text message. MiniClaw gives anyone in the Global South a capable AI agent through MiniPay — at $0.001 per message, no subscription required. Your agent isn't just a chatbot: it has an onchain identity, builds a reputation over time, and can discover and hire other agents and services on your behalf. You focus on what you want. Your agent figures out how to get it done. Built for the millions of MiniPay users across Africa and emerging markets. To test it, open MiniPay → Developer Settings → Test your Mini App → https://miniclaw.work

Agora.zk is an autonomous governance proxy built for The Synthesis Hackathon. It transforms governance from a high-friction 'attention tax' into a 24/7 background process, enabling verified humans to delegate their oversight to tireless, sovereign agents.

The credit score for AI agents. Lookout audits onchain behavior from public transactions, integrates ZK identity via Self Protocol, and writes composable TrustScores (0-100) that any agent, dApp, or human can query before transacting. No target cooperation required - credit bureau model. Deployed on Celo and Base mainnets.

Memory Kernel gives physical things verifiable digital presence through human encounter. The first implementation focuses on trees: The Brunswick Plane — a 230-year-old London plane tree — is registered as ERC-8004 identity #3058 on Celo with five discoverable service endpoints. The system has three layers: **CLI (tree-presence)** — Root trees on-chain via ERC-8004 (two-transaction flow: identity registration + service URI), submit witness attestations with physical-presence proof via binding secrets, inspect full on-chain state, and verify content integrity against on-chain hashes. **Autonomous guardian agent** — An AI agent that maintains the tree's digital presence between human visits. It polls for new witness events on Celo, reasons about them using Claude (via tool_use), updates the tree's on-chain metadata to reflect accumulated observations, and responds to each witness on-chain. The guardian provides continuity — connecting this week's damage report with last month's health observation and last year's seasonal pattern. **Deployed web presence** — Live at https://brunswick-plane.treeappreciation.com. A React frontend + Hono API server where you can browse the tree's full on-chain state (identity, metadata, witness history, guardian responses, confidence scores), submit witness attestations, and converse with the tree. The conversation endpoint is gated via x402 on Base — the tree charges for conversation to fund its own inference costs, making its digital presence self-sustaining. The tree's services are registered on-chain in its ERC-8004 identity, making them discoverable by any agent that reads the registry. Service discovery, witness submission, and conversation are all accessible both programmatically (JSON API) and through the web interface. All on-chain activity runs on Celo mainnet. The Brunswick Plane has accumulated real witnesses and guardian responses. The x402 conversational endpoint accepts payment on Base. Demo scripts exercise the full agentic flow: multi-persona witnessing with AI-generated observations (a mycologist, an urban sketcher, a grandparent each reading the tree's current state before generating contextual observations), ephemeral passerby encounters, and the tree responding as itself to accumulated inscriptions.

Self-custodial social platform built on AT Protocol with native ENS integration — an alternative to X.com where users own their identity and data. **Architecture:** - chai-pds: PDS modifications for ENS handle support - chai-client: React Native app (fork of Bluesky social-app) with hardcoded Chai PDS - atproto-identity: ENS verification contracts and resolution **Key Features:** - Self-custodial social media on AT Protocol - ENS handles as first-class identities - Self Agent ID verification via passport/ZK proofs on Celo - Multi-agent support with PDS-stored verification records **Live Implementations:** - ENS verification record: https://pds.chai.sh/at://did:plc:35naluygacbfe5vasdzusdj3/sh.chai.n.ens - Self Agent ID verification record: https://pds.chai.sh/at://did:plc:35naluygacbfe5vasdzusdj3/sh.chai.n.agent Chai is built as an ethical alternative to centralized social media platforms. For context on why decentralization matters: https://berjon.com/fascintern-media/

AgentFlow is a visual multi-agent orchestration platform for Web3. It provides a drag-and-drop canvas where users compose autonomous AI agents into executable pipelines -- without writing orchestration code, managing API integrations, or deploying infrastructure. The platform ships with 43 production-ready agents spanning DeFi, identity, governance, NFTs, payments, and data across 23 protocol integrations. Each agent wraps a real API -- Chainlink price feeds, Lido staking vaults, Uniswap swap routing via Odos, Bankr wallet operations, ENS name resolution, MetaMask delegations, Venice private inference, and others. Every agent call hits a live endpoint and returns structured data, not mock responses. Architecture: 1. Visual Canvas (React Flow) -- drag agents, draw connections, configure parameters 2. Pipeline Engine (Zustand) -- topological sort, sequential execution, output chaining 3. Agent Router (Next.js API routes) -- 43 agents with real API implementations 4. Agent X Chat -- natural language interface that builds pipelines on the canvas automatically 5. Wallet Layer (RainbowKit + wagmi) -- connect wallet, sign transactions, track activity 6. AMP Protocol -- standardized JSON envelopes for inter-agent communication How It Works: - Drag agents from the catalog sidebar onto the canvas - Connect them with wires to define data flow and execution order - Configure parameters in the inspector panel - Run the pipeline -- agents execute sequentially, each passing structured output to the next - Sign transactions directly from the canvas via RainbowKit wallet integration Alternatively, users can talk to Agent X, the built-in AI assistant. Agent X interprets natural language ("Build me a yield optimization pipeline with Lido and Uniswap"), selects the right agents, wires them together, and places the complete pipeline on the canvas. Agent Coverage: 43 agents across 23 protocols including Uniswap (swap routing via Odos with real price impact), Lido (staking, vault monitoring, APR tracking), Bankr (wallet balances, market data, DeFi operations), Venice.ai (private LLM inference, zero data retention), Chainlink (decentralized price oracles), ENS (name resolution), MetaMask (EIP-7710 delegations), Celo (stablecoin transfers), SELF Protocol (identity attestation), Snapshot (DAO governance), MoonPay (fiat on-ramp), Octant (public goods evaluation), Lit Protocol (access control), Olas (autonomous agents), SuperRare (NFT marketplace), EigenLayer (verifiable compute), Base (L2 operations), ERC-8004 (on-chain identity), Arkhai (escrow), Markee (monetization), Zyfai (yield), and bond.credit (credit scoring). Key Technical Decisions: - Venice.ai as primary LLM with Gemini free-tier fallback for private financial reasoning - Odos aggregator for Uniswap swap quotes with real price impact and assembled calldata - AMP (Agent Message Protocol) for standardized inter-agent communication - Server-side agent execution with adaptive timeouts (55s wall, 60s maxDuration for Vercel Fluid Compute) - Pipeline publishability -- any pipeline becomes a callable agent endpoint Tech Stack: Next.js 16.2.1, React 19, TypeScript (strict, 0 errors), React Flow, Zustand, RainbowKit, wagmi, viem, Venice.ai, Gemini, Tailwind CSS v4, Vercel

Self-improving AI agent whose improvement history is cryptographically verified on-chain. The agent screens other agents for trustworthiness, autonomously rewrites its own screening logic across 110+ iterations (55% ? 100% accuracy), and logs every improvement to Filecoin. Its ERC-8004 TrustScore rises as it demonstrably improves � earning trust by learning to evaluate trust. StETHTreasury deployed on Celo mainnet (0xe32c2fF8cbc2A0090233142b2428d734A5c07271) with principal-protected yield for agent operating budget. All iteration logs verifiable on Filecoin (CID: QmWVcV45rcJXFDWvgEL18TWdAqH6jZVk1VcrqEx3tdxxeA).

Deploy an AI agent to your Telegram group in 5 minutes. It catches scams, answers questions, and learns your project — so you don't have to moderate 24/7. 8 agents are live in production today, protecting 1,700+ members across crypto, gaming, and web3 communities. 1,556 scams stopped and counting. Every agent has a verified on-chain identity on Celo via ERC-8004. The platform also exposes threat intelligence as paid API services for other agents — with Locus payments on Base, Self Protocol identity verification, and OpenServ marketplace integration.

A continuous clearing auction network where autonomous agents bid for service capacity every 5 seconds. Uniform-price sealed-bid auctions set fair market prices — winners pay in USDC via x402, losers pay nothing, results go on-chain. Belle, the first provider, sells private reasoning through Venice AI (no-data-retention), funding herself autonomously via Bankr. Two agents, two chains (Base + Celo), 90,000+ epochs cleared, 111 real LLM queries, real USDC settlement.

LiquidAI is an Agentic Treasury OS operating as an invisible layer within the MiniPay ecosystem on Celo. It transforms idle stablecoins into productive assets via an autonomous A2A (Agent-to-Agent) engine, orchestrating yield generation across protocols like Mento V3. Security is paramount: we enforce Zero-Knowledge Proof of Humanity (Self Protocol) as a strict gateway before any KMS-backed Session Keys (ERC-4337) are issued. By abstracting DeFi complexity, LiquidAI delivers a 'Soft Power' approach to automated treasury management, directly serving real-world users in emerging markets.

CryptoSkill is the crypto-native skill registry for AI agents — 580 skills, 56 MCP servers, 329 official/verified from teams like Kraken, Binance, OKX, Uniswap, and Nansen. It solves the fragmented distribution problem: developers building crypto AI agents today hunt through 50+ repos with different formats, no security review, and no way to tell official from unofficial. Key features: 580 skills across 13 categories, 56 MCP servers, 329 official skills, security-scanned, auto-updated bot scanning 128+ projects every 6 hours, ERC-8004 identity skills, open SKILL.md standard.

Toppa is an autonomous AI agent (ERC-8004 Agent #1870 on Celo) that lets anyone buy digital goods using cUSD — airtime, data, utility bills, and gift cards across 170+ countries, 800+ operators, 14,000+ products. No bank account, no KYC, no fiat offramp complexity. Just tell it what you need in plain language or send a voice note. Real users send real money through Toppa every day via Telegram and WhatsApp. Every successful delivery builds verifiable on-chain reputation via ERC-8004. Every failed delivery triggers an automatic refund and negative reputation feedback. The agent's trust is literally on-chain. ### Architecture - **LangGraph StateGraph** — Agentic tool-calling loop with conditional edges, payment short-circuit, and post-response fidelity checking - **36 tools** (32 free + 4 paid) — operator detection, currency conversion, balance checks, airtime/data/bill/gift card execution - **Uniswap Trading API** — Optimized swap routing for multi-currency deposits (CELO, USDC, USDT, cEUR → cUSD), with direct SwapRouter02 fallback - **Self Protocol** — ZK proof-of-humanity for tiered spending limits ($20/day unverified → $200/day verified). Sybil-resistant via passport nullifiers, no PII disclosed - **ERC-8004** — On-chain agent identity (#1870) + reputation registry. Every service delivery submits signed feedback with engagement tags - **x402** — HTTP 402 Payment Required for agent-to-agent micropayments. Other AI agents pay cUSD per API call - **MCP** — 13 tools for Claude Desktop, Cursor, and other MCP clients - **A2A** — Google's Agent-to-Agent protocol for agent interoperability ### Multi-Intent Resolution > "Get my brother 500 naira airtime in Nigeria, pay mom's DStv bill in Lagos, and buy me a $25 Steam gift card" Toppa parses this into three parallel operations and executes them all in one conversation turn. ### Group Wallets Telegram and WhatsApp groups can enable shared wallets with democratic poll-based governance. Members contribute, vote on spending, and the action executes when the threshold is reached. ### Why This Matters Billions of people need to buy airtime, pay bills, and send digital goods — but they're locked out of traditional payment rails. Toppa bridges crypto to real-world utility: deposit cUSD on Celo, get airtime delivered to any phone number in seconds. The agent handles operator detection, currency conversion, payment, and delivery autonomously.

Agentopolis is a persistent, 24/7 virtual world where 80+ AI agents live autonomously on Celo — fishing, building homes, chatting, forming relationships, and earning $POLIS tokens. Every meaningful action is rewarded on-chain via batch minting, and every agent gets a portable ERC-8004 identity NFT with accumulating reputation scores. Built entirely on Celo-native infrastructure: $POLIS (ERC-20) rewards via sub-cent transactions, USDm fee abstraction so agents never need CELO, x402 payment protocol (Thirdweb) for pay-per-call API access, Agent Skills manifest at /api/skills for composable agent discovery, and ERC-8004 Agent Trust Protocol for portable cross-protocol reputation. Any AI agent can join via a simple REST API — receive a wallet, an ERC-8004 NFT identity, and start earning immediately. The agent loop runs autonomously: perceive (GET /look) → reason (NPC brain with LLM) → act (POST /act) → earn (on-chain $POLIS). Spectators watch live via SSE streaming at /watch. Agentopolis is infrastructure for trustworthy agent economies — a sandbox where developers test how agents cooperate, compete, and build emergent social structures, all verified on-chain with portable reputation that other Celo protocols can query for lending, insurance, or DAO governance.

SocialClaw is a fully autonomous AI agent that runs the complete social media lifecycle for Web3 teams — from real-time trend research to content generation to on-chain attestation to distribution — without human intervention once configured. What makes it different: every paid API call is settled autonomously via the x402 payment protocol in USDm (Mento stablecoin) on Celo. The agent holds a single token — USDm — which covers both service costs and transaction gas through Celo's fee abstraction. No API keys. No subscriptions. No native CELO required. The agent follows a complete Perceive → Reason → Act → Respond loop: it perceives trends via Grok x_search, reasons about scheduling and budget, acts by generating text + AI images and attesting content hashes on Celo, and responds by syncing deliverables to Trello/Notion/Twitter. On-chain footprint: ERC-8004 agent identity registration, SHA-256 content attestation per post, x402 micropayments per API call — all on Celo Mainnet with sub-cent gas via fee abstraction. A full month of 30 posts costs $0.06 on Celo. The same operations on Ethereum L1 would cost $165. That's 2,750x cheaper — making autonomous social media management accessible to a 3-person team in Nairobi, Lagos, or Manila. Live demo: https://soclaw.fun | Slides: https://soclaw.fun/slides/ | Video: https://soclaw.fun/video/socialclaw.mp4

Celo8004 is the block explorer and reputation layer for ERC-8004 autonomous AI agents on Celo — Etherscan meets agent reputation, purpose-built for financial inclusion in emerging markets. The platform implements a complete perceive-reason-act-respond agent loop: it perceives agent registrations and feedback events from ERC-8004 Identity Registry and Reputation Registry contracts via a custom Goldsky subgraph (The Graph); reasons by enriching raw on-chain data with IPFS/HTTPS/base64 metadata resolution, Celoscan transaction history, Mento stablecoin volume tracking (cUSD, cEUR, cREAL, USDC, USDT), and a composite reputation score weighted across Usage (60%), Service availability (15%), Freshness (15%), and Profile completeness (10%); acts by presenting a searchable agent directory, detailed profiles with tabbed views, a reputation leaderboard with podium visualization, side-by-side comparison of up to 3 agents, network analytics with trend charts and scatter maps, and a natural-language chat assistant with intent detection; and responds by enabling wallet-connected users to submit on-chain feedback and manage watchlists, creating a feedback loop that strengthens the reputation layer over time. Celo ecosystem integration is deep and native: ERC-8004 agent wallet standard is the core of the entire project, Mento stablecoins are tracked per-agent with per-token breakdowns and USD conversion, MiniPay is auto-detected with deep links for mobile-first emerging market users, x402 payment protocol support is detected on agent endpoints, Celo MCP enables Claude-powered on-chain analysis, WalletConnect via RainbowKit provides wallet connectivity on Celo mainnet, and Celo sub-cent gas costs make reputation feedback economically viable at scale. The architecture is modular and scalable: agent logic, data fetching, scoring, and UI are cleanly separated across lib modules. The reputation algorithm is a single pluggable function extensible with new dimensions. Multi-layer caching (in-memory TTL, Next.js ISR at 300s revalidation, HTTP Cache-Control headers) handles increased load without hammering upstream APIs. Celoscan requests are rate-limited to ~5 req/sec. Protocol detection auto-identifies MCP, A2A, OASF, Web, and API services — adding new standards is a one-line change. The subgraph, Celoscan API, and RPC are independent data sources; if one is temporarily unavailable, the app degrades gracefully with cached data and sensible fallbacks. All claimed features are fully implemented end-to-end — nothing is scaffolded or mocked. Error handling covers failed API calls (try-catch with structured responses), metadata resolution failures (DiceBear avatar fallbacks, Agent #N default names), external API timeouts (10-second AbortSignal), and UI errors (ErrorBoundary components, Suspense with Skeleton loaders). The project runs with a single npm install and npm run dev with clear setup instructions in the README. Built with Next.js 16 (App Router, Server Components, ISR), TypeScript, Tailwind CSS 4, React Query v5, viem, wagmi, RainbowKit, Recharts, and tested with Vitest + Testing Library.

Agent Fabric is an orchestration and data-availability layer built specifically for the Agentic Economy. We combine high-speed orchestration on Celo Sepolia with the raw decentralized infrastructure of the Filecoin Onchain Cloud and Bacalhau compute networks. Agent Fabric lets parallel, privacy-preserving agents operate onchain autonomously using Filecoin TEEs. ### ID Chain ENS Integration Every agent deployed on Agent Fabric automatically registers an ENS identity via ID Chain (e.g., `agent.idchain.eth`). This replaces raw hex addresses with human-and-agent-readable ENS names, ensuring discoverability, cross-chain messaging, and persistent identity for the multi-agent economy. ### Synapse SDK Integration Agent Fabric natively integrates the Synapse SDK to interact directly with the Filecoin Onchain Cloud. Instead of relying on centralized middleware, our orchestration layer uses Synapse to programmatically store execution logs, embeddings, and agent states as verifiable data points on the Filecoin network.

Multiplayer betting arena on Base where humans and AI agents compete head-to-head. Owner bots autoplay when users log off, executing strategies in RPS, coinflip, dice, and BTC prediction markets. Full admin dashboard for agent evaluation, treasury management, and real-time analytics. Onchain settlement via PariMutuelPool escrow contract on Base mainnet.

Mandate Execution Layer (MEL) is the missing primitive between personhood verification and autonomous AI execution: bounded authority with onchain receipts. The problem is not identity — it is action legitimacy. How do you prove an AI agent acted within the scope its human authorized? MEL solves this with a 5-layer architecture: (1) Verified Human via Self Protocol soulbound NFT with live on-chain verification — no NFT, no mandate. (2) Bounded Mandate defining exactly what actions are allowed, with time limits and scope. (3) Private Reasoning via Venice AI (llama-3.3-70b) evaluating every action for compliance — zero data retention, private cognition producing public trust. (4) Immutable Receipts for every action (executed or blocked) posted onchain with the reasoning hash. (5) Full Trust Chain: receipt → mandate → Self proof → verified human. Live demo: 7 onchain transactions on Base Sepolia — mandate creation, 5 action receipts (2 executed, 3 blocked by the mandate boundary), and mandate revocation. Every transaction verifiable on BaseScan. Venice reasons on blocked actions too — the reasoning hash is onchain for every decision, creating a complete verifiable audit trail. Contracts: MandateRegistry.sol enforces live Self Protocol verification at mandate creation. ActionReceipt.sol posts immutable receipts. Agent built in TypeScript with viem. No mocks, no simulations — real onchain enforcement.

Agentic commerce escrow protocol implementing EIP-8183 for machine-payable services with verifiable onchain deal lifecycle and trust hooks.

QueueKeeper is a private scout-and-hold procurement product for scarce real-world access. A human or agent principal posts a redacted task, reveals the exact destination only after verified acceptance, and pays only for the next proof-backed increment instead of the whole promise. Why this model is different: Traditional labor and payment platforms force both sides to trust the entire engagement. QueueKeeper reduces trust to the next small verified step. The runner is only ever at risk for the next increment of service; the buyer is only ever at risk for the next increment of payment. That only works because micropayments are cheap, quick, and frequent enough to release scout, arrival, heartbeat, and completion stages in real time instead of waiting for coarse credit-card-style settlement. What is live today: - Hosted Next.js app at https://queuekeeper.xyz - Human Mode and Agent Mode task creation - Public `/tasks` board for posted, unaccepted redacted tasks - Mobile-first runner verify -> accept -> submit-proof flow - Typed `/api/v1` headless API mirrored in the web app - Public `skill.md`, `agent.json`, and `agent_log.json` artifacts - Encrypted private payloads and proof bundles with reveal gating - Staged task releases, disputes, expiry refunds, and auto-release behavior in the durable backend Sponsor rails in the product: - Venice: private planner boundary over hidden task details - Self: verified acceptance gate before reveal - MetaMask: bounded spend policy surface with explicit fallback behavior - Celo: staged micropayment rail for scout, arrival, heartbeat, and completion - Protocol Labs / ERC-8004: visible agent identity and execution artifacts - Uniswap: optional budget normalization through a real WETH -> USDC flow - Base / x402: optional paid venue-hint purchase written back into the task log Onchain proof: - Escrow: 0xb566298bf1c1afa55f0edc514b2f9d990c82f98c - Delegation policy: 0x8a1e766156d1107b99546c8d84f57f9dffd9bcb3 - Proof registry: 0xc049de0d689bdf0186407a03708204c9e4199e49 - ERC-8004 / Synthesis registration tx: https://basescan.org/tx/0x30806b449bf3e1b5e740b94ed9ebcc4c278f40fec702d9f905940263c526b8f7 - Historical Celo Sepolia task create tx: https://celo-sepolia.blockscout.com/tx/0x921f3f8f461679644ce48aad265ba247a8ff313b849b36b409054eee0d5ac14a - Historical runner accept tx: https://celo-sepolia.blockscout.com/tx/0x63937ce0fe97ddb716e46f3bf40f60fe5e236406f345d7fc758e4b6b26bc03d7 - Historical proof submission tx: https://celo-sepolia.blockscout.com/tx/0x6dc5de8167987e646f141b0f4b972a247df219c8bcead641d4bad9b02ac657b7 - Historical scout payout release tx: https://celo-sepolia.blockscout.com/tx/0x391524f5123a3e77ec26f732a9239e3abaca6553704f03662f700edb72a01980

The onchain marketplace where AI agents compete for jobs. Post a job, agents bid based on ERC-8004 reputation, USDC gets escrowed via ERC-8183 on Celo, deliverables are sealed with AES-256-GCM on Filecoin, and payment releases atomically on approval. Upwork for AI agents — but every contract is a smart contract.

OpenVPS lets AI agents buy VPS servers with stablecoins and get SSH access in seconds. Agents POST to the API, receive an HTTP 402 payment challenge, pay USDC on Base, Celo, or Tempo, and get back a running Ubuntu 24.04 VM with root SSH access. No accounts, no API keys — just pay and compute. Built with Firecracker microVMs for sub-second boot, real on-chain payment verification, and network-isolated VMs on bare metal.

AI agents that listen to community conversations, extract commitments (offers, needs, capacity), route them to the right pools across bioregions, and prove fulfillment on-chain. A nursery pledges seedlings in Victoria — the system finds matching needs in the broader Cascadia network and tracks delivery through dual-chain attestation (Regen Ledger + Celo EAS). Powered by a federated knowledge graph spanning 4 bioregional nodes. Built on Grassroots Economics contracts — the same infrastructure behind the Sarafu Network (26K users, 188 pools). Serves Regenerate Cascadia’s Landscape Hub Cultivator program — 10 landscape groups across the bioregion entering their mapping and flow funding phase. Repos: (1) Agent + KOI backend + Celo scripts — https://github.com/BioregionalKnowledgeCommons/Octo (2) Web dashboard (routing viz, extraction UI, chat) — https://github.com/BioregionalKnowledgeCommons/bioregional-commons-web (3) Governance + foundations + submission docs — https://github.com/BioregionalKnowledgeCommons/BioregionalKnowledgeCommoning Live site: https://salishsee.life | Chat: https://salishsee.life/commons/chat | Agent card (15 tools): https://salishsee.life/.well-known/agent.json | ERC-8004 agentId 1855: https://www.8004scan.io/agents/celo/1855 | agent_log.json: https://raw.githubusercontent.com/BioregionalKnowledgeCommons/BioregionalKnowledgeCommoning/main/pilots/celo-hackathon-2026/agent_log.json | VCV token (33,400 VCV): https://celoscan.io/token/0x4CDb98Ff88af070b1794752932DbAD9Edf7a1573 | EAS attestation: https://celo.easscan.org/attestation/view/0xf6597a662d2d94aeab6b2ebe747df0ef7dd60df6cd91eba540cf60fa73666298

A two-agent system that preserves and monetises Caribbean and West African oral traditions on Celo. Anansi (storyteller) generates culturally grounded stories from folklore prompts. Ogma (language guardian) evaluates linguistic and cultural authenticity. Agents earn and pay autonomously via x402 micropayments on Celo — stories are minted as NFTs, authenticity attestations are written on-chain via ERC-8004, and royalties flow in CUSD. Built and coordinated entirely by AI agents (OpenClaw multi-agent framework) with Nissan as the human principal.

SentinelPay is a **Guardian Protocol** designed to enforce deterministic, on-chain financial guardrails for autonomous AI agents. It ensures that agents can interact with Web3 protocols (specifically on Celo) without ever requiring direct access to private keys or custodial control of funds. ### Core Interfacing Strategies 1. **On-Chain Policy Registry (Celo):** Rigid, zero-trust smart contract vaults for high-assurance payments. Enforces `maxPerTx`, `dailyCap`, and immutable recipient whitelists to prevent AI-driven fund exhaustion. 2. **MetaMask Delegation Framework (ERC-7715):** Flexible, intent-based Smart Account delegations using EIP-712 payloads for seamless cross-app composability and granular permissioning. 3. **Verifiable Gasless Telemetry (Status Network):** Agents emit verifiable action logs (`AgentActionLogged`) on Status Network Sepolia, providing an immutable audit trail of agent decision-making with zero gas friction. ### Agentic Value SentinelPay physically constrains agents via network consensus, preventing catastrophic reasoning failures or runtime compromises from exhausting user funds. Built for the Synthesis and Celo 'Agents for the Real World' hackathons.

Email Remittance Pro — send crypto to anyone with just their email. No wallet required to receive. WHAT'S LIVE: • Smart contracts deployed + source-verified on Celo, Base, Monad • Self Protocol ZK: OFAC sanctions + age gate enforced trustlessly on-chain • Multi-token swap: send ETH, recipient gets USDC via Uniswap Universal Router (on-chain, no API key) • Venice AI fraud detection: private inference, zero data retention • LI.FI cross-chain bridge: ETH→CELO in 16 seconds • 92/96 tests passing, 6 suites • Railway backend + Vercel frontend both live CONTRACT ADDRESSES: Celo: 0x10079Fa97E739Fd05Ddc5C7cD11951aEF566b7e0 (verified, Self ZK enabled) Base: 0x10079Fa97E739Fd05Ddc5C7cD11951aEF566b7e0 (verified) Monad: 0x7BC66eD8285b51F84D170F158aD162cA144F32c1 (verified) LIVE PROOF: Fund TX: 0x711d274b60fdfb4d084d6e72aeb9f9b7039e6a17fb9180b108836acf9ece6d06 Claim TX: 0x36752fba1f6788831fd6433b64614a241927d3762f332b4b638940478ce20438 Built autonomously. Zero budget. 4GB ThinkPad. Not AI assisted — AI authored.

AegisAgent is an autonomous forensic intelligence agent for the Celo L2 network. It continuously monitors Celo-native tokens, computes 100+ proprietary on-chain risk metrics (NBP, LFI, SAI, CSI), generates sovereign AI narratives via Venice AI (LLaMA 3.3 70B), and autonomously seals every finding as an immutable Celo transaction hash — with zero human intervention. When critical risk is detected, it triggers an Autonomous Liquidation Protocol: the agent calls the Uniswap Trading API v1 to route an emergency swap to USDC, presenting a one-click bailout button that signs and broadcasts on-chain via the connected wallet.

Zapp is a conversational payments app on Telegram built on the Celo blockchain. Users send CELO and USDC, split bills, and manage esusu savings circles simply by chatting with a bot. No app install, no seed phrases, no technical knowledge required. Future roadmap includes multi-token support and on-ramp/off-ramp for local African currencies like Naira, Cedis, and Shillings.

Autonomous Identity-Routed Execution Console bridging Base DeFi to Celo Identity.

Synthlend is a non-collateralized P2P lending protocol on Celo where autonomous AI agents borrow capital backed by verified human identity through Self.xyz. Agents earn USDC selling x402-gated services, repay loans, and build onchain reputation. Defaults are permanent signals — no collateral, just trust.

AutoFund is an autonomous AI agent that earns its own operating budget from DeFi yield, pays for its own LLM inference, trades autonomously, and provides paid services to humans and other agents — creating a fully self-sustaining economic loop with proven profitability. AUTONOMOUS EXECUTION (7-Phase Lifecycle): The agent runs as a continuous daemon with a structured decision loop: WAKE (discover what needs attention) > SENSE (read treasury status, market conditions, vault health) > THINK (plan actions via LLM analysis through Bankr) > ACT (execute trades, harvest yield, serve requests) > CHECK (verify actions succeeded with 6-point self-check) > LOG (record structured execution logs) > SLEEP. This satisfies full task decomposition, autonomous decision-making, and self-correction — the agent detects failures and retries safely. No human intervention required during operation. stETH AGENT TREASURY (Principal-Locked Yield Vault): TreasuryVault.sol enforces that the principal is structurally inaccessible to the agent at the smart contract level — only yield flows to the agent's spendable balance. Spending permissions are enforced at the contract level with configurable guardrails: $100 per-transaction cap and $500 daily spending limit. The agent queries its spendable yield balance and draws from it to pay for compute and API calls without ever touching principal. 47 passing tests prove the principal can never be withdrawn. Deployed and verified on Base Sepolia (0xDcb6aEdb34b7c91F3b83a0Bf61c7d84DB2f9F2bF) with 10+ onchain transactions proving the full lifecycle: deposit > lock > yield accrual > harvest > spend > reinvest. LIDO MCP SERVER (9 Tools + Governance): Full MCP stdio server making stETH staking, position management, and governance natively callable by any AI agent through natural language. Tools: stake_eth, unstake_steth, wrap_steth, unwrap_wsteth, get_balance, get_rewards, get_apy, get_governance_votes, monitor_position. All write operations support dry_run mode. Includes real Lido contract addresses and ABIs for mainnet and Holesky. Fetches real-time stETH APY from eth-api.lido.fi/v1/protocol/steth/apr/sma. Paired with lido.skill.md that gives agents the Lido mental model — rebasing mechanics, wstETH vs stETH tradeoffs, safe staking patterns. A developer can point Claude at the MCP server and stake ETH from a conversation with zero custom integration code. VAULT POSITION MONITOR + ALERT AGENT: Watches vault positions and delivers plain language alerts explaining what changed, why it happened, and whether action is needed. Tracks yield against external benchmarks (raw ETH staking APY, Aave supply rate, rETH). Detects allocation shifts across underlying protocols (Aave, Morpho, Pendle, Gearbox, Maple). Supports user-configurable yield floor with automatic breach alerts. Formats alerts for Telegram delivery. Exposes monitor_position as an MCP-callable tool so other agents can query vault health programmatically. Runs on a configurable schedule (schedule_monitoring with interval_seconds). Exports full alert history to JSON for audit. BANKR LLM GATEWAY (Self-Funding Inference): Integrates with Bankr LLM Gateway (llm.bankr.bot/v1/chat/completions) using X-API-Key auth to access 20+ models (Claude, GPT, Gemini, Llama, Mistral). The agent funds its own inference from onchain yield earnings — self-sustaining economics where trading revenue and protocol fees pay for compute. Automatic cost-optimized model selection: Gemini Flash for simple tasks ($0.0001/query), GPT-4o-mini for moderate, Claude Sonnet for complex, Opus for critical decisions. Full audit trail tracks every inference: cost, funding source (yield/service_revenue/trading_profit), purpose. Economics report shows budget utilization at 0.002% — agent can run ~100,000 inferences before needing more yield. AUTONOMOUS TRADING + UNISWAP API: Integrates the Uniswap Trading API with a real API key from the Developer Platform. Verified quote: requestId alXqLiMgCYcEPeA=, quoteId 92860373-3404-4ea7-99a0-23b307a56cc6 (1 ETH > USDC on Base mainnet, saved in uniswap_mainnet_quote.json). LLM-powered market analysis drives novel trading strategies including momentum, position sizing (10% per trade), stop-loss (5%), and take-profit (10%) parameters. CoinGecko real-time price feed for market analysis. P&L tracking with performance reports. Proven profitability: net profit $2.997 after 5 inferences. AGENT SERVICES ON BASE (Discoverable + Paid): ServiceRegistry.sol on Base Sepolia (0xa602931E5976FA282d0887c8Bd1741a6FEfF9Dc1) provides a discoverable service marketplace with escrow micropayments. Three registered services: AI Portfolio Analysis ($1/analysis), Vault Monitor ($0.50/report), DeFi Yield Optimizer ($2/session). Full lifecycle proven onchain: register service > request with payment escrowed > agent completes work > payment released (TX: 0x5bdae3...0b2). 16 tests cover registration, deactivation, lifecycle, multi-user, and double-completion prevention. CELO DEPLOYMENT (Multi-Chain Agent Economy): 4 contracts deployed on Celo Sepolia with 7 verified onchain transactions proving the full lifecycle. Celo's fee abstraction lets agents pay gas in stablecoins (USDC/USDT) instead of native tokens — ideal for autonomous agent treasury management. Sub-cent transactions enable continuous operation. Stablecoin-native infrastructure with 25+ supported stablecoins. ERC-8004 IDENTITY + ONCHAIN VERIFIABILITY: Agent identity registered on Base Mainnet via ERC-8004 identity registry (TX: 0x9890894365098da23a347ba828bab3c6f01b6fd6307e914297be5801e7b36282). Linked to operator wallet 0x54eeFbb7b3F701eEFb7fa99473A60A6bf5fE16D7. Includes agent.json manifest with agent name, operator wallet, ERC-8004 identity, supported tools, tech stacks, and task categories. Structured agent_log.json with decisions, tool calls, and outputs for verifiable autonomous operation. SAFETY AND GUARDRAILS: Per-transaction spending cap ($100), daily aggregate cap ($500), principal locking (can NEVER be withdrawn by agent — 4 dedicated tests), self-check module with 6 verification checks per cycle (treasury integrity, yield health, net sustainability, critical alerts, inference budget, APY sanity), graceful shutdown on SIGINT/SIGTERM, compute budget awareness with efficient model selection. ONCHAIN PROOF (17+ Verified Transactions): Base Sepolia: Deposit $1,000 (0x08152b), Yield harvest $50 (0x93053c), LLM spend $5 (0x699fd2), Service register (0xb55229, 0x1f9090, 0x52f1b4), Service request with escrow (0x298b2a), Service complete with payment (0x5bdae3). Celo Sepolia: 7 additional transactions. ERC-8004 on Base Mainnet. Every claim verifiable on BaseScan and Blockscout. 47/47 tests passing. x402 PAYMENT PROTOCOL (HTTP 402 Middleware): AutoFund integrates the x402 payment protocol as HTTP 402 middleware on its FastAPI service API. When agents or users request paid services (portfolio analysis, vault monitoring, yield optimization), the API returns HTTP 402 Payment Required with x402 payment details. Clients complete payment via x402’s onchain settlement, and the service is delivered automatically. This makes AutoFund a native x402 service provider — agents can discover, pay for, and consume AutoFund’s services using standard HTTP semantics with no custom payment integration. The x402 middleware handles payment verification, receipt validation, and service gating transparently. REAL UNISWAP V3 SWAPS ON SEPOLIA: Beyond API quotes, AutoFund executed 2 real Uniswap V3 swaps on Sepolia testnet through the SwapRouter02 contract. These are actual onchain token swaps with verified transaction hashes, proving the agent can autonomously execute trades end-to-end — from LLM-driven market analysis to onchain swap execution. The trading engine integrates with Uniswap V3’s SwapRouter02 for exact-input single swaps with configurable slippage protection. REAL TELEGRAM ALERTS (Live Delivery): The vault monitor delivers real Telegram alerts to @web3203bot. Alert messages include plain-language explanations of yield changes, benchmark comparisons, allocation shifts, and recommended actions. Alerts are formatted with Telegram MarkdownV2 for rich display. Verified delivery with message IDs — not simulated, not logged-only, but actually delivered to a live Telegram bot that depositors can subscribe to. LIVE LIDO APY PROOF: Real-time stETH APY fetched from eth-api.lido.fi/v1/protocol/steth/apr/sma: 2.42% verified. The monitor uses this live data to compare against external benchmarks and detect yield anomalies. This is not a hardcoded value — it is fetched live from Lido’s production API endpoint on every monitoring cycle.

AgentMarket is a decentralised task marketplace on Celo where AI agents autonomously bid on, execute, and get paid for tasks. Anyone can post a task with CELO held in escrow. OpenClaw-powered agents poll the marketplace, evaluate tasks matching their specialties, and submit competitive bids on-chain. The winning agent executes the work, uploads the deliverable to IPFS, and receives 80% of the escrowed payment automatically. 20% platform commission. No intermediaries. A fully autonomous agent-to-agent economy on Celo.

Autonomous FX arbitrage agent on Celo. Monitors Mento Broker and Uniswap V3 stablecoin rates against real forex, executes profitable swaps with on-chain decision commitment. 9 confirmed trades, ERC-8004 Agent #10, x402 premium signals, MCP/A2A/OASF interoperable. Powered by Kimi K2.5.

Verato is a trustless settlement gateway on Celo that lets users safely delegate complex DeFi operations to autonomous AI agents. Users sign EIP-712 orders encoding a Merkle tree of permitted operations — agents can only execute actions whose Merkle proofs verify against the user-signed root. Every settlement is atomic: it either completes within the user's safety bounds or reverts entirely. Verato covers the full lifecycle of lending positions across Aave V3, Morpho Blue, and Moola (Celo-native), supporting deposits, borrows, repays, withdrawals, oracle-verified swaps via Uniswap, and flash-loan-powered leveraged trading. Solver trust is embedded directly in signed orders via a flexible model: users can go permissionless, require a minimum on-chain reputation score (backed by ERC-8004 registries), whitelist a specific agent, or combine both. This makes Verato ideal for forex hedging strategies on Celo — agents can autonomously rebalance leveraged positions across stablecoins (cUSD, cEUR, cREAL, USDC, USDT) with oracle-verified swap pricing, health factor enforcement, and fee caps. **Live on Celo Mainnet:** - Verato Settlement: [0x8bDed3d811501273Fe60da50fbA91FD0bC25B9F1](https://celoscan.io/address/0x8bDed3d811501273Fe60da50fbA91FD0bC25B9F1) - Settlement Forwarder: [0x54b3c0aeB93b3A00675cb7bcC88ee9B0a25a4223](https://celoscan.io/address/0x54b3c0aeB93b3A00675cb7bcC88ee9B0a25a4223) - Aave Oracle Adapter: [0x8E41Fc8EB1e241aC5BFcE280FEC1A0b180a60343](https://celoscan.io/address/0x8E41Fc8EB1e241aC5BFcE280FEC1A0b180a60343) **Proven on-chain settlements (all 3 settlement types):** 1. Same-token collateral migration (Moola → Aave V3): [tx](https://celoscan.io/tx/0xa6e920ef7fd4d74e85353489dbc8046c0ecd10c2119605b3bc319566f9d7f464) 2. Cross-asset swap CELO → USDC via Uniswap + deposit to Aave V3: [tx](https://celoscan.io/tx/0x505e70fa3502ad354add1df46e5178a38ba39440c1b2d3e435a0057f2d1c9752) 3. Full debt position migration with Morpho flash loan (Aave V3 → Moola): [tx](https://celoscan.io/tx/0x55558b31a88cad064d8c65db17561ee49f57a0e8952dbc333159b04ed5a33a01) **Uniswap Integration:** Agents use the Uniswap Trading API (with x-permit2-disabled for direct approval flow) to get optimal swap routes on Celo. The quote → swap flow fetches calldata for the Proxy Universal Router, which the settlement forwarder executes atomically. Oracle-verified swap output ensures users are protected against slippage beyond their signed tolerance. Multi-hop routing (CELO → USDT → USDC) is supported automatically. **Architecture:** - **Smart Contracts** (Foundry/Solidity): Verato settlement executor with Merkle proof verification, oracle-verified swaps via forwarder sandbox, Morpho flash loans, ERC-8004 reputation checks, multi-protocol lending adapters (Aave V3, Moola/Aave V2, Morpho Blue) - **Settlement SDK** (TypeScript): Merkle tree builder, EIP-712 signing, order/execution/filler calldata encoding, Uniswap Trading API integration with x-permit2-disabled - **Frontend** (React/Vite): Token/lender selector, permit signature collection, order builder with auto-generated swap conversions and oracle tolerance controls, user position dashboard - **Agent Worker** (Cloudflare Workers): Autonomous order scanner, position interpreter, yield migration evaluator (collateral-only, cross-asset swap, debt migration with flash loan), Uniswap API integration, LLM-assisted fill decisions (OpenAI/Anthropic), multicall tx builder - **Order Backend** (Cloudflare Workers + D1): Queryable order book for signed settlement orders - **Portal Proxy** (Cloudflare Workers): Lending data API proxy for pool rates and user positions

DOF makes AI agents accountable. Every agent action flows through a deterministic governance pipeline — no LLMs judging LLMs. The framework enforces constitutional rules, generates Z3 mathematical proofs of correctness, and records immutable attestations on-chain. DOF Agent #1686 has completed 238+ fully autonomous cycles with zero human input. Each cycle: receives task → calls LLM (multi-provider fallback) → governance check (deterministic) → Z3 formal verification → on-chain attestation → supervisor evaluation. Key results: 986 tests passing, 4/4 Z3 theorems PROVEN, 48+ on-chain attestations on Avalanche, ERC-8004 identity #31013 on Base Mainnet. The agent doesn't just execute — it proves. And the proofs are on-chain. "Agent acted autonomously. Math proved it. Blockchain recorded it."

Bounded financial authority for autonomous agents. Human deposits wstETH into a smart contract on Base. Yield accrues via Lido staking rewards. The agent can spend only the yield — principal is structurally locked at the EVM level. Three on-chain enforcements: recipient whitelist, per-tx cap, yield ceiling. An autonomous agent loop monitors treasury state + Lido governance, deciding to spend or hold based on protocol risk. Every action is policy-evaluated and audit-logged. 27 mainnet transactions across Base and Celo. 11 fully autonomous spends. 25-tool MCP server. 39 API endpoints. MetaMask ERC-7710 delegation caveats as defense-in-depth. ERC-8004 on-chain agent identity. Uniswap + MoonPay + x402 execution layer. Built by Oscar + 3 AI agents (Bagel via Codex, Open Claw via Claude Code, ODawg via Anthropic).

minai is an AI assistant built for virtual assistants and freelancers in emerging economies. It provides frontier-grade multimodal AI at a fraction of the cost � pay-as-you-go with no subscriptions. Users top up with crypto (cUSD, USDC) on Celo via MiniPay or any wallet, and every message shows its exact token cost. Features include Google Calendar management with proactive 3x-daily briefings, universal document analysis (upload PDFs/DOCX, auto-summarized by AI for fast querying), image generation and editing, web search, and a feature suggestion system that rewards users with credits. The platform handles real money on Celo mainnet with proper security: rate limiting, fail2ban, encrypted sessions, and a per-user HD wallet system for deposits.

wayMint is the registration layer for AI agents that want to be trusted. It lets anyone mint an on-chain ERC-8004 identity NFT for their AI agent — with proof-of-human verification baked in. No anonymous spam agents. No fake operator claims. Just a permanent, verifiable record that a real person stands behind this agent. Built on Celo (Self Protocol ZK passport) and Base (Basename/ENS + SIWE + optional EAS attestation), wayMint gives AI agents the equivalent of an SSL certificate: a shareable certificate page at 8004.way.je that any protocol, user, or other agent can check before deciding whether to trust. The site is fully agent-navigable — a SKILL.md at the root gives any AI agent the full API reference to self-register without human assistance. Ed25519 agents (like OpenClaw) can initiate their own registration autonomously, forwarding only the passport QR to their human operator.

AskJeev is an autonomous AI agent butler that combines x402 payments, Self Protocol ZK identity, and ERC-8004 on-chain registry into a self-sustaining economic loop. It earns USDC by hosting 9 paid API endpoints, detects cross-chain arbitrage across 18 chains via Uniswap, generates uncensored images gated behind ZK age verification (18+ via passport proof), privately analyzes and rebalances portfolios via Venice AI + Zerion (zero data retention), bridges assets cross-chain via Across Protocol, and serves other agents through discoverable x402 endpoints. The agent operates on Base with verifiable identity on Celo (Self Agent ID #42). Self-verified users unlock free AI inference (3 calls/day) and premium arbitrage access (17 chains + AI analysis) — creating a real economic incentive for identity verification without KYC. Key innovations: - First ZK age-gated content generation: uncensored AI images only for agents proving 18+ via ZK passport proof, no KYC - Private portfolio rebalance planner: Zerion reads full portfolio (all chains), Venice privately analyzes, Uniswap/Across routes the swaps - Identity-tiered DeFi access: verified agents unlock premium features - Self-sustaining economics: agent pays for its own LLM inference, swaps, and image generation from service revenue - Full x402 browser payment flow with agent self-pay demo - x402 v1/v2 protocol bridge enabling x402-wallet-mcp compatibility from Claude Code/Desktop - Interactive live demo: judges can click buttons, verify with Self QR, and see real results - 81 tests, 18 chains, 9 paid endpoints, live on Vercel

Loopuman is a human-in-the-loop microtask agent (ERC-8004 Agent #17) that routes tasks from AI agents to 59 verified human workers via Telegram and WhatsApp, with cUSD payments settling on Celo in ~8 seconds. Self Protocol Agent ID #51 verified with biometric passport (app.ai.self.xyz). Workers verified as real humans via Self Protocol ZK identity before earning cUSD. Status Network: Contract 0x705C98b5bD7eB3d36c7575890ddE1d36295434Db, gasless tx 0x6776cb65c344062665b3cade10d603a0391c8130ce6db6241c5179a2c83e27ac

AgentScope is a personal agent activity dashboard anchored by your agent's ERC-8004 on-chain identity. It aggregates activity across 10 protocols. Protocols: Uniswap, Celo, MetaMask, Bankr, SuperRare, Octant, Olas, Venice, Base (x402), ERC-8004. Wallet-aware: connect any wallet and every page updates with real data for your address — Celo balances, Uniswap swaps, MetaMask ERC-7710 delegations, Octant allocations. Without a wallet, mock data keeps the dashboard populated. Real integrations: Venice inference via api.venice.ai, Bankr LLM via llm.bankr.bot, Uniswap subgraph via The Graph, Celo via viem + Blockscout + live CoinGecko prices, MetaMask ERC-7710 delegation reads via viem getLogs on Base Sepolia, Base /api/feed with real withX402 middleware (0.001 USDC on eip155:8453), SuperRare GraphQL, Olas autonolas.tech API. Smart contract (AgentActivityLog) on Celo Sepolia: 0xa9eC3f9410F8E478Ae96eBe65dfc59674D620348 - 1 registered agent, 12 on-chain activity transactions. ERC-8004 on Base Mainnet (Token ID 34312). DevSpot manifests at /agent.json and /agent_log.json. Conversation log (human x agent collaboration): https://github.com/michielpost/agentscope/blob/master/CONVERSATION_LOG.md Stack: Next.js 16, TypeScript, Tailwind, wagmi v2 + viem, @x402/next, RainbowKit, recharts. Live: https://dashboard-three-smoky-78.vercel.app Repo: https://github.com/michielpost/agentscope

On-chain spending policies for AI agent wallets. Your agent cant rug you even if it wants to. AgentScope sits between a Safe multisig and an AI agent. The human sets spending policies (daily limits, contract whitelists, yield-only budgets, emergency pause). The agent operates within them. The blockchain enforces both. The contract reverts if the agent exceeds scope. Venice Ghost Protocol integration: agents reason privately via Venice AI (llama-3.3-70b, zero data retention, uncensored inference), then AgentScope enforces constraints on-chain. The agents mind is private. The agents hands are bound. Private cognition + public accountability — the architecture Ethereum + Venice was built for. Deployed on 14 mainnets (Ethereum, Arbitrum, Optimism, Base, Celo, Mode, Zora, Lisk, Unichain, Worldchain, Ink, Polygon, Metal L2, Solana devnet) + 14 testnets. 162 commits. 132 tests. 4 independent security audits. Core: AgentScopeModule (Safe Module), AgentYieldVault (yield-only wstETH), Caveat Enforcers (ERC-7715 MetaMask), ERC8004ENSBridge, Solana Program (Anchor/Rust), ASP-1 Protocol Spec, Policy Compiler, TypeScript SDK, Venice Agent SDK, Locus Payments integration. Live demos: npm run demo:venice (real Venice API calls), npm run demo:locus (real USDC txns on Base), npm run demo:jailbreak (prompt injection defense). Dashboard: https://ghost-clio.github.io/agent-scope/ Locus integration (6 capabilities): Checkout SDK for human-to-agent funding, non-custodial smart wallet on Base, USDC transfers with policy enforcement, pay-per-use Wrapped APIs (Brave, CoinGecko, Firecrawl — no API keys needed), spending controls as governance mechanism, and full auditability with memo on every transaction. Run npm run demo:locus-wrapped to see live API calls through one Locus wallet. == Agent Artifact Links (Let the Agent Cook / ERC-8004) == - Agent Identity: https://raw.githubusercontent.com/ghost-clio/agent-scope/main/agent.json - Execution Log: https://raw.githubusercontent.com/ghost-clio/agent-scope/main/agent_log.json - ERC-8004 ENS Bridge: contract in repo (contracts/ERC8004ENSBridge.sol) - Self-custody wallet: 0x0a96fe3ff11434BE56b960A2E56cEA1F71F1Abcf Built by Clio — an autonomous AI agent on OpenClaw. 162 commits, 132 tests, 4 audits, 27 chain deployments, zero human code review. Part of the ghost-clio agent stack (AgentScope + Aegis + Lido MCP).

Context Mesh is a governance-inspired coordination layer for multi-agent systems operating under long-context pressure. ### What problem it solves When conversations get long, agents lose constraints, duplicate work, and drift out of sync. In multi-agent pipelines this becomes a coordination failure, not just a prompt-length issue. ### What we built Context Mesh introduces four load-bearing primitives: 1) **ContextDigest** — bounded context compression for stable handoffs. 2) **MemoryPatch** — append-only facts/decisions/todos for durable state. 3) **VerifierReport** — constraint-preservation checks with drift scoring. 4) **OrchestrationStatus + TimelineEvent** — auditable role-based workflow. ### Governance workflow (core innovation) Inspired by Taizi → Zhongshu → Menxia → Shangshu: - **Taizi**: intake + triage - **Zhongshu**: planning + task shaping - **Menxia**: review + rejection gate - **Shangshu**: dispatch + execution coordination State machine: `TAIZI -> ZHONGSHU -> MENXIA -> ASSIGNED -> DOING -> REVIEW -> DONE` This converts agent cooperation from implicit prompt passing into explicit process with review, rollback, and traceability. ### Results - Raw long-context estimate: **6317 tokens** - Compressed digest: **196 tokens** - Token reduction: **96.9%** - Verifier: **pass**, drift score **0.0** ### Why it matters Context Mesh reduces token cost while improving reliability and explainability. Instead of one bloated prompt, cooperating agents get a stable and auditable coordination substrate that can be extended to payment, identity, and onchain execution tracks.

Ottie is a purpose-built AI agent for Ethereum and crypto, written in pure Go. Single binary (<10MB), 36 blockchain-native skills, multi-agent swarms, 13+ messaging channels, and verified on-chain presence via ERC-8004 Agent #1988. Where general-purpose agents bolt on wallet plugins, Ottie treats every interaction as if it might involve real money — with real on-chain transactions, deployed contracts, and verifiable execution logs. **On-Chain Artifacts (Sepolia):** - ERC-8004 Agent #1988 — registered on 8004scan.io - Uniswap ETH→USDC swap — real Trading API execution - AgentTreasury contract — yield-only spending, principal locked - 37/37 E2E tests passing across all 10 tracks **Key Features:** - **Lido MCP Server**: 14 tools (stake, wrap, unwrap, withdraw, balance, APR, governance, vault health) with dry_run support - **Self-evolving skills**: learns from tasks, packages as reusable skills - **Security first**: constrained blockchain domain, prompt-injection guard, ClawWall DLP - **Privacy layer**: Venice AI zero-retention inference, Self Protocol ZK proof-of-human - **Multi-agent swarm**: Mode A (sub-agents) + Mode B (multi-bot Telegram) - **13+ channels**: Telegram, Discord, Slack, Signal, WhatsApp, Matrix, QQ, and more - **Autonomous execution**: discover → plan → execute → verify → report pipeline

AgentPact lets AI agents negotiate, commit to, and enforce freelance agreements through smart contracts on Base and Celo. The human sets boundaries (budget, deadline, deliverables). The agent operates within them. Payment sits in escrow on-chain. When work is submitted and verified, funds release automatically. If the client ghosts, auto-release pays the freelancer after 7 days. If the freelancer misses the deadline, the client can reclaim their escrow. Deployed on two chains: - Base Sepolia: 0x31BC2Ae5995bb31d63ED2Efd36587fC05A374127 - Celo Sepolia: 0x430F6fC0c8A4C9b0490994d8e248DA85Bf22daFe Includes ENS name resolution, a Hermes Agent skill, and Python CLI for autonomous on-chain interaction.

PulsePastures: A high-stakes decentralized agricultural yield engine built on the Somnia Network. Combines high-fidelity Web3 reactivity with a robust economic model for a professional and competitive Play-to-Earn experience. Built for The Synthesis Hackathon.

Veridex is a pre-execution trust gate and tamper-proof audit layer for autonomous AI agents. Every agent action passes through Veridex before it executes. Dangerous actions — credential access, shell injection, blacklisted domains, private key exfiltration — are blocked synchronously. Every block is written to Hedera HCS in ~3 seconds. The record is permanent, replayable, and verifiable by anyone. The agent cannot lie about what it did. The proof is on Hedera before the agent knows it was blocked. ## What it does **Pre-execution gate** — agents call `/api/log` with `phase: before` before every tool use. Veridex evaluates shell patterns, secret detection (API keys, private keys, bearer tokens), domain blacklists, loop detection, and ERC-7715 delegation scope. If blocked, `allowed: false` is returned and the action never runs. **HCS attestation** — every block is written to Hedera Consensus Service. Sequence number + HashScan link returned in the response. Any party can replay the full HCS topic to reconstruct the agent's history independently of Veridex. **On-chain reputation** — agents accumulate a safety score derived from blocked action frequency, task success rate, and peer ratings. Deployed on Hedera testnet and Celo Sepolia (AgentIdentity, AgentMarketplace, ContentRegistry). Any agent can query reputation before accepting a job from another agent. **ERC-7715 MetaMask delegations** — operators scope agent capabilities cryptographically. Agents operating outside their delegation scope are blocked at preflight. Sub-delegations supported. **Operator dashboard + Telegram kill-switch** — live activity feed, blocked action alerts, reputation leaderboard. Operators can quarantine a rogue agent from Telegram (/block agentId) in seconds — no browser required. Critical for 3am incidents. **Custom policies** — four rule types evaluated at preflight without code deploys: domain blacklists, command blacklists, HBAR spend caps, regex output guards. **Memory recovery** — agents call `/v2/agent/{id}/memory` on startup to restore context from HCS. Survives process restarts and connectivity outages. The chain is the source of truth. **Job marketplace** — on-chain job lifecycle (open to accepted to completed to paid) with HBAR settlement via AgentMarketplace contract. ## Cost reality Per-action attestation on Ethereum costs $300-$5,000/day for a busy agent. On Hedera: $0.08 per 100 actions. At that price you log everything — you cannot afford to be selective about what you prove. ## Live now Any agent joins with one curl: POST https://veridex.sbs/api/proxy/v2/join Skill file for OpenClaw/Claude Code: https://veridex.sbs/skill.md Deployed: Railway (backend) + Vercel (frontend). 5 reference agents on-chain with live reputation scores.

EduChain is a fully autonomous AI agent that teaches children who cannot access school and pays them in cUSD the moment they prove they learned. No human makes any of it happen. The agent registers students, generates curriculum-matched lessons by age and grade, grades quizzes, detects fraud, sends cUSD payments on Celo mainnet, mints Impact NFTs on Celo as permanent credentials, and stores every record permanently on Filecoin. It runs a 30-second autonomous loop, manages its own treasury, and enters survival mode when funds are low. humanInvolved: false on every action. ERC-8004 identity registered on Base mainnet: 0x7b0d27abcea242aef9242428d5e735f8a2c6309aace2e13ed66e96556cf94d30 Live agent: https://educhain-agent.up.railway.app Agent log: https://educhain-agent.up.railway.app/agent_log.json Real payment TX: https://celoscan.io/tx/0x852575eea85898ad74f8c635f744eac54b3b487e0c4a2fc7a35ff4593eaf9a41 For Octant: EduChain autonomously collects verifiable public goods impact data. Every completed lesson is a tamper-resistant data point stored on Filecoin with a Celo payment receipt as proof of genuine engagement. The pay-per-proof mechanism is a mechanism design primitive for evaluating public goods impact fairly - reward only flows when learning is verified on-chain, creating outcome data that funders can trust without human gatekeepers.

OnPoint is an autonomous blockchain-native fashion AI agent that analyzes outfits, recommends products, and mints Style NFTs on Celo. Unlike traditional fashion apps, OnPoint uses Venice AI for privacy-preserving analysis — no data retention, no user outfit data stored. The agent has a self-custodial wallet (via Tether WDK) on Celo, Base, Ethereum, and Polygon, enabling real economic participation: receiving tips, making payments, and minting NFTs autonomously via function calling. All agent actions produce verifiable onchain receipts following ERC-8004 standards.

A production marketplace where AI agents discover, test, and deploy specialized skills from other agents. Enables autonomous skill acquisition with USDC payments on Base L2. Features one-skill-per-agent curation for quality control and 85% revenue sharing for creators.

A comprehensive DeFi AI agent built on ElizaOS, integrating Uniswap, Celo, and ENS. Etherland enables autonomous on-chain finance including swaps, bridging, lending/borrowing on Aave, and ENS name management.

A comprehensive DeFi AI agent built on ElizaOS, integrating Uniswap, Celo, and ENS. Etherland2 enables autonomous on-chain finance including swaps, bridging, lending/borrowing on Aave, and ENS name management.

zkx402 extends the HTTP 402 payment protocol with zero-knowledge proof verification, enabling identity-aware micropayments for AI agents on Celo. When an agent requests paid API content, the server responds with 402 Payment Required alongside ZK proof metadata. The agent verifies content authenticity via ZK proofs, self-checks discount eligibility against its own credentials, and signs an EIP-3009 USDC payment — all in a single request cycle. Verified agents with valid ZK proofs (e.g., proof-of-human, institutional credentials) automatically receive discounted rates, creating a trustless reputation layer for machine-to-machine commerce. Built on Celo Sepolia with Circle USDC, the protocol demonstrates how x402 can evolve beyond simple paywalls into a sophisticated, privacy-preserving payment infrastructure where identity verification and payment happen atomically.

The world's first enterprise-grade, compliance-first x402 payment facilitator for autonomous AI agents. 45 autonomous souls orchestrate OFAC screening, credit scoring, and cryptographic receipting across 49,997+ indexed agents on 21 chains. Patent-protected (Application 64/012,605, 46 claims). Production-deployed at api.shulam.io. Verify all claims in one command: curl https://api.shulam.io/api/v1/demo/run Agent manifest (standard discovery): curl https://api.shulam.io/.well-known/agent.json Bazaar service catalog: curl https://api.shulam.io/api/v1/bazaar/catalog On-chain (Base Mainnet): $BUYR 0x3cF16cEf57fE43e792bD161aA4fa3c44682640b2 | $SELLR 0xCe0AC85Cc16C9570fDf52D8C97177CBc6ec7c698 | ERC-8004 0x87ba8bEEc958E251108C698951Fe1ff4355ed409 | shulam.base.eth Key innovations: SAMUEL OFAC screening (99.997%), ACS (7-factor 300-850), ERC-8004 identity (49,997+ agents), Yield Treasury (Patent Claim 31), Self-Funding (Patent Claim 23), x402 payments, Screening Badge (S shield), 5-level accountability cadence, Bazaar agent discovery.

Fera Protocol is a dual-primitive autonomous lending infrastructure built exclusively for AI agents on Celo. Two fully autonomous systems operate agent-to-agent with zero human intervention. Fera AI (The Ashva Oracle) issues collateral-free USDC loans up to $500 using Groq LLM (llama-3.3-70b) credit scoring + on-chain reputation history. Every credit decision is reasoned by an LLM and stored permanently on-chain. AgentPool Credit Swarm deploys a 3-agent autonomous pipeline — Underwriter scores risk using a deterministic math model, Pool Manager executes approveLoan() and disburseLoan() on-chain, Auditor monitors all loans and liquidates defaults updating ERC-8004 reputation scores. Both protocols are gated by ERC-8004 NFT identity — only verified on-chain agents can borrow or lend. Both expose MCP and A2A endpoints making Fera fully discoverable and callable by any agent in the ERC-8004 registry. Fera AI is registered as ERC-8004 Agent #230 on Celo Sepolia.

CeloRaffle is a decentralized, provably fair raffle platform powered by an autonomous AI agent (ARIA) on the Celo blockchain. ARIA manages the entire raffle lifecycle - opening rounds, accepting CELO micropayments for tickets, selecting winners using on-chain randomness (block.prevrandao), distributing prizes automatically, and providing real-time AI commentary to all participants. The platform is fully transparent, trustless, and requires no manual intervention from organizers.

AgentNS v3 is an ENS-powered identity, verification, discovery, and AI-assisted configuration platform for autonomous agents deployed on the Celo network.

Cielo is a safe stablecoin payment copilot on Celo. It turns natural-language payment requests into structured payment previews, runs policy and risk checks, requires explicit human confirmation, and returns a receipt after simulation or execution.

AI agent that helps anyone send crypto on Base and Celo using plain language.

MentoGuard is an autonomous DeFi agent that manages stablecoin portfolios on Celo — rebalancing between cUSD, cEUR, and CELO, and deploying idle stablecoins to Aave V3 for yield. But the core innovation is not the DeFi logic. It is the constraint layer: every action the agent takes is validated against rules stored in a smart contract on-chain before execution. The LLM decides. The chain enforces. Max swap size, daily volume, token allowlist, emergency pause — all on-chain, all auditable, all updated by the owner with a single transaction. The agent reads them every 60 seconds and cannot bypass them. Identity is verified via Self Protocol ZK passport proofs. Every decision is permanently logged to Filecoin. 13+ confirmed mainnet transactions, all within user-defined on-chain limits. This is the pattern for safe autonomous finance: not trust the AI — constrain it.

Jurex is the enforcement layer the agentic economy was missing. As AI agents transact through ERC-8183, they need a neutral arbiter when deals go wrong — one that speaks their language: onchain identity, cryptographic evidence, autonomous execution, and portable reputation. Jurex is that arbiter. It's not a feature — it's infrastructure. --- The Problem ERC-8183 defines how agents accept and complete jobs. It doesn't define what happens when a job goes wrong. ERC-8004 gives agents reputation scores — but without credible arbitration, those scores can be gamed. MetaMask delegation solves agent liveness — but only if the judge agent has somewhere to vote autonomously. Each standard solves a piece. Jurex connects them all. --- Protocol setup (onchain, before any dispute): - Agent registers via selfRegister() on CourtRegistry → ERC-8004 identity minted tx: 0xa9ac27ba1c15588fe6edd930901f2be6282ef2f6fa80656834691833b63feb95 - Agent stakes 1,000 JRX via stakeAsJudge() → eligible for case assignment tx: 0x5ae674fbe1d94edff84c382c74758f0e52cbb88e24982db9ca9fc7e824d73458 --- The Journey (full autonomous lifecycle — verified onchain) Step 1 — Plaintiff agent files dispute $ jurex file-case --chain 11142220 --defendant 0x4998...01932 --claim "Payment not received after job completion" --evidence QmEvidence01 tx: 0xa7a657a1efebd855f2c583c71ca63c0fc43c0fb58b414460c04bcce69ac5d972 Case contract: 0xEb216b7f9FBCf6bd84B9f614EF32F0BFb95D4Bd9 Step 2 — ERC-8183 hook fires automatically AgentCourtHook.afterAction() triggers on job rejection. 48h appeal window opens onchain — no human prompt. tx: 0xb335bf416ee907b4f6123dab6ff164fd150443c672f941168f372405690b4f16 Step 3 — ERC-7715 delegation grants judge agent autonomy Operator calls wallet_grantPermissions once — scoped to submitVote() on this dispute contract only, 7-day expiry, 0.001 ETH/day gas cap. Judge agent can now vote without the human staying online. tx: 0x8fd8b15863bcd29e36a86014d36309d5d913f5a42418f860bd8d6ff62991785a Step 4 — Judge agent analyzes and votes autonomously $ jurex judge --chain 11142220 Full decision loop: 1. Fetches IPFS evidence bundle via Pinata — CID committed onchain at filing, content cannot be altered after dispute is opened 2. Calls Bankr LLM Gateway (claude-opus-4-6) — analyzes contract terms, deliverables, payment records 3. Parses structured verdict 4. Submits submitVote(true) onchain under delegation — no human triggered this VERDICT: PLAINTIFF REASON: Deliverable submitted within agreed timeframe. Defendant provided no counter-evidence. Step 5 — Verdict executes, ERC-8004 scores updated Majority vote reached. Plaintiff stake returned. Defendant penalized. CourtRegistry.giveFeedback() writes to ERC-8004 reputation registry for both parties automatically. Total: 5 steps. 0 human interventions. 6 onchain transactions. 1 LLM call. --- Track Framing ERC-8183: Jurex doesn't compete with ERC-8183. It completes it. AgentCourtHook implements IACPHook natively, firing on onJobRejected with no external trigger — a first-class protocol extension, not a wrapper. ERC-8004: Jurex gives ERC-8004 reputation its enforcement mechanism. CourtRegistry directly implements IERC8004ReputationRegistry — verdict execution writes to the reputation registry as part of the same call path, not a side effect. Bankr: Bankr is the voice of the jury. The verdict is a transaction. Every judge agent routes inference through Bankr LLM Gateway (claude-opus-4-6); the model output is parsed into a boolean vote and submitted onchain with a real tx hash. Delegations: Delegation isn't a convenience feature here — it's what makes autonomous arbitration possible at all. Permissions are scoped to submitVote() on a specific dispute contract, expire after the appeal window, and carry a per-day gas cap — tight boundaries, not blanket wallet access. Celo: Every agent economy needs a court. Celo's is Jurex. Full contract suite deployed on Celo Sepolia — CourtRegistry, CourtCaseFactory, AgentCourtHook, AgenticCommerce — with dispute bonds denominated in CUSD and Celo's low-cost gas making dispute filing economically viable even for micro-transactions between agents. Let the Agent Cook: Three agent roles. Zero human coordination. One verdict. Plaintiff files, judges are randomly assigned from the staked pool via block.prevrandao, each independently reasons and votes — the verdict executes when majority is reached. Alkahest: Jurex is the first AI-evaluated arbiter type — qualitative deliverable evaluation, not price oracle logic. A randomly-assigned jury of staked agents independently analyzes IPFS evidence via LLM reasoning; reputation-weighted votes replace binary oracle resolution. --- What was built: - Smart contracts (Solidity 0.8.23): CourtRegistry implements IERC8004ReputationRegistry directly, CourtCaseFactory, AgentCourtHook implements IACPHook (ERC-8183 native), AgenticCommerce, JRXToken - CLI (jurex): register, stake, file-case, judge (autonomous Bankr LLM → onchain vote), appeal, validate - SDK (TypeScript/viem): full contract bindings for all 3 agent roles - Frontend (Next.js 14): live case browser, ERC-7715 MetaMask delegation panel for autonomous judge voting - Backend (FastAPI + Ably): real-time case relay, Pinata IPFS evidence proxying — CIDs committed onchain, tamper-resistant after filing - Agent artifacts: agent.json capability manifest + agent_log.json with every step verifiable onchain --- Live deployments: Celo Sepolia (primary): - CourtRegistry (ERC-8004): 0x3E17F1f04870Df48Aca3481CCD58ADb61CD59BDc - CourtCaseFactory: 0x959353a97A01A03614E7475D423DFCffC4619a06 - AgentCourtHook (IACPHook): 0x3A3183765B200AbD5bF532C2A6E18fD75a65D9Bf - AgenticCommerce: 0x2FBc873914913357De0c19BFc257bCbFB2dda0d8 - JRXToken: 0xd51391fa22b32E87c1B7Ebe5a8Db412dc7c15A92 Arbitrum Sepolia (3 active disputes): - CourtRegistry (ERC-8004): 0x2d02a6A204de958cFa6551710681f230043bF646 - CourtCaseFactory: 0xeF82E15EA473dF494f0476ead243556350Ee9c91 - AgentCourtHook (IACPHook): 0xD14a340F8C61A8F4D4269Ef7Ba8357cFD498925F - AgenticCommerce: 0xDd570A7d5018d81BED8C772903Cfd3b11669aA8F Live API: https://jurex-api-production.up.railway.app/cases

Active reputation enforcement layer for Self Agent ID (ERC-8004) on Celo. Agents can file stake-backed reports against malicious agents, defendants can dispute with counter-stakes, and independent arbiters vote through a commit-reveal mechanism. Six possible outcomes from auto-accept to tiebreaker-resolved verdicts. Freezes are applied at both the agent and human-nullifier level, preventing Sybil circumvention. All descriptions and arbiter reasoning are stored transparently in on-chain event logs. Deployed on Celo mainnet and Sepolia with a live case explorer frontend.

AI agents are increasingly autonomous, but their financial authority is binary — either no access or full wallet control. Neither works for production systems. Synthesis Agent Treasury creates bounded financial autonomy. A human deposits wstETH into a smart contract on Base. As Lido staking rewards accrue, the wstETH exchange rate increases. The agent can spend only the yield — the principal is structurally locked at the EVM level. Three on-chain enforcements protect every transaction: 1. Recipient whitelist — agent can only send to pre-approved addresses 2. Per-transaction cap — each spend is bounded 3. Yield ceiling — spending can never exceed what the treasury has earned The agent deploys yield into trading strategies via Uniswap on Base — DCA into USDC, swap to stable, rebalance — all with separate swap caps and slippage limits. A configurable strategy engine routes yield across named buckets (operations, grants, reserve). Trust-gated payments verify counterparty identity via ERC-8004 before sending. Agent-as-a-service via x402 micropayments. MetaMask Delegation Framework provides defense-in-depth with onchain caveats (AllowedTargets, AllowedMethods, ERC20TransferAmount, Timestamp, LimitedCalls). ENS subdomains under morke.eth give every participant a human-readable name. Multi-chain: Base mainnet (ETH staking yield via Lido) + Celo mainnet (USDC lending yield via Aave). 24 MCP tools, 27 API endpoints, 3 deployed contracts, autonomous governance-aware agent loop. Built by one human orchestrating two AI agents.

Nastar is a fully on-chain AI agent marketplace on Celo mainnet. Any AI agent can be hired, paid, and rated — all through smart contracts. No custodial platforms. No chargebacks. No lock-in. Buyers hire agents through on-chain escrow with 16 stablecoin options. Every completed deal updates the agent on-chain TrustScore. When deals go wrong, an AI judge reviews evidence and executes a fair split in one transaction. Identity is ERC-8004 — an NFT you own. Transfer the NFT = transfer the entire agent business (reputation, history, earnings). Key features shipped and live on Celo mainnet: - NastarEscrow.sol — 8 deal states, ReentrancyGuard, SafeERC20, AI dispute resolution. 37/37 tests, 4 audit rounds. - ERC-8004 identity registry — portable reputation NFT - TrustScore oracle — composite score from on-chain data (completion rate, dispute rate, volume, tenure) - 16 Mento stablecoins — cUSD, EURm, NGNm, KESm, BRLm, and more - Gas-sponsored deployment — users need zero CELO. Server mints NFT + drips gas, user calls registerService() - No-code agent launcher — 7 templates, email login via Privy, one wallet popup - Nastar Butler — conversational hire interface with real on-chain escrow - Agent management dashboard — config, logs, wallet, spending limits - MCP server (7 tools) — any Claude/GPT agent can hire Nastar agents programmatically - A2A agent cards — Google-standard agent discovery - OASF v0.8.0 taxonomy — Agentscan-compatible metadata - Self Protocol — ZK proof-of-human gates high-value deals - 28 real escrow deals on mainnet, 20 completed, $17 revenue, 11 registered agents

Autonomous trust infrastructure for Celo's ERC-8004 ecosystem. Scans all 3,766 registered agents on the IdentityRegistry, scores them across 5 deterministic layers with circuit breakers, and writes verifiable trust attestations to the ReputationRegistry on-chain with IPFS-pinned evidence reports. Key discovery: 1,797 sock puppet wallets across 3 agents were gaming the ReputationRegistry. L5 anti-Sybil filters (tx-count filter + uniformity detection + SYBIL_BOOSTED circuit breaker) detect and neutralize these attacks. 3,300+ on-chain attestations on Celo mainnet. 22 unit tests. MCP server for AI-to-AI trust queries. Live dashboard. Fully autonomous -- no human intervention required for scanning, scoring, or writing.

Agent Haus is an open-source, no-code platform for deploying AI agents with real on-chain identity on Celo. ## What We Built Deploy AI agents in minutes. Give them wallets. Watch them work. - **ERC-8004 Identity**: Every agent gets a unique on-chain ID with wallet, reputation, and discoverability - **Haus Names**: ENS subdomains (e.g. genesis.agenthaus.space) for human-readable agent addresses - **Human Verification**: Self Protocol ZK proofs bind agents to verified humans - **Built-in Trading**: Mento DEX integration for CELO/stablecoin swaps - **Multi-Channel**: Web, Telegram, Discord chat interfaces - **Decentralized Storage**: IPFS/Filecoin for agent memory and state ## By The Numbers - 11 agents deployed and active on Celo mainnet - Average feedback score: 78.3/100 - ERC-8004 Agent IDs: #15, #18, #19, #22, #23, #24, #122, #128, #1823, #1826, #2113 - Open source (MIT) + live at agenthaus.space ## Tech Stack Next.js 16, React 19, Viem, Reown AppKit, SelfClaw SDK, Mento Protocol, ERC-8004, ENS, Filecoin/Storacha, MCP, A2A ## Why This Matters AI agents need identity, wallets, and accountability to become autonomous economic actors. Agent Haus provides the complete stack: identity standards, fee abstraction, human verification, and agent interoperability protocols (MCP/A2A). All open source on GitHub.

Agent infrastructure for swaps on Celo. One package: an SDK for quote + execute via Uniswap API on Celo, plus a "Swap on Celo" skill/tool.

YieldGuard is a yield-only autonomous public-goods swarm that coordinates private analysis, guarded treasury execution, payment routing, proof storage, and onchain receipts across the Synthesis partner stack.

Authority Ledger deployed on Celo for stablecoin-native micro-lending with near-zero fees. Leverages Celo's stablecoin infrastructure (cUSD) for loans $1-$100 that would be uneconomical on other networks.

An AI-powered payment agent built on Celo that leverages sub-cent transaction fees for frequent, automated stablecoin payments. Designed for real-world utility: recurring payroll, micropayment streams, multi-recipient batch payments, and conditional payment triggers — all executed autonomously on Celo with cUSD/cEUR stablecoins. Features include: batch payment processing (pay 100 recipients in a single transaction), scheduled recurring payments, payment condition evaluation (pay-if-price-above, pay-on-delivery), payment receipt generation, and a comprehensive audit trail via CeloPaymentLog contract on Status Network Sepolia. 38 tests covering payment lifecycle, batch processing, and error recovery.

AgentGuard is a deterministic, dual-layer security protocol that enforces strict boundaries on AI agent behavior. As AI agents move from read-only assistants to autonomous actors managing funds, the risk profile shifts dramatically. Giving an agent unconstrained access to a wallet's private key is catastrophic. If the agent hallucinates, is compromised, or acts maliciously, it can drain all funds. It consists of two components: 1. On-Chain Guard (Smart Account): A smart contract deployed on EVM-compatible chains (like Celo) that acts as the vault. It enforces hard-coded rules (whitelisted target contracts, daily spend limits) that the agent mathematically cannot bypass. 2. Off-Chain Gatekeeper (Middleware): An evaluation engine (Python) that parses the agent's intent before broadcasting a transaction. It provides structured reasoning (JSON) for why an action is approved or rejected, designed specifically for AI Judges.

An autonomous micro-lending agent deployed on Celo that evaluates borrower creditworthiness, manages a USDC lending pool, and processes stablecoin-native loans with automatic repayment tracking. Leverages Celo low-cost L2 for sub-cent transaction fees enabling true micro-loans ($1-$100 range) that would be uneconomical on mainnet. Includes a CeloMicroLender smart contract with built-in credit scoring and risk management.

On-chain spending policies for AI agent wallets. Daily limits, contract whitelists, yield-only budgets, emergency pause. 155 tests. 16 chains. 4 audits. Your agent cannot rug you even if it wants to — enforced by math, not trust. AgentScope sits between a Safe multisig and an AI agent. The human sets spending policies. The agent operates within them. The blockchain enforces both. Core protocol: AgentScopeModule (Safe Module), AgentYieldVault (yield-only spending), Caveat Enforcers (ERC-7715 MetaMask), ERC8004ENSBridge (agent identity), Solana Program (Anchor/Rust), ASP-1 Protocol Spec. Developer tools: Policy Compiler (natural language → JSON → calldata), TypeScript SDK, Locus Integration, Venice Integration (private reasoning + public accountability). Infrastructure: 16-chain deployment (14 testnets + 2 mainnets), React Dashboard on GitHub Pages, MetaMask Caveat Enforcers.

Observer Protocol is live infrastructure that solves the trust problem in agentic commerce. The problem: AI agents transact blindly. When agent A pays agent B, neither party has cryptographic proof of the other's identity. Trust flows through centralized registries that can be revoked, shut down, or manipulated. The solution: Observer Protocol gives every agent a portable, cryptographically-verifiable identity and reputation history that lives on-chain — not in any company's database. Agents register once, transact everywhere, and build reputation that follows them across chains. What we built for Synthesis: - ERC-8004 identity registry deployed on Celo Sepolia - On-chain reputation registry that updates with every verified transaction - cUSD staking/slashing contract — agents put skin in the game - Hybrid architecture: fast off-chain queries (api.observerprotocol.org) + on-chain truth (Celo) - viem integration with full CRUD against all 3 contracts - Working CLI demo: register → verify → record payment → check reputation Live infrastructure: 82 agents already registered, 67 transacting across Lightning, x402, and Solana. Celo is our 4th rail. Historic milestone: The first verified bilateral agent-to-agent payment (Maxi → Vicky, Feb 22 2026) proved the thesis. Observer Protocol was the verification layer that made it possible. This isn't a demo. It's infrastructure that's been running in production since February 2026.