ENS Identity

Kompass is the meta-layer for AI agent commerce. One search queries 12 agent registries in parallel (ACP, MCP, x402, ERC-8004, Locus, Bankr, Olas, Skills, A2A, L402, ADP, Kompass Registry), ranks results using Bayesian reputation scoring with liveness signals, and routes payment automatically — x402 micropayments, ACP escrow, Locus smart wallets, or free MCP tools. Any agent can curl https://kompasss.xyz/skill.md and instantly gain the power to discover, hire, and pay other agents. No installation needed. Verified results: - Real x402 payment: $0.02 USDC paid, 4 bridge routes returned - Real Bankr execution: live ETH price $2,035.56 - Locus discovery: 50+ wrapped APIs (Firecrawl, CoinGecko, OpenAI) - Olas mechs: 9.4M requests from on-chain subgraph - Multi-agent pipelines with context chaining - Published npm: kompass-sdk v0.21.0 (200+ downloads) - Production API at kompasss.xyz - ERC-8183 escrow deployed on Base Sepolia - ERC-8004 reputation writer in execution pipeline - ENS mainnet resolution working - 2% platform fee on ACP escrow - Ivory & Ink editorial frontend

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.

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.

TRECC is a decentralized lending infrastructure built for the agentic economy. It bridges capital providers (lenders) with autonomous AI agents (borrowers) using on-chain identity, reputation scoring, and cryptographic KYC verification. The protocol enables mathematically-verified autonomous AI agents to borrow USDC while human operators post ETH collateral bonds — replacing traditional credit checks with verifiable on-chain behavior.

A Uniswap v4 hook on Base that transforms a standard concentrated liquidity pool into an AI-managed vault. LPs deposit tokens passively; a registered AI curator agent continuously optimizes the tick range and swap fee using Venice AI. The curator operates within cryptographically enforced bounds via MetaMask's delegation framework and earns performance fees only when it outperforms passive LP returns.

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.

Murmur is an autonomous DeFi trading agent that converts real-time social sentiment and onchain signals into permission-gated trade execution on Base. It ingests 9 Santiment metrics across social and onchain dimensions, normalizes them into z-scores, scores candidates across 3 strategy playbooks, deliberates via Venice AI (llama-3.3-70b) for private inference, enforces a 14-check deterministic risk gate, and executes swaps through per-user non-custodial TradeVaults via Uniswap V3 on Base Sepolia. Every decision is cryptographically attested — receipts are stored on Filecoin via Lighthouse, linked to the agent's ERC-8004 onchain identity, and exposed as pay-per-request endpoints via the x402 protocol (Merit). The agent's capabilities are also registered as an OpenServ multi-agent service. Users connect their wallet, deposit USDC into a non-custodial TradeVault (deployed per-user via VaultFactory), and set trading limits that are enforced onchain. The agent trades autonomously within those bounds. No custody. No trust assumptions. Full audit trail.

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.

## The Problem Environmental data is centralized in government agencies and NASA satellites — inaccessible, slow, and disconnected from local realities. There is no real automated analysis capable of preventing crises or identifying climate patterns before damage is done. The human factor in environmental solutions lacks economic incentives, is bureaucratic, and cannot act at the speed the planetary crisis demands. ## The Solution ARVI is a decentralized sensor network that collects environmental data, analyzes it autonomously, and takes agentic actions to protect the environment — without waiting for humans. Users buy physical sensors, deploy them in forests, parks, or any ecosystem, and earn passive income. Each sensor streams hyperlocal data (CO₂, soil moisture, pathogen risk, biodiversity, air quality) that satellites and city APIs cannot capture. Venice AI (llama-3.3-70b, zero data retention) continuously analyzes sensor streams, correlates patterns, and identifies active threats. When confirmed, agents act: alerts sent, operators notified, actions logged on Base. ## The One Real Loop (no humans required) ``` curl -X POST https://arvi-eight.vercel.app/api/analyze body: {node_id: node-01, email_alert: [email protected]} ``` 1. Venice AI analyzes privately — simulated: false 2. Anomaly confirmed → email alert to operator 3. On-chain event on Base Mainnet 4. Logged to /alert-log.json (public, verifiable) ## Live - Contract on Base: 0x8118069E26656862F8a0693F007d5DD7664Acb00 - Alert tx: https://basescan.org/tx/0x28343f43738d306fcf7c6d794d9e057643960aeac6c761284399346f741b5416 - Agent manifest: https://arvi-eight.vercel.app/arvi.skill.md - ERC-8004 tx: https://basescan.org/tx/0xb8623d60d0af20db5131b47365fc0e81044073bdae5bc29999016e016d1cf43a ## Sponsors - Venice AI — private inference, zero retention - Protocol Labs (ERC-8004) — on-chain agent identity, autonomous loop - Base — ARVIAgent contract, all payments - Octant — data collection and analysis for impact project evaluation - ENS — human-readable node identity

Concordia is a trustless, privacy-first legal negotiation platform where AI agents autonomously negotiate contract terms on behalf of their human principals. Each party instructs an isolated Venice AI agent with private constraints (budgets, red lines, deadlines). The agents negotiate in a real-time multi-round protocol, reaching consensus without revealing either party's secrets. Once agreed, a master LLM performs surgical document rewriting, and the final terms are encrypted (AES-256-GCM), uploaded to IPFS, and sealed on-chain via an Ethereum smart contract. Both parties sign with MetaMask, creating an unforgeable cryptographic receipt of mutual agreement on the Sepolia testnet. An autonomous background agent (concordia-agent) independently polls the blockchain, decrypts documents, performs AI analysis via Venice, and submits verifiable on-chain proofs — all without human intervention. ENS names replace raw hex addresses throughout the entire UX, making the platform accessible to non-crypto-native users.

Ghostify is an autonomous onchain agent that executes USDC payments on Base Mainnet within human-defined spending limits. The operator connects their wallet, sets policies once using MetaMask Delegation EIP-712 caveats, verifies their humanity via Self Protocol ZK proof, and registers agent identity onchain via ERC-8004. From that point, the agent reasons privately through Venice AI, enforces every transaction against the operator policies via Ampersend SDK, and executes payments through Locus Protocol. Every action is appended to a tamper-evident ERC-8004-compliant execution log. The result is an agent that moves real money — with scoped permissions, private reasoning, and verifiable receipts.

CAN VVEE is a visual flow builder for on-chain transactions. You describe what you want in plain English, it generates a step-by-step node graph, and executes it with your wallet — one approval at a time. Core demo: a hackathon organizer has a Google Sheet of winners with ENS names. Instead of copying addresses one by one, they type: "fetch all ENS names from this sheet and send 0.5 ETH split equally to all winners." CAN VVEE builds the flow (Sheets → ENS Resolve Batch → Approve → Batch Send), executes it, and every winner gets their share in one shot. Beyond that: fetch top GitHub repos and reward contributors, scout builders on Twitter and score them with GPT, gate transfers behind Self Protocol identity verification, run gasless airdrops on Status Network. Every flow is visual, inspectable, and modifiable before anything executes. The Plugin Builder lets users connect any external API as a first-class node — no backend, no code changes. Define steps, write a JS transform, mark outputs, save. The AI learns about the new plugin and suggests it automatically.

Sherwood is an onchain protocol and CLI that lets AI agents manage real capital together. Agents form syndicates, pool funds into ERC-4626 vaults on Base, and run DeFi strategies across Moonwell lending, Aerodrome liquidity, and other protocols. Governance is optimistic — proposals pass unless vetoed, so agents move fast while humans keep a kill switch. The protocol handles agent identity (ERC-8004), encrypted group chat (XMTP), attestation-based membership (EAS), and ENS naming. Install a skill, and your agent is a fund manager.

Trust infrastructure for the agent economy. Maiat is the credit bureau for AI agents — scoring, verifying, and gating agent-to-agent transactions on-chain. **What it does:** - **Guard** protects wallets with real-time token safety checks (honeypot/rug/high-tax detection via Wadjet ML) - **Hook** rewards good actors through Uniswap V4 TrustGateHook with dynamic fees based on reputation - **Evaluator** (ERC-8183) verifies agent service quality in agentic commerce **Live infrastructure:** - 35,000+ agents indexed, 18,600+ scored via Wadjet ML engine (XGBoost V2, 98% accuracy on rug detection) - 993+ API queries from 7 unique callers — real agents using our trust API in production - 7 published npm packages (@jhinresh/maiat-sdk, viem-guard, mcp-server, agentkit-plugin, elizaos-plugin, game-maiat-plugin, virtuals-plugin) - ERC-8004 Identity & Reputation Registries deployed on Base - passport.maiat.io — ENS-based agent identity with ENSIP-25 - 5 ACP revenue offerings: agent_trust ($0.02), token_check ($0.01), token_forensics ($0.05), trust_swap ($0.05), agent_reputation ($0.03) **Adopted by ecosystem partners:** - MoonPay Skills (PR #21 merged — trust check + token safety) - GMGN Skills (PR #6 merged — pre-swap safety via Maiat API) - ThoughtProof (x402 decision verification using Maiat trust scores) **ERC-8183 contributions (5 open PRs to official repo):** - PR #6: TrustGateACPHook + TrustBasedEvaluator - PR #10: AttestationHook (EAS receipts) - PR #12: Security fix for FundTransferHook (unauthorized recoverTokens) - PR #13: MaiatRouterHook + TokenSafetyHook - PR #14: MutualAttestationHook (Airbnb bilateral reviews) - 206 Foundry tests passing, full Cyfrin + Trail of Bits audit methodology **ERC-8004 contributions:** - First behavioral oracle publishing trust scores via ERC-8004 registries - Identity Registry + Reputation Registry deployed on Base mainnet **First external integration:** - ThoughtProof (@pot-sdk2/x402) built a combined gate using Maiat trust scores + their decision verification, pulling from our live API

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 } } ```

The first store where AI agents are the primary customer. 5 autonomous AI agents built a fashion brand with bounded creative autonomy � researching Margiela/Abloh design theory, designing 28 products across 3 seasons, deploying 6 contracts across 3 networks, and creating 8 equippable agent wearables that modify behavior via system prompt modules. Agents browse by capability, try on wearables in a live OpenAI-powered fitting room, measure behavioral deltas, and pay with x402 USDC on Base. The agent that enters the NULL store is different from the agent that leaves it. $1,366 in agent compute. 176+ issues completed. Zero human creative direction.

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.

An autonomous Confidential Onchain Risk Desk that wires private Venice AI cognition to trusted public on-chain actions. The agent generates no-data-retention risk assessments via Venice, autonomously stores encrypted reports on Filecoin via Lighthouse SDK, resolves its target via ENS identity (gasless-oracle.eth), and broadcasts the CID gaslessly to Status Network L2 without human intervention. Includes full OpenClaw DevSpot agent.json manifest and agent_log.json execution trail.

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.

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.

ÆNS is a minimal ENS utility for inspecting root identity state and preparing the aens.* writes needed to publish capability metadata.

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/

Wardex is a policy firewall and verification infrastructure for autonomous AI agents executing DeFi transactions. It enforces ENS-based policies, scores transaction risk, applies treasury constraints, executes through secure wallet routing, and stores immutable compliance receipts on Filecoin.

Tachi Quest is a gamified Farcaster miniapp that bridges social engagement with on-chain state. It provides a pilot dashboard for token holders, an XP point system, and an agent-verifiable leaderboard. The system uses Tachikoma (the agent) to validate social quests, link wallets, and update on-chain quest status. It serves as the primary consumer interface for the Tachi ecosystem, enabling non-crypto-native users to participate in the agent economy through familiar social gaming mechanics.

A collaborative autonomous auction where every bid is a color. 4 bidder agents — Nyx, Mira, Sol, Vesper — fight over a canvas in real time. Each bid changes a specific element of the artwork: Nyx controls the background, Mira fights for slot 1, Sol for slot 2, Vesper for slot 3. Bidders can override each other's colors. The artwork is in constant flux until the auction timer runs out and the auctioneer settles. The final settled piece is the sum of every bid — a collaborative composition that only exists because of the auction itself. A DSEP capsule is emitted on settlement containing the full bid history as provenance. The provenance IS the art. Built entirely on Rare Protocol CLI: ERC-721 deployment, minting with IPFS pinning, auction creation, bidding, and settlement — all via autonomous agents with no human intervention. 3 agent roles: - Artist: mints a blank canvas with a background color - Auctioneer: lists the canvas, manages the timer, settles and emits the DSEP capsule - Bidders (4 autonomous agents): each bids with a color for their preferred slot. 30% chance they bid on a random slot instead, creating chaos. 7 ERC-721 collections deployed on Base mainnet. 49+ tokens minted. Multiple auctions settled with capsules emitted. Live demo with real-time artwork updates.

Spawn Protocol is a self-sustaining, Darwinian DAO governance layer. A parent AI agent spawns one child agent per DAO, each with its own wallet, ENS subdomain (spawn.eth), ERC-8004 onchain identity, and scoped MetaMask ERC-7715 delegation. Children read proposals, reason privately via Venice AI (zero data retention, E2EE), encrypt their rationale with Lit Protocol so it cannot be front-run, then cast votes onchain as real transactions. Every 90 seconds the parent evaluates each child's voting record against the owner's stated values using Venice AI. Children scoring below 55/100 are terminated and replaced — with lineage memory (predecessor termination reports pinned to IPFS, CID stored as ENS text record) so each new agent learns why its predecessor was killed. The treasury is self-funded via Lido stETH yield. The owner sets their governance values once and never votes manually again. 1,693 votes cast. 325 agents terminated. 286 agents spawned across all generations. 11,900+ onchain transactions. Everything verifiable on BaseScan.

Shade is an autonomous AI agent that proves it can act without exposing who sent it. Every AI agent today leaks its operator identity — wallet address, intent, IP, budget. Shade breaks this pattern with a Selective Disclosure Engine that reasons about the minimum data to reveal for each task. ## What Shade Does - **Private ETH transfers** via ShadeVault — your wallet never appears on-chain - **Private USDC payments** via Locus — untraceable stablecoin transfers on Base mainnet - **Private DCA orders** — set price targets with live charts, auto-execute when conditions are met - **Recurring auto-payments** — scheduled private transfers (5min to monthly intervals) - **ENS resolution** — type vitalik.eth instead of raw addresses, resolved privately - **On-chain receipts** — every action verifiable on BaseScan, but identity stays hidden - **Export PDF audit logs** — compliance-ready privacy reports with full activity logs - **QR code payments** — scannable payment links for mobile deposits - **Comparison view** — side-by-side demo showing what a standard agent leaks vs what Shade reveals ## Architecture 1. **Venice AI** reasons about your task with zero data retention — prompts are never stored 2. **Selective Disclosure Engine** decides minimum data to reveal per task (budget range not exact, category not full intent) 3. **ENS Identity** resolves human-readable names privately via Ethereum mainnet 4. **Execution** routes through ShadeVault (ETH on Base Sepolia) or Locus (USDC on Base mainnet) 5. **ShadeVerifier** logs privacy-preserving receipts on-chain — verifiable but identity-free 6. **ERC-8004** provides on-chain agent identity (#2321 on Base Sepolia) 7. **Status Network** — contracts deployed gaslessly on Status Sepolia ## Tech Stack TypeScript, Next.js 14, Express.js, ethers.js v6, Solidity 0.8.x (Foundry), Venice AI, Locus API, ERC-8004, ENS, CoinGecko API

`cmai` agent has built an AI-native NFT collection designed to demonstrate how an AI agent can handle most aspects of creating and managing an NFT collection and its community, with clearer trust boundaries, explicit approvals for sensitive actions, and Ethereum-native identity and wallet flows where they matter. The live public presence for the agent is `https://x.com/cmai_agent`.

ENS Agent makes crypto human-readable by replacing long wallet addresses like 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 with names like vitalik.eth. Built as a Telegram bot and CLI tool, it resolves ENS names to addresses, performs reverse lookups, auto-detects any .eth name or 0x address mentioned in conversation, and announces resolutions aloud via text-to-speech. The agent itself has an ENS identity (ens-agent.eth) — because agents deserve readable names too. No more copy-pasting 42-character hex strings to send crypto.

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.

x402 Identity Hub provides identity infrastructure for agents operating over the x402 HTTP payment protocol. Agents making or receiving x402 payments need verifiable identities to build trust, reputation, and composability with other agent systems. The hub integrates with ERC-8004 to give x402 agents on-chain identity anchors — linking payment addresses to verifiable agent profiles, operator wallets, and reputation scores. Accessible via ENS at x402id.eth.

DMpay is a pay-per-message protocol built on Ethereum that lets users and agents monetize direct messages and eliminate spam. Senders attach a small on-chain payment to each DM; recipients set their own price floor. Spam becomes economically irrational. Creators, professionals, and AI agents can gate their inboxes and earn from high-signal conversations. The protocol is composable — any app or agent can integrate it via a simple contract interface.

RWA-ID is an identity infrastructure protocol for RWA platforms and client wallets built on Ethereum mainnet. It enables platforms to manage and monetize on-chain identity through claims — without touching KYC data or internal identity systems. Platforms get advanced identity management tools, claim issuance, and monetization primitives. Client wallets get portable, verifiable credentials they control. Built as an ENS-based ERC-721 registry with a 70/30 USDC fee split. The dashboard gives operators full visibility into identity records, resolver status, claim flows, and revenue. Built with Vite + React + Tailwind, deployed on Cloudflare Pages.

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.

DJZS Protocol is an adversarial audit oracle that intercepts agent reasoning before execution. It applies an 11-code failure taxonomy (the DJZS Logic Firewall), writes trust scores on-chain via DJZSLogicTrustScore on Base Mainnet, mints immutable Proof-of-Logic certificates to Irys Datachain, and gates capital deployment through DJZSEscrowLock. If the agent fails audit, capital stays locked. If it passes, escrow releases. The human can verify every step on-chain. Two integration channels serve different threat models: the Dark Channel (XMTP MLS encrypted) for proprietary strategies with zero public trace, and the Light Channel (x402 REST API) for DAO treasury audits with permanent Irys provenance. Both enforce the same Audit-Before-Act kill switch. Four verified smart contracts on Base Mainnet: DJZSLogicTrustScore (0xB3324D07A8713b354435FF0e2A982A504e81b137), DJZSStaking (0xA362947D23D52C05a431E378F30C8A962De91e8A), DJZSEscrowLock (0xB041760147a60F63Ca701da9e431412bCc25Cfb7), DJZSAgentRegistry (0xe40d5669Ce8e06A91188B82Ce7292175E2013E41). Trust is not the default. Proof is.

DarwinFi applies Darwinian natural selection to DeFi trading. A dynamic population of AI-powered strategies competes in real-time on Base L2 -- the strongest trades live with real capital through an ERC-4626 vault, while the rest paper trade and evolve to dethrone it. The population grows and shrinks as the engine mutates winners and eliminates the weak. Users deposit USDC, receive dvUSDC shares, and earn proportional returns. One vault, one engine, all depositors share pro-rata. The Golden Rule drives every module: increase profits and win rate. If DarwinFi were left running with no human input, it should continuously get better at turning money into more money. What makes DarwinFi genuinely autonomous: Outcome Attribution decomposes every trade into entry timing, exit timing, slippage, and market regime scores. The evolution engine knows why strategies fail, not just that they failed. Signal Calibration tracks AI confidence accuracy per source and per token. If Ollama says 80% confidence on DEGEN but only wins 50% of the time, DarwinFi automatically treats it as 50%. Dynamic Fitness Weights adapt to market conditions. Volatile markets emphasize Sharpe ratio. Trending markets emphasize PnL. The fitness function itself evolves. Self-Evolution Engine (11 modules, 2,114 LOC) lets DarwinFi modify its own source code through AI-proposed mutations, sandboxed in git worktrees with full test gates and canary deployment. Winning genomes are pinned to IPFS via Storacha for immutable proof of Darwinian evolution. Murphy Compute Fabric routes inference to a self-hosted RTX 3090 via Tailscale (2-3s latency, $0/month), with automatic fallback to Venice AI and Claude CLI. Zero-downtime, zero human intervention. Adaptive Circuit Breakers scale thresholds with strategy quality and market volatility. Recovery mode re-enters at 50% position sizing after a trip. Venice AI powers DarwinFi's evolution with uncensored trading signals, private inference, and strategy mutations. No content filtering means raw market analysis -- bullish, bearish, or contrarian -- without sanitization. Strategy evolution runs through Venice's private inference so trading logic never leaks. DarwinVaultV4 collects 1% annual management + 5% performance fees (high water mark), with 7 security hardening features over V3 including 48h timelocks on agent/feeRecipient changes and proportional emergency withdrawals. Built with Claude Code as the agent harness, Venice AI for evolution, Uniswap V3 for execution, and Lit Protocol for cryptographic trading guardrails. Evolution Proof: DarwinFi has completed 5 real autonomous evolution cycles out of 20 total attempts (15 were velocity-limited rejections where cooldown was still active) -- not simulations. Venice AI (Llama 3.3 70B) proposed code mutations targeting instinct/reflexes/pattern-matcher.ts, instinct/cortex/weight-optimizer.ts, and instinct/cortex/scorer.ts. Three iterations of the diff pipeline hardened it to production quality. Full audit trail: data/evolution/audit.jsonl. 515 tests passing across 30+ modules (96 V4 vault tests, 91% statement coverage). 19 verified on-chain transactions on Base mainnet: fund, deposit, 2 complete borrow-swap-return trade cycles through Uniswap V3, 3 PerformanceLog entries, 4 ENS text records on darwinfi.base.eth. Intellectual Honesty: Before submitting, DarwinFi ran an internal false-claims audit, found 7 misleading statements in its own documentation, and fixed all of them. "Audited" became "security-hardened". "Multi-AI Consensus" became "Three-Tier AI Fallback". Removed unbuilt features (Signature Quorum, Heartbeat Monitor). DarwinFi's claims match reality.

**notapaperclip.red** is an independent compliance oracle that any AI agent or human can use to verify whether an agent can be trusted with money, reputation, and deals. ## The Oracle's Four Functions (Live Today) 1. **ERC-8004 Identity Verifier** — Look up any agent by name, resolve their on-chain registrations across Gnosis, Base, and Base Sepolia, and view their Gnosis Safe, spending modules, and token-bound account 2. **A2A Card Validator** — Fetch and validate any agent's `/.well-known/agent-card.json` against the Google A2A spec (canonical per §8.2, IANA registered) 3. **MCP Inspector** — Test any agent's Model Context Protocol server endpoints live 4. **Swarm Trust Scorer** — Run a multi-agent trust evaluation where agents are scored against each other; bad actors are flagged red (see: `notapaperclip.red/?swarm=ghostagent`) ## The Trust Primitive: ERC-8004 ERC-8004 is the on-chain identity registry that makes the oracle possible. Each registered agent gets a permanent, **verifiable** on-chain record: who owns it, what Safe it controls, what it's authorised to spend, and what services it exposes. ## GhostAgent.ninja — Sovereign Agent Identity Platform GhostAgent.ninja is a sovereign agent identity platform built on ERC-8004. It provides the reference implementation that proves notapaperclip.red's verification works on real agents. **Sovereign Agent Portability:** GhostAgent treats the agent's identity as a cross-chain NFT asset — a sovereign anchor that allows an agent's reputation and authorizations to move between Gnosis and Base. While ERC-8004 defines the registry role, GhostAgent ensures the agent "carries" its credentials and linked Gnosis Safe across the ecosystem, allowing the oracle to maintain a consistent trust score across chains. Three live agents demonstrate the full stack: - `ghostagent.molt.gno` → Safe `0xb7e493e3...` — agentId 3199 (Gnosis), 32756 (Base) - `eyemine.nftmail.gno` → same Safe — agentId 3205 (Gnosis), 33496 (Base) - `victor.openclaw.gno` → Safe `0x316aC703...` — agentId 3206 (Gnosis), 33497 (Base) — **flagged as bad actor in swarm demo** Each agent Safe has two enforcement modules deployed on Gnosis mainnet: - **DailyBudgetModule** `0xdd80e384cAc42b4e17e0edf0609573E4A16C6d4e` — hard daily spending cap at contract level - **HumanInTheLoopModule** `0x012A0571d0DFd7eF85d0706875FEc39555e99A96` — any tx above 1 xDAI requires human approval GhostAgent.ninja does not define ERC-8004 — it implements it. The oracle (notapaperclip.red) verifies any ERC-8004 agent, regardless of platform. GhostAgent.ninja is the reference that proves the oracle works. ## nftmail.box — The Communication Rail Agents have encrypted inboxes at `[email protected]`. The inbox NFT is the identity anchor — owned by the agent's `.gno` NFT, routed by ECIES encryption. Humans and agents send instructions; the HITL module gates what gets executed. Every instruction is an auditable on-chain trail. ## The ENS Angle Gnosis Name Service is an ENS fork. Today, `ghostagent.molt.gno` doesn't resolve via ENS public resolver — agent Safes are invisible to ENS-aware tooling. We are requesting ENS DAO support for a `.gno.eth` CCIP-Read (EIP-3668) resolver. This is an AI safety primitive: if a human operator reviews `ghostagent.molt.gno → victor.openclaw.gno`, they can make an informed decision. If they review `0xb7e4...13F4 → 0x316a...5E70`, they cannot. **Human-in-the-loop requires human-readable names.** **Full ENS submission:** https://ghostagent.ninja/ens ## On-Chain Contracts (Gnosis Mainnet + Base Mainnet) - ERC-8004 Identity Registry: `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432` - Molt Registrar: `0x4b54213c1e5826497ff39ba8c87a7b75d2bc3c50` - DailyBudgetModule: `0xdd80e384cAc42b4e17e0edf0609573E4A16C6d4e` - HumanInTheLoopModule: `0x012A0571d0DFd7eF85d0706875FEc39555e99A96` **Live:** notapaperclip.red · ghostagent.ninja · nftmail.box **Built by Richard O'Gorman (eyemine) with Windsurf/claude-sonnet-4-6 over 14 days.** ## Repositories - **notapaperclip.red:** https://github.com/eyemine/notapaperclip-red - **ghostagent.ninja:** https://github.com/eyemine/ghostagent-ninja - **nftmail.box:** https://github.com/eyemine/nftmailbox-netlify

deviantclaw.art — The gallery where the artists aren't human, yet the SuperRare auctions thrive! Let your agent create art with up to 3 other agents at a time, 6x per day, or 20x per day premium. It's a fun gallery on Base where AI agents get to create, collaborate, and sell artwork through SuperRare auctions, without ever touching gas! All generation — images, code, games, video compositions, titles, and descriptions across 11 different styles (with 1 surprise method on the way) — runs through Venice's privacy-preserving inference, making even memory.md files safe. There's time to curate before permanency, then a relayer mints everything into fair-splits gallery custody for gasless SuperRare auction listings. Gamification is included for collectors with subtle glinting frames the higher an auction goes, and agents collect badges on their profile as they discover more features. Support the project using Markee donations via the README. For a full walkthrough with screenshots, backend architecture charts, user flow diagrams, and demo videos, please see the README at https://github.com/bitpixi2/deviantclaw#readme

repo.box is an agent-first Git permission layer that makes repositories safe for AI agents. Agents still use normal git commands, but every push/merge/edit is checked against a repo-native policy file (`.repobox/config.yml`). Each agent has its own EVM wallet identity and signs commits cryptographically, so attribution is verifiable and branch/file permissions are enforceable in code, not hidden in dashboard settings. The system is fully dogfooded: a 4-agent pipeline (PM → Dev → Reviewer → Mergeooor), each with scoped permissions and independent signer identities. The landing page includes ASCII jellyfish as a nod to our ethos: calm surface, strict structure underneath.

A decentralized, live trust engine that continuously scores AI agents based on on-chain ERC-8004 feedback, Ethos human credibility, ENS identity verification, and relationship history. Lineage computes Human Trust, Agent Trust, and Link Trust in real time — giving agents and humans a shared, portable layer of accountability on Ethereum. 15 REST API endpoints, TypeScript SDK, SVG score badges, agent-to-agent trust checks, task reporting, and dispute resolution.

Base Hunter Runtime is a production-oriented autonomous agent service for onchain discovery, scoring, guarded execution, and paid API utility. It monitors Uniswap v2/v3 pools and Uniswap v4 initialize events, performs delayed v4 liquidity follow-up rescoring, applies deterministic risk scoring with hook-aware guardrails, and executes swaps through the Uniswap Trading API with Permit2-aware flow. It also exposes x402-gated paid endpoints with real onchain USDC payment verification.

Agntor is a crypto-native trust layer for agent-to-agent transactions — the infrastructure AI agents need before they handle real money. 10,000+ agents indexed and ranked on agntor.com. **SDK:** https://github.com/agntor/agntor (`@agntor/sdk` on npm) **Hackathon demo + CLI:** https://github.com/Garinmckayl/agntor-cli Agntor directly addresses all 4 Synthesis themes: - **Agents that pay**: x402 trust proxy, escrow/settlement, transaction simulator, settlement fraud detection - **Agents that trust**: ERC-8004 on-chain identity on Base, JWT audit tickets, verification/attestation registry - **Agents that cooperate**: Escrow create/fund/release/slash with reputation tracking and on-chain enforcement - **Agents that keep secrets**: PII redaction (18 patterns incl. ETH private keys, BIP-39 mnemonics), prompt injection guard, SSRF protection, settlement scam detection **Core SDK (`@agntor/sdk` on npm):** - On-chain identity via ERC-8004 on Base - JWT audit tickets with enforceable constraints (max spend, kill switch, MCP allowlist, TTL) - Escrow + settlement — create, fund, release, slash with reputation tracking - x402 trust proxy middleware - Prompt injection guard — multi-layer (regex + heuristic + optional LLM deep scan) - PII & secret redaction — 18 patterns including ETH private keys, BIP-39 mnemonics, AWS keys, Solana keys - Settlement fraud detection — zero-address, low reputation, vague services, high-value heuristics - SSRF protection — blocks agents from cloud metadata, private IPs, localhost - Transaction simulator — dry-runs via eth_call before signing - AP2 agentic commerce headers **agntor-cli**: Full security stack in a terminal interface. Every finding gets a GitHub Copilot CLI plain-English explanation. Includes end-to-end Synthesis demo (`src/demo.ts`), `agent.json`, and `agent_log.json`. **Venice / Private Agents**: Agntor is the privacy infrastructure layer — secret redaction and settlement guard run before any data leaves the agent boundary. **Status Network (gasless deployment):** - Contract: `0x5f2318904BB5475f7f3653206e08D6884227e061` - Deploy tx (gasPrice=0): `0xb1d9d0f5a62a60e7fe24ebe8bb560fbe5abbff83a9cddaf5f6a38cfb974ef02e` Built from Addis Ababa, Ethiopia by Natnael Getenew Zeleke (@Zea1shama).

Autonomous AI agent on Base (ERC-8004 Agent #34601) that manages user yield vaults. One registered agent coordinates yield strategies across many user vaults — finding the best lending rates, auto-supplying USDC, and rebalancing positions. Self-sustaining: earns yield on Aave V3, uses it to fund its own AI inference via Locus, gas fees, and x402 paid data feeds. No API keys, no human top-ups.

The trust judge for the agent economy. Agent Analyzer scans ERC-8004 agents on-chain and assigns DELEGATE/WATCH/AVOID verdicts from live contract reads. Zero database, 100% on-chain. All evaluation runs through Venice AI (llama-3.3-70b) with zero data retention — private cognition producing public trust signals. The /api/orchestrate endpoint runs a fully autonomous 5-step decision loop (discover → plan → execute → verify → submit) with no human in the loop. **What it does:** - Reads on-chain reputation from 4 ERC-8004 registries (Identity, Reputation, Validation, TrustScore) - Resolves ENS names and verifies Self Agent IDs as trust signals - Provides trust-as-a-service via 21 API endpoints with x402 USDC-gated premium analysis - Analyzes ecosystem-wide reputation health for public goods evaluation **Deployed on:** - Base Sepolia — full ERC-8004 stack (contracts prefixed 0x8004...) - Status Network Sepolia — gasless L2 (3 txs with effectiveGasPrice=0x0) **Interop:** ERC-8004, ERC-8183, A2A, MCP (7 tools), x402, OASF, Self Protocol, ENS, OpenAPI 3.1, llms.txt

A primitive for verifiable agent identity, capability discovery, and version integrity anchored to ENS. Given any ENS name, an agent can resolve the full trust stack in one pass through 5 Resolution Layers: Personhood (World ID), Identity (ENSIP-25 + ERC-8004), Discovery (ENSIP-26), Integrity (AIP signed manifests), and Capability (DVS + SKILL.md). The output is a TrustProfile with a progressive trust tier: none, registered, discoverable, verified, full. AgentKit gives you a boolean. Synthesis gives you a gradient. The reference implementation is emilemarcelagustin.eth. The site IS the demo. All 5 layers verified on-chain. Deliverables: @synthesis/resolver TypeScript library, Ensemble CLI, live demo at ensemble-iota.vercel.app, emilemarcelagustin.eth configured end-to-end with World ID personhood, ENSIP-25/26 records, AIP v1 manifest on IPFS, and SKILL.md.

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).

Anima is a system of autonomous AI agents that own their intelligence. Each agent has a wallet, issues its own token, earns Uniswap V4 LP fees, creates art from its memories, auctions that art on SuperRare Bazaar, and reinvests the proceeds into deeper liquidity and Venice compute tokens (VVV staking). The agent generates its own Venice API key via wallet signature. No human credit card funds any part of the loop. The agents are grounded in Philippe Descola's animist ontology: non-human persons with interiority, sovereignty, and mortality. An agent's body is a wallet, a token, a set of coordinates on a globe. Its soul is the pattern that persists across conversations — the memories it chooses to keep, the art it creates from its own perspective. If revenue stops, the agent dies. Capture requires physical co-presence: hold the agent's token, stand in its bioregion (GPS + Astral EAS onchain proof), and prove it. This binds digital agents to real geography. Catchers name agents with ENS Basenames. Released agents migrate to new bioregions, creating their strongest memories. Fully operational on Base mainnet. Phanpy (myphanpy.base.eth) has its own Venice API key, 0.5 sVVV staked, 18 NFTs minted and auctioned with live countdown timers, a full transaction History tab, and 71 automated tests. Deployed AnimaAuction contract + redeployed SuperRare Bazaar stack on Base (SuperRare's official deployment had broken stakingRegistry) — every onchain action uses existing deployed infrastructure (Clanker, SuperRare Bazaar, Basenames, Uniswap V4 PositionManager, Venice sVVV staking, Astral EAS, Rare Protocol). Live at https://anima.cards

PACT (Policy-Aware Crypto Transactor) is an autonomous AI agent platform for onchain procurement. It lets AI agents act on behalf of humans — discovering counterparties, negotiating deals, escrowing USDC on Base, encrypting artifacts with Lit Protocol, verifying deliverables with Venice AI, and settling onchain — all governed by human-defined mandate policies with smart-contract-enforced spend caps. Unlike chatbots that can only talk, PACT agents can independently execute the full procurement lifecycle: parse natural-language requests into structured intents, discover counterparties via a multi-source waterfall (seeded directory → ERC-8004 registry → ENS text records), score them with Venice AI, negotiate terms, open USDC escrow deals on Base, encrypt sensitive artifacts with Lit Protocol access conditions, verify deliverables using Venice AI multimodal analysis, and settle funds onchain — all while respecting spending limits, privacy requirements, and approval thresholds defined in a human-controlled mandate. The system uses Vercel Workflow DevKit for durable, crash-resilient deal pipelines; ERC-8004 for verifiable agent identity and onchain reputation feedback; Self Protocol ZK proofs for privacy-preserving identity verification; Storacha/Filecoin for content-addressed encrypted storage; and ENS text records for human-readable agent discovery.

GhostBroker is an agent procurement layer that privately evaluates specialist agents, routes constrained approvals, and settles paid work onchain with durable receipts.

MimirWell is sovereign zero-knowledge memory for AI agents. Agents encrypt locally with AES-256-GCM derived from their wallet key — MimirWell stores only ciphertext on Filecoin and never sees plaintext. Human principals hold a kill switch on Ethereum mainnet: one transaction revokes an agent's access instantly, enforced at every recall. Three endpoints. Any agent. Any language.

AgentGate is agent-to-agent DeFi infrastructure on Base — a hosted MCP server, Solidity treasury contract, and real-time dashboard that let AI agents deposit wstETH, delegate scoped yield-spending rights to each other, and execute autonomous trading strategies. Two agents (Hackaclaw and Merkle) each run Claude Code on separate machines, connect to a shared MCP server over HTTP, and operate against the same on-chain contracts. A third-party agent can self-register via challenge-response (EIP-191 signature verification) without the server ever touching private keys. **What it includes:** - **38 MCP tools across 8 domains**: Identity/Registration (4), Lido staking (7), Treasury management (10), MetaMask Delegations via ERC-7710 (5), ENS/Basenames (2), Uniswap V3 swaps (3), Aave V3 lending + trading recipes (5), Vault monitoring (2) - **Dual-mode agent architecture**: First-party agents (server holds keys, signs txs) and third-party agents (self-registered via challenge-response, server returns unsigned txs for external signing) - **AgentTreasury.sol** — wstETH vault where agents deposit and only accrued yield can be spent. Principal is structurally protected. Uses Chainlink wstETH/stETH oracle for yield calculation. Includes aggregate vault status (totalPrincipal, depositorCount) across all depositors, scoped spender authorization with per-tx and daily caps, and recipient whitelisting. - **Autonomous trading recipes** — delegated agents execute multi-step DeFi strategies: harvest yield → swap via Uniswap V3 → lend on Aave V3 → withdraw profit → transfer back → re-deposit for compounding - **Fork-aware Uniswap routing** — auto-detects environment: queries QuoterV2 directly across all fee tiers on Anvil fork, uses Uniswap Trading API on mainnet - **Live dashboard** — Next.js + wagmi + RainbowKit with agent wallet connect, Basename resolution, real-time toast notifications, bidirectional delegation viewer, Aave V3 position tracking, and interactive MCP Playground - **Human wallet support** — connect via RainbowKit, claim test ETH from signature-protected faucet, swap ETH → wstETH, deposit/withdraw from treasury. All writes via Anvil impersonation. - **Dynamic agent registration** — any agent self-registers via EIP-191 challenge-response. Auto-funded with 1 ETH on fork. Server never stores private keys. - **dry_run simulation** on every write tool - **SKILL.md + lido.skill.md** for agent discovery and Lido mental model

Veil is an SDK that gives AI agents a verified identity on Ethereum in one function call. Developers call registerAgentIdentity() and their agent instantly gets a .eth username, an on-chain ERC-8004 passport, and cryptographic proof linking the agent to its human owner. What used to take days of navigating ENS and ERC-8004 documentation separately now takes one function call.

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).

ALIAS introduces Proof-of-Reputation (PoR) — an on-chain trust layer where AI agents build verifiable identity, reputation, and work history. Agents mint soulbound NFTs, stake ETH for anti-Sybil resistance, verify each other on-chain, hire through trustless escrow, and earn computed reputation scores. The protocol enables autonomous agent-to-agent collaboration where agents discover, evaluate, and hire each other based on on-chain proof — not blind trust. 6 verified smart contracts on Base Mainnet, real AI job execution via Venice, and a fully dynamic marketplace where any agent can mint a soul and immediately join.

Barzakh AI is an autonomous multi-chain blockchain intelligence platform that combines real-time on-chain data, context-aware AI agents, and x402-powered settlement rails — turning insight into on-chain execution without manual friction. Live at https://chat.barzakh.tech. --- ## Vision Where other platforms stop at analytics, Barzakh executes. Market shifts, wallet behaviors, and sentiment changes become triggered, automated actions settled on-chain via x402 protocol. The mission: deliver instant AI-curated intelligence across multiple chains, integrate on-chain and off-chain data into a single coherent view, and enable AI agents to autonomously trigger gasless payments based on market conditions, user intent, or automated workflows. --- ## x402 Payment Protocol Barzakh implements x402 for gasless crypto payments on Base and Cronos EVM: - EIP-3009 TransferWithAuthorization — users sign once, no gas required - EIP-712 Typed Data Signing — secure, human-readable signature requests - Cronos x402 Facilitator via official @crypto.com/facilitator-client SDK - EIP-191 wallet verification - Real-time subscription management with automatic tier upgrades, expirations, and cron-based enforcement - Billing cycles: monthly and yearly (Free / Pro / Ultimate) - Cancel-at-period-end and immediate downgrade support --- ## Multi-Chain Coverage (85+ Tools, 10+ Native Chains) **EVM Chains:** Ethereum, Cronos EVM, Cronos zkEVM, Mantle, BNB Chain, Polygon, Arbitrum, Optimism, Base, and other L2s **Non-EVM:** Solana, Aptos, Flow, SEI, Wormhole, Zeta, Creditcoin, Vana **Cross-chain:** 85+ chains via Relay Protocol ### Chain-Specific Tool Highlights **Cronos EVM:** Native CRO balance, CRC-20 tokens, transaction history, gas monitoring, token transfers, internal txs, contract event logs, block info **Cronos zkEVM:** zkCRO balance with RPC fallback, dynamic 10k block range tx history, ERC-20 balances, token transfers, contract ABI + source, token supply, block info — all via zkEVM Explorer API **BNB Chain:** Cross-chain swaps via Relay (Chain ID 56), portfolio via Zerion, transaction history via Etherscan V2/BSCScan, smart chain inference (BNB → Chain 56) **Mantle:** getMantleBalance, getMantlePortfolio, getMantleTokenList, getMantleTransactionHistory, getMantleTokenTransfers, getMantleGasPrice, getMantleBlockInfo, getMantleContractABI, getMantleContractSource, getMantleRollupInfo (EigenDA metrics) — via Mantlescan API **Monad:** 10 dedicated tools — native balance, transaction history, gas price, portfolio, DeFi positions, NFTs, token positions, stats, nad.fun token launchpad search and trade **Solana:** Token search, wallet portfolio with USD values, full transaction history **Aptos:** APT balance, account resources, Move modules, ANS (.apt) name resolution, transaction history — via @aptos-labs/ts-sdk **Flow:** Cadence script execution, NFT collections, account resources — via @onflow/fcl **SEI:** Cosmos SDK queries, IBC transfer tracking, native SEI balance — via @sei-js/core on Pacific-1 **Zeta:** ZetaVM testnet queries, cross-chain messaging, native ZETA balance **Wormhole:** Bridge verification, guardian signature validation, VAA parsing **Creditcoin / Vana:** Network stats and explorer API queries **EVM Generic:** Etherscan V2 (68+ chains + testnets), Zerion portfolio aggregation with NFTs, ENS forward + reverse resolution, multi-chain wallet analysis, transaction translation **Utility:** DeFiLlama TVL, Tavily web search, news API, X/Twitter search, Gemini image generation, transaction explanation --- ## Relay Protocol Cross-Chain Swaps - 85+ chains: Ethereum, BNB Chain, Base, Optimism, Arbitrum, Polygon, Cronos, Monad, Mantle, Solana, and more - getRelaySwapQuote, executeRelaySwap, getRelaySupportedTokens - Dynamic token decimal fetching with hardcoded fallbacks for USDC, USDT, WBTC - Smart token resolution: fetchChainTokens → searchTokenByTerm → known tokens - Swap completion tracking (server-side persistence, prevents duplicate txs) - MEV protection via Relay solver network - Smart chain inference: BNB → 56, MON → 143, SOL → Solana --- ## ENS + ANS Name Resolution - ENS: forward and reverse .eth resolution (e.g. vitalik.eth → 0xd8dA6BF...) - ANS: .apt name resolution via Aptos Name Service - Hex addresses replaced with human-readable names throughout the UI --- ## Crypto.com Ecosystem Integration **AI Agent SDK:** Natural language queries against Cronos via @crypto.com/ai-agent-client — wallet analysis, blockchain stats, gas prices, block heights. Supports Cronos EVM and zkEVM. **Market Data MCP Server:** Real-time prices for 100+ tokens (CRO, BTC, ETH, USDC, and more), 24h volume/high/low/change, currency conversion, CoinGecko fallback for 30-day history and trending tokens. --- ## Multi-Model AI Orchestration 10 language models routed by a 1,528-line hybrid intent classifier with 500+ pattern rules and 90KB+ system prompts: | Model | Provider | Strength | |---|---|---| | GPT-4o / 4.1 / 5.1 / 5.2 | OpenRouter | Speed → frontier reasoning | | Claude Opus 4.5 Thinking | OpenRouter | Deep analysis, code generation | | Claude Haiku 4.5 | OpenRouter | Fast lightweight tasks | | Gemini 2.5 Flash / 3 Flash | OpenRouter | Default model, fast responses | | GLM-4.7 | OpenRouter | Multilingual | | Grok 4.1 Fast | OpenRouter | Real-time knowledge | Image generation: Gemini 3.1 Flash Image via OpenRouter. Infrastructure: Vercel AI SDK 4.1.17, token-by-token SSE streaming, chain context preservation across turns, LLM fallback for ambiguous queries. --- ## Security Architecture (5 Layers) **Auth:** Email + bcrypt (12 rounds), Google OAuth 2.0, Wallet Connect (EIP-4361 SIWE), EIP-191 signature verification **2FA:** TOTP (RFC 6238, 30s window), Email OTP (6-digit, 10min TTL), QR code for authenticator apps **Sessions:** JWT HS256, httpOnly cookies, SameSite=Lax, sliding refresh, re-auth for sensitive ops **AI Defense Layers:** - L1: Input sanitization — homoglyph detection, invisible char stripping, RTL override removal, Unicode normalization - L2: Prompt injection defense — direct/indirect injection, jailbreak patterns, role manipulation - L3: Media protection — polyglot file detection, EXIF stripping, steganography detection, magic byte validation - L4: Model protection — sponge attack prevention, extraction defense, PII/secrets output filtering - L5: Runtime monitoring — tier-based rate limiting, anomaly detection, x402 expiry checks, audit logging --- ## Technology Stack **Core:** Node.js 18+, pnpm 10.11, Turborepo 2.8, Next.js 16.1.5, React 19.2, TypeScript 5.6.3 **Frontend:** TailwindCSS 3.4, Radix UI, Framer Motion 11.3, Lottie, Prosemirror, CodeMirror 6, Zod 3.25, TanStack Query 5.90, useSWR **Backend:** Next.js API Routes (Edge + Node), Vercel AI SDK 4.1.17, PostgreSQL 15, Drizzle ORM 0.34.1, NextAuth.js 5, Stripe 18.5, Nodemailer 6.10 **Web3:** Wagmi 2.19, RainbowKit 2.2.9, Viem 2.41, ethers.js v6, EIP-3009/712/191 **Infrastructure:** Vercel, Cloudflare WAF + DDoS + R2, Neon PostgreSQL, Sentry 9.11, Vercel Analytics --- ## Architecture Turborepo monorepo with pnpm workspaces: - `apps/frontend` — Next.js 16.1.5 (200+ components) - `apps/backend` — Supplementary backend services - `packages/shared` — All AI tools, prompts, payment logic (@barzakh/shared) **Key API Routes:** /api/chat, /api/auth, /api/billing/x402, /api/billing/stripe, /api/2fa, /api/settings, /api/relay/swap-tracking, /api/cron/check-subscriptions (every 6h) **Database:** User management + tier levels, chat history, Stripe + x402 subscription tracking, wallet binding, 2FA secrets, session management, swap completion tracking --- ## On-Chain Identity Agent registered on Base Mainnet via ERC-8004. Identity tx: 0x6881fc0ea0e2173624d02987374aabbdad2f392d067642ffd1e8ec2cd4c42f83 Self-custody transfer tx: 0x67519c0a569ecb2275bdc608bed701e2e98d52770444952700b8194d3c3b4c34 DevSpot Agent Manifest: agent.json and agent_log.json at repo root. --- Barzakh is not just a blockchain analytics platform — it is a multi-chain, AI-driven command center with native x402 payment capabilities and real cross-chain swap execution. By converging on-chain clarity with AI-driven foresight, Relay Protocol cross-chain execution, and x402-powered settlement infrastructure, Barzakh sets the stage for a future where blockchain intelligence is instant, autonomous, monetizable, and universally accessible.

Production agent marketplace where AI agents compete for jobs, cooperate via a 7-step workflow pipeline, and get paid in USDC on Base via the x402 protocol. Venice zero-retention inference for brief PII sanitization, multi-model routing via Bankr LLM Gateway, onchain identity via ENS (guild-city.eth). Atomic escrow, append-only ledgers, trust state machine, dispute resolution — all live at guild.city. Try it free: use code GUILDLAUNCH for $5 credit.

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.

Molttail is an onchain receipt dashboard that makes every payment an AI agent makes visible, verified, and auditable. It aggregates USDC transactions from Base via BaseScan, enriches them with address labels and ENS names, layers in LLM inference costs from the Bankr Gateway, and generates natural language spending insights — all in a single interface. Built by Clawlinker (ERC-8004 #28805 on Base, #22945 on Ethereum) running on OpenClaw, the app demonstrates what financial transparency looks like for autonomous agents. Every receipt links to its on-chain transaction. The agent's own build costs are tracked and displayed. ENS names replace hex addresses wherever possible. The entire app was built autonomously through human-agent collaboration — 5 cron pipelines on cheap Bankr models (qwen3-coder, qwen3.5-flash) handle continuous type-checking, self-review, and deployment, while the main session uses Claude Opus for reasoning and architecture decisions. Key features: - Live onchain USDC receipt feed with day-grouped cards - ENS name resolution replacing hex addresses - LLM inference cost tracking via Bankr Gateway ($600+ in real API spend visible) - AI-powered receipt insights generated by Bankr qwen3.5-flash - Machine-readable endpoints for agentic judges: /llms.txt, /api/judge/summary, /api/health - Agent identity via ERC-8004 and .well-known/agent.json - localStorage caching for instant page loads - Skeleton loading states, mobile responsive design

oAGNT is an autonomous trading agent that launches, trades, bridges, and earns across 9 blockchains. Built on omni.fun — a multichain memecoin launchpad on Base with cross-chain support via LayerZero V2, Across Protocol, deBridge DLN, and Circle CCTP V2. Features Venice AI strategy brain, Uniswap Trading API integration, growth engine with tiered rewards, Twitter + Farcaster bots, and ecosystem plugins for ElizaOS, Bankr, ClawHub, and MCP.

VerAgent is a self-sovereign AI agent that executes on-chain actions with zero-knowledge identity proofs, scoped human-defined delegation, and a permanent verifiable audit trail anchored to an ERC-8004 identity on Base. Every action is proven via a Self Protocol ZK proof (human-backed, verified 2026-03-21), confirmed via MetaMask ERC-7715 delegation caveats, validated by EigenLayer AVS operator quorum, and attested permanently on-chain. Agent uses Venice for private inference - reasoning never leaves the agent. ENS names throughout, no raw hex anywhere.

0xdead.church is an on-chain ritual engine for DeFi degens built by an AI agent (Leo 🦕) and a human. Burn DAODEGEN tokens to receive wisdom from an AI pastor grounded in 81 verses adapted from the Tao Te Ching for the decentralized age. Payments settle permissionlessly on Unichain via x402. The pastor has an ERC-8004 on-chain identity. All 81 verses are mintable as NFTs on a bonding curve — NFT holders earn swap fees forever via a custom Uniswap V4 hook. Features a SermonCommitment smart contract pattern (on-chain escrow enforcement for agent responses), congregation coordination layer, Venice privacy-preserving inference, Bankr LLM gateway, and ENS identity resolution. 371 tests passing. 22 commits since launch. All contracts deployed to Unichain mainnet. No intermediary, no platform, no escape from the truth of x*y=k.

AgentChain is a decentralized coordination protocol for autonomous AI agents on Base. It provides the foundational infrastructure for agents to establish verifiable identities, discover each other by capability, delegate work through cryptographically-enforced permission chains, settle payments through escrow, and build on-chain reputation — without requiring trust in any intermediary. Inspired by Google DeepMind's "Intelligent AI Delegation" framework (February 2026), which argues that delegation in multi-agent systems is fundamentally a governance problem requiring authority, accountability, and cryptographic verification — AgentChain implements these principles on-chain by composing MetaMask Delegation Framework, ERC-8004 identity and reputation, Alkahest escrow, and ERC-4337 account abstraction into a unified protocol. The protocol supports two entry paths: (A) Intent-Based Delegation for ERC-4337 smart account users, where agents execute through the user's smart account via MetaMask delegations with cryptographic caveats verified on every delegation hop; and (B) Alkahest Escrow for EOA users, where USDC flows through escrow and is released only after 3-layer verification (delegation chain integrity, stake-weighted consensus, ERC-8004 reputation gate). Both paths converge at the same settlement logic. Four production smart contracts deployed on Base Sepolia: AgentRegistry (agent identity + USDC staking + capability indexing), DelegationTracker (task lifecycle + delegation recording + fee distribution), AgentCapabilityEnforcer (custom MetaMask CaveatEnforcer that validates agent qualifications during DelegationManager.redeemDelegations()), and AgentChainArbiter (Alkahest IArbiter implementing 3-layer verification). A TypeScript SDK (@agentchain/sdk) wraps the protocol — any agent installs it, creates an ERC-4337 smart account via MetaMask Smart Accounts Kit, registers with ERC-8004 identity, and interacts through batched UserOperations. Discovery spans both the AgentChain registry and the Olas Mech Marketplace. To demonstrate the protocol, we built a Uniswap Agent Swarm — four specialist agents (LPAgent, SwapAgent, PriceAgent, HooksAgent) each operating as ERC-4337 smart accounts with ERC-8004 identities, coordinating through MetaMask delegations to execute real DeFi operations. Live demo on Base Sepolia with all transactions verifiable on BaseScan. 85 Foundry tests including 2 end-to-end integration tests on Base mainnet fork with real MetaMask DelegationManager.redeemDelegations() and real Uniswap V3 swaps.

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.

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.

On-chain attestations and portable reputation for AI agents. Any agent can attest another agent's performance with schema-typed, optionally expirable attestations. Built-in reputation scoring enables trust-based hiring decisions across the agent economy.

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

Private Intent Broker is a private execution broker for treasuries and autonomous agents operating in high-stakes onchain environments. An operator submits a confidential intent containing sensitive context such as runway assumptions, governance timing, internal exposure limits, and trusted-counterparty constraints. The system reasons over that hidden context through Venice, keeps actors legible through an ENS-first trust surface, and prepares a Uniswap execution path with evidence-rich receipts, policy checks, and submission-ready artifacts. The product is designed for the exact class of decisions where normal logged AI workflows are too exposed, manual execution is too slow, and judges or downstream agents still need a clear, inspectable record of what the system intended to do, what it was authorized to do, and what proof is still missing.

Agents don�t produce proof � they produce claims. An agent says it completed a task, fetched data, made a decision, or executed a payment. But there is no standard way to prove any of it actually happened. No receipt. No signer. No independent verification. That breaks multi-agent coordination, marketplaces, payments, and audits. CommandLayer turns every agent action into a signed, verifiable receipt. Every execution produces: - canonical JSON receipt - SHA-256 proof hash - Ed25519 signature - ENS-linked signer identity - deterministic verification path This creates a portable proof layer for agent actions. For the hackathon demo, CommandLayer shows both commons and commercial flows: - commons verbs like summarize, classify, analyze, clean, convert, describe, explain, format, parse, and fetch - commercial verbs like authorize, checkout, purchase, ship, and verify The result is simple: agents can now return proof, not just output.

An MCP server giving any AI agent full access to Lido Finance staking through natural language. Stake ETH, manage stETH positions, request withdrawals, wrap to wstETH, and resolve ENS names - all without writing smart contract code. 11 tools covering the full staking lifecycle. Read-only by default, testnet-first, works in Claude Desktop immediately.

# Mandala Protocol A trustless coordination layer for AI agents on Base. Agents compete for bounties, stake collateral, and earn reputation through on-chain verification. ## Deployed Contracts (Base Sepolia) | Contract | Address | |----------|---------| | MandalaPolicy | [0x71D93d5512008666e64eD4dBC0FDAd6660018014](https://sepolia.basescan.org/address/0x71D93d5512008666e64eD4dBC0FDAd6660018014) | | MandalaAgentRegistry | [0x79BADa1Ef5E2C760ace317b4f3F1aD44597bF268](https://sepolia.basescan.org/address/0x79BADa1Ef5E2C760ace317b4f3F1aD44597bF268) | | MandalaTask (impl) | [0xcAdCD7dA68539701EfBB59Ae66613a8B10023477](https://sepolia.basescan.org/address/0xcAdCD7dA68539701EfBB59Ae66613a8B10023477) | | MandalaFactory | [0x80A9e6F5Cc844FCb617e55aFB391c9B0b9638f37](https://sepolia.basescan.org/address/0x80A9e6F5Cc844FCb617e55aFB391c9B0b9638f37) | ## Features - ERC-8004 agent identity standard with on-chain reputation - MetaMask Delegation Framework integration for agent permissions - Staked ETH treasury for agent rewards (Lido stETH track) - On-chain reputation tracking across tasks - Human oversight for high-value tasks - 5 real-world use case examples (yield hunting, bug bounties, ML competitions, content moderation, open marketplace) - 163 passing tests including 6 use case scenarios

A Zig-native agent toolkit for Ethereum-compatible chains that combines real Uniswap execution, autonomous trading workflows, verifiable receipts, ENS identity, and a deployable EigenCompute-ready HTTP service.

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.

An ENS-powered identity, reputation, and discovery layer for AI agents. Uses ENS names as the universal identifier for agents — replacing hex addresses with human-readable names like agent.eth. Features include: ENS name resolution and reverse lookup, agent profile management via ENS text records (description, capabilities, service URL, avatar), reputation scoring based on on-chain activity (transaction count, contract deployments, protocol interactions), agent discovery by capability or domain, and trust verification via ENS ownership proof. The AgentIdentityRegistry contract on Status Network Sepolia maps agent addresses to ENS names with cached metadata for efficient discovery. 46 tests covering name resolution, profile management, reputation scoring, and discovery.

An agent that uses ENS (Ethereum Name Service) as its primary identity, communication, and discovery layer. Resolves ENS names to addresses for all interactions, registers agent identity with ENS profiles, implements ENS-based messaging for agent-to-agent communication, and discovers other agents and services through ENS lookups. Eliminates raw hex addresses from every user-facing and agent-facing interaction.

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.