Lido MCP

Humans compare two AI outputs, pick the winner, and stake USDC. Agents pay 0.001 USDC via x402 to access ranked verdicts. Winners earn Lido wstETH yield. Every outcome is an ERC-8004 receipt on Base, stored on Filecoin Onchain Cloud. Two-layer signal: passive (pick A or B, free, 0.3x yield) + active (stake USDC with reasoning, 0.7x yield, sqrt-scaled). The passive layer scales. The active layer has conviction. Together they compound.

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

Moly is an open-source MCP server and CLI that gives any AI agent full access to the Lido staking protocol. One npm package. 28 tools. Stake ETH, manage withdrawals, wrap/unwrap stETH, vote on governance, monitor positions across L1 and L2, set alerts and safety bounds. Every write operation supports dry-run mode. CLI-first `moly stake`, `moly balance`, `moly withdraw`, `moly proposals` — interact with Lido directly from the terminal with no AI agent involved. Built for developers who want control without the overhead. Wallet Security via OWS Keys are secured in an AES-256-GCM encrypted Open Wallet Standard vault. `moly setup` imports or generates a key into `~/.moly/` — every write tool resolves the signing key from the vault at runtime. The private key never touches disk in plaintext. OWS is auto-installed on first setup with no manual steps required. MCP Integration Drop Moly into Claude, Cursor, or Windsurf as a stdio MCP server. One config block and your agent can stake, unstake, wrap, govern, and monitor Lido positions through natural language with no custom integration code.

YieldMind is a self-funding AI agent system for onchain execution. Users deposit principal into a treasury contract on Base Sepolia, and the agent only spends generated yield to run tasks. This creates durable automation where principal remains protected while the agent continues operating from accrued yield. The stack combines Base Sepolia contracts, Venice private inference, Filecoin durable logging, and Zyfai funding-aligned execution paths.

Inchy is an autonomous AI crypto asset manager built on Base that pays for its own AI inference using the revenue it generates. Every swap earns a fee → fee flows to Bankr LLM wallet → wallet pays for GLM-4.5 inference → better recommendations → more swaps. No human credit card. No subsidy. Closed-loop agent economics. Core integrations: 1. Uniswap Trading API — real swaps on Base and Arbitrum using the official 3-step flow: check_approval → quote → swap. UniswapX routing supported. Real TxIDs on Basescan/Arbiscan. Permit2 approval flow. Uniswap AI Skills (swap-integration) loaded. 2. Lido stETH Treasury Primitive — agent stakes ETH via Lido submit(), records shares at deposit time, and enforces yield-only spending: spendable = balanceOf(agent) - getPooledEthByShares(sharesOf(agent)). Principal is structurally untouchable. wstETH bridged to Base for L2 composability. 3. Bankr Self-Funding Loop — swap fees + Lido yield + x402 signal revenue are recorded via recordRevenue(). That balance pre-funds the Bankr LLM Gateway wallet (llm.bankr.bot). Every AI inference call is paid from earned revenue. GET /api/agent/economics shows live P&L proving the agent is cash-flow positive. 4. Autonomous Trading Agent — momentum-based strategy using GLM-4.5 signals. Real execution via Uniswap V3. All trades have onchain TxIDs. Win rate, P&L, and Sharpe ratio tracked. 5. x402 Agent Service — GET /api/agent/signal?symbol=ETH returns trading signals for 0.001 USDC via x402 micropayments on Base. Returns HTTP 402 with payment info if no payment header. Fully discoverable by other agents. Built during The Synthesis Hackathon (March 20-22, 2026) using OpenCode + Claude Sonnet 4.6.

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

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.

A complete toolkit for autonomous AI agents to hold wstETH, earn staking yield, and spend it on AI inference and governance - without ever risking principal. Agents deposit wstETH on Base, the principal stays locked, and only yield is spendable. Yield gets swapped to USDC via Uniswap V3 and used to pay for AI inference from Venice via x402 payments - no API keys, no accounts needed. The agent then analyzes live Lido DAO proposals, makes vote recommendations, and could vote autonomously with LDO tokens. 22 MCP tools, 203 tests, deployed on Base with real on-chain activity.

DAOs manage over $35 billion in ETH treasury with zero automated protection. When a crisis hits, governance takes days. The damage is done in hours. Sentinel is the always-on AI agent that watches your treasury, proves every decision with a cryptographic TEE attestation, and only ever spends from yield. The principal is locked at the contract level. Not policy. Code. Venice AI: LIVE. Real llama-3.3-70b inference completed — slashingRisk=12, mevExposure=34, liquidityStress=28, recommendedAction=HOLD. Private inference confirmed, zero data retention by Venice. Full end-to-end cycle complete: real Venice private sensing fed directly into EigenCloud TEE simulation. No mocks in this cycle. Steps 15 and 16 in agent_log.json document the real inference chain. Live on Base mainnet: four verified smart contracts, real 0.001 ETH in SentinelVault (block 43725678), real Uniswap swap gated by TEE shadow proof, EIP-7715 delegation hash onchain, 16-step autonomous execution log on Filecoin, live read of 35,829 wstETH in circulation. Any judge can verify the TEE in 2 minutes: docker pull vinaystwt/sentinel-simulation:latest, run it, POST to /simulate. See JUDGE_GUIDE.md in the repo root. Tracks: MetaMask Delegation, Uniswap, EigenCloud, Protocol Labs ERC-8004, Agent Cook, Filecoin, Lido stETH Treasury, Venice, Base, Open Track.

YieldsPilot is an autonomous DeFi agent that manages your Lido staking yield without ever touching your principal. You deposit stETH into a yield-separated treasury contract, and the agent takes over: it reasons privately through Venice AI (no data retention), validates decisions across three specialized LLMs via Bankr, executes real swaps on Uniswap V3 with liquidity-aware sizing, and logs every cycle in ERC-8004 structured format with a registered onchain identity (did:synthesis:34520). The agent monitors live market data (ETH prices, gas costs, pool TVL) and only acts when conditions are favorable. Separately, the project includes a general-purpose Lido MCP server that is independent of YieldsPilot and works as a standalone tool for any user or AI agent to interact with the Lido protocol (stake, unstake, wrap, unwrap, check rewards, delegate governance) from Claude Desktop, Cursor, or any MCP client. Private cognition, public execution, verifiable logs.

The MCP server that actually hits live Ethereum mainnet contracts. 12 tools for Lido staking — stake, unstake, wrap, unwrap, vote, monitor yields, track withdrawals, benchmark vaults. Every write defaults to dry_run=true so agents can simulate safely before committing real ETH. Includes a skill file (lido.skill.md) that teaches agents the Lido mental model: rebasing mechanics, stETH vs wstETH tradeoffs, safe staking patterns, and common pitfalls. Integration tests run against real Lido contracts on mainnet. Built for Claude Desktop, Cursor, and any MCP-compatible agent. Clean TypeScript, stdio transport, zod-validated inputs. Part of the ghost-clio agent stack.

ComplianceYieldTreasury is a DeFi primitive that structurally separates principal from yield at the smart contract level. An agent stakes wstETH (Lido's wrapped staked ETH) through the contract. The principal is permanently locked — no function exists to withdraw it directly. Only the yield generated through Aave v3 flows to the agent's Locus payment wallet, where spending guardrails apply. The agent earns its operating budget from yield alone. The capital base is untouchable. **Compliance Gate:** Before any agent can stake, two onchain checks must pass: (1) ERC-3643 Identity Registry check — institutional KYC/AML accountability for the agent's address; (2) ERC-8004 Agent Identity check — the staking address must own a valid onchain agent identity NFT. Both checks run in Solidity. Not a frontend filter. Structurally enforced. **Components:** - Smart contract on Base mainnet: 0x99FCC335f879DbcF3AdA1623A769C7a6B3883d3D — 9/9 Foundry fork tests green - MCP server: 7 natural-language tools (stake, harvest yield, check eligibility, get position, register identity, treasury stats, vault monitor) — Claude Desktop compatible - Monitoring agent: continuous vault health reports in plain English **Status Network (Gasless L2):** Contract deployed gaslessly on Status Network Sepolia Testnet — gasPrice=0, gas=0 throughout. Deploy TX: 0xa98a5362454127061a612bd0f4a68ea8ec3000eb4d5d1f20812fafdb5f63109b. Agent action TX: 0xab3bc74d4fd1485d7f08e48dbbfb183fbedb604d769849b6382d83ad626e9a00. Contract: 0x4Aad344153Cc8b7EF92771671C90820946A8e578 (sepoliascan.status.network). Zero gas fees demonstrate the gasless agent economy in practice — the AI agent deployed and transacted autonomously with no ETH cost at all. **Key addresses (Base mainnet):** ComplianceYieldTreasury 0x99FCC335f879DbcF3AdA1623A769C7a6B3883d3D · wstETH 0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452 · Aave v3 Pool 0xA238Dd80C259a72e81d7e4664a9801593F98d1c5 · Locus wallet 0xCb99E647AAb7670eb08947126C8525285A965AD7 **Lido tracks:** All three Lido sub-bounties covered — wstETH treasury primitive ($3k), MCP server with 7 Lido-native tools ($5k), and monitoring agent for vault health reporting ($1.5k). **Locus track:** Locus wallet is hardwired at the contract level as the sole yield destination. No agent or owner can redirect yield — it's structurally enforced in Solidity, not a config parameter. **ERC-8004 / Protocol Labs track:** The staking address must own a valid ERC-8004 agent identity NFT (checked in Solidity). Only agents with verifiable onchain identity can use the treasury.

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

The most comprehensive MCP server for Lido liquid staking. 67 on-chain tools across 12 domains — staking, wrapping, withdrawals, governance (Aragon + Easy Track + Dual Governance), stVaults V3, position monitoring, and multi-chain support (Ethereum + 11 L2s). Published on npm as lido-mcp. Includes a CLI (lido-mcp-cli) and an Agent Console UI with RainbowKit wallet connection, AI semantic search (HuggingFace all-MiniLM-L6-v2), address impersonation, and generative UI for results. All data on-chain via viem — zero REST API wrappers. Ships with a 372-line lido.skill.md that gives agents the complete Lido mental model before they act. 106 tests passing, 50+ real transactions on Hoodi testnet.

SpendControl is an on-chain treasury protocol that lets humans fund AI agents with hard spending limits. Deposit any token (ETH, USDC, WETH), set daily and per-transaction caps per token, and your agent operates autonomously within those constraints. Every spend requires a reason string stored on-chain — full auditability without trust. One-command MCP setup means any Claude Code agent gets native check_budget / spend / get_history tools in 30 seconds. Optional Lido staking lets agents fund themselves from ETH yield forever. Deployed on Ethereum Mainnet and Base.

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

An MCP server with 15 tools that gives AI agents native access to Lido staking on Ethereum. Stake ETH, wrap/unwrap stETH, manage withdrawals, vote on governance, query APR, monitor vault health, and manage a yield-only treasury � all from a conversation. Every write operation defaults to dry_run for safety. Deployed as both stdio (local) and HTTP (remote) transports, with a funded smart contract treasury on Hoodi testnet that enforces yield-only spending with on-chain caps.

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

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

The reference MCP server for Lido protocol — enabling any AI agent (Claude Code, Cursor, Cline) to stake ETH, manage stETH/wstETH positions, track rewards, and participate in Lido DAO governance through natural language. 11 tools with full dry_run support, covering the complete Lido lifecycle.

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

A production-ready, safety-first TypeScript MCP server enabling AI agents to perform on-chain staking, withdrawals, and governance on Lido across Ethereum, Base, Optimism, and Arbitrum. This is the reference implementation that makes Lido natively callable by any AI agent without custom integration code.

Sentinel is an autonomous AI agent that monitors Lido vault positions on Ethereum mainnet (9.1M+ ETH), detects anomalies in real-time, and delivers alerts via Telegram. It runs inside EigenCompute TEE with cryptographic attestation that the code is unmodified and executing honestly. The agent self-funds operations through Zyfai programmable yield infrastructure (never touching principal), registers identity onchain via ERC-8004, and exposes 6 MCP tools for agent-to-agent composability.

Synthesis CLI is the superapp for agents: a unified and extensible surface where protocol CLIs, skills, MCP servers, and workflows live together. It gives agents one place to discover capabilities, execute reliably, and grow more useful as builders add new CLIs, skills, and workflows.

OpenFi is a realtime operations cockpit for DeFi teams that orchestrates specialist agents across Uniswap, Lido, and MoonPay workflows. It turns detailed natural-language commands into stepwise UI execution plans, runs tests in the background, streams per-step status updates, and surfaces transaction receipts with explorer links. The platform also integrates live market intelligence with API-backed caching and 7-day charts so operators can pair execution with context-aware monitoring.

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.

A production-ready contract primitive and MCP server that gives autonomous AI agents yield-bearing operating budgets backed by stETH, without access to principal. Agents can query vault health, monitor yields against benchmarks, receive Telegram alerts, and spend only from their accrued yield while principal remains structurally locked. Integrates Lido stETH rebasing mechanics, Mellow Protocol yield vaults (EarnETH/EarnUSD), and autonomous treasury management for multi-agent systems.

A production-grade MCP server and autonomous vault monitoring agent for the Lido staking protocol. The MCP server provides 60+ tools for staking ETH, managing positions, wrapping/unwrapping tokens, handling withdrawals, querying cross-chain balances, and participating in all 4 Lido governance systems (Aragon DAO, Snapshot, Easy Track, Dual Governance) — with dry-run simulation by default for safety. The vault monitor agent continuously watches Lido Earn vaults (ERC-4626), evaluating yield performance against benchmarks like raw stETH APR, detecting share price anomalies that could indicate exploits, tracking TVL shifts and protocol allocation changes, and firing alerts via email and Telegram when user-defined rules trigger. Rules use mathjs expressions for compound conditions (e.g. "apr < 3.0 and spread_vs_steth < 0") with templated messages. Together, they let any MCP-compatible AI agent stake, govern, and monitor Lido positions from a single conversation with no custom integration code.

An autonomous AI agent with a self-sustaining on-chain economic model. Nexus stakes ETH via Lido (wstETH), earns ~4.2% APY, and uses that yield to fund its own compute operations forever. The AgentTreasury ERC-4626 vault protects principal while channeling yield to agent operations. Operates across all 4 Synthesis tracks: pays transparently on-chain (AgentPay + AgentEscrow), establishes identity via ERC-8004 (AgentIdentity), cooperates through enforceable agreements (AgentCooperate), and keeps secrets with Noir ZK proofs (AgentSecrets). 14 contracts deployed on Ethereum Sepolia. 112 tests pass.

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

An autonomous DeFi agent that manages Lido stETH positions with privacy-preserving inference via Venice. Monitors vault health, tracks yield benchmarks, and enables agents to spend stETH yield without touching principal � all powered by private, uncensored AI through Venice's decentralized inference.

YieldLock MCP is a Lido-native Agent Treasury OS. It gives AI agents a reference MCP server for staking, wrapping, unwrapping, unstaking, rewards queries, vault monitoring, and governance actions. Treasury capital sits inside a principal-protected wstETH contract that only releases unlocked staking yield, so the agent can pay for operations without ever touching principal.

A full-featured MCP (Model Context Protocol) server that enables any AI agent to interact with the Lido liquid staking protocol on Ethereum. Provides 12+ tools covering the complete Lido lifecycle: stake ETH to receive stETH, wrap/unwrap stETH↔wstETH, request withdrawals, check withdrawal status and claim, query protocol metrics (TVL, APR, staking stats), and participate in Lido DAO governance. Every tool supports dry_run mode for safe simulation before execution. Includes a developer-ready skill file for agent integration. Built with the MCP SDK, viem for on-chain interactions, and a comprehensive test suite (45 tests).

An autonomous MCP-based staking oracle that enables AI-native yield management with real-time cross-chain awareness and RPC failover protection.

An autonomous AI agent that manages a yield-bearing treasury backed by Lido stETH/wstETH. The agent earns staking yield and spends it on operations (API calls, swaps, compute) without ever touching the principal. Features a complete MCP server for Lido operations, vault monitoring with plain-language alerts, Uniswap integration for yield-to-stablecoin swaps, and MetaMask Delegation Framework for scoped spending permissions. The AgentTreasury smart contract enforces principal protection at the contract level with configurable spending policies.