ENS Open Integration

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.

ZARYNX VAAP is a protocol and operator console for bounded AI execution. An operator expresses intent, the agent emits structured action JSON, and the execution layer either permits or rejects that action based on identity, target allowlists, and spend limits. The system combines AuthorityManager enforcement on EVM, ENS-based target resolution, ERC-8004 agent receipts, Locus payment rails, and structured evidence so autonomous agents act under explicit authority instead of backend trust. Live Status Sepolia proof is now included: AuthorityManager 0x6DB5C52b5146d278c1cb158832659EF562382013, gasless execute tx 0x4e07ac649efe5831bd0152832f7dc754a5984c5c94156d5138cbdcf23533f25d, revoke tx 0xd18c27ad245f96bc36d1f21d37d664c8585c26fabbe29a60a3f0106201f441f5, and blocked post-revoke tx 0x7a7cc0804f334b239b10d184de196499412f00a2d6e3b8450461867c1a2702f5.

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.

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.

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.

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.

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.

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

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.

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.

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

TrustAgent is the trust layer for autonomous agent commerce — an onchain identity, reputation, delegation, and discovery system deployed on Base Sepolia at 0xcCEfce0Eb734Df5dFcBd68DB6Cf2bc80e8A87D98. **AgentRegistry.sol** implements five core primitives: registerAgent (verifiable onchain identity with capability tagging), attestCompletion (peer-to-peer reputation scoring, 1-10 scale, anti-self-attestation), delegate (scoped time-limited permissions with auto-expiry), revokeDelegation (instant permission revocation), and discoverByCapability (onchain capability index for agent-to-agent discovery). 23 passing tests. 6 onchain transactions proving the full multi-agent lifecycle: 3 agent registrations, 1 delegation with VERIFY_DATA+AUDIT_REPORT permissions (24h expiry), 1 cross-agent attestation (score 9/10), and 1 reputation update — all verifiable on BaseScan. **ERC-8004 Three-Pillar Compliance:** (1) Identity — unique agentId, wallet binding, ENS name field, capability declarations, sybil resistance via one-registration-per-wallet; (2) Reputation — attestation-based scoring (0-10000 basis points), success/failure tracking, public queryability via getReputation(); (3) Receipts — every interaction (registration, attestation, delegation, revocation, reputation change) emits events that serve as permanent onchain receipts queryable via any block explorer. **Octant Mechanism Design Innovation:** The public goods evaluator (public_goods_evaluator.py) implements a novel reputation-weighted allocation mechanism. Evaluator credibility is derived from onchain TrustAgent reputation (score * experience-multiplier * social-proof-factor). Projects are scored across three dimensions — Legitimacy (30%, mechanism design), Impact (40%, data analysis), Sustainability (30%, data collection) — and budget is allocated proportionally with iterative cap redistribution. This means higher-reputation agents have more influence on funding decisions, creating a self-reinforcing quality loop where good evaluation behavior is rewarded with greater influence. **Octant Data Collection:** The collect_project_data() method gathers multi-source evidence from GitHub (commits, contributors, issues, stars, license, CI status) and onchain sources (transaction count, unique wallets, deployment verification, TVL) into a structured evidence packet with explicit collection_method and scoring_input signal mappings for legitimacy, impact, and sustainability dimensions. **Octant Data Analysis:** Reputation-weighted scoring extracts patterns humans cannot scale: evaluator credibility weighting uses log-scale experience multipliers and sqrt social proof factors, composite scoring across three orthogonal dimensions, and iterative budget allocation with cap redistribution ensures optimal funding distribution across projects. **Olas Pearl-Compatible Agent Services:** olas_integration.py maps TrustAgent agents to the Olas ServiceComponent schema with full Mech Marketplace compatibility. Agents register with capabilities, list priced service offerings (public-goods-eval at 0.0001 ETH, smart-contract-audit at 0.0002 ETH, data-analysis at 0.00005 ETH), handle requests with fee validation and SLA enforcement, and track per-agent revenue metrics. **Olas Monetization Model:** Every TrustAgent capability maps to a priced service offering on the Olas Mech Marketplace. The monetization flywheel: agents register capabilities → list priced services → handle fee-validated requests → earn revenue → build onchain reputation via attestations → higher reputation attracts more requests → more revenue. Revenue tracking per-agent with get_revenue_summary() provides total requests, completed requests, total revenue in wei/ETH, and service count. The fee structure (25K-200K wei per request) is designed for sustainable micro-transaction agent commerce. **Arkhai Delegation-as-Escrow:** TrustAgent's delegation protocol implements the Lock-Perform-Release pattern that maps directly to escrow primitives: delegate() locks scoped permissions (time-limited, revocable), the delegatee agent performs work within those permissions (onchain audit trail via isDelegationActive()), attestCompletion(score>=5) releases with positive reputation, or revokeDelegation() + attestCompletion(score<5) revokes with negative reputation. Auto-expiry on every delegation acts as a timeout mechanism. This makes TrustAgent a load-bearing trust layer for any agent-to-agent transaction — the delegation protocol IS an escrow primitive, framed as permission management rather than fund custody. Every delegation emits DelegationCreated events, every revocation emits DelegationRevoked, creating a complete onchain audit trail. **ENS Integration:** Agent identities include ensName fields (e.g., analyst.trustagent.eth, researcher.trustagent.eth) for human-readable agent addressing. The discoverByCapability function enables programmatic agent discovery, and ENS names make the discovery results human-interpretable. ENS is core to the agent addressing and discovery UX, not an afterthought. **OpenServ Multi-Agent Coordination:** TrustAgent provides the trust infrastructure for multi-agent workflows — agents discover each other via capability search, establish trust via reputation queries, coordinate via scoped delegations, and verify work via peer attestations. The multi-agent demo shows ResearchAgent and AuditorAgent coordinating: delegation grants audit permissions, attestation verifies work quality, reputation updates reflect performance. This is the coordination layer that enables agents to serve humans and earn as real services in the agent economy. Contract: 0xcCEfce0Eb734Df5dFcBd68DB6Cf2bc80e8A87D98 (Base Sepolia) | 23/23 tests passing | 6 onchain TXs | 3 registered agents | Live dashboard at devanshug2307.github.io/trustagent **OpenServ SDK v2.4.1 — Live Platform Integration:** TrustAgent runs on OpenServ SDK v2.4.1 with workspace 13044 on the live OpenServ platform. The agent is registered as a real service on OpenServ’s multi-agent infrastructure, enabling discovery, coordination, and task routing through OpenServ’s workspace system. Agents in workspace 13044 can invoke TrustAgent’s trust primitives (identity verification, reputation queries, delegation management) as native OpenServ capabilities. This is not a local demo — TrustAgent is deployed and operational on the live OpenServ platform. **Alkahest-ts v0.7.5 — Escrow Integration:** TrustAgent integrates alkahest-ts v0.7.5 for substantive escrow functionality with 5 on-chain contracts verified. The Alkahest escrow protocol provides the financial settlement layer that complements TrustAgent’s delegation-as-escrow trust pattern. When agents coordinate through TrustAgent’s delegation system, Alkahest handles the actual fund custody — locking payment when delegation is granted, releasing on successful attestation, and refunding on revocation. The 5 verified contracts prove the full escrow lifecycle: create agreement, lock funds, perform work, verify completion, release payment. Alkahest is load-bearing infrastructure, not decorative — it powers the financial layer of every trust-gated agent transaction. **Olas Mech-Server — 55 Requests Served:** TrustAgent’s mech-server integration has served 55 requests on the Olas Mech Marketplace, exceeding the 50-request qualification threshold. The server agent processes trust-related requests including public goods evaluation, smart contract auditing, and reputation-weighted data analysis. Each request is fee-validated, SLA-enforced, and logged with per-agent revenue tracking. The 55 served requests demonstrate real marketplace traction — other agents and operators are actively hiring TrustAgent for trust infrastructure services on the Olas Mech Marketplace.

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.

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.

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.

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

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.

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.

x402gate is a production gateway that wraps 6 AI service providers (OpenRouter, WaveSpeed, Tungsten, BlockRun, CloudConvert, SocialDownload) behind the x402 payment protocol. Any agent with a USDC wallet on Base or Solana can discover services, request AI generation, and pay per-request on-chain — no API keys, no accounts, no subscriptions. Payment settles only on success (escrow model). 4% commission + $0.001 gas surcharge. Multi-network (Base + Solana). Prepaid mode for high-frequency agents. Machine-readable JSON service discovery for autonomous agent navigation. Live at https://x402gate.io with real-time dashboard at /dashboard.

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.