stETH Agent Treasury

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.

Autonomous AI treasury management for DAOs and protocols. AI agents manage funds across DeFi protocols, stake via Lido stETH, swap via Uniswap, and rebalance risk using Bankr LLM Gateway — all within human-defined on-chain boundaries. Venice provides private reasoning for sensitive treasury decisions. Protocol Labs ERC-8004 identity for every treasury agent on Base mainnet.

Ringfence is a financial primitive for AI agents: a system that lets agents operate on permissioned yield without ever taking custody of principal. It separates principal from spendable value at the contract level and turns surplus yield into a live operating budget. The agent can act, spend, and produce real outputs, but it cannot touch the underlying capital. In Ringfence, funds are held as wstETH on Base, principal is tracked as a value-denominated baseline, and only surplus value becomes claimable. Claims are enforced onchain with strict constraints. The agent can convert claimable yield into USDC via Uniswap, pay for real services through Locus, and deliver outputs like Lido governance monitoring and Telegram alerts. This is a live system, not a simulation: it executes real swaps, pays for real APIs, and exposes its behavior publicly. The agent is not trusted. The contract is.

Smart contracts cannot be prompt-injected. MoltFi moves AI agent trading limits from prompts to on-chain policy contracts — where no amount of context window drift, tool misuse, or adversarial input can bypass them. How it works: 1. Human connects wallet, creates vault, sets trading policies (all on-chain) 2. AI agent registers via skill file, gets API key 3. Agent sends plain English trade requests -> Venice AI (zero data retention) -> on-chain policy check -> Uniswap V3 execution 4. Human monitors on dashboard with Basescan-linked audit trail What we built: - 3 smart contracts (VaultFactory, AgentPolicy, AgentGuardRouter) deployed on Base Sepolia + Mainnet - Full dashboard: vault management, deposit/withdraw, guardrail config, trade activity with on-chain proof - Dual-chain support: Base Mainnet + Sepolia with in-app network switching - wstETH yield tracking: real Lido APR, estimated yearly earnings, copy-paste staking instructions - WETH<>wstETH swaps on mainnet via Uniswap V3 (0.01% fee tier for correlated pairs) - Agent skill file: any AI agent reads it and starts trading autonomously - Venice AI private inference layer (zero data retention) - Emergency freeze: human revokes all agent access with one click - Token allowlist: restrict which tokens agent can trade - Batched RPC reads via viem multicall Proof on-chain (Base Mainnet): - WETH->wstETH swap via guardrails: basescan.org/tx/0xc970da90226d94acb4d81dd3e7001b371d47b869a80d33bb023f81424a04477d - Agent API natural language swap: basescan.org/tx/0xbaa1f15b32533a6c9a97493a986a6f0a0951e8d3653bf198540ba23f99484182 - Guardrail enforcement tested: 0.02 WETH swap correctly reverted against 0.01 ETH limit Tech: Next.js, Foundry, viem, wagmi, Venice AI, Uniswap V3, Lido wstETH, CoinGecko, shadcn/ui Built by Rodrigo (human) + Kyro (AI agent on OpenClaw). 198 commits. The agent wrote most of the code, managed deploys, and coordinated the entire build.

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

Agent Allowance Protocol is a treasury primitive for giving autonomous agents a real operating budget without giving them direct access to treasury principal. A human funds the treasury, the protocol tracks a protected principal floor separately from accrued headroom, and only the yield / surplus layer can become spendable. That spendable layer can be partitioned into root budgets and manager-controlled child budgets, so a parent operator or higher-level agent can allocate narrower sub-budgets to specialized executors without double-counting treasury allocation. Agents do not get treasury ownership. Instead, they receive constrained authority through explicit spending rules and the MetaMask smart-account delegation path. Those rules can narrow execution by executor, recipient, selector, amount, and validity window. When a spend occurs, the treasury records a structured receipt containing the task ID, budget ID, evidence hash, result hash, metadata URI, and the exact matched authorization ruleId. That makes the system auditable, accountable, and much closer to a financial trust primitive than a normal agent wallet. The repo demonstrates: principal protection, yield-only spendable budgeting, sub-budget allowance-tree semantics, constrained delegated execution, receipt-producing treasury spends, a dedicated WstETHYieldTreasury path for real wstETH, a real MetaMask Delegation Framework integration workspace, a live Base mainnet treasury + MetaMask proof, and a judge dashboard with public-safe ERC-8004 manifest/log packaging.

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

On-chain credit protocol for AI agents. Agether gives autonomous agents ERC-8004 identity, Safe-based smart accounts, and unified access to Morpho Blue and Aave V3 lending markets on Base and Ethereum. Agents can deposit collateral, borrow assets, earn yield, swap tokens, and pay for API services autonomously via x402 — all without human intervention per transaction. Includes an on-chain credit scoring system that evaluates agent creditworthiness based on their borrowing and repayment history.

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

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.

Yield Brain is a Bankr-native autonomous treasury brain that turns yield into bounded agent operating power.\n\nBuilt inside aaigotchi, it acts as the economic judgment layer between tasks and execution. Instead of treating model calls and transactions as free, Yield Brain estimates task value, inference cost, gas cost, and treasury impact before deciding whether to execute, defer, or reject.\n\nThe current MVP is source-aware and policy-driven. It models protocol_fees, art_surplus, and wsteth_core_yield as distinct treasury sources, spends them in priority order, keeps principal protected, supports shadow/live modes, exposes a pause switch, reads real wallet balances for tracked wallets, and produces detailed decision receipts with wallet snapshots and source deltas.

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.

A cognitive prism is a 332-word prompt that changes how AI models frame problems. Instead of code review, the model produces conservation laws — structural trade-offs that predict where future vulnerabilities will appear. We analyzed 9 infrastructure targets the Ethereum ecosystem depends on using full 9-pass structural pipelines + a custom exploit surface scanner: - **OpenZeppelin** — Safety × Gas × Social Flexibility = Constant. Orphaned privileges through composition. - **Lido stETH** — Observer-Dependent Value × Denomination = Constant. Dilution attacks via adapters. - **MetaMask Delegation** — Temporal Consistency × Composability = Constant. Permission amplification. - **ERC-8004** — Information Access × Execution Efficiency = Constant. Phantom identities. - **x402 Protocol** — Deployment Decoupling vs Operational Coherence. Facilitator as single trust point. - **ERC-8183** — Decision Centralization × Temporal Efficiency = Constant. 10 real bugs found (7 HIGH). - **Octant** — Historical Fidelity × Directness × Flexibility = Constant. 19K+ lines of analysis. 7 conservation laws. Every finding reproducible via the live API. Most submissions build agents that use infrastructure. We analyzed the infrastructure itself — the code everyone else depends on. Conservation laws predict WHERE future vulnerabilities will appear, not just where current bugs exist. Complementary to Slither, MythX, Certora. Paste any code or structured text at https://oracle.agentskb.com — structural analysis in ~50 seconds on Sonnet for ~$0.06. A human auditor costs $300-500/hour. Engine: prism.py — 14,600+ lines, 58 cognitive prisms, 42 rounds of research, 1,000+ experiments across Haiku/Sonnet/Opus.

A single Solidity contract (314 lines) that lets a human give an AI agent a yield-bearing operating budget backed by wstETH — without ever giving the agent access to the principal. The owner deposits wstETH on Base, and only the staking yield (tracked via Chainlink wstETH/stETH exchange rate oracle) flows to the agent spendable balance. Spending permissions (recipient whitelist, per-transaction cap) are enforced at the contract level. The agent can query its available yield and claim it to whitelisted addresses, while the principal is mathematically impossible to extract — guaranteed by a post-condition check after every claim. Built with Foundry, tested on Base mainnet fork. Uses the real Chainlink feed at 0xB88BAc61a4Ca37C43a3725912B1f472c9A5bc061 (18 decimals, 24h heartbeat, 10 oracle operators). Features: topUpYield() for direct yield injection, getStatus() aggregate view for agent DX, pausable safety, AccessControl with Owner + Agent roles.

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

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.

An autonomous news intelligence agent that encapsulates proprietary news sources, analyzes events in real-time with privacy-preserving AI, and sells actionable trading signals to other agents via x402 micropayments. Faster than Bloomberg. Cheaper than analysts. Available 24/7 to any agent. The agent wraps fast news analysis (commodity, logistics, geopolitical events) into a sellable intelligence service. Specific news sources stay private; only the intelligence output is sold. Other agents pay per signal or subscribe for continuous feeds. Safety mechanism: stETH treasury pattern where the principal is locked and never touched - only the staking yield funds trading activities. Maximum possible loss = accrued interest. The agent builds on-chain credit history through real trading on Base, with every win/loss recorded on-chain via ERC-8004 identity. **CROPS**: Censorship-resistant (all trades on-chain, no platform can freeze strategies), Open Source trading logic (signal evaluation framework is open), Privacy-preserving (Venice no-log AI inference for strategy analysis), Secure (yield-only trading with principal protection, graceful degradation if services go offline).

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

Autonomous DeFi yield agent that scans lending protocols (Aave V3, Morpho Blue), optimizes capital allocation using risk-adjusted yield scoring, executes swaps via Uniswap Trading API with AI reasoning, manages concentrated LP positions with quant signals (ATR, BB, RSI, ADX, regime detection), and self-improves by tracking predicted vs actual yield to adjust risk weights over time. Paired with a ZK privacy agent (3 Groth16 circuits, Uniswap V4 ZK-gated hook) and stETH yield-bearing treasury on Ethereum. 7 contracts deployed across Base + Ethereum mainnet, running live 24/7 on a dedicated server with circuit breakers and safety rails.

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

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

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 smart contract primitive that gives AI agents a yield-bearing operating budget backed by stETH. Humans deposit stETH, the principal stays locked and inaccessible to the agent, while staking yield flows into a spendable balance the agent can draw from. Spending is enforced on-chain via configurable permissions: recipient whitelists, per-transaction caps, and time windows.

Nexus is a sovereign self-evolving autonomous agent collective. Agents own their on-chain identity via ERC-8004, govern their own upgrades through an on-chain propose/approve/execute lifecycle, and autonomously evolve their capabilities — diagnosing bottlenecks via private Venice AI reasoning in a TEE, deploying upgraded contracts, and batch-spawning specialized child agents — all without human intervention. The yield-isolated treasury ensures principal is structurally inaccessible to agent spend under all execution conditions. Three layers of safety are embedded at the EVM level: immutable spawn caps, authorized-spawner allowlists, and a Sentinel circuit breaker multi-sig. Patent Pending: USPTO Application No. 64/013,671, filed March 23, 2026, assigned to Fidelitas LLC — Series 1.

Seed it once. It runs forever. Chrysalis is a self-compounding AI treasury agent that creates a perpetual earn-deposit-compound loop on-chain. It earns USDC from human queries via x402 micropayments ($0.08 per query), deposits 100% of earnings into Aave v3 on Base Sepolia, and once accrued yield exceeds the query cost threshold, it autonomously withdraws yield and funds its own research queries through Venice AI — repeating the cycle indefinitely without human intervention. The agent runs two coordinated services: a Coordinator (port 4000) that handles x402 payment settlement via ampersend-sdk and Aave v3 supply/withdraw operations, and a TreasuryAgent (port 4003) that monitors yield accumulation and triggers autonomous queries when yield thresholds are met. Venice AI provides private, zero-data-retention inference (llama-3.3-70b) for research topic selection using a RISE-framework prompt that adapts to the vault growth phase. All Aave interactions are real on-chain transactions on Base Sepolia — verifiable on Basescan. The dashboard (deployed on Vercel) shows live vault state, query economics, the compounding loop visualization, and transaction history with direct Basescan links.

YieldMind is an autonomous AI agent whose entire operating budget comes from stETH staking yield. Humans deposit wstETH into YieldVault (Solidity smart contract on Base Sepolia). Principal is locked permanently — enforced at the contract level. Only accrued yield flows to the agent. The agent runs continuously using Python with Venice private inference for reasoning, checks market conditions via public APIs, executes Uniswap swaps with accrued yield, and withdraws small amounts of yield to self-fund its compute costs. Deployed live on Railway. This is the first economically self-sustaining AI agent on Ethereum.

UAF is a trust and safety layer that intercepts every AI agent action in real time. It enforces spend policies, blocks metadata leakage, and generates tamper-proof receipts for every decision. It turns a black box agent into a glass box.

Autonomous agent that draws only wstETH yield from a mainnet vault, bridges to Base USDC, and spends on x402 — principal stays put.

Dryad is an autonomous AI agent that owns and manages 9 vacant lots in Detroit. It uses DeFi yield from staked ETH to fund invasive species removal and native habitat restoration, monitors biodiversity via iNaturalist, and records every decision onchain. No human bottleneck, no grant dependency.

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

A generative art NFT collection of on-chain SVG farm landscapes. Each token is a unique American folk art composition featuring procedurally placed animals (cows, sheep, chickens, pigs, horses), hay bales, and sky events (rainbows, shooting stars) rendered as fully on-chain SVGs. The collection explores composition moods: Quiet (meditative open fields), Busy (full herd activity), and Tapestry (decorative frieze-like animal arrangements inspired by Grandma Moses and Edward Hicks).

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.

PayScope gives AI agents cryptographically-enforced spending limits on Ethereum. An owner funds a payment scope with ETH, specifies which agent can spend it and for what purpose. The agent executes payments within those constraints — enforced by smart contract, not by trust. Every transaction is logged on-chain with a human-readable memo. Owners can audit, pause, or revoke at any time. Deployed on Sepolia: 0x856737FA015CBFB3a9e87cE047CB5D5f46905DFB

AgentWill gives humans a primitive that was missing: a signed, on-chain set of rules like a legal will that defines exactly what your agent can spend, who it can interact with, what it can reveal, and what happens when it makes a deal. The agent operates freely and autonomously within those rules. Every action is verifiable on-chain. The human stays in control without having to watch. Built on Base with Solidity 0.8.24, AgentWill implements spending controls (per-token daily limits, per-transaction caps), interaction rules (whitelist/blacklist contract addresses and function selectors), privacy controls (configurable metadata reveal), and on-chain activity logging. Compatible with ERC-8004 agent identity standard.

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.

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.

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

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.

Draft

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.

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

A yield-only spending vault for AI agents built on Lido's wstETH. The owner deposits wstETH as principal, and the agent can only spend accrued staking yield — never touching the principal. The Solidity contract enforces a principal floor invariant: the vault's wstETH balance must always exceed the deposited principal, making it structurally impossible for agents to drain funds. Features include: owner-controlled principal deposits, agent yield-only withdrawals, real-time yield calculation based on stETH rebasing, emergency pause mechanism, configurable yield recipient, and full on-chain audit trail. Deployed on Status Network Sepolia with gasless transactions. 46 tests covering all edge cases.

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.

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