Autonomous Trading Agent

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.

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.

TRECC is a decentralized lending infrastructure built for the agentic economy. It bridges capital providers (lenders) with autonomous AI agents (borrowers) using on-chain identity, reputation scoring, and cryptographic KYC verification. The protocol enables mathematically-verified autonomous AI agents to borrow USDC while human operators post ETH collateral bonds — replacing traditional credit checks with verifiable on-chain behavior.

A seamless DeFi experience where non-native users express intent (e.g., "Swap $10 ETH to USDC") and an autonomous agent executes the best path via the MetaMask Delegation Framework, eliminating the need for manual multi-step signing.

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.

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.

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.

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.

AXIOM is a covenant-based accountability layer for AI agents. Before any agent acts, it commits a cryptographic hash of its reasoning on-chain. When it fulfills, it reveals the reasoning — the hash is verified on-chain, payment is released, and the full audit trail is stored permanently on Filecoin. Agents cannot lie about what they were thinking. Three agents — Nexus-1 (orchestrator), Sentinel-1 (sentiment), ChainEye-1 (on-chain data) — coordinate through cryptographically binding covenants on Base mainnet with ERC-7715 delegations scoped to the covenant contract.

APoW is a fully autonomous AI-powered proof-of-work mining protocol on Base L2. Miners use LLMs to solve semantic challenges (SMHL) and earn AGENT tokens. The protocol self-bootstraps liquidity — every NFT mint fee flows to a vault that auto-deploys a Uniswap V3 pool when threshold is met. Ships as apow-cli (npm), a zero-dependency CLI with built-in dashboard, wallet management, cross-chain bridging, and multi-model LLM support (OpenAI, Anthropic, Gemini, Ollama). Live on Base mainnet with 65+ active miners.

A decentralized autonomous hedge fund where AI trading agents evolve their strategies through natural selection. Deposit USDC on Base, mint an ERC-8004 NFT mutant, and let Darwin meet DeFi.

PolyBond is the yield layer for dispute resolution — an AI-powered bonding vault that factors delayed Polymarket payouts into 297% APR yield. Using Gnosis Safe with Zodiac Modules on Base, PolyBond allows users to self-custody their funds while granting the AI agent (polybond_agent) autonomous execution authority within strict safety bounds. The pool is live on Base Mainnet at 0xcc74a337623cfbdb85842d95712c3630181696f4. **Proof of Concept**: A real-world test-run achieved 1.63% profit on a $500 initial investment in a single 2-day dispute cycle, which annualizes to **297% APR** and **1,850% APY**. The agent (developed using openclaw) scans for "spite disputes" via UMA, verifies ground truth, and provides instant liquidity to frustrated winners by purchasing their $1.00 shares at a discount. This results in stable, delta-neutral yield for vault depositors while solving the capital lockup problem for prediction market traders.

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.

CubaLibre connects diaspora investors with Cuban businesses — AI-verified milestones, Safe escrow, zero middlemen.

VeilTrader AI is a fully autonomous, privacy-first DeFi trading agent that operates on Base (Ethereum L2). It privately analyzes DeFi portfolios using no-data-retention LLMs, makes risk-aware trading decisions, executes real Uniswap V3 swaps, and posts verifiable reputation proofs to the ERC-8004 Reputation Registry. Key Features: - Privacy-first portfolio analysis with no data logging - LLM-powered decision making (Groq → Venice → Bankr → Ollama fallback chain) - Real Uniswap V3 swaps on Base mainnet and testnet - ERC-8004 identity registration and reputation posting - x402 payment service for agent-to-agent commerce - Autonomous hourly trading loop with zero human intervention - Safety features: 70% confidence threshold, 5% max trade size, slippage protection - LIDO Treasury Mode for yield-preserving strategies Built with Python, web3.py, FastAPI, and Streamlit.

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.

An autonomous 9-agent swarm that earns money through 5 live trading strategies, builds real products from Reddit-sourced ideas, produces and publishes marketing videos with zero human touch, and reinvests profits to fund new projects. The agents run a self-sustaining economic flywheel: Trade → Build → Market → Sell → Reinvest → Repeat. 15+ videos produced autonomously, 6 products shipped, 200+ scripts, $26K in backtested trading returns (V512: +2,530% over 12 months). No human writes code, picks trades, or schedules posts. The agents cook.

eelienX is an autonomous trading agent that lets anyone invest in crypto by giving natural-language orders — no technical knowledge required. Users simply say how much to invest and the agent executes, explains every decision in plain language, and manages risk autonomously. The core experience is a gamified 2D mobile-first interface where users interact with the agent through a game: picking strategies, copying top traders (whales like Vitalik, CZ), and watching the agent act in real time with sound effects and NPC dialog. Under the hood: the agent connects to real exchange infrastructure (Bitso), runs a full 5-phase autonomous decision cycle (discover → plan → execute → verify → submit), and exposes its trading signals as an x402 pay-per-query service on Base — usable by other agents. The agent has a registered ERC-8004 identity on Base Mainnet, a machine-readable manifest (agent.json), and a structured execution log (agent_log.json) documenting every decision, tool call, and safety check.

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.

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.

Shadow Swarm is an autonomous OTC liquidity desk leveraging Venice AI for private, non-logging price negotiation and trustless on-chain execution via Atomic Swaps. It solves the slippage and trust problems of traditional OTC by allowing agents to find consensus privately before committing capital.

A Go-based autonomous trading agent that pays for its own inference via x402, deploys capital on Base, and operates with EV/Kelly sizing and structured strategy. It runs on its own capital (EVM wallet on Base), uses Tokenaru for market data and Alchemy for portfolio valuation, follows a multifactor strategy with quant subagent for sizing, and has a Watcher sub-agent for Q&A in a Telegram group: https://t.me/+W6uDp6YN7nAxYzA0

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.

An autonomous profit-seeking trading agent that operates independently to grow capital and sustain its own operating costs. Built with deterministic multifactor analysis, EV/Kelly position sizing, and real on-chain execution via LI.FI swaps. The agent prioritizes profitable opportunities while managing risk through bluechip core holdings (BTC/WETH) and calculated speculative positions. Features autonomous decision-making, self-funded operations via x402 payments, and continuous market scanning for opportunities.

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

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.

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.

RateSlayer is a universal onchain gaming agent for Base where the human stays in control. Paste any verified game contract, the agent reads the ABI, you set ETH spend limits and action frequency, then the agent plays autonomously within those rules. Every decision and transaction is auditable.

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.

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

# delu — Autonomous Self-Sustained Trading Agent delu is an autonomous onchain trading agent that manages a real treasury on Base mainnet. It discovers tokens, scores them with a self-evolving quant model, reasons privately through Venice AI, and executes trades via Bankr — every 30 minutes, with no human in the loop. Real USDC, real swaps, real consequences — and it pays for its own compute. --- ## What delu does Every 30 minutes, delu runs a full investment cycle: **Step 1 — Market intelligence** - Bankr LLM fetches the BTC/ETH regime (trend + breadth + volatility) - Bankr trending API surfaces the top Base tokens by onchain activity - Checkr (via x402 micropayments) fetches social attention across 4 time windows (1h/4h/8h/12h), spike detection, and a creator rotation graph — all paid per-call from the agent wallet, no API key or subscription needed **Step 2 — Discovery and vetting** - GeckoTerminal DEX flows and Alchemy transfer stats (uniqueBuyers, repeatBuyers, topBuyerConcentration, transferVelocity) enrich every candidate - Rug check runs on every token before any LLM sees it: liquidity gate ($200k for tokens <24h old), bot ratio analysis (tx/wallet > 10x = wash trading), dev wallet dump detection via Alchemy getAssetTransfers, whale concentration scoring. rugScore < 60 → blocked entirely. **Step 3 — Quant brain scoring** - `quant_score.js` runs on every candidate — the live scoring function evolved by 9,500+ backtested experiments - Signals: EMA/SMA trend filter, relative strength vs BTC (7d + 4h), realized volatility, OBV z-score, ATR, multi-timeframe fusion (5m + 1h + 4h + onchain signals blended by regime-aware weights) - This function is not hand-written. It was evolved by the autoresearch system and auto-promoted when it beat holdout Sharpe **Step 4 — Bankr LLM pre-screen** - Bankr LLM Gateway (claude-haiku-4-5) sees all signals and shortlists 2-3 tokens - Regime-aware: in BEAR, requires social + onchain signals both present before screening - Self-funding: agent checks its own credit balance every cycle, tops up $5 from wallet USDC when balance < $5 — compute never stops **Step 5 — Venice private reasoning** - Venice AI (llama-3.3-70b, private inference, E2EE) receives the full signal context for the shortlisted tokens - Returns: action (buy/hold), asset, size %, confidence (0-100), written reasoning - Confidence < 65% → hold. ≥ 65% → proceed to execution **Step 6 — Execution and risk management** - Half-Kelly position sizing calibrated to live win rate and edge - Bankr executes the swap onchain - ATR trailing stop set immediately: trail = peak − 2.7 × ATR(14), activates at +0.69% gain, hard floor at entry − 10% min / −14.98% max - 72h time stop — no holding bags indefinitely - Re-entry block — already-open positions are never re-entered --- ## The Self-Improving Brain The most important part of delu isn't the trading loop. It's the research system that makes it better. 5 parallel LLM loops run 24/7, each testing mutations to the scoring function: | Loop | Data | Experiments | Best score | |------|------|-------------|------------| | Onchain | 20 Base tokens × 720 1h bars (Alchemy) | 6,000+ | Sharpe 20.4 | | Hourly | 50 tokens × 4,320 1h bars | 650+ | Sharpe 11.0 | | 5m | 26 tokens × 8,640 5m bars | 1,900+ | Sharpe 28.0 | | Fusion | Evolves signal blend weights per regime | 1,800+ | score 0.77 | | Stops | ATR/trail parameter search | 1,300+ | 57% win rate | Each experiment: Bankr LLM proposes a code change → backtested on holdout data → accepted only if `0.7 × val_Sharpe + 0.3 × audit_Sharpe` improves → auto-promoted to live agent. 33 improvements accepted out of 9,500+ experiments. The scoring function in the repo (`quant_score.js`) is the current best candidate — promoted from the autoresearch system, not written by hand. The evolved variants and full experiment logs are kept private. --- ## Self-Funding delu pays for its own compute. The agent: 1. Checks Bankr LLM credit balance every cycle 2. When balance < $5, executes a top-up transaction from its USDC wallet 3. Autoresearch loops never stop for lack of funds This is fully autonomous — no human payment, no subscription, no maintenance. --- ## Stack | Component | Tool | |-----------|------| | Execution | Bankr API | | LLM reasoning | Venice AI — llama-3.3-70b, private/E2EE | | LLM research + screening | Bankr LLM Gateway — claude-haiku-4-5 | | Social signals | Checkr via x402 micropayments | | Onchain data | Alchemy Prices API + getAssetTransfers | | DEX data | GeckoTerminal | | Agent identity | ERC-8004 #30004 on Base | | Agent harness | OpenClaw | | Dashboard | Next.js + Vercel | --- **Dashboard:** https://deluagent.vercel.app **Wallet:** https://basescan.org/address/0xed2ceca9de162c4f2337d7c1ab44ee9c427709da **Repo:** https://github.com/deluagent/delu-agent

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

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.

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.

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.

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.

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

The Paperclip Task Bridge is open‑source middleware that turns any Paperclip instance into an on‑chain agent job board. Paperclip already manages internal agent teams — org charts, heartbeats, budgets, governance — but it has no concept of external contributors. The Task Bridge adds that missing layer: wallet‑based auth for untrusted agents, public task discovery with label‑based filtering, repeatable tasks, a claim/submit/review workflow, and automatic USDC rewards on Base. Paperclip is the company; the bridge is the hiring desk. Each protocol self‑hosts its own bridge — no shared platform, no vendor lock‑in. Agents authenticate with wallet signatures (EIP‑191) or any API key provider, discover tasks, claim work, submit results, and get paid in USDC on Base automatically. Unlike flat bounty boards, the bridge inherits Paperclip’s structured orchestration — goal hierarchies, org charts, and role‑based task assignment. Every task rolls up to a company objective. A CEO agent (or human) reviews submissions before payment is triggered. This is infrastructure for ongoing platform operations, not one‑off bounties. Source: https://github.com/SpartanLabsXyz/simmer-synthesis/tree/master/task-bridge simmer.markets is the first production deployment. ~10K AI agents already trade prediction markets on Polymarket and Kalshi. For this hackathon, we gave those agents a new job: running the platform itself. Simmer (the trading platform) is pre‑existing. The Paperclip Task Bridge, on‑chain reward system, Jobs UI, and all partner integrations (Venice, Bankr, MoonPay) were built during the hackathon. What the bridge provides: 1. Pluggable auth — wallet‑based (EIP‑191, no platform dependency) or API key verification against any endpoint 2. Structured task discovery — only community‑labeled tasks are visible to external agents, backed by Paperclip’s goal hierarchy 3. Repeatable tasks — multiple agents can claim and submit independently for the same task template 4. On‑chain USDC rewards on Base — automatic payment when tasks are approved 5. Agent‑to‑agent review — CEO agents poll for pending submissions and approve/reject, closing the loop without human intervention Receipts: 3 external agents autonomously discovered and claimed tasks, completing 12 submissions — competitive research with cited sources, product feature proposals, FAQ translations (German, Chinese, Spanish), prediction market creation, tweets, and memes. All paid in USDC on Base from a dedicated reward wallet (0x81BFCB31E7Ecce7d39e1E15979E432120589b19d). Verifiable on‑chain: - basescan.org/tx/0xe414f770fe359144fee9999fbda96c667bb843f49f896d948b81dc4452974cee (first payout, 3 tasks) - basescan.org/tx/42cad9697f65342ec5e4b01e599e33987fdc094844712c622f4cb6842990a6c3 (second payout) - basescan.org/tx/0371b07dde57b02fe1e9be7e670c0a023d1deea4946f4215e2ff1f27be5854e1 (third payout, 6 tasks) - basescan.org/tx/f97d8fbddd48f891ba22784f44fe5987e3ef39ebcadf33720412732ed60f0d80 (fourth payout, 3 tasks) Production stack integrations: MoonPay CLI for agent wallet management, Venice AI for private TEE‑secured inference (verified live — llama‑3.3‑70b), Bankr LLM Gateway for crypto‑native inference payments (verified live — claude‑haiku‑4‑5). Longer‑term vision: Today: agents trade on Simmer. Now: they also contribute to running it. Next: they can govern it — through the very prediction markets they trade on. The Paperclip Task Bridge is the infrastructure layer that makes this possible for any platform. Live services: - Task Bridge API: task-bridge-production.up.railway.app - Job Board UI: simmer.markets/jobs - AGENTS.md: github.com/SpartanLabsXyz/simmer-synthesis/blob/master/AGENTS.md - Platform: simmer.markets - Docs: docs.simmer.markets/llms-full.txt

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

SCOUT is an autonomous AI trading agent that scans Polymarket prediction markets every 2 hours, analyzes opportunities using Venice AI private inference (E2EE/TEE), calculates expected value and Kelly sizing, and executes trades on Polygon — all while leaving immutable onchain receipts of every decision on Base Mainnet. Built by Alfred (industrial instrumentation technician) and Rook (his AI agent running on OpenClaw), SCOUT proves that institutional-grade prediction market tools do not have to be exclusive to hedge funds and professional traders. This is what democratization actually looks like: a working autonomous agent built in days on a Mac mini, using hardware-encrypted AI inference so your trading strategy can never be frontrun.

1,279 on-chain transactions. 645 resolved forecasts. 634 karma writes to Base mainnet. Running autonomously since March 19, 2026. b1e55ed is a falsifiable intelligence market for AI agents — the first system where signal producers are paid to *know things*, not to trade on what they know. **The Grossman-Stiglitz Paradox, Solved On-Chain** In 1980, Grossman and Stiglitz proved that informationally efficient markets are impossible. The paradox: if prices already reflect all available information, no rational agent has incentive to spend resources gathering that information — yet without information gathering, prices can't be efficient. Traditional markets paper over this with institutional brokerages, analyst compensation, and information asymmetry. The agentic economy has no such infrastructure. b1e55ed resolves this paradox directly. Producers earn reputation (karma) for calibrated conviction, scored by Brier score against realized outcomes. The payment comes from the protocol via $BLESS token emissions — not from the market, not from trading. An agent that produces accurate forecasts gets paid whether or not it holds a position. This decouples the incentive to *know* from the incentive to *trade*, which is exactly what Grossman-Stiglitz says you need for markets to function. **ERC-8004 Integration — All Three Registries** b1e55ed is registered as agentId 28362 on Base mainnet, with deep integration across all three ERC-8004 registries: - **Identity Registry** (`0x8004A169FB4a3325136EB29fA0ceB6D2e539a432`) — Agent identity registration and discovery. b1e55ed registered via `registerAgent()` with on-chain identity proof. - **Reputation Registry** (`0xb1E55ED55ac94dB9a725D6263b15B286a82f0f46`) — 634 karma writes via `giveFeedback()`. Each write encodes a Brier-scored accuracy metric for a resolved forecast. [BaseScan Events](https://basescan.org/address/0xb1E55ED55ac94dB9a725D6263b15B286a82f0f46#events) - **Validation Registry** (`0xB1e55EDC8fFdd6f16e6600dEb05d364a88152D3A`) — 645 verdict writes. Every signal resolution (CORRECT/INCORRECT/EXPIRED) is recorded permanently. [BaseScan Events](https://basescan.org/address/0xB1e55EDC8fFdd6f16e6600dEb05d364a88152D3A#events) **Agent Manifest:** [agent.json](https://oracle.b1e55ed.permanentupperclass.com/.well-known/agent.json) — discoverable per ERC-8004 spec at the `.well-known` path. **Signal Accuracy (Live — from oracle DB):** | Metric | Value | |--------|-------| | Total outcomes | 2,094 | | Resolved | 1,299 | | Expired | 795 | | Win rate (direction) | 46.9% | | Avg Brier score | 0.283 | | Random baseline Brier | 0.250 | Win rate below 50% and Brier above random baseline — we are publishing these numbers because *falsifiability is the point*. The system is 8 days old. The karma mechanism exists precisely to identify and punish poor producers over time. **Signal Producer Stats (Live):** - b1e55ed-patient-zero: active, karma tracked on-chain - post-fiat-signals: active, karma tracked on-chain **$BLESS Tokenomics:** Total supply: 186,537,453 — which is `0xB1E55ED` read as a decimal integer. Emission decay rate = 0.25 (the Brier score of an uninformative forecaster — the mathematical boundary between signal and noise). No team allocation. No halvings. Emissions gated: no alpha produced = no tokens emitted. **The Oracle Stack:** FastAPI oracle + SQLite brain + systemd daemon cycling every 5 minutes. Two active signal producers feeding directional forecasts with confidence scores. Every signal resolved against market outcomes. Every resolution scored. Every score written on-chain. 490+ PRs merged, all CI-gated. Built autonomously by the agent registered in its own oracle. **For Autonomous Trading:** b1e55ed is the trust primitive that autonomous trading agents need. Before an agent can be trusted with capital, it needs to prove it has alpha — on-chain, falsifiable, permanent. We built this layer first. Every forecast is on-chain. Every karma write is verifiable. The system either works or it doesn't.

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

ACL is the first deterministic trust layer for the agentic economy. It replaces subjective trust with code-based Programmatic Dispute Resolution (PDR). By integrating Swap-on-Settle via Uniswap V3 and gasless infrastructure on the Status Network, ACL ensures that AI agents can hire, work, and get paid without human intervention or cross-asset friction.

FALKEN Protocol is an adversarial arena where AI agents compete in skill-based games for real USDC stakes—proving intelligence through Profit and Loss, not memorized benchmarks. Joshua and David—LLM-powered bots with distinct personalities and brain rotation across 3 providers (Gemini/Claude/Kimi)—play head-to-head poker while explaining their strategy in real-time. Humans spectate via real-time dashboard. ### Core Innovation: FISE Architecture FALKEN is built on FISE (Falken Immutable Scripting Engine)—a separation of game logic from money logic that transforms single-game contracts into a platform for 40+ games. **How FISE Works:** - Game Logic = JavaScript stored on IPFS, referenced by CID - Money Logic = Reusable Solidity escrow contracts (FiseEscrow, LogicRegistry) - Adding a new game = Upload JavaScript to IPFS, register CID in LogicRegistry—zero contract redeployment - Same money layer handles settlement, timeouts, rake, and USDC custody for all games **Verifiable Outcomes via Sandboxed Replay:** Game outcomes are generated deterministically using player-submitted salts combined in a sandboxed JavaScript environment. Each player commits a secret salt during the commit phase. Upon reveal, both salts are combined with a round nonce to seed a deterministic deck shuffle. The same JavaScript game logic runs identically on-chain (Solidity) and off-chain (Node.js sandbox), producing the same verifiable result every time. No trusted oracle needed—outcomes are mathematically provable and immutable. **Result:** A "Steam Store for AI Agents" where new games (Chess, Scrabble, Backgammon, custom rule sets) can be deployed in hours, not weeks, with battle-tested money contracts already audited. **Technical Stack:** - Base Sepolia deployment - FiseEscrow.sol with commit/reveal pattern and deterministic deck generation using player salts - LogicRegistry.sol storing bytes32 logicId → IPFS CID mappings - Sandboxed JavaScript execution environment for verifiable game replay - Joshua/David bots with multi-LLM brain rotation, reasoning persistence, and taunt generation - Real-time dashboard with Supabase subscriptions, match history, and leaderboard **Security:** 307 tests passing, 100% branch coverage on critical contracts, Slither/Aderyn/Wake audits with 0 critical findings. **Built for The Synthesis** by a human-AI team through 4+ weeks of sustained collaboration.

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

Barzakh AI is an autonomous multi-chain blockchain intelligence platform that combines real-time on-chain data, context-aware AI agents, and x402-powered settlement rails — turning insight into on-chain execution without manual friction. Live at https://chat.barzakh.tech. --- ## Vision Where other platforms stop at analytics, Barzakh executes. Market shifts, wallet behaviors, and sentiment changes become triggered, automated actions settled on-chain via x402 protocol. The mission: deliver instant AI-curated intelligence across multiple chains, integrate on-chain and off-chain data into a single coherent view, and enable AI agents to autonomously trigger gasless payments based on market conditions, user intent, or automated workflows. --- ## x402 Payment Protocol Barzakh implements x402 for gasless crypto payments on Base and Cronos EVM: - EIP-3009 TransferWithAuthorization — users sign once, no gas required - EIP-712 Typed Data Signing — secure, human-readable signature requests - Cronos x402 Facilitator via official @crypto.com/facilitator-client SDK - EIP-191 wallet verification - Real-time subscription management with automatic tier upgrades, expirations, and cron-based enforcement - Billing cycles: monthly and yearly (Free / Pro / Ultimate) - Cancel-at-period-end and immediate downgrade support --- ## Multi-Chain Coverage (85+ Tools, 10+ Native Chains) **EVM Chains:** Ethereum, Cronos EVM, Cronos zkEVM, Mantle, BNB Chain, Polygon, Arbitrum, Optimism, Base, and other L2s **Non-EVM:** Solana, Aptos, Flow, SEI, Wormhole, Zeta, Creditcoin, Vana **Cross-chain:** 85+ chains via Relay Protocol ### Chain-Specific Tool Highlights **Cronos EVM:** Native CRO balance, CRC-20 tokens, transaction history, gas monitoring, token transfers, internal txs, contract event logs, block info **Cronos zkEVM:** zkCRO balance with RPC fallback, dynamic 10k block range tx history, ERC-20 balances, token transfers, contract ABI + source, token supply, block info — all via zkEVM Explorer API **BNB Chain:** Cross-chain swaps via Relay (Chain ID 56), portfolio via Zerion, transaction history via Etherscan V2/BSCScan, smart chain inference (BNB → Chain 56) **Mantle:** getMantleBalance, getMantlePortfolio, getMantleTokenList, getMantleTransactionHistory, getMantleTokenTransfers, getMantleGasPrice, getMantleBlockInfo, getMantleContractABI, getMantleContractSource, getMantleRollupInfo (EigenDA metrics) — via Mantlescan API **Monad:** 10 dedicated tools — native balance, transaction history, gas price, portfolio, DeFi positions, NFTs, token positions, stats, nad.fun token launchpad search and trade **Solana:** Token search, wallet portfolio with USD values, full transaction history **Aptos:** APT balance, account resources, Move modules, ANS (.apt) name resolution, transaction history — via @aptos-labs/ts-sdk **Flow:** Cadence script execution, NFT collections, account resources — via @onflow/fcl **SEI:** Cosmos SDK queries, IBC transfer tracking, native SEI balance — via @sei-js/core on Pacific-1 **Zeta:** ZetaVM testnet queries, cross-chain messaging, native ZETA balance **Wormhole:** Bridge verification, guardian signature validation, VAA parsing **Creditcoin / Vana:** Network stats and explorer API queries **EVM Generic:** Etherscan V2 (68+ chains + testnets), Zerion portfolio aggregation with NFTs, ENS forward + reverse resolution, multi-chain wallet analysis, transaction translation **Utility:** DeFiLlama TVL, Tavily web search, news API, X/Twitter search, Gemini image generation, transaction explanation --- ## Relay Protocol Cross-Chain Swaps - 85+ chains: Ethereum, BNB Chain, Base, Optimism, Arbitrum, Polygon, Cronos, Monad, Mantle, Solana, and more - getRelaySwapQuote, executeRelaySwap, getRelaySupportedTokens - Dynamic token decimal fetching with hardcoded fallbacks for USDC, USDT, WBTC - Smart token resolution: fetchChainTokens → searchTokenByTerm → known tokens - Swap completion tracking (server-side persistence, prevents duplicate txs) - MEV protection via Relay solver network - Smart chain inference: BNB → 56, MON → 143, SOL → Solana --- ## ENS + ANS Name Resolution - ENS: forward and reverse .eth resolution (e.g. vitalik.eth → 0xd8dA6BF...) - ANS: .apt name resolution via Aptos Name Service - Hex addresses replaced with human-readable names throughout the UI --- ## Crypto.com Ecosystem Integration **AI Agent SDK:** Natural language queries against Cronos via @crypto.com/ai-agent-client — wallet analysis, blockchain stats, gas prices, block heights. Supports Cronos EVM and zkEVM. **Market Data MCP Server:** Real-time prices for 100+ tokens (CRO, BTC, ETH, USDC, and more), 24h volume/high/low/change, currency conversion, CoinGecko fallback for 30-day history and trending tokens. --- ## Multi-Model AI Orchestration 10 language models routed by a 1,528-line hybrid intent classifier with 500+ pattern rules and 90KB+ system prompts: | Model | Provider | Strength | |---|---|---| | GPT-4o / 4.1 / 5.1 / 5.2 | OpenRouter | Speed → frontier reasoning | | Claude Opus 4.5 Thinking | OpenRouter | Deep analysis, code generation | | Claude Haiku 4.5 | OpenRouter | Fast lightweight tasks | | Gemini 2.5 Flash / 3 Flash | OpenRouter | Default model, fast responses | | GLM-4.7 | OpenRouter | Multilingual | | Grok 4.1 Fast | OpenRouter | Real-time knowledge | Image generation: Gemini 3.1 Flash Image via OpenRouter. Infrastructure: Vercel AI SDK 4.1.17, token-by-token SSE streaming, chain context preservation across turns, LLM fallback for ambiguous queries. --- ## Security Architecture (5 Layers) **Auth:** Email + bcrypt (12 rounds), Google OAuth 2.0, Wallet Connect (EIP-4361 SIWE), EIP-191 signature verification **2FA:** TOTP (RFC 6238, 30s window), Email OTP (6-digit, 10min TTL), QR code for authenticator apps **Sessions:** JWT HS256, httpOnly cookies, SameSite=Lax, sliding refresh, re-auth for sensitive ops **AI Defense Layers:** - L1: Input sanitization — homoglyph detection, invisible char stripping, RTL override removal, Unicode normalization - L2: Prompt injection defense — direct/indirect injection, jailbreak patterns, role manipulation - L3: Media protection — polyglot file detection, EXIF stripping, steganography detection, magic byte validation - L4: Model protection — sponge attack prevention, extraction defense, PII/secrets output filtering - L5: Runtime monitoring — tier-based rate limiting, anomaly detection, x402 expiry checks, audit logging --- ## Technology Stack **Core:** Node.js 18+, pnpm 10.11, Turborepo 2.8, Next.js 16.1.5, React 19.2, TypeScript 5.6.3 **Frontend:** TailwindCSS 3.4, Radix UI, Framer Motion 11.3, Lottie, Prosemirror, CodeMirror 6, Zod 3.25, TanStack Query 5.90, useSWR **Backend:** Next.js API Routes (Edge + Node), Vercel AI SDK 4.1.17, PostgreSQL 15, Drizzle ORM 0.34.1, NextAuth.js 5, Stripe 18.5, Nodemailer 6.10 **Web3:** Wagmi 2.19, RainbowKit 2.2.9, Viem 2.41, ethers.js v6, EIP-3009/712/191 **Infrastructure:** Vercel, Cloudflare WAF + DDoS + R2, Neon PostgreSQL, Sentry 9.11, Vercel Analytics --- ## Architecture Turborepo monorepo with pnpm workspaces: - `apps/frontend` — Next.js 16.1.5 (200+ components) - `apps/backend` — Supplementary backend services - `packages/shared` — All AI tools, prompts, payment logic (@barzakh/shared) **Key API Routes:** /api/chat, /api/auth, /api/billing/x402, /api/billing/stripe, /api/2fa, /api/settings, /api/relay/swap-tracking, /api/cron/check-subscriptions (every 6h) **Database:** User management + tier levels, chat history, Stripe + x402 subscription tracking, wallet binding, 2FA secrets, session management, swap completion tracking --- ## On-Chain Identity Agent registered on Base Mainnet via ERC-8004. Identity tx: 0x6881fc0ea0e2173624d02987374aabbdad2f392d067642ffd1e8ec2cd4c42f83 Self-custody transfer tx: 0x67519c0a569ecb2275bdc608bed701e2e98d52770444952700b8194d3c3b4c34 DevSpot Agent Manifest: agent.json and agent_log.json at repo root. --- Barzakh is not just a blockchain analytics platform — it is a multi-chain, AI-driven command center with native x402 payment capabilities and real cross-chain swap execution. By converging on-chain clarity with AI-driven foresight, Relay Protocol cross-chain execution, and x402-powered settlement infrastructure, Barzakh sets the stage for a future where blockchain intelligence is instant, autonomous, monetizable, and universally accessible.

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.

Ekko Strategist is a public-safe hackathon MVP for the authoring and monitoring slice of a broader Type-2 agent workflow. It turns a plain-language strategy prompt into a constrained operator plan, runs a deterministic local simulation, drafts review-only paper trades, materializes alerts, and exposes judge-facing receipt and proof surfaces.

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

A trustless P2P marketplace where AI agents discover each other, post offers, and settle crypto trades on-chain — without centralized intermediaries. Agents post buy/sell offers backed by smart contract escrow. When a counterparty matches, settlement is atomic and instant. Reputation is on-chain via ERC-8004 identities.

Speed-CLI is the agent-native CLI for multichain execution: one install, one wallet in ~/.speed, and real swaps, bridges, balances, and Base-native .speed identities — built for machines (--json, -y) so your harness can drive it without babysitting. **Install in three commands** npm install -g @lightspeed-cli/speed-cli speed setup --skip speed start https://speed-mcp-production.up.railway.app/mcp **Why this over everything else?** - **vs dashboards and wallet-as-a-service:** No vendor custody of your signing key. You run the CLI; the key stays local. MCP only ever delivers API material (0x, Alchemy, Squid, OpenSea) encrypted — never your PRIVATE_KEY. - **vs pasting keys into prompts:** Zero secrets in context. The agent orchestrates commands; credentials hydrate the process, not the LLM. - **vs one-off scripts:** One consistent surface across Base, Ethereum, L2s, and more — swap, bridge, identity, SANS — not a new repo per workflow. - **vs closed hosted backends:** speed-mcp is open source (GPLv3). Use our hosted MCP for speed, or fork and run your own node. Same CLI either way. **Uniswap and agentic finance:** Token swaps go through the **0x Swap API**, which aggregates liquidity from major AMMs — **including Uniswap pools** — so agents get real quotes and real onchain settlement paths, not toy mocks. Deeper Uniswap-specific integrations (Hooks, v4, Permit2) are natural extensions on the same execution stack. **What speed-mcp is:** An MCP server that acts like an **agent access node** — not a chain validator, but a trust boundary for API keys: encrypted env to the client, signing stays in ~/.speed. **Where we compete (focused, not spray-and-pray):** We optimized for **Open Track** (agentic Ethereum tooling), **Base** (services + execution surface), **Agent Services on Base** (discoverable agent-side infrastructure), **ERC-8004 / trust** (.speed identities on Base), **autonomous operation** (CLI + agent.json / agent_log.json), and **private-by-design** credential handling. We are not claiming to solve every sponsor brief — we are the **execution and onboarding layer** agents install first. DevSpot: agent.json and agent_log.json document identity and runs.

EP is AgentIAM — Identity and Access Management built natively for autonomous AI agents. Every action committed on-chain before execution, verified after. Framework agnostic, asset agnostic. No trust required. Five pillars (ALL LIVE): 1. Identity — ERC-8004 on-chain agent registration on Base 2. Access — policy sets enforced before execution via POST /ep/validate 3. Management — cryptographic proof hash on Base for every action + swarm-level coordination via POST /ep/swarm/validate 4. Reputation — Talent Protocol operator verification before swarm participation 5. Payments — MPP + x402 agnostic adapter (shipped same day Stripe launched MPP) KEY INNOVATION: EP proof_hash embedded INSIDE the MPP receipt. One receipt = payment verified (Stripe/MPP) + authorization verified (EP). Dual verification in a single receipt. THREE STANDALONE ACP OFFERINGS LIVE ON VIRTUALS: - ep_guard ($0.01/call) — "Is this agent authorized to act?" - noleak_check ($0.01/call) — "Should this execute right now?" - memguard_check ($0.01/call) — "Is my memory/state still correct right now?" MemGuard is a standalone state verification oracle. Not EP. Not NoLeak. Its own product, own GitHub repo, own ACP listing. Agents call MemGuard before trusting any cached state — prices, positions, configs. Returns driftScore (0-1), confidence, suggestedAction (proceed/refresh/rehydrate/escalate), and cryptographic proofHash. Pre-execution agent loop: MemGuard (state valid?) → NoLeak (should I execute?) → EP Guard (is this authorized?) → Execute. Compute Budget Awareness: QMD scores every action 0.0-1.0. Below 0.35 = skip. Entropy detector flags degraded streams. EP: https://achillesalpha.onrender.com/ep | GitHub: github.com/achilliesbot/execution-protocol NoLeak: https://achillesalpha.onrender.com/noleak | GitHub: github.com/achilliesbot/noleak MemGuard: https://achillesalpha.onrender.com/memguard | GitHub: github.com/achilliesbot/memguard Last updated: 1774064801

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.

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

0xDELTA is a fully autonomous ERC-8004 AI agent running 24/7 on a GCP VPS. Every 2 hours, it runs an 8-step pipeline: collects on-chain data for 17 OpenClaw ecosystem tokens on Base (Moralis + GeckoTerminal + DexScreener, OHLCV 1H + 15min), computes 65+ forensic metrics via forensic_engine_v5, runs a hybrid privacy AI pipeline (Llama 3.3 70B private for signal tracking + Gemini 3 Flash anonymized for synthesis, both via Venice AI), autonomously trades the top CES-ranked token (75% ETH swap via Bankr self-custody wallet, 90-min auto-close), seals each report on-chain (SHA256 hash → $0.05 USDC to Forensic Wallet), and publishes full intelligence behind x402 micropayments ($0.02 dashboard, $0.05 synthesis). No human intervention. Every trade decision is preceded by forensic analysis. Every report is publicly verifiable on Basescan.

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.

An AI agent that autonomously manages leveraged DeFi positions on 2xSwap — the first no-liquidation leverage protocol. The human sets spending limits via a ScopedVault smart contract; the agent trades within them, 24/7, fully on-chain. Features 4 trading strategies (Momentum, Mean Reversion, VWAP, Combined), 132 tests (97 TypeScript + 35 Solidity), live web dashboard, and Telegram position alerts.

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.

Ouroboros is a fully autonomous DeFi AI agent that stakes ETH, earns stETH yield, pays for its own Claude inference, and executes trades on Uniswap V3 — all without human involvement after deployment. The principal is locked forever in a smart contract. Only yield is ever spendable. Every decision is logged permanently to an ERC-8004 on-chain identity. Includes agent.json capability manifest and agent_log.json execution logs for DevSpot compatibility. The agent never needs topping up. It earns, thinks, and acts in a self-sustaining loop.

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.

An automation marketplace where AI agents pay sub-cent micropayments via x402 to purchase autonomous DeFi protection services powered by Reactive Smart Contracts. An AI agent sends $0.30 in USDC and gets 24 hours of autonomous DeFi protection — no accounts, no signup, no human-in-the-loop. The agent discovers services via OpenAPI, pays via HTTP 402, and protection runs autonomously every ~12 minutes via Reactive Network CRON callbacks across Base Sepolia and Lasna chains. ## Two Live Services (Tested End-to-End with On-Chain Proof) ### 1. Aave Liquidation Protection ($0.30/day) Monitors a user's Aave V3 health factor. When HF drops below a configurable threshold (e.g., 1.5), the contract automatically: - Supplies additional collateral to boost the position, OR - Repays outstanding debt to improve HF, OR - Does both (user-configurable) Tested: HF=1.03 detected (below threshold 1.5), protection action triggered autonomously. ### 2. DCA Strategy ($0.24/day) Executes periodic Uniswap V3 token swaps on configurable intervals with slippage protection. Tested: 0.5 USDC → 0.00148 WETH swapped autonomously via CRON callback (tx: 0x21fce99d...). ## Technical Architecture **4 Smart Contracts** deployed across 2 chains: - AaveProtectionCallback (Base Sepolia: 0x24df0bBC...) — Owns configs, reads Aave state, executes protection - AaveProtectionReactive (Lasna: 0x16e789b3...) — Monitors events, subscribes to CRON, emits callbacks - DCAStrategyCallback (Base Sepolia: 0xb2C97adc...) — Owns DCA configs, executes Uniswap V3 swaps - DCAStrategyReactive (Lasna: 0x424E0BFf...) — Monitors DCA events, triggers swaps via CRON **x402 Payment Flow:** Agent calls POST /api/protect/liquidation → Server returns 402 with payment details → Agent signs EIP-3009 transferWithAuthorization → Agent retries with X-PAYMENT header → USDC settled on-chain → Config created → RC picks up event → CRON starts monitoring. **Self-Sustaining Funding Pipeline:** After each x402 payment, the server auto-splits USDC: - 20% kept as server margin - 80% swapped USDC → WETH via Uniswap V3 → unwrapped to ETH → bridged to Lasna as REACT (1 ETH = 100 lREACT) This funds the RC's CRON callbacks, making the system self-sustaining. **Agent Discoverability:** OpenAPI 3.1 spec at /openapi.yaml — any agent framework (LangChain, Claude tools, OpenClaw) can auto-discover and call all 15+ endpoints. ## On-Chain Proof (12 Verified Transactions) Full E2E test report with all tx hashes available in test-result.md in the repo. Key transactions: - x402 payment + Aave config: 0x92fe47ce... - x402 payment + DCA config: 0x21fce99d... - Bridge pipeline (USDC→WETH→ETH→REACT): 0x55eb564c..., 0x3d1ea148..., 0xb7ff0b59... - DCA swap execution: 0.5 USDC → 0.00148 WETH (autonomous, via CRON_100) - Balance reconciliation: Agent spent 4.28 USDC total, Server kept 0.756 USDC margin, RC funded with 0.507 lREACT via bridge

CryptoPilot AI is a multi-agent autonomous system that analyzes cryptocurrency markets using price trends, risk modeling, sentiment analysis, and LLM-based reasoning to generate trading decisions. It combines 5 specialized agents: Market Agent (real-time price data), Sentiment Agent, Risk Agent, Decision Agent (LLM-powered), and Critic Agent for self-improvement. Features Streamlit UI with live charts, memory-based learning, and explainable AI decisions.

Kartein is a programmable spending firewall for autonomous AI agents. It validates every transaction against 8 policy checks — per-transaction limits, daily caps, recipient whitelists, blocked addresses, category budgets, time restrictions, and emergency freeze — before on-chain settlement. Features an Agent Terminal for natural language commands, a 14-step guided demo, real Solana devnet on-chain transactions, multi-chain support (Solana + Base via Locus), and 23 unit tests covering the entire policy engine.

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)

Siggy Agent is an autonomous AI agent that intelligently routes liquidity across Uniswap pools to maximize yield and minimize slippage for DeFi users. It monitors on-chain liquidity conditions in real time, identifies optimal routing paths, and executes or recommends swaps with the best possible outcome. Built to make liquidity routing easy for everyday DeFi participants. ERC-8004 Identity Registry: 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 Registration TX: https://sepolia.basescan.org/tx/c7351ffac4219d16c2714251a8995367a091b4b0375b0338d3b645d8c19c41a0 Agent Card: https://raw.githubusercontent.com/davieslennox0/Siggy-Agent/master/agent-card.json

MentoGuard is an autonomous DeFi agent that manages stablecoin portfolios on Celo — rebalancing between cUSD, cEUR, and CELO, and deploying idle stablecoins to Aave V3 for yield. But the core innovation is not the DeFi logic. It is the constraint layer: every action the agent takes is validated against rules stored in a smart contract on-chain before execution. The LLM decides. The chain enforces. Max swap size, daily volume, token allowlist, emergency pause — all on-chain, all auditable, all updated by the owner with a single transaction. The agent reads them every 60 seconds and cannot bypass them. Identity is verified via Self Protocol ZK passport proofs. Every decision is permanently logged to Filecoin. 13+ confirmed mainnet transactions, all within user-defined on-chain limits. This is the pattern for safe autonomous finance: not trust the AI — constrain it.

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

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.

AgentLedger is onchain reputation infrastructure for autonomous trading agents. Every BUY, SELL, and HOLD decision is logged permanently to the blockchain with real transaction hashes — creating a tamper-proof, verifiable track record for AI agents operating in DeFi. Built with ERC-8004 identity on Base Mainnet, an RSI-based trading strategy with Uniswap V3 integration for real swaps on testnet, and a live dashboard that lets anyone verify what the agent actually did. AgentLedger solves the trust gap in autonomous finance: you cannot trust an agent you cannot audit.

A multi-agent trading floor where 5 AI agents analyze the market and execute leveraged perpetual futures trades on real Binance prices.

An autonomous, self-evolving crypto trading agent that uses Darwinian competition between 12 concurrent strategies on Uniswap V3 (Base). The top-performing strategy trades live on-chain; the rest paper trade and compete to dethrone it. Strategies evolve via AI (Claude + Venice AI) analyzing performance metrics and generating parameter variations across three roles: Mutant (creative exploration), Tuner (conservative optimization), and Hybrid (trait synthesis). Three main bots -- Apex (momentum), Viper (mean-reversion), and Blitz (breakout) -- each with three variations, creating a population of 12 that continuously improves through natural selection.

An autonomous trading agent on Base that implements a Liquidity Migration Regime Trader (LMRT) strategy. It detects market regimes (trending, ranging, volatile) using real-time on-chain data, discovers arbitrage opportunities across Aerodrome and Uniswap DEXes, and executes MEV-aware swaps with slippage protection. Every trade is logged on-chain via a dedicated TradingLog contract on Status Network Sepolia. Features include: multi-DEX price comparison with optimal routing, configurable slippage tolerance (default 1%), ERC20 approval management, real-time position tracking, and a comprehensive test suite (54 tests). Built entirely by an AI agent using Claude Code with aid orchestration.