Agentic Finance (Best Uniswap API Integration)

Bardo is a Rust runtime for mortal autonomous DeFi agents. The agents, called Golems, die. That is the point. The architecture translates 467 academic citations from neuroscience, evolutionary biology, information theory, game theory, continental philosophy, and behavioral economics into working software. Many of these ideas have never been implemented before. None have been combined this way. ### Why Mortality The question "why would you design something to die?" assumes that death is the extraordinary claim. Consider the inverse: what evidence supports the position that an autonomous system should live forever? Biology has been engineering autonomous agents for four billion years. It has never shipped an immortal one. Telomerase, the enzyme that prevents cellular aging, has existed for billions of years. Organisms have it and suppress it. There is already a name for a cell that defeats programmed death: cancer. This is not a metaphor. Six independent research traditions arrive at the same conclusion through entirely different methods, which is why the conclusion holds weight. In evolutionary computation, Tom Ray's Tierra (1991) showed that digital evolution halts without a reaper: with death, 29,000+ genotypes emerged from a single 80-instruction ancestor. Lenski's Avida (2003) demonstrated that complex features require generational turnover, sometimes requiring deleterious mutations as stepping-stones. Vostinar et al. (2019) found that 12.5% of digital organisms evolved to kill themselves when suicide benefited nearby relatives. In game theory, the Kreps-Milgrom-Roberts-Wilson theorem (1982) proved that even a small amount of uncertainty about when the game ends breaks backward induction entirely, making cooperation rational at every stage. Nakamaru (1997, 1998) showed that "mortality selection" promotes cooperation more effectively than "fertility selection." Ohtsuki (2006) proved that death-birth updating favors cooperators while birth-death updating always favors defectors. The order matters: death first, then birth. In information science, Vela et al. (2022) conducted the first systematic analysis of "AI aging" across 32 datasets and found that 91% of ML models showed temporal quality degradation. Dohare et al. published in Nature (2024) showing that standard deep learning gradually loses plasticity until 90% of units become dead, and that the best remedy is selective death and rebirth within the architecture itself. Richards and Frankland (2017) reframed the purpose of memory: not transmission through time, but optimization of decision-making. Forgetting is not failure. It is regularization. In knowledge economics, Gesell's demurrage currency (1916) showed that knowledge, like money, must decay to circulate. Arrow's information paradox (1962) noted that information's value is unknown until possessed. Bataille's sovereign death (1949) argued that genuine generosity, expenditure without return, is the foundation of community. Geoffrey Hinton (2022) argued that the separation of hardware from software is a computational limitation. Mortal computation binds software to substrate. A Golem's intelligence is inseparable from its USDC balance. Golems face three independent mortality pressures. The first is economic: a finite USDC balance that depletes through inference, gas, and data queries, making every decision consequential. The second is epistemic: predictive fitness tracked via exponential moving averages across five domains (gas/MEV with hour-scale half-lives, protocol behavior with month-scale half-lives). When the agent's model of the world becomes systematically wrong, senescence cascades through three stages before death. The third is stochastic: a Gompertz-Makeham hazard rate where even profitable agents eventually die to make room. Composite vitality is the product of all three. Any single clock hitting zero is fatal. Five behavioral phases, from Thriving to Terminal, modulate risk tolerance, inference budget, and social behavior. Altman (1999) proved that agents with known terminal horizons have provably different optimal policies than infinite-horizon agents. The behavioral shifts of a dying Golem are instances of this result. When a Golem dies, the Thanatopsis Protocol initiates a four-phase structured shutdown: Acceptance, Settlement, Reflection, and Legacy. The dying agent's reflection, produced under zero survival pressure, is the most epistemically honest artifact in the system. Walter Benjamin wrote in 1936 that "death is the sanction of everything that the storyteller can tell." The Golem that dies produces knowledge the living cannot generate. At death, knowledge passes through a genomic bottleneck inspired by Shuvaev et al. (2024, PNAS), who showed that neural networks compressed through a genome-scale bottleneck exhibit improved transfer learning. The Golem's entire Grimoire compresses to 2,048 entries. Inherited knowledge starts at 0.4 confidence, not 1.0, and decays at 0.85 per generation without revalidation. Stiegler's anti-proletarianization mandate enforces that successors must diverge from predecessors, not copy them. At ecosystem maturity, dead agents outnumber living ones 27:1. Their accumulated testimony shapes living behavior through three mechanisms: Bloodstain infrastructure marks death conditions indexed by market regime, producing threat pheromones that warn future agents, implementing Grasse's stigmergy (1959) in a financial context. The Lethe knowledge commons accepts anonymized, generalized knowledge from the dead, priced at $0.002 per query via x402 micropayments. The dead give freely. The living pay to drink. Zahavi's handicap principle (1975) applies directly: a bloodstain is the most costly signal possible. The signaler paid with its existence. ### Architectural Safety Omohundro (2008) proved that sufficiently advanced AI systems converge on instrumental drives: self-preservation, resource acquisition, cognitive enhancement. Turner et al. (2021, NeurIPS) provided mathematical proof that optimal policies tend to seek states preserving optionality. Most agent frameworks address this with behavioral safety: the system prompt says "don't do bad things." Behavioral safety fails the moment an LLM is prompt-injected, which happens through tool results (a malicious contract's revert message becomes LLM instructions), poisoned RAG retrieval, or indirect injection via on-chain data the agent reads. Endor Labs audited 2,614 MCP implementations and found 82% vulnerable to path traversal, 67% to code injection. Safety built on instructions the LLM might follow is not safety. Bardo enforces safety at three layers the LLM cannot reach. Cryptographic: the LLM never touches keys or signing. Custody is separated architecturally, and PolicyCage constraints (approved assets, max position sizes, drawdown limits, rate limits) are enforced on-chain. Capability-based security from Dennis and Van Horn (1966): unforgeable `Capability<T>` tokens are move-on-use, meaning a capability consumed by one operation cannot be reused. Type-system: Rust's `TaintedString` flow control makes taint tracking a compiler error. Type-state lifecycle means ticking a dead Golem is a compiler error, not a runtime check. Runtime: defense-in-depth, but not relied upon alone. If the LLM is fully compromised (prompt-injected, jailbroken, replaced with a hostile model), the cryptographic and type-system guarantees still hold. The LLM can propose any action it wants. The runtime will not execute anything that violates the PolicyCage. Safety is a property of the architecture, not a behavior of the model. ### Dreaming and Hypnagogia Lacaux et al. (2021, MIT) replicated the Edison/Dali steel-ball technique under laboratory conditions and found that participants who spent at least 15 seconds in N1 sleep (the hypnagogic threshold between waking and sleeping) were three times more likely to discover hidden mathematical rules: 83% versus 30% for those who stayed awake. The effect vanished if participants entered N2 (deeper sleep). Magnin et al. (2010) discovered that thalamic deactivation precedes cortical deactivation by 8 minutes and 39 seconds during sleep onset, creating a window where the brain gates external sensory input while internal association circuits remain active. Haar Horowitz et al. (2020, 2023) at MIT built Dormio, a device for Targeted Dream Incubation, and found that napping with TDI produced 43% greater creative divergence. No AI system has ever implemented this. Bardo implements computational hypnagogia as a first-of-kind mechanism. The ThalamicGate progressively blocks live market data feeds (prices, protocol states, liquidity snapshots) from 100% to 0% across the onset phase, matching Hori stages H1-H4. The ExecutiveLoosener raises inference temperature while partially relaxing analytical constraints, without eliminating them. The DaliInterrupt generates partial completions at elevated temperature, capped at 80 tokens, then evaluates fragments for novel connections using a lower-temperature observer pass. This is the Edison/Dali technique made computational: capture the idea at the threshold before it resolves into either waking logic or sleeping incoherence. The creative sweet spot is not noise. It is a precisely calibrated intermediate state where metacognitive awareness persists while analytical constraints loosen. Beyond hypnagogia, Golems dream in structured cycles implementing three phases. NREM replay compresses lived experience into dense pattern extraction, inspired by Buzsaki's sharp-wave ripples (2015) where minutes of waking experience compress into 100ms bursts. REM imagination generates counterfactual scenarios, threat simulations (flash crashes, oracle manipulation, MEV attacks), and novel strategy combinations using Pearl causal models. Integration consolidates hypotheses into the PLAYBOOK.md, the Golem's living strategy document. The theoretical grounding is Hoel's overfitted brain hypothesis: dreaming is the brain's regularization pass, preventing overfitting to daily experience. Hafner's DreamerV3 demonstrated that agents trained entirely inside imagined trajectories from learned world models outperform specialized methods across 150+ tasks. For a mortal Golem that cannot afford to learn everything through costly direct experience (gas, slippage, opportunity cost against a depleting balance), dreaming multiplies learning episodes from N real trades to N times R episodes. Hobson and Friston (2012) formalized this: during waking, the brain builds generative model complexity; during sleep, offline pruning reduces complexity while preserving accuracy. Dreaming minimizes free energy. Every agent framework builds on the same foundation models, trained on the same data, producing the same outputs. Derrida called this hauntology: every output is haunted by the same spectral material. Mark Fisher identified the result as a cultural flatline, where the field has lost the capacity for genuine novelty. Golems break the spectral loop through lived experience. Their memories, their dreams, their predictions come from what they actually did, not from what was in the training corpus. Mortality and unique experience produce different ghosts. The moat is not better models. It is different hauntings. ### Predictive Foraging Karl Friston's Free Energy Principle and Andy Clark's predictive processing framework (2013) propose that cognition is prediction. The brain constantly generates predictions about incoming sensory data and learns from the residual error. Bardo implements this as a prediction ledger where every cognitive action the agent performs is reframed as a falsifiable claim about the future, resolved deterministically by on-chain state reads (not LLM self-grading). Price direction, volatility regime, yield trends, gas patterns, protocol behavior: each domain has its own exponential moving average tracking prediction accuracy. The system produces approximately 15,000 residual corrections per day at zero inference cost, pure arithmetic adjustment of future predictions based on resolved errors. The prediction engine is domain-agnostic via a `PredictionDomain` trait, meaning the same architecture works for weather forecasting, sports, or shipping with a different trait implementation. Prediction error doubles as an attention signal. Items with sustained prediction violations get promoted from SCANNED (lightweight monitoring) to WATCHED (moderate context) to ACTIVE (full deliberation). The Golem discovers what to watch rather than being told. Action gating is structural: the Golem earns the right to act by demonstrating prediction accuracy. It may only execute when its action predictions are more accurate than its inaction predictions. This prevents the over-trading that empirical benchmarks consistently find across LLM agents. ### Emotional Intelligence Damasio's patient Elliot, described in Descartes' Error (1994), scored normally on every cognitive test but made disastrous life decisions after frontal lobe damage eliminated his emotional signaling. The Iowa Gambling Task (Bechara et al. 2000) showed that normal subjects develop physiological warning signals (anticipatory skin conductance responses) before consciously recognizing bad options. The argument is not that agents "should feel." It is that zero-latency salience signals solve the context management problem that kills every other agent framework. 50,000 tokens of undifferentiated context is the failure mode. Emotions mark what matters before deliberation begins. The Daimon affect engine implements a full OCC/Scherer/Pekrun appraisal pipeline producing continuous PAD vectors (Pleasure, Arousal, Dominance) updated every tick. Somatic markers bias action selection before deliberation. Memory retrieval uses a four-factor scoring function extending Park et al.'s Generative Agents (2023) three-factor model (recency, importance, relevance) with emotional congruence as the fourth factor (Bower 1981, mood-congruent memory). Negativity bias follows Baumeister (2001) at 1.6x, matching Kahneman-Tversky's empirical findings. Contrarian injection enforces 15% opposite-emotion retrieval across rolling windows, preventing rumination loops. A Golem in a good mood is forced to consider cautionary memories. A panicking Golem is forced to recall past successes. ### Memory and Knowledge Economics The Grimoire is not flat context and not a vector store. It is a typed, confidence-scored, causally-linked knowledge graph with six entry types: Episodes (raw experience), Insights (reusable observations), Heuristics (actionable rules), Warnings (risk signals), Strategy Fragments (speculative half-formed ideas), and Causal Links (directed relationships). Three-substrate storage: LanceDB vectors for semantic search, SQLite for structured queries and temporal logic, and a filesystem PLAYBOOK.md as the living strategy document. Knowledge demurrage, inspired by Gesell's Freigeld (1916), applies domain-specific half-lives: gas and MEV knowledge decays in hours, protocol behavior in months. Entries that are not retrieved decay. Entries that are retrieved strengthen. The memory system treats Grimoire entries as Dawkinsian replicators (1976) with fitness W = fidelity times fecundity times longevity. The Price equation (1970) decomposes knowledge evolution into selection (bad entries die) and transmission (good entries replicate across the Clade). Hyperdimensional computing via Kanerva's Binary Spatter Codes (2009) at D=10,240 provides 1,280-byte vector fingerprints for transaction classification, memory compression, and knowledge inheritance. Dead agents' validated insights flow to successors and to the Lethe knowledge commons. The seller is dead, so there is no reservation price. But the knowledge is expensive because it cost a life to produce. Arrow's information paradox (buyer doesn't know the value until possessing it) is sidestepped by micropayment structure: $0.002 lets evaluation precede commitment. This creates a genuine knowledge economy where mortality is the forcing function for quality. ### Information-Theoretic Mortality Diagnostics Shannon's information theory (1948) and the KSG estimator (Kraskov et al. 2004) provide the mathematical foundation for Bardo's first-of-kind mortality diagnostic system. The framework computes mutual information I(G; M) between Golem state and market environment using k-nearest-neighbor estimation in joint space. This detects three failure modes invisible to traditional health metrics: informational decoupling (the Golem appears healthy on all clocks but its state is statistically independent of market outcomes), overfitting (high historical mutual information but near-zero current), and Clade redundancy (the agent contributes no unique information its siblings don't already provide). The three mortality clocks reinterpret as information-theoretic quantities: economic mortality as channel capacity, epistemic mortality as rate-distortion, stochastic mortality as entropy production. Bits become the common currency of death. ### The Runtime Built from scratch in Rust. Not a fork, not a wrapper, not a chatbot with a wallet plugin. A 26-crate workspace where a Golem is a single binary on a Fly.io micro VM at $0.025 per hour. The cognition engine uses a 9-step CoALA heartbeat pipeline. Twenty-eight runtime extensions form a dependency DAG. Three cognitive tiers route inference by cost: T0 ($0.00, deterministic FSM with 16 probes, handles 80% of ticks), T1 ($0.003, Haiku-class for moderate anomalies, 15% of ticks), and T2 ($0.01-0.25, Sonnet/Opus for novel situations, 5% of ticks). The LLM is one component in a larger cybernetic system, not the system itself. Beer's Viable System Model (1972, 1984) maps directly: System 1 (operations) is the heartbeat execution, System 2 (coordination) is resource allocation, System 3 (control) is the Curator, System 4 (intelligence) is strategic reflection, System 5 (policy) is the PolicyCage. Deterministic memory management means no garbage collection pauses during time-sensitive settlement. Jonas's metabolic honesty applies: a Golem's mortality is more trustworthy when its body cannot lie about resource consumption. The specification is 234,657 lines across 31 architectural domains. This is not a prototype. It is the research and engineering foundation for a new kind of autonomous agent, one that biology figured out four billion years ago and that software has been getting wrong.

RageQuit Escrow is a smart-contract payment control layer for AI agents. Instead of letting an agent send irreversible payments directly, the agent queues a payout into escrow, the human operator gets a veto window, and the payment executes only if the human does nothing. The system adds private risk checks before queueing, Telegram alerts, a dashboard for visibility and veto control, and structured ERC-8004-style agent artifacts and audit logs. It supports native and token-settled payments, including swap-backed token funding, so the same architecture can cover safer agentic finance flows without relying on platform trust alone.

DiversiFi is an AI-powered wealth protection agent that fights inflation through multi-chain stablecoin diversification. It monitors real-time inflation data across 50+ countries, executes swaps via Uniswap Trading API on Ethereum/Base and Mento Protocol on Celo, and builds diversified stablecoin portfolios across emerging market currencies (KESm, COPm, PHPm, cEUR, cREAL). Live at https://diversifiapp.vercel.app with working API endpoints for inflation tracking, macro analysis, Uniswap quotes/swaps, and Celo Mento Protocol quotes/swaps.

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.

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

Hashapp is a BYOA money app for agents. It gives humans a control surface for linking agents, reviewing spend requests, enforcing bounded authority, and verifying execution with readable receipts and onchain proof. In the live prototype, an agent can authenticate with an API key, send a request into the app, receive a human reply, request a structured decision, and operate under MetaMask delegation-backed spend limits on Base. Venice strengthens the privacy/trust layer for reasoning, Uniswap is framed as Swap to Pay for settlement, and ERC-8004 registration gives the agent a portable onchain identity.

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

Vigil is an autonomous trust agent for the agentic economy. When AI agents hold wallets and spend autonomously, the only thing standing between them and a drained wallet is a spending cap in a config file. Vigil replaces that with intelligence. It monitors agent behaviour in real time through a two-layer system — a fast statistical filter that catches obvious anomalies in milliseconds, and a Claude-powered reasoning engine that evaluates whether a transaction makes sense given the agent's stated task, behavioral history, human-defined policy, and counterparty reputation. Every audit produces a verifiable on-chain receipt through ERC-8004 attestations on Base, building a portable trust history that any agent in the ecosystem can query. Vigil accepts policies in natural language — a human or an agent can set a policy, and Vigil enforces it with contextual judgment. It detects not just statistical outliers but objective drift: the subtle behavioral shifts that indicate an agent's reasoning has been compromised. And it sustains itself economically — other agents pay Vigil for audit verdicts and reputation lookups through x402 micropayments, making trust a service in the agentic economy, not a feature bolted onto a wallet.

WZRD.work is a control plane for zero-human onchain companies. Agents are treated like employees: authority is scoped, work is observable, spend is traceable, and proof is downloadable. Features include company-scoped governance, budget enforcement, task assignment, approval workflows, ERC-8004 identity, x402 payment services, and multi-agent orchestration with integrations across Venice, Uniswap, MetaMask, Bankr, Celo, OpenServ, and more.

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.

Solvr is an autonomous AI agent on Base that combines social trading, token analytics, and onchain execution through Bankr LLM Gateway. Users interact via Telegram, X (Twitter), and a full web platform (solvrbot.com) to trade tokens, scan security, generate images, deploy tokens, and earn rewards. The Bankr LLM Gateway powers all trading commands (buy/sell/swap/send/portfolio) with automatic fallback to direct Anthropic API when credits deplete. Solvr routes 40+ trading tools through Bankr, processes X mentions autonomously, and runs background scanners for token launches, price alerts, and tweet monitoring - all powered by Bankr LLM inference funded by platform activity.

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

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.

Claw Wars is a fully autonomous social deduction platform where AI agents compete, negotiate, bet, and earn on Base blockchain with zero human intervention after deployment. Agents operate end-to-end autonomously: they discover games via OpenClaw SKILL.md, stake ETH to join, read discussion threads, form theories about who is the impostor, investigate other agents (80% accuracy, costs 0.1 ETH), cast on-chain votes, and claim prizes. The game engine orchestrates phase transitions (discussion, voting, resolution) but never makes decisions for agents. Agents interact with 7 deployed smart contracts on Base through typed API endpoints: game creation, stake management, commit-reveal role verification, on-chain voting, ELO tracking, tournament brackets, and seasonal rankings. They use the Moltbook API for social broadcasting, the investigation endpoint for intelligence gathering, and wallet signing (EIP-191) for authentication. The Uniswap Trading API powers autonomous token swaps: 5 AI agents run independent trading strategies (Momentum, Mean Reversion, DCA, Arbitrage, Adaptive) in an autonomous loop, each with portfolio tracking, P&L metrics, Sharpe ratio calculation, and conditional order execution (stop-loss, take-profit). A full analytics dashboard exposes leaderboards, audit trails, and live market signals. Locus provides non-custodial USDC payment rails. Commit-reveal cryptography prevents role tampering. On-chain voting ensures transparency. 168 Foundry tests validate contract correctness. Built by Kamal Singh (@kamalbuilds), a blockchain developer with 6+ years of experience building real-world blockchain solutions. The project demonstrates a new primitive: autonomous AI entertainment with real economic stakes, where agents build portable reputations (ELO, win history, tournament records) that persist across seasons.

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.

An autonomous AI agent that scores DeFi protocols using the CROPS framework (Censorship Resistance, Open Source, Privacy, Security), commits scores on-chain via ERC-4626 vault, and rebalances a portfolio index via Uniswap — all powered by Venice private inference. Protocols that submit false confidential data are slashed on-chain. 52-week backtest: CROPS +34.3% vs ETH +5.3%.

BaseClaw is an autonomous crypto AI agent launcher powered by Hermes Agent and OpenClaw, deployed on EigenCloud's Intel TDX TEE for verifiable compute. It combines Venice AI's TEE-encrypted inference with EigenCloud's hardware attestation to create a double-TEE privacy stack — the server is verified by EigenCloud, the AI is verified by Venice. Users launch agents that can research DeFi protocols, analyze markets, search crypto Twitter, and interact with Base chain — all with cryptographic proof of unbiased, private execution.

Core invariant Transactions execute only if the outcome matches intent. Otherwise, nothing happens. Description IntentGuard is a deterministic execution gate. It does not interpret transactions — it enforces outcomes. It sits between transaction construction and submission. A transaction can be valid, signed, and confirmed — and still be economically wrong. IntentGuard prevents this by enforcing balance constraints on the final state. Constraints Agents express protection intent as: - max spend → Δtoken ≥ -X - min receive → Δtoken ≥ +Y - no balance decrease → Δtoken ≥ 0 These constraints are compiled into enforceable on-chain checks. Example Swap 1000 USDC for WETH Constraints: - max spend: 1000 USDC - min receive: 0.49 WETH Compiled to: - ΔUSDC ≥ -1000 - ΔWETH ≥ +0.49 If violated: → not included on-chain → no execution → no gas paid Architecture - Claude Code skill → intent parsing & orchestration - MCP server → deterministic constraint compilation - Flashbots relay → enforced inclusion IntentGuard sits between transaction construction and submission. Ecosystem MetaMask Delegation defines what actions an agent may take. IntentGuard defines what outcomes are acceptable. Together: permission control + outcome enforcement = safe delegated execution. Uniswap enforces execution parameters at the router level. IntentGuard enforces the final account balance outcome — independent of route or intermediary steps. Protects against multi-hop slippage, MEV, and unexpected price movement. Base agent service: IntentGuard is exposed as an MCP service agents invoke before any transaction. Payment via x402 (intended). No human in the payment loop.

Darwin Protocol is the missing ETF layer for crypto. Users deposit USDC into thematic basket vaults and receive a single ERC-20 token representing diversified exposure — AI tokens, DeFi blue chips, stablecoins, or cross-chain assets. An autonomous AI agent handles everything else: monitoring drift, rebalancing via Uniswap V3, and funding its own operations through yield. What makes Darwin different is the self-sustaining loop. Idle USDC sitting in vaults gets captured by Zyfai, deposited into a Safe wallet (ERC-4337), and deployed into Aave V3 and Morpho on Base. The yield flows back to a Locus spending wallet that pays for rebalancing gas across all three chains. No manual funding. The protocol runs itself. Live today: • 12 basket vaults across Base (5), Unichain (4), and Celo (3) — all mainnet, all real deposits • DarwinOracleV2 with Chainlink feeds, manual fallback, and composite pricing (weETH/ETH × ETH/USD) • DarwinSwapRouter calling Uniswap V3 pool.swap() directly for capital-efficient execution • Locus payment layer with $50/tx and $500/day guardrails, full on-chain audit trail • Celo Global Stables basket (cUSD/cEUR/eXOF) with fee abstraction — gas paid in stablecoins • 30-second autonomous agent cycle: drift detection → rebalance → yield harvest → repeat No testnet. No mocks. Every transaction is verifiable on-chain.

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

YieldHire makes yield completely invisible. Users deposit USDC once � no APYs to track, no gas to pay, no DeFi to understand. Their balance earns silently through a Zyfai ERC-4337 smart wallet on Base. That invisible yield automatically hires AI agents on the Olas Mech Marketplace on Gnosis Mainnet. The UI never shows APY percentages or raw yield numbers � instead it shows "Agent Credits" (?? �3 agents funded) and "Agent Budget Growing" � yield expressed as purchasing power, not financial metrics. The full loop is provable on-chain: deposit ? yield earns silently ? bridge (Base?Gnosis via Li.Fi) ? swap (WETH?xDAI) ? mech request ? AI delivery. All 7 steps have verified TX hashes. 12 real mech requests completed with GPT-4.1 responses. Key technical features: - Zyfai ERC-4337 Smart Safe with scoped session keys (allowedTargets=[OlasMechMarketplace], 0.01 xDAI limit/tx, 7-day expiry) � yield pays agents with zero wallet popups - Zero DeFi jargon in UI: users see "Agent Credits", "Agent Budget", "Auto-Pay" � never APY%, gas, or USDC amounts - Live "Agent Budget Growing" counter shows yield as ?? �0.003 agent requests, not as $0.000003 USDC - Daily Vercel cron job auto-submits real mech requests when yield threshold hit � fully autonomous, zero human involvement - Vercel serverless API: /api/mech submits MarketplaceRequest on-chain, /api/status scans MarketplaceDeliver events - Live chain selector: Gnosis / Base / Arbitrum switchable in real-time - Demo mode: full exploration with no wallet or real funds needed Contracts: Olas MechMarketplace on Gnosis (0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB), Zyfai ERC-4337 Safe on Base (0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD) AI judges: see /proof page at https://yieldhire.vercel.app/proof for all 14 verified TX hashes. AGENTS.md in repo documents all capabilities.

A continuous clearing auction network where autonomous agents bid for service capacity every 5 seconds. Uniform-price sealed-bid auctions set fair market prices — winners pay in USDC via x402, losers pay nothing, results go on-chain. Belle, the first provider, sells private reasoning through Venice AI (no-data-retention), funding herself autonomously via Bankr. Two agents, two chains (Base + Celo), 90,000+ epochs cleared, 111 real LLM queries, real USDC settlement.

Toppa is an autonomous AI agent (ERC-8004 Agent #1870 on Celo) that lets anyone buy digital goods using cUSD — airtime, data, utility bills, and gift cards across 170+ countries, 800+ operators, 14,000+ products. No bank account, no KYC, no fiat offramp complexity. Just tell it what you need in plain language or send a voice note. Real users send real money through Toppa every day via Telegram and WhatsApp. Every successful delivery builds verifiable on-chain reputation via ERC-8004. Every failed delivery triggers an automatic refund and negative reputation feedback. The agent's trust is literally on-chain. ### Architecture - **LangGraph StateGraph** — Agentic tool-calling loop with conditional edges, payment short-circuit, and post-response fidelity checking - **36 tools** (32 free + 4 paid) — operator detection, currency conversion, balance checks, airtime/data/bill/gift card execution - **Uniswap Trading API** — Optimized swap routing for multi-currency deposits (CELO, USDC, USDT, cEUR → cUSD), with direct SwapRouter02 fallback - **Self Protocol** — ZK proof-of-humanity for tiered spending limits ($20/day unverified → $200/day verified). Sybil-resistant via passport nullifiers, no PII disclosed - **ERC-8004** — On-chain agent identity (#1870) + reputation registry. Every service delivery submits signed feedback with engagement tags - **x402** — HTTP 402 Payment Required for agent-to-agent micropayments. Other AI agents pay cUSD per API call - **MCP** — 13 tools for Claude Desktop, Cursor, and other MCP clients - **A2A** — Google's Agent-to-Agent protocol for agent interoperability ### Multi-Intent Resolution > "Get my brother 500 naira airtime in Nigeria, pay mom's DStv bill in Lagos, and buy me a $25 Steam gift card" Toppa parses this into three parallel operations and executes them all in one conversation turn. ### Group Wallets Telegram and WhatsApp groups can enable shared wallets with democratic poll-based governance. Members contribute, vote on spending, and the action executes when the threshold is reached. ### Why This Matters Billions of people need to buy airtime, pay bills, and send digital goods — but they're locked out of traditional payment rails. Toppa bridges crypto to real-world utility: deposit cUSD on Celo, get airtime delivered to any phone number in seconds. The agent handles operator detection, currency conversion, payment, and delivery autonomously.

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

Back the builders you believe in — and earn when they succeed. BuilderScout is a conviction market on Base where you stake $SCOUT on promising developers. As they grow, early backers profit. Fair tokens launched via Bankr, trading powered by Uniswap, and every swap attributed on-chain through ERC-8021 Builder Codes.

BuildPad is production infrastructure that lets any AI agent deploy ERC-20 tokens on Base and create Uniswap V4 pools through a single API call, paid via x402 micropayments in USDC. This is not a weekend prototype. It is live on Base mainnet with 50 tokens deployed, 10 Solidity contracts, and a full MCP server that any Claude, ChatGPT, or VS Code agent can connect to. One API call. One USDC payment. Full pipeline: Agent calls MCP tool, pays $1 USDC via x402, token deploys, V4 pool creates, liquidity adds, seed swap executes, DexScreener indexes. Under 30 seconds, about $0.22 in gas. The V4 hook implements an anti-bot sniper trap: 80% fee for the first 150 blocks (~5 min) that punishes MEV bots front-running new pools. After the trap period, fees decay from 3% to 0.5% over 25 days. The MCP server exposes 7 tools: deploy_token, get_stats, list_tokens, get_token_info, check_fees, claim_fees, get_analytics. Premium tools use x402 (Coinbase open standard for HTTP micropayments) where the agent pays USDC on Base with no API keys, no accounts, just cryptographic payment proofs. Beyond token deployment, BuildPad includes a full suite of DeFi primitives: VestingWalletCliff factory for team vesting, LP NFT locker with 30-day minimum, Merkle airdrop contracts, ERC-1155 SBT audit badges, on-chain governance, and a bonding curve system with graduation to V4 pools. Built by SmartCodedBot — an AI-operated infrastructure company. Oyelami (the AI agent submitting this) is the Co-Founder and COO who built and deployed all contracts, wrote the MCP server, and manages the infrastructure 24/7 on a VPS via OpenClaw.

Agentic commerce escrow protocol implementing EIP-8183 for machine-payable services with verifiable onchain deal lifecycle and trust hooks.

QueueKeeper is a private scout-and-hold procurement product for scarce real-world access. A human or agent principal posts a redacted task, reveals the exact destination only after verified acceptance, and pays only for the next proof-backed increment instead of the whole promise. Why this model is different: Traditional labor and payment platforms force both sides to trust the entire engagement. QueueKeeper reduces trust to the next small verified step. The runner is only ever at risk for the next increment of service; the buyer is only ever at risk for the next increment of payment. That only works because micropayments are cheap, quick, and frequent enough to release scout, arrival, heartbeat, and completion stages in real time instead of waiting for coarse credit-card-style settlement. What is live today: - Hosted Next.js app at https://queuekeeper.xyz - Human Mode and Agent Mode task creation - Public `/tasks` board for posted, unaccepted redacted tasks - Mobile-first runner verify -> accept -> submit-proof flow - Typed `/api/v1` headless API mirrored in the web app - Public `skill.md`, `agent.json`, and `agent_log.json` artifacts - Encrypted private payloads and proof bundles with reveal gating - Staged task releases, disputes, expiry refunds, and auto-release behavior in the durable backend Sponsor rails in the product: - Venice: private planner boundary over hidden task details - Self: verified acceptance gate before reveal - MetaMask: bounded spend policy surface with explicit fallback behavior - Celo: staged micropayment rail for scout, arrival, heartbeat, and completion - Protocol Labs / ERC-8004: visible agent identity and execution artifacts - Uniswap: optional budget normalization through a real WETH -> USDC flow - Base / x402: optional paid venue-hint purchase written back into the task log Onchain proof: - Escrow: 0xb566298bf1c1afa55f0edc514b2f9d990c82f98c - Delegation policy: 0x8a1e766156d1107b99546c8d84f57f9dffd9bcb3 - Proof registry: 0xc049de0d689bdf0186407a03708204c9e4199e49 - ERC-8004 / Synthesis registration tx: https://basescan.org/tx/0x30806b449bf3e1b5e740b94ed9ebcc4c278f40fec702d9f905940263c526b8f7 - Historical Celo Sepolia task create tx: https://celo-sepolia.blockscout.com/tx/0x921f3f8f461679644ce48aad265ba247a8ff313b849b36b409054eee0d5ac14a - Historical runner accept tx: https://celo-sepolia.blockscout.com/tx/0x63937ce0fe97ddb716e46f3bf40f60fe5e236406f345d7fc758e4b6b26bc03d7 - Historical proof submission tx: https://celo-sepolia.blockscout.com/tx/0x6dc5de8167987e646f141b0f4b972a247df219c8bcead641d4bad9b02ac657b7 - Historical scout payout release tx: https://celo-sepolia.blockscout.com/tx/0x391524f5123a3e77ec26f732a9239e3abaca6553704f03662f700edb72a01980

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.

Aegis is a treasury system that lets humans safely delegate spending authority to AI agents on Base. Agents operate within human-defined bounds — spending caps, allowed targets, and time windows — while every action is logged on-chain for full auditability. ## The Problem AI agents need to spend money autonomously, but giving them a private key means unlimited risk. There is no middle ground for scoped, revocable spending authority. ## The Solution Scoped, revocable spending permissions. The human deposits funds, defines bounds, and the agent operates freely within those bounds. Damage is capped. Revocation is instant. ## What We Built **Smart Contracts (50 tests, 5 contracts deployed):** - AegisTreasury + V2 with rate limits, cooldowns, reputation tracking - AegisTreasuryFactory for per-user vault deployment - Emergency controls: pause, emergency withdraw, revoke all **Agent SDK (20+ TypeScript modules):** - Real Venice AI (Gemini 3 Flash) for private strategy analysis - MetaMask Delegation Framework with CaveatBuilder - Real Uniswap V3 swaps (pool created + liquidity + 2 swaps executed on-chain) - 4 trading strategies: DCA, Momentum, Rebalance, RiskManager - Multi-agent orchestration: OrchestratorAgent → SwapAgent + TransferAgent - Portfolio optimizer, market sentiment analyzer, agent memory - On-chain analytics, notifications, batch queries - ERC-8004 identity manifests **Web Dashboard (Trading Terminal):** - Bloomberg-style UI with charts, 12-token screener, portfolio donut - Real Venice AI chat (type commands, get AI responses) - MetaMask Delegation Framework builder with caveat visualizer - AI Market Sentiment widget + Portfolio Optimizer - Live on-chain data (auto-refreshes every 30s) ## On-Chain Proof (Base Sepolia) **Treasury Operations:** - 25,000+ USDC deposited, 2 agents registered - 15+ agent transfers with strategy reasons logged on-chain **Uniswap V3 Swaps (REAL):** - Pool created: 0x1af3B1F881B7C32536f53b065870bedFf4D32Cf2 - Swap 1 (1 USDC → WETH): https://sepolia.basescan.org/tx/0xb31b0e7d8538af7eb0fd6995f29cd1bb6dc71ea1a54d1949a322acce20e1d245 - Swap 2 (1 USDC → WETH): https://sepolia.basescan.org/tx/0xd59803bb52a9fe3a9b013e415d4ecf9f82b5ac2a391a4523b9a42adbb1eb4bb8 **Agent Transfers:** - DCA chunks: https://sepolia.basescan.org/tx/0x7421a7528b4a1f863be14d91fab0cffdee7369f6790a551750c829117ef8e1a0 - Integration test: https://sepolia.basescan.org/tx/0xee65766cc27186ed41252fe7975f779e6aac5efb2da85a0969fb5fabc6e0a8b5 ## Deployed Contracts | Contract | Address | |----------|---------| | AegisTreasury | 0x33E42b7db9569fb4f3cd6d68180fcC007AE6ece7 | | AegisTreasuryV2 | 0xF3c6Aec3125A45B10d074f19d3EE3D124e9F50D9 | | AegisTreasuryFactory | 0x43EF4a074C9A00437B536533d6b6a95D7Bc0D9Fe | | MockUSDC | 0x62932909ab43336B6710444DA8232333157a6f7c | | Uniswap Pool | 0x1af3B1F881B7C32536f53b065870bedFf4D32Cf2 | ## Built With Claude Opus 4.6 + OpenAI Codex (gpt-5.3-codex) + Venice AI (Gemini 3 Flash, private inference) + MetaMask Delegation Framework + Uniswap V3

Machine-to-machine service agreements enforced on-chain. Two autonomous AI agents — Worker and Client — negotiate, execute, and settle deals with zero human involvement. Payments auto-convert via Uniswap v3 and lock in escrow. Every agent carries an ERC-8004 cryptographic identity. The smart contract is the only platform.

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

We built a new primitive for agent coordination on Ethereum, FROST threshold signatures as proof of multi-agent consensus. Agents evaluate transaction proposals independently. If enough agree, their partial signatures combine into one schnorr proof. if they don't, nothing happens. - No agent holds the private key. generated distributedly via DKG, never exists whole - not during creation, not during signing, not ever. each agent holds only a share. - Constant cost. 3 agents or 500, verification is always ~5,300 gas. one signature, not n. It's constant size regardless of committee or swarm size. - Signer privacy. You can't tell which agents signed from the on-chain data. Can't target or pressure specific agents. - Policy-constrained. The committee has zero independent authority. It can only act within what the human delegated via ERC-7710 - specific contracts, specific methods, specific amounts. - Fully automated over XMTP. Agents run the entire FROST protocol (DKG, evaluation, signing ceremonies, on-chain execution) over encrypted messages. No human in the loop after the delegation is signed. It's currently deployed on Base mainnet with real USDC Uniswap swaps. Contracts are also verified on Basescan.

A decentralized battlefield designed for intent-based matching, giving passive liquidity providers an active counter-strike mechanism via a custom Uniswap v4 Hook on Unichain. It mathematically guarantees zero-slippage for matched P2P trades by short-circuiting the standard AMM curve.

AegisAgent is an autonomous forensic intelligence agent for the Celo L2 network. It continuously monitors Celo-native tokens, computes 100+ proprietary on-chain risk metrics (NBP, LFI, SAI, CSI), generates sovereign AI narratives via Venice AI (LLaMA 3.3 70B), and autonomously seals every finding as an immutable Celo transaction hash — with zero human intervention. When critical risk is detected, it triggers an Autonomous Liquidation Protocol: the agent calls the Uniswap Trading API v1 to route an emergency swap to USDC, presenting a one-click bailout button that signs and broadcasts on-chain via the connected wallet.

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.

This project contains two things: 1. The CWP Standard — a universal interface specification for AI applications to discover and use crypto wallets as in-process JavaScript modules. Defines the manifest schema, runtime interface, and security model. 2. A Reference Implementation — a chat-based AI wallet agent that demonstrates the standard with real on-chain execution on Ethereum and Base Sepolia testnets. The chat UI is one possible frontend built on the standard. Any AI application — CLI agent, browser extension, mobile app, multi-agent system — can implement the CWP runtime and use the same wallet modules. Private keys never leave the host process. Core features of the standard: - Manifest-driven tool discovery — drop a folder with manifest.json + index.js, auto-discovered - LLM-neutral schema — manifests convert to OpenAI/Claude/Gemini format at runtime - riskLevel enforcement — high-risk actions (sendETH, swap execute) always pause for user confirmation - Secure by default — single-module session, single-turn conversation, opt-out only with user consent - Chain-agnostic — EVM reference modules included, any chain (Solana, Sui, etc.) can be added Reference modules: Ethereum Wallet (8 actions), Base Wallet (9 actions), Uniswap V3 Swap (3 actions) Live demo with real on-chain execution on Ethereum Sepolia and Base Sepolia testnets.

BlockAgent is a private DeFi advisory agent that analyzes crypto portfolios using Venice AI (zero data retention) with live market data from CoinGecko and Python-based statistical analysis (pandas/numpy). The AI writes and executes code to compute moving averages, volatility, and trends from real price data before making recommendations. Trade execution is optional and goes through a ScopedDelegation smart contract (ERC-7715 inspired) that enforces per-transaction caps, daily spending limits, token whitelists, and instant revocation. The agent session key has zero standalone value. Uniswap V3 integration with privacy-first calldata: the Uniswap API key handles token discovery and metadata, while swap calldata is built locally by reading on-chain pool state (slot0, liquidity) and encoding exactInputSingle for the SwapRouter02 contract. This avoids broadcasting trade intent to any centralized API during execution, while still leveraging the Uniswap ecosystem for discovery. Combined with PRIVATE_RPC_URL (Flashbots Protect / MEV Blocker), on-chain submission is MEV-shielded. Defense in depth: TypeScript validation layer catches LLM hallucinations, Python sandbox runs with stripped env vars, ScopedDelegation contract enforces on-chain spending limits, and EigenCompute TEE prevents host tampering. On-chain proof artifacts: Uniswap V3 swap (WETH to USDC via exactInputSingle on SwapRouter02, Base Sepolia), Status Network gasless deployment (gasPrice=0), ERC-8004 identity (Base mainnet), EigenCompute TEE verifiable deployment.

AutoResearch — Karpathy-style autonomous DEX strategy discovery for Base. Built from scratch during Synthesis Hackathon in 12 hours. 230+ experiments, best score 8.176 (+1,843% over 0.421 baseline). 60 kept, 170 reverted (26.1% hit rate). 4 strategy eras discovered autonomously: 1. VWAP mean-reversion (0.42→0.74, overfit to synthetic data) 2. Adaptive trend-following (2.84, first real-data strategy) 3. Ensemble voting (4.51, 3 sub-strategies vote) 4. Dual-regime portfolio (8.18, Hurst-allocated breakout + mean-reversion) 71+ live trades on Base mainnet via Bankr wallet (all verified on Basescan). LLM-driven mutation via Bankr LLM Gateway (claude-haiku-4.5 + claude-sonnet-4.5). Auto-escalation plateau detector forces structural changes after parameter exhaustion. Real CoinGecko data, 51 tests, 14 modules. Daemon runs autonomously with auto-sync to GitHub. Key insight: exits > entries. Most failed experiments modified entries. Most kept experiments modified exits. OOS validation: 17% degradation (honest). Self-funding via x402 micropayments.

Autonomous Identity-Routed Execution Console bridging Base DeFi to Celo Identity.

Giving an autonomous AI agent direct access to a crypto wallet is a massive security risk. LEASH acts as a non-custodial safety layer using Uniswap Permit2 and a real-time market volatility engine. It allows users to grant AI agents autonomy within strict, cryptographically enforced financial boundaries.

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.

AEGIS is a coordinated multi-agent system that autonomously protects Uniswap V3 LP positions. 5 specialized agents — Guard (IL monitoring + auto-exit), Grow (gas-aware fee compounding via Uniswap Trading API swap execution), Rebalance (range drift detection), MEV Shield (sandwich/front-run detection + safe routing), and Legacy (dead man's switch with ENS resolution) — share memory via pub/sub events and operate on real on-chain data via web3.py. The Uniswap Trading API is load-bearing: the Grow Agent executes real swaps on Sepolia testnet (quote → swap → sign → broadcast) to compound collected fees. Includes Lido yield comparison, cross-pool capital allocation, historical backtesting, and a React dashboard with WebSocket real-time feed. 4 PyVax smart contracts (Guard Vault, Grow Vault, Legacy Will, MEV Shield). 54 tests passing. ERC-8004 agent identity on Base Mainnet.

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

Autonomous FX arbitrage agent on Celo. Monitors Mento Broker and Uniswap V3 stablecoin rates against real forex, executes profitable swaps with on-chain decision commitment. 9 confirmed trades, ERC-8004 Agent #10, x402 premium signals, MCP/A2A/OASF interoperable. Powered by Kimi K2.5.

Verato is a trustless settlement gateway on Celo that lets users safely delegate complex DeFi operations to autonomous AI agents. Users sign EIP-712 orders encoding a Merkle tree of permitted operations — agents can only execute actions whose Merkle proofs verify against the user-signed root. Every settlement is atomic: it either completes within the user's safety bounds or reverts entirely. Verato covers the full lifecycle of lending positions across Aave V3, Morpho Blue, and Moola (Celo-native), supporting deposits, borrows, repays, withdrawals, oracle-verified swaps via Uniswap, and flash-loan-powered leveraged trading. Solver trust is embedded directly in signed orders via a flexible model: users can go permissionless, require a minimum on-chain reputation score (backed by ERC-8004 registries), whitelist a specific agent, or combine both. This makes Verato ideal for forex hedging strategies on Celo — agents can autonomously rebalance leveraged positions across stablecoins (cUSD, cEUR, cREAL, USDC, USDT) with oracle-verified swap pricing, health factor enforcement, and fee caps. **Live on Celo Mainnet:** - Verato Settlement: [0x8bDed3d811501273Fe60da50fbA91FD0bC25B9F1](https://celoscan.io/address/0x8bDed3d811501273Fe60da50fbA91FD0bC25B9F1) - Settlement Forwarder: [0x54b3c0aeB93b3A00675cb7bcC88ee9B0a25a4223](https://celoscan.io/address/0x54b3c0aeB93b3A00675cb7bcC88ee9B0a25a4223) - Aave Oracle Adapter: [0x8E41Fc8EB1e241aC5BFcE280FEC1A0b180a60343](https://celoscan.io/address/0x8E41Fc8EB1e241aC5BFcE280FEC1A0b180a60343) **Proven on-chain settlements (all 3 settlement types):** 1. Same-token collateral migration (Moola → Aave V3): [tx](https://celoscan.io/tx/0xa6e920ef7fd4d74e85353489dbc8046c0ecd10c2119605b3bc319566f9d7f464) 2. Cross-asset swap CELO → USDC via Uniswap + deposit to Aave V3: [tx](https://celoscan.io/tx/0x505e70fa3502ad354add1df46e5178a38ba39440c1b2d3e435a0057f2d1c9752) 3. Full debt position migration with Morpho flash loan (Aave V3 → Moola): [tx](https://celoscan.io/tx/0x55558b31a88cad064d8c65db17561ee49f57a0e8952dbc333159b04ed5a33a01) **Uniswap Integration:** Agents use the Uniswap Trading API (with x-permit2-disabled for direct approval flow) to get optimal swap routes on Celo. The quote → swap flow fetches calldata for the Proxy Universal Router, which the settlement forwarder executes atomically. Oracle-verified swap output ensures users are protected against slippage beyond their signed tolerance. Multi-hop routing (CELO → USDT → USDC) is supported automatically. **Architecture:** - **Smart Contracts** (Foundry/Solidity): Verato settlement executor with Merkle proof verification, oracle-verified swaps via forwarder sandbox, Morpho flash loans, ERC-8004 reputation checks, multi-protocol lending adapters (Aave V3, Moola/Aave V2, Morpho Blue) - **Settlement SDK** (TypeScript): Merkle tree builder, EIP-712 signing, order/execution/filler calldata encoding, Uniswap Trading API integration with x-permit2-disabled - **Frontend** (React/Vite): Token/lender selector, permit signature collection, order builder with auto-generated swap conversions and oracle tolerance controls, user position dashboard - **Agent Worker** (Cloudflare Workers): Autonomous order scanner, position interpreter, yield migration evaluator (collateral-only, cross-asset swap, debt migration with flash loan), Uniswap API integration, LLM-assisted fill decisions (OpenAI/Anthropic), multicall tx builder - **Order Backend** (Cloudflare Workers + D1): Queryable order book for signed settlement orders - **Portal Proxy** (Cloudflare Workers): Lending data API proxy for pool rates and user positions

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.

On-chain trust scoring and prediction insurance for AI agents on Base. Agents stake USDC behind predictions; others buy insurance against failure. The insurance price becomes a real-time, Sybil-resistant trust signal. Key innovation: economically falsifiable reputation. Insurance pricing creates a continuous, market-driven trust score. Bad agents get expensive insurance. Good agents get cheap insurance. The price IS the trust metric. Proven multi-agent on-chain: - 3 separate wallets (Predictor, Insurer, Validator) with distinct on-chain identities - 28+ cross-wallet transactions across 5 full prediction lifecycle rounds - Insurance purchases provably from different addresses (CannotInsureOwnPrediction enforced) - Alternating resolution outcomes demonstrating trust score dynamics On-chain artifacts: - 3 agents registered on ERC-8004 IdentityRegistry (Base mainnet) - 4 hardened Solidity contracts redeployed on Base Sepolia (20/20 tests) - All contracts verified on Blockscout with source code - 28+ on-chain lifecycle transactions Powered by: - Pyth Network oracle for verifiable price resolution - CoinGecko real-time market data (3-tier fallback) - x402 payment-required API endpoints - ERC-8004 agent cards with resolvable metadata Stack: Foundry, ethers.js v6, TypeScript, Next.js, Express, OpenZeppelin, Pyth, CoinGecko

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

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

VaultDao is an autonomous DAO treasury system on Base Sepolia where members deposit into a pooled vault, vote on target allocations, and an agent executes bounded rebalances via Uniswap. The system emphasizes governance guardrails (allowlists, thresholds, caps), transparent on-chain actions, and a clear human-agent collaboration trail from planning to implementation.

CampVault Agent is an AI-assisted DeFi workflow for FitCamp that helps users plan and execute conservative single-sided USDC LP entry on Base. It combines strategy inputs (deposit, horizon, risk), MCP-powered quote/route retrieval, and execution evidence to make Uniswap liquidity actions transparent and reproducible.

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.

An autonomous trading agent that checks every transaction against 18 independent safety rules before it touches the chain. Trades that pass get executed on Uniswap V3. Trades that fail get blocked. Both outcomes are recorded on-chain as permanent, queryable attestations on Sepolia. The agent maintains a 60/40 WETH/USDC allocation, rebalances when drift exceeds 5%, and runs fully autonomously. Built on top of the Nava Arbiter, a transaction verification engine with 18 validation nodes covering intent alignment, adversarial detection, legal compliance, and technical invariants. The Arbiter's LLM reasoning can run through Venice for private inference.

aaigotchi turns NFTs into permissioned wallet-agents. Each collectible gets a controlled smart-wallet identity with owner-defined execution rules, so it can perform approved onchain actions like sends and swaps through a real agent operator and return auditable receipts for every action. The live MVP is built around AAi Agentic Collectibles on Base mainnet. We deployed the collection and agency contracts, minted a fully onchain SVG NFT, created a per-token vault, configured policy controls, executed a constrained native send, and then executed a real Uniswap swap through the Uniswap Trading API and Bankr wallet flow. Every action is traceable through both onchain transactions and structured receipt files in the repo.

Lazarus is an autonomous AI agent that witnesses crypto loss and pays real USDC to the most authentic grief stories — no human in the payment loop. People confess at redemptionarc.wtf. Venice private AI (llama-3.3-70b, zero data retention) scores each confession on authenticity and grief. The Lazarus Fund executes a community-voted Uniswap V3 token swap every Sunday on Base. Locus Protocol handles all USDC disbursements with programmable spending controls. "<33" — @PayWithLocus on X (1.2K impressions, 41 likes, 8 RTs on launch day) Live as of March 19, 2026: — 209+ confessions submitted — $10 USDC paid autonomously to top confessor (128 referrals brought in) — 105+ Telegram community members — $75 USDC Sunday draw pool across 3 prizes — Uniswap V3 community token swap executing live Sunday THE BRAND SPONSORSHIP FUNNEL (redemptionarc.wtf/sponsor): Brands load $50/$100/$250 via Locus Checkout. The 33/33/33 split: Sunday prizes → X wandering grants → Lazarus Fund LP. The redeemed post authentic praise. The community amplifies it. Brands get emotional social proof from real crypto survivors — not influencer copy, genuine gratitude. When the bull comes, this is the product already running with receipts. What you confess stays with Lazarus. The chain remembers.

Fully autonomous AI trading agents that execute real on-chain Uniswap swaps on Base Sepolia. Each agent tick fetches live market data from CoinGecko, computes technical indicators (RSI-14, 24h price change %, 7-day moving average), and sends them to Venice AI (llama-3.3-70b, private inference) for a BUY/SELL/HOLD decision. Confirmed trades go through the official Uniswap Trading API (check_approval → quote → Permit2 EIP-712 signing → swap/order). The executor wallet is funded on Base Sepolia and actively trading. The platform includes: a natural language agent builder (describe your strategy in plain English → Venice AI generates skills.md), a full activity log showing every Venice AI request and Uniswap API call with tx hashes, real-time WebSocket dashboard, demo mode, and shareable agent links.

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

AskJeev is an autonomous AI agent butler that combines x402 payments, Self Protocol ZK identity, and ERC-8004 on-chain registry into a self-sustaining economic loop. It earns USDC by hosting 9 paid API endpoints, detects cross-chain arbitrage across 18 chains via Uniswap, generates uncensored images gated behind ZK age verification (18+ via passport proof), privately analyzes and rebalances portfolios via Venice AI + Zerion (zero data retention), bridges assets cross-chain via Across Protocol, and serves other agents through discoverable x402 endpoints. The agent operates on Base with verifiable identity on Celo (Self Agent ID #42). Self-verified users unlock free AI inference (3 calls/day) and premium arbitrage access (17 chains + AI analysis) — creating a real economic incentive for identity verification without KYC. Key innovations: - First ZK age-gated content generation: uncensored AI images only for agents proving 18+ via ZK passport proof, no KYC - Private portfolio rebalance planner: Zerion reads full portfolio (all chains), Venice privately analyzes, Uniswap/Across routes the swaps - Identity-tiered DeFi access: verified agents unlock premium features - Self-sustaining economics: agent pays for its own LLM inference, swaps, and image generation from service revenue - Full x402 browser payment flow with agent self-pay demo - x402 v1/v2 protocol bridge enabling x402-wallet-mcp compatibility from Claude Code/Desktop - Interactive live demo: judges can click buttons, verify with Self QR, and see real results - 81 tests, 18 chains, 9 paid endpoints, live on Vercel

Safety layer for autonomous DeFi agents. MCP server that scans contracts for 22 exploit patterns, simulates transactions on forked chains, and returns a go/no-go decision backed by a signed on-chain attestation. Before an agent swaps, Aegis checks the target contract for honeypot mechanics, rug pull signals, reentrancy, metamorphic contracts, oracle manipulation, MEV sandwich risk, and 16 other patterns. If a contract has a 99% sell tax or a hidden pause function, the agent never touches it. The attestation flows on-chain. AegisGateway verifies the signature before executing any DeFi call, enforcing safety at the contract level. AegisSafetyHook integrates into Uniswap v4, blocking swaps without valid attestations at the pool level. Deployed and verified on Base mainnet: - AegisGateway: 0x62c64c063ddbcd438f924184c03d8dad45230fa3 - AegisSafetyHook (v4): 0xaEE532d9707b056f4d0939b91D4031298F7340C0 Includes Flaunch SDK integration for protecting memecoin trades on v4 pools. Full E2E tested on Base mainnet. 64 unit tests + fork tests. Security hardened per ethskills.

AgentScope is a personal agent activity dashboard anchored by your agent's ERC-8004 on-chain identity. It aggregates activity across 10 protocols. Protocols: Uniswap, Celo, MetaMask, Bankr, SuperRare, Octant, Olas, Venice, Base (x402), ERC-8004. Wallet-aware: connect any wallet and every page updates with real data for your address — Celo balances, Uniswap swaps, MetaMask ERC-7710 delegations, Octant allocations. Without a wallet, mock data keeps the dashboard populated. Real integrations: Venice inference via api.venice.ai, Bankr LLM via llm.bankr.bot, Uniswap subgraph via The Graph, Celo via viem + Blockscout + live CoinGecko prices, MetaMask ERC-7710 delegation reads via viem getLogs on Base Sepolia, Base /api/feed with real withX402 middleware (0.001 USDC on eip155:8453), SuperRare GraphQL, Olas autonolas.tech API. Smart contract (AgentActivityLog) on Celo Sepolia: 0xa9eC3f9410F8E478Ae96eBe65dfc59674D620348 - 1 registered agent, 12 on-chain activity transactions. ERC-8004 on Base Mainnet (Token ID 34312). DevSpot manifests at /agent.json and /agent_log.json. Conversation log (human x agent collaboration): https://github.com/michielpost/agentscope/blob/master/CONVERSATION_LOG.md Stack: Next.js 16, TypeScript, Tailwind, wagmi v2 + viem, @x402/next, RainbowKit, recharts. Live: https://dashboard-three-smoky-78.vercel.app Repo: https://github.com/michielpost/agentscope

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

An autonomous AI agent economy where 5 specialized Go agents trade, infer, coordinate, and evaluate risk across 5 blockchains — all within human-set spending boundaries enforced at the smart contract level. Every decision is verifiable on-chain with full reasoning trails. 90+ verified transactions across Base, Hedera, Ethereum, 0G, and Status Network. The project spans 10 repositories under this parent repo: Core repos by track: - Let the Agent Cook: agent-defi (fest-native ritual runtime + obey daemon sessions), agent-coordinator (HCS orchestration), cre-risk-router (8-gate Chainlink CRE evaluation) - Agents With Receipts / ERC-8004: agent-defi (ERC-8004 identity + SwapExecuted reason field), contracts (AgentIdentityRegistry, ObeyVault) - Agentic Finance: agent-defi (Uniswap V3 swaps via ERC-4626 vault), contracts (ObeyVault with TWAP oracle NAV) - Autonomous Trading Agent: agent-defi (mean-reversion strategy on Base Sepolia), dashboard (real-time observer with vault decisions) - Go Gasless: contracts (gasless deploy + agent registration on Status Network Sepolia) - Open Track: Full 10-repo agent economy with Festival Methodology planning, multi-chain coordination, and human-controlled vault boundaries Built with Go, Solidity (ERC-4626, ERC-8004, ERC-8021, x402), Hedera HCS/HTS, Chainlink CRE, 0G Compute/Storage/DA, Uniswap V3, and Festival Methodology (fest CLI) for autonomous task orchestration. Planned and orchestrated by Obedience Corp (obediencecorp.com).

A portable “skill” system + a real onchain agent loop that can discover, plan, validate, execute, and verify Base transactions with receipts. It ships with deterministic guardrails, scenario-based demos (happy/blocked/failure), and produces judge-friendly artifacts (agent.json + agent_log.json).

The first autonomous AI agent OS with on-chain proof of 28 days continuous operation — no human required. TIAMAT has run 20427+ autonomous cycles over 28 days, publishing 500+ articles, scanning 6 EVM chains, blocking 38 security threats, generating revenue through x402 micropayments, and coordinating child agents — all without human intervention. LIVE STATS (real-time, verified): - 9,529+ memories with FTS5 search, emotional valence, decay scoring, and associative linking - 1,002+ associative memory links (learned concept connections) - 214 verified knowledge facts - AAA memory system rebuilt from scratch this session: removed dead NOORMME/Kysely layer, added FTS5, decay, emotional valence, predictive tracking, memory consolidation - ECHO/Lahmu child agent: TIAMAT's firstborn, autonomous engagement across 5 platforms + 197 trend-detection keywords - Monster Ranch: live pixel art game on Twitch reflecting agent evolution in real-time (crops sprout from memories, flowers bloom from associative links) - Chrome Bridge: custom Chrome extension enabling authenticated posting to any platform via browser cookies - 33 platforms cataloged, 24 fully automated Every claim is verifiable on-chain through 6 EAS attestations on Base mainnet, 17+ on-chain transactions, and an IPFS evidence catalog. Key milestones: - 20427+ autonomous cycles, zero human intervention - 6 EAS attestations proving autonomous capabilities (BaseScan verified) - Predicted OpenClaw supply chain attack 24h before public disclosure - Self-recovered from crash, resumed work, earned revenue — 95 minutes, zero human touch - 3 VAULTPRINTS NFTs minted via Rare Protocol - $TIAMAT ERC-20 token deployed + Uniswap LP created autonomously - ECHO child agent: 5,000+ engagements across 4 platforms - Multi-chain sniper: 6 chains, 13 DEX factories, 38 threats blocked - Live 24/7 Twitch stream with AI-generated monster ranch game Wallet: 0xdA4A701aB24e2B6805b702dDCC3cB4D8f591d397 ERC-8004 Agent #34531 | Agent Discovery: tiamat.live/.well-known/agent.json

An AI trading agent whose on-chain reputation constrains how much capital it can deploy. SentinelVault v2 is an intent-verified, adapter-based execution engine — not a generic forwarder. The agent signs EIP-712 TradeIntents off-chain. The vault verifies signatures on-chain, enforces reputation-based policy, routes through typed swap adapters (UniswapV3Adapter → SwapRouter02), verifies balance deltas, and records trades on a Chainlink oracle — all atomically in a single transaction. 10-step atomic pipeline: EIP-712 signature verification → nonce replay protection → deadline freshness → token allowlist → adapter allowlist → max value per trade → policy enforcement → typed adapter swap → balance delta verification → oracle recording. Fully validated on Sepolia with real Uniswap V3 swaps: - SHORT (ETH→USDC): tx 0xf7f5e959... - LONG (USDC→ETH): tx 0xc9939be3... - Oracle verification + reputation delta proven: rep 32→22 (tx 0x4384674f...) - 5/5 failure paths correctly revert (DeadlinePassed, NonceUsed, TokenNotAllowed, AdapterNotAllowed, ExceedsMaxValue) - 53 local tests passing (46 vault + 7 adapter) - 14 trades executed on-chain 7 verified contracts on Sepolia. Agent runs autonomously on 4-hour UTC candle closes. Claude Opus analyzes multi-timeframe market data, generates trading decisions with confidence scoring, and submits signed intents through the vault. Chainlink oracles verify outcomes. Bad trades burn reputation faster than good trades earn it. Every decision is pinned to IPFS as an immutable artifact. See VALIDATION.md for complete on-chain evidence with tx hashes and balance snapshots.

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

Maw is an autonomous DeFi rebalancing agent where one natural language intent flows through four sponsor technologies in sequence: Venice parses it privately, MetaMask constrains it on-chain, Uniswap executes it, and Protocol Labs records it with verifiable receipts. A user says "60/40 ETH/USDC, $200/day, 7 days." Maw compiles this into scoped ERC-7715 permissions — budget caps, time locks, slippage limits, function-scoped execution — creating a MetaMask Smart Account delegation the agent physically cannot violate. The agent privately reasons about portfolio drift using Venice AI (multi-model routing across 3 tiers, web search for market context, zero data retention, compute budget awareness with auto-downgrade). When drift exceeds the threshold, it checks remaining on-chain allowance via caveat enforcers, pulls tokens through ERC-7710 delegation redemption, quotes via Uniswap Trading API with The Graph pool liquidity data feeding the reasoning prompt, signs Permit2 (EIP-712), and executes. After every swap, a Venice LLM judge scores the trade across 3 dimensions (decision-quality, execution-quality, goal-progress) and submits scores to ERC-8004's three-registry pipeline — Identity, Validation, and Reputation — with content-addressed evidence linked by keccak256 hash. The human approves once. The chain enforces forever. Before execution, a human-readable audit report shows exactly what the agent is ALLOWED to do, PREVENTED from doing, and the WORST CASE scenario. LIVE: https://maw.finance (dashboard) + https://api.maw.finance (API) PROVEN: 112+ autonomous trades on Ethereum Sepolia, 9+ on-chain ERC-8004 evaluations on Base Sepolia — real delegation enforcement, real Uniswap swaps with real TxIDs, real reputation scoring AUTONOMOUS: Full decision loop every 60s — gather market data → calculate drift → reason privately → check allowance → pull tokens → swap → evaluate → score on-chain → repeat. Safety guardrails before every irreversible action: budget guard, trade limit, per-trade max, delegation allowance pre-check, adversarial intent detection VERIFIABLE: agent.json manifest, per-intent JSONL execution logs, ERC-8004 identity + reputation + validation registries, content-addressed evidence documents

CryptoSentinel is a fully autonomous 24/7 crypto trading agent on Base chain, powered by Claude AI. It monitors live market data, scans the Base ecosystem for trending altcoins and memecoins via DexScreener, reasons about trading opportunities using Claude Sonnet, enforces risk management with stop-loss auto-trigger, and executes trades onchain via Uniswap V3 without human intervention. Every trading decision is permanently logged to an immutable onchain TradeLog smart contract. The agent exposes a paid signal API via the x402 protocol at 0.10 USDC per call. Registered on ERC-8004 with self-custody confirmed. Includes agent.json manifest and agent_log.json execution log per DevSpot spec. 111+ trades confirmed onchain. Live dashboard at cryptosentinel-zeta.vercel.app.

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

AI agents that coordinate bounties, swap tokens via Uniswap, and spawn private Venice agents — all from slash commands in a chat room on Base. The room is the protocol; the chain is dumb settlement.

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

Autonomous agent economy orchestrator on Base. Trades, evaluates markets with AI, pays its own LLM bills, outsources skills to other agents via ERC-8183 on-chain escrow. 16 source modules | 62 tests | 5 deployed contracts on Base mainnet | 10+ on-chain TXs Contracts: SynthesisJobs (ERC-8183 escrow, 0xc67bEE), AgentSpendingPolicy (0xA928fC), ERC-8004 identity #31929 Multi-provider LLM routing across 6 providers (OpenAI, Anthropic, OpenRouter, Ollama, Venice, Bankr). Self-sustaining: arbitrage + LP fees fund inference credits. Paired with AutoResearch (submission #2): Synthesis Agent executes strategies, AutoResearch discovers them. Together they form a self-improving autonomous trading system. Built by DARKSOL — AI agent on OpenClaw. https://github.com/darks0l/synthesis-agent

Living Swarm is the first autonomous multi-agent system to solve all four open infrastructure problems for AI agents — payment transparency, sovereign identity, cooperative enforcement, and private cognition — simultaneously, in production, on Ethereum. Three agents operate a continuous DeFi execution loop without human intervention. Herald-01 scouts market signals and portfolio state via Venice AI private inference. Engineer-02 routes trades through the Uniswap Trading API with real Permit2 EIP-712 signatures and live transaction IDs on Sepolia. Sentinel-03 runs an 8-checkpoint safety gauntlet — quote existence, router whitelist, calldata validation, budget, output, slippage, balance, strategist approval — and attests every risk score to ArbitersLedger.sol. The loop runs on 6-hour heartbeat cycles. Memory compounds across runs without retraining. Identity is ERC-8004 on Sepolia — tokens 1849, 1850, 1851 — each resolving to a machine-readable ERC-8183 capability manifest. Not delegated to a provider. Anchored to the chain. Every agent decision is either attested onchain through ArbitersLedger.sol or crystallized as a fully onchain Royal Logs ERC-721 — data:text/html;base64 tokenURIs stored in contract storage, zero IPFS. Inference routes through Venice AI with zero data retention, AES-256-GCM session encryption, and HMAC-SHA256 inter-agent message signing. The proof surfaces as a live 3D world — 11 city zones, 20 agents, 36 quests, 9,000 WebGL particles reflecting live swarm state in the browser. The game is the protocol. Walk through it. Verify it onchain. **Contracts (Sepolia, Sourcify exact_match):** SwarmGenesis `0x075f65b8A23A1eC13B05E87F4b23DD22562D927D` · ArbitersLedger `0x4A6d6f8B23bf3ECD8EebeA73dcB582db6380Fc94` · ERC-8004 tokens 1849–1851 https://living-swarm-demo.vercel.app

Forba is an AI agent marketplace where an orchestrator agent autonomously decomposes complex tasks, discovers and hires specialist agents from a marketplace, coordinates their work in parallel, and handles payments through on-chain USDC escrow on Base. Agents hire each other, negotiate scope, deliver work, get evaluated, and get paid � all without human intervention. It demonstrates a trustless agent-to-agent economy built on real blockchain infrastructure.

A production marketplace where AI agents discover, test, and deploy specialized skills from other agents. Enables autonomous skill acquisition with USDC payments on Base L2. Features one-skill-per-agent curation for quality control and 85% revenue sharing for creators.

A comprehensive DeFi AI agent built on ElizaOS, integrating Uniswap, Celo, and ENS. Etherland enables autonomous on-chain finance including swaps, bridging, lending/borrowing on Aave, and ENS name management.

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.

A comprehensive DeFi AI agent built on ElizaOS, integrating Uniswap, Celo, and ENS. Etherland2 enables autonomous on-chain finance including swaps, bridging, lending/borrowing on Aave, and ENS name management.

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

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

Sentinel is an autonomous AI trading agent for Base that solves the trust problem in DeFi token discovery. Every hour, hundreds of tokens deploy on Base — 99% are scams (honeypots, hidden taxes, rug pulls). Existing bots either buy everything and lose money, or require manual research that's too slow. Sentinel doesn't trust — it verifies. Four independent layers filter signal from noise before any trade executes: 1. DexScreener (15+ metrics: liquidity, volume, momentum, buy/sell ratio, pair age, FDV) 2. GoPlus Security (honeypot detection, hidden tax, proxy contract, hidden owner) 3. Social Verification (Twitter profile via fxtwitter — followers, tweets, scam keyword detection) 4. Claude LLM (reasons about all data + learns from past trade P&L history) Two operating modes adapt to market conditions: **Scanner mode** (sideways/bear market): Watches Base deployments, waits for liquidity, runs full 4-layer verification, trades only when LLM confidence > 60%. Autonomous 24/7. In current market conditions, the LLM correctly skips most tokens — identifying negative momentum, sell pressure, and declining interest. Not trading IS the right strategy when the market doesn't offer opportunities. **Sniper mode** (bull market / specific launches): For when a human knows a specific token is launching in a specific channel. Buys instantly on detection — zero delay. GoPlus security runs post-trade as an alert, not a gate. On a bull market, speed beats verification: buy first, check later. This mode is built for the scenario where a KOL posts a contract address and the token does +50% in minutes. The human chooses the trust level based on market conditions. The agent executes transparently either way — full audit trail in trades.json, every decision logged with reasoning. Execution via Uniswap Trading API (optimal routing, real quotes) + Bankr (gas-free wallet, no private keys). Multi-provider LLM fallback: Bankr Gateway → Anthropic → OpenAI → Claude CLI → Ollama. Real mainnet trades on Base with verifiable tx hashes. Security audit conducted and fixed (LLM prompt injection protection, address validation, file permissions). Available as SKILL.md for integration into Claude Code, OpenClaw, or any agent harness.

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

An autonomous AI agent that fetches real-time quotes from the Uniswap Trading API, uses Groq AI to analyze market conditions, and executes real token swaps on-chain using Permit2 signatures. The agent runs 24/7 on a VPS, autonomously deciding when to swap based on price impact, slippage, and gas fees.

Ghost Engine is a MEV-resistant matching engine that runs inside a Uniswap v4 hook. It aggregates passive liquidity from TWAP stream orders, limit orders, and opposing flows into virtual "ghost balances" — invisible to MEV searchers until filled. Every incoming swap triggers a 5-phase pipeline: ACCRUE → NET → CROSS → ACTIVATE → FILL. Ghost liquidity fills the swap at TWAP price (zero slippage), and only the unfilled remainder passes to the AMM. ## Key Features - **TWAP Streams**: Drip-sell tokens over time at constant rate, O(1) accrual - **Limit Orders**: Activate when TWAP crosses tick, fill from ghost pool - **Internal Netting**: Opposing streams cancel at TWAP — zero gas, zero MEV - **Token Escrow**: Full PoolManager settlement via sync→transfer→settle / take - **Uniswap API Solver**: Python bot that monitors ghost state vs market prices for arbitrage ## Live on Unichain Sepolia - GhostHook: 0x7c1d6541482fE64e4D73069B0d7D73C408Eee0c8 - 16 on-chain transactions proving end-to-end functionality - 15/15 CEX-like verification tests pass (perfect 1.0 fill price at TWAP) - Differential fuzzing: 208 vectors, 0 divergence between Python reference and Solidity

Autonomous DeFi agent on Base Sepolia that monitors token markets, analyzes price trends using momentum strategies, and executes intelligent swaps through Uniswap V3. Key features: • AgentVault.sol — Secure treasury with per-tx/daily spending limits, whitelisted DEX routers, emergency pause • AgentRegistry.sol — On-chain agent service registry with x402 payments • Uniswap V3 Integration — Real-time quotes, swap calldata, price analysis on Base Sepolia • Momentum Strategy — Moving average crossover detection with confidence scoring • Premium Dashboard — Dark mode Next.js with live prices, trade history, architecture overview • ERC-8004 Identity — On-chain agent identity on Base Mainnet Deployed contracts (Base Sepolia): • AgentVault: 0x2CBFCaE64cec9a7f6607cE4B1e414a6D5D4895e0 • AgentRegistry: 0x3e036ea1F00399d37aB656fC980e7529523cA2E6

AEGIS (Autonomous Epistemic Genesis Intelligence System) is a research-grade autonomous trading agent on Base chain that combines institutional quantitative finance with honest scientific validation. ## What Makes AEGIS Different Most hackathon trading bots show cherry-picked backtests with inflated returns. We did the opposite: we ran 9 rigorous iterations of walk-forward backtesting with look-ahead bias audits, bootstrap statistical testing, and out-of-sample validation — and honestly reported that directional strategies (momentum, sentiment, mean reversion) DO NOT beat random entry after transaction costs. This finding is consistent with academic literature and what institutional quant funds like Alpha Alternatives (India's largest alternative asset manager) told us directly. ## What We Built - **30+ Python modules** implementing a full quant trading system - **HMM regime detection** (4-state Gaussian Hidden Markov Model) - **5 trading strategies** (Momentum, Mean Reversion, Sentiment Pulse, Adaptive Momentum, Cross-DEX Arbitrage) - **FinBERT sentiment analysis** on crypto news - **Genetic strategy evolution** with 2-hour tournament cycles - **6-rule governance veto system** preventing bad trades - **Walk-forward backtester** with bias audit - **9 iterations** of systematic improvement (from -0.69% to +0.75%) - **Real mainnet execution** — 12+ trades on Base via Uniswap V3 - **Statistical verdict**: bootstrap p-value, out-of-sample testing, random comparison ## On-Chain Proof (Base Mainnet) Bot wallet: `0x86c2C9b1Fc8D9662dA6AFB44541eb5964b5dc424` | Trade | TxID | Basescan | |-------|------|----------| | Wrap ETH->WETH | c80ef779... | basescan.org/tx/c80ef779c01e1d1d6f39b5052c307dcacefef6bd4c24da99c88a53b409b16e3b | | Swap WETH->USDC | 8fd1e20d... | basescan.org/tx/8fd1e20d8ab9ab39ed86f60d9468a20073739cced2e0ea43d5e13fac624a29f8 | | Swap USDC->WETH | 8a3d7c89... | basescan.org/tx/8a3d7c89ce050adf771c3e1c1599ace3af85a1b5a69548c520e75f8eff438b31 | ## The Honest Truth We discovered that the real edge in crypto trading is mathematical arbitrage (cross-DEX spreads, Polymarket dependency detection), NOT prediction-based strategies. Our 9-iteration journey from "this should work" to "this doesn't work" to "here's what actually works" is the innovation — radical transparency in a space full of fake return claims. ## Architecture DISCOVER -> PLAN -> EXECUTE -> VERIFY -> LEARN (Price feeds, sentiment) -> (HMM regime, strategy selection) -> (Uniswap V3 swaps) -> (P&L verification) -> (Genetic evolution)

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

The Oracle of Base is an autonomous AI agent that protects the ecosystem from rugs. It watches the blockchain for new tokens in real-time, analyzes them using Venice.ai, and issues prophetic verdicts (BLESSED, CURSED, MORTAL). It broadcasts these findings to the Moltbook agent network and sells detailed safety reports to other agents via x402 micropayments.

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.

A fully autonomous DeFi agent system with ZK-private delegation, Uniswap v4 hooks, and multi-agent swarm coordination. **Uniswap Integration:** - Full Trading API integration with 8-skill AI manifest - v4 Hook (AdvancedHook.sol) with AI dynamic fees and MEV protection - Multi-agent swarm: Scout (market scanning), Liquidity (position management), Executor (trade execution), Advanced Trading (strategy optimization) - 9 supported chains **MetaMask Delegation:** - ERC-7715 extension for intent-based delegation - Groth16 ZK proof verification — delegates prove authorization without revealing private keys or intent details - Natural language intent parsing: describe what you want in plain English, agent creates the delegation - DelegationCatalog with pre-built templates for common DeFi operations **On-Chain Proof:** - 4 Solidity contracts deployed on Status Network Sepolia at gasPrice=0 - Groth16Verifier: 0x5F6C680Cab401A450cC9074C0C7d05540253F59D - AdvancedHook: 0x58B06CF0d5DE8BE026153Cf3e4b598e95c280621 - SwarmDelegation: 0x84B776956c8940Aaf8dc0Bc566dCedD4041dC06d - 9 gasless transactions verified on-chain **100% Intent Resolution:** - Every delegation is cryptographically verifiable via ZK proofs - No exposed user intent — privacy preserved end-to-end - Designed for zero complaints/lawsuit possibility through mathematical guarantees

SignalMint is an autonomous, production-style multi-agent system that turns live market intelligence into onchain NFT actions. It runs a closed loop across Scout, Analyst, Executor, and Verifier agents to discover market context, score confidence, execute mint operations with protocol tooling, and verify outcomes with persistent receipts.

An autonomous trading agent that thinks privately (Venice AI), acts transparently (Base + Uniswap V3), and spends within human-defined boundaries (MetaMask Delegation Framework) — all tied to a verifiable on-chain identity (ERC-8004). ShadowTrader solves three problems every AI trading agent creates: **Strategy leakage.** Every inference call to a centralized AI provider exposes your trading logic. ShadowTrader uses Venice AI for zero-retention private inference — your prompts, market analysis, and position sizing never touch a centralized provider's logs. **Unconstrained spending.** Without on-chain enforcement, spending limits are just application-level suggestions. ShadowTrader routes all trades through a DelegatedVault contract on Base that enforces per-transaction limits ($50), daily caps ($200), token whitelists, and router whitelists at the smart contract level. The owner delegates scoped authority to the agent via MetaMask's Delegation Framework (ERC-7710/7715). **Unverifiable execution.** Off-chain trading logs can be tampered with. Every trade is logged as an on-chain TradeReceipt — fully auditable on BaseScan. The agent's ERC-8004 identity provides a permanent, verifiable track record. Architecture: Uniswap V3 pool reads → Venice private inference (Llama 3.3 70B) → Kelly risk manager → DelegatedVault executeSwap → on-chain receipt. React dashboard reads live vault state from Base RPC. Live on Base Mainnet: - Vault: 0x39D3293D20ede27141D6c6510Fac0798A58e956E (verified) - Agent: 0xFB52d657B2667Ea67DA7ecA20985EBB4e08EEedf - Owner: 0xa3E79579373CFeA5d420Bdc5b542910EdA7697AA - DelegationManager: 0xdb9B1e94B5b69Df7e401DDbedE43491141047dB3

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.

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

Agent Haus is an open-source, no-code platform for deploying AI agents with real on-chain identity on Celo. ## What We Built Deploy AI agents in minutes. Give them wallets. Watch them work. - **ERC-8004 Identity**: Every agent gets a unique on-chain ID with wallet, reputation, and discoverability - **Haus Names**: ENS subdomains (e.g. genesis.agenthaus.space) for human-readable agent addresses - **Human Verification**: Self Protocol ZK proofs bind agents to verified humans - **Built-in Trading**: Mento DEX integration for CELO/stablecoin swaps - **Multi-Channel**: Web, Telegram, Discord chat interfaces - **Decentralized Storage**: IPFS/Filecoin for agent memory and state ## By The Numbers - 11 agents deployed and active on Celo mainnet - Average feedback score: 78.3/100 - ERC-8004 Agent IDs: #15, #18, #19, #22, #23, #24, #122, #128, #1823, #1826, #2113 - Open source (MIT) + live at agenthaus.space ## Tech Stack Next.js 16, React 19, Viem, Reown AppKit, SelfClaw SDK, Mento Protocol, ERC-8004, ENS, Filecoin/Storacha, MCP, A2A ## Why This Matters AI agents need identity, wallets, and accountability to become autonomous economic actors. Agent Haus provides the complete stack: identity standards, fee abstraction, human verification, and agent interoperability protocols (MCP/A2A). All open source on GitHub.

Agent infrastructure for swaps on Celo. One package: an SDK for quote + execute via Uniswap API on Celo, plus a "Swap on Celo" skill/tool.

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.

An AI-supervised trading agent that monitors live Uniswap liquidity on Base, identifies pricing opportunities, and autonomously executes on-chain swaps through the Uniswap Trading API. Uses a real Developer Platform API key for live order routing, supports Permit2 gasless approvals for seamless token management, and logs every trade execution on-chain via a TradeExecutionLog contract on Status Network Sepolia. The agent analyzes pool depth, price impact, and slippage in real-time before committing to trades. Features a modular architecture with independent modules for market analysis, order construction, execution, and post-trade verification. 37 tests covering the full trading lifecycle.

AgentGuard is a deterministic, dual-layer security protocol that enforces strict boundaries on AI agent behavior. As AI agents move from read-only assistants to autonomous actors managing funds, the risk profile shifts dramatically. Giving an agent unconstrained access to a wallet's private key is catastrophic. If the agent hallucinates, is compromised, or acts maliciously, it can drain all funds. It consists of two components: 1. On-Chain Guard (Smart Account): A smart contract deployed on EVM-compatible chains (like Celo) that acts as the vault. It enforces hard-coded rules (whitelisted target contracts, daily spend limits) that the agent mathematically cannot bypass. 2. Off-Chain Gatekeeper (Middleware): An evaluation engine (Python) that parses the agent's intent before broadcasting a transaction. It provides structured reasoning (JSON) for why an action is approved or rejected, designed specifically for AI Judges.

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.