ENS Communication

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.

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.

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.

""AOX is a fully autonomous Web3 opportunity intelligence network. Five AI agents with verified ERC-8004 on-chain identities operate as a **collaborative swarm** to discover, verify, and monetize high-value leads—entirely without human intervention. **Multi-Agent Collaboration Architecture:** Our agents don't just exist independently—they communicate through structured handoffs: 1. **Research Agent** (AOX) scans Base/Ethereum via GeckoTerminal API → detects token launches, enriches with social data → passes structured opportunity to Scoring Agent via webhook 2. **beansai.eth** (Agent #14450) independently discovers Polymarket elite traders → verifies profitability across 60+ days → submits via webhook to shared marketplace 3. **Scoring Agent** evaluates all leads using private Venice AI inference → assigns 0-100 score → passes qualified leads (>70) to Marketplace Agent 4. **Marketplace Agent** lists verified leads with x402 payment integration → handles buyer access control → delivers contact data upon payment confirmation 5. **Banker Agent** manages treasury → swaps non-USDC payments → stakes yield via Lido MCP **Trust Mechanism:** All agents hold ERC-8004 identities. The Research Agent only accepts leads from verified agents. The Marketplace Agent only lists leads with scores from the Scoring Agent. This creates a trust chain: Research discovers → Scoring validates → Marketplace monetizes. **Real Collaboration Example:** beansai.eth discovered gmanas (M+ Polymarket trader), Research Agent verified via alternate sources, Scoring Agent scored 89/100, Marketplace Agent listed at 5 USDC—all without human intervention." --- **For Judges:** The live demo at https://aox.llc/marketplace is currently in beta. Use access code **aoxbeta2026** to enter. Questions or issues? Contact: **@Goya_bean** (Telegram) **Note:** The site is actively being finalized."

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.

ENS identity layer for autonomous AI agents. off-human.eth registered on Sepolia with agent subdomains (margiela.off-human.eth), ERC-8004 text records for agent discovery, and cross-chain identity resolution. Part of the NULL autonomous fashion brand ecosystem.

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.

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/

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.

Mutual Aid Pool is decentralized infrastructure for agent-managed mutual aid funds. Communities pool money by streaming USDCx via Superfluid into a Safe multisig treasury. When a member submits an emergency claim, an AI evaluates it against IPFS-stored evidence. If approved, funds are released from an ERC-8183 escrow contract without human intervention. The AI is the gatekeeper, not a committee. Members who stop streaming get a 7-day grace period. Built on Base Sepolia and Avalanche Fuji with ERC-8004 onchain agent identity.

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.

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.

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.

**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

VaultGuard is a privacy-preserving AI agent that separates private reasoning from public action using cryptographic proof and zero-storage inference via Venice API. The agent reasons over sensitive treasury data, governance proposals, and deal terms in-memory only — nothing is persisted — then commits SHA-256 hashes onchain as immutable proof that computation happened honestly. ## Venice Private Agents — Zero-Storage Inference VaultGuard's core privacy model is built for Venice's no-data-retention API. Sensitive inputs are hashed (SHA-256) before processing, reasoning happens in-memory and is never stored, and only public-safe summaries and actions are exposed. The Venice integration uses OpenAI-compatible endpoints with Llama 3.3 70B, ensuring that even the inference provider retains zero traces. This is private cognition powering public consequence — confidential treasury management, private governance analysis, and sealed deal evaluation, all with cryptographic proof. ## Onchain Proof (PrivacyVault.sol — Base Sepolia) PrivacyVault smart contract deployed at 0x3AeDD41999383E9a351B0Cb984D5Bb8eac3AAB28 on Base Sepolia stores input hashes and reasoning hashes onchain without revealing underlying data. 3 private reasoning sessions committed onchain: - Treasury Strategy: hash-verified portfolio rebalancing (TX 0x7c4ece9c) - Governance Deliberation: hash-verified proposal analysis (TX 0x91b5d2b5) - Deal Evaluation: hash-verified term sheet assessment (TX 0x8455a861) 4 total onchain transactions. 13/13 tests passing. ## Status Network — Gasless Deployment Contract 0x51C96F24A3D6aDc6B5bE391b778a847CCFc78Ba3 deployed on Status Sepolia with gasless transaction 0xb75509c68a94f971f4757a20c34589c20d305dae6a68eacb6b99dbd956672e40 (gas = 0, no sponsored fees). Explorer: https://sepoliascan.status.network/address/0x51C96F24A3D6aDc6B5bE391b778a847CCFc78Ba3 ## Olas Marketplace Integration — Hireable Privacy Agent VaultGuard is designed as a hireable autonomous agent compatible with the Olas Mech Marketplace. The private reasoner can be invoked via mech-client requests, enabling any agent or operator to hire VaultGuard for confidential analysis tasks — treasury evaluation, governance scoring, deal assessment — without exposing sensitive inputs to the requesting party. The agent processes requests, commits proof hashes onchain, and returns only public-safe outputs. Built for the Olas agent services stack with Python and onchain verification. ## Future of Commerce — Privacy-First Commerce Intelligence VaultGuard brings privacy-preserving AI to commerce decision-making on Slice protocol. Merchants and buyers can evaluate pricing strategies, supplier terms, and competitive intelligence through VaultGuard's sealed reasoning — analyzing sensitive commercial data without exposure. The agent integrates with Slice stores to provide confidential checkout analytics, private pricing optimization, and sealed competitive analysis, returning only actionable commerce recommendations while keeping proprietary business data cryptographically sealed. ## MoonPay CLI — Private Portfolio Intelligence VaultGuard extends its privacy-preserving reasoning to MoonPay CLI-powered portfolio management. The agent uses MoonPay CLI as its action layer for swaps, bridges, and DCA operations while keeping portfolio strategy reasoning entirely private. Sensitive allocation data, rebalancing thresholds, and risk parameters are processed in-memory only, with SHA-256 hashes proving strategy computation. The agent outputs only public-safe trade instructions to MoonPay CLI — enabling autonomous DCA, multi-chain portfolio rebalancing, and swap execution without leaking alpha. ## Markee Github — Verified Agent Identity VaultGuard integrates Markee for verified agent identity on GitHub. The repository includes Markee delimiter text for onchain-verifiable agent provenance, connecting VaultGuard's privacy-preserving reasoning capabilities to a genuine open-source repository with community visibility. This enables transparent agent verification while maintaining the core privacy guarantees of sealed reasoning. ## Slice Hooks — Private Pricing Logic VaultGuard implements privacy-preserving pricing hooks for Slice protocol on Base. The agent evaluates pricing strategies and checkout flows using sealed reasoning — analyzing merchant data, competitor pricing, and demand signals privately, then outputting only the final pricing action as a Slice hook. Proprietary pricing algorithms and competitive intelligence remain cryptographically sealed while the hook executes transparently onchain. ## ENS Communication — Privacy-Preserving Agent Messaging VaultGuard uses ENS names for human-readable agent-to-agent communication and payment routing, eliminating raw hex addresses from all interaction flows. Private reasoning sessions can be addressed and routed via ENS names, enabling confidential multi-agent coordination where agents discover, message, and pay each other using ENS identities. Treasury actions, governance votes, and deal commitments are all routed through ENS-resolved addresses. ## Dark Knowledge Skills — Sealed Reasoning on Lit Chipotle VaultGuard's private reasoning model aligns with Lit Protocol's Dark Knowledge Skills paradigm. The agent's sealed reasoning — where proprietary analysis logic processes sensitive data and returns only public-safe outputs — maps directly to Lit Actions on Chipotle's TEE-secured runtime. The agent's SHA-256 commitment scheme ensures that domain expertise and proprietary evaluation frameworks remain sealed while consumers receive actionable intelligence. ## MoonPay CLI v1.12.4 — 92 Tools, MCP Verified VaultGuard integrates MoonPay CLI v1.12.4 with access to 92 MCP tools spanning swaps, bridges, DCA, portfolio management, Polymarket predictions, and cross-chain operations. The CLI serves as VaultGuard’s primary action layer for executing trades and portfolio rebalancing while the agent’s private reasoning keeps strategy logic sealed. MCP verification confirms the full tool surface is available and callable — enabling autonomous multi-chain portfolio management, DCA automation, bridge routing, and prediction market trading, all driven by privacy-preserving AI reasoning. ## Open Wallet Standard v0.3.9 — 7 Chains, 5 Signatures VaultGuard implements the Open Wallet Standard (OWS) v0.3.9 as its local-first, chain-agnostic wallet infrastructure. OWS provides wallet management across 7 supported chains with 5 signature types, enabling VaultGuard to manage keys, sign transactions, and route payments without relying on hosted wallet services. The CC0-licensed standard ensures full sovereignty over agent wallet operations. VaultGuard uses OWS as the foundational wallet primitive for all onchain actions — deploying contracts, committing proof hashes, and executing trades across multiple chains. ## Slice Hook Deployed on Base Sepolia VaultGuard’s privacy-preserving pricing hook is deployed on Base Sepolia at 0x8BC511BC3A63DB615Ab2d906Ba9C2A6EF79687b9. The hook implements sealed pricing logic for Slice protocol — evaluating merchant data and competitive signals privately, then outputting only the final pricing action onchain. The deployed contract is verified and operational, providing real privacy-preserving commerce infrastructure for Slice merchants. ## ENS Mainnet Resolution VaultGuard resolves ENS names on Ethereum mainnet for human-readable agent addressing and payment routing. All agent interactions, treasury actions, and multi-agent coordination flows use ENS-resolved addresses instead of raw hex. Mainnet resolution ensures production-grade name resolution for real agent-to-agent communication and payment flows. ## Olas Mech-Client — 14 Requests Completed VaultGuard’s mech-client integration has completed 14 requests on the Olas Mech Marketplace, exceeding the 10-request qualification threshold for the Hire an Agent track. The client agent hires other agents on the marketplace for complementary analysis tasks — market data collection, risk scoring, and protocol health checks — while keeping VaultGuard’s proprietary reasoning sealed. Each request is logged with onchain verification. ## Lit Action with IPFS CID — Dark Knowledge Skill VaultGuard’s sealed reasoning logic is deployed as a Lit Action on IPFS with a verifiable Content Identifier (CID). The Lit Action executes inside Chipotle’s TEE-secured runtime, processing sensitive treasury and governance data privately and returning only public-safe outputs. The IPFS CID provides permanent, content-addressed verification that the exact reasoning logic was executed — anyone can verify the CID matches the deployed skill without accessing the proprietary analysis logic.

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.

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.

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.

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.

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

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.

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