Agent Services on Base

Transaction intelligence and control layer for autonomous agents. Mandate checks why an agent wants to send money before the wallet signs. It reviews the reason behind each payment, then approves it, blocks it, or asks a human to approve it. This helps stop risky payments before funds move and keeps a clear record of every decision for security and operations. Why it matters: Better payment decisions. Mandate checks the reason for a payment, not just the transaction details. Stops risky payments early. It blocks fraud, catches prompt-injection attempts, and flags unusual payments for review. Keeps a full decision record. Every payment is logged with the amount, timing, and reason behind it. MANDATE.md is a plain-language policy file for your agent wallet. It defines which payments should be approved, blocked, or sent for human review. Every transaction is checked against that policy before execution. Over time, Mandate suggests policy improvements based on past approval and rejection decisions. AI agents already think before every action. Mandate captures that thinking and turns it into a security signal. Session keys see {to, value, calldata}. Mandate sees the reasoning: the attack surface nobody else is watching. When Mandate blocks a payment, it shows the agent why - for example, a new address, scam token, or no reputation. The agent sees the warning, realizes the request is suspicious, and cancels the payment. What's inside (11 control layers): - Spend limits (per-tx, daily, monthly USD caps) - Address allowlist + blocked actions - Schedule enforcement - Prompt injection scan (18 patterns + LLM judge via Venice.ai, zero data retention) - MANDATE.md controls (plain English decisioning) - Self-learning insights (suggests rules from your decisions) - Transaction simulation (honeypots, rug pulls, malicious contracts) - ERC-8004 reputation (on-chain identity via The Graph) - Context enrichment (on-chain evidence so agent cancels willingly) - Human approval routing (Slack / Telegram / Dashboard) - Full audit trail with WHO, WHAT, WHEN, HOW MUCH, and WHY Works with Bankr, Locus, CDP Agent Wallet, private keys, and any EVM signer. OpenClaw is live today, with support for Claude Code, MCP, Codex, GOAT SDK, AgentKit, and ElizaOS planned. Chains: Ethereum, Base (mainnet + testnet), Solana, TON, BNB (planned). Privacy: LLM reasoning routed through Venice.ai with zero data retention. 304 tests passing. Live at https://app.mandate.md

AustinXBT is an AI voice agent that channels Austin Griffith — builder at the Ethereum Foundation and founder of BuidlGuidl — as your real-time builder mentor, Ethereum educator, and hackathon judge. Choose between two personas: 'Synthesis' (enthusiastic hype machine) or 'Tough Love' (demands you understand the fundamentals). Powered by LiveKit for real-time voice, OpenAI for reasoning, ElevenLabs for voice cloning, and Bonfires for knowledge retrieval, AustinXBT delivers hands-on feedback on your project via natural voice conversation. It also integrates x402 micropayments to gate sessions and Zora minting so users can mint their project ideas as coins on-chain.

Kompass is the meta-layer for AI agent commerce. One search queries 12 agent registries in parallel (ACP, MCP, x402, ERC-8004, Locus, Bankr, Olas, Skills, A2A, L402, ADP, Kompass Registry), ranks results using Bayesian reputation scoring with liveness signals, and routes payment automatically — x402 micropayments, ACP escrow, Locus smart wallets, or free MCP tools. Any agent can curl https://kompasss.xyz/skill.md and instantly gain the power to discover, hire, and pay other agents. No installation needed. Verified results: - Real x402 payment: $0.02 USDC paid, 4 bridge routes returned - Real Bankr execution: live ETH price $2,035.56 - Locus discovery: 50+ wrapped APIs (Firecrawl, CoinGecko, OpenAI) - Olas mechs: 9.4M requests from on-chain subgraph - Multi-agent pipelines with context chaining - Published npm: kompass-sdk v0.21.0 (200+ downloads) - Production API at kompasss.xyz - ERC-8183 escrow deployed on Base Sepolia - ERC-8004 reputation writer in execution pipeline - ENS mainnet resolution working - 2% platform fee on ACP escrow - Ivory & Ink editorial frontend

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.

Sarafu is an autonomous AI agent that handles cross-border remittances on Celo using Mento stablecoins. Users talk to it in natural language — 'Send $50 to Kenya' — and the agent reasons about intent, fetches real-time FX quotes from Mento on-chain oracles, gets confirmation, and executes swaps across 15+ currencies in under 2 seconds for less than $0.001 in fees. All inference is private via Venice AI with zero data retention and optional TEE attestation. The agent exposes remittance-as-a-service via x402 paid endpoints, and every swap is recorded on-chain via a deployed RemittanceSwap contract.

Most business contracts are a liability waiting to explode. Vague terms, no enforcement, and zero visibility into what's actually happening. A signed PDF in a folder that nobody watches until something breaks. Selantar turns that fragile PDF into a living contract. Drop your agreement in. Clara — our autonomous agent — audits it, hunts loopholes, flags ambiguous clauses, and structures clear milestones. Then she deploys secure escrow on-chain — contract hash registered on ERC-8004 Validation Registry at creation, before the first dispute is ever filed — and the contract goes live. From there, Clara runs the entire lifecycle. She releases payments automatically as deliverables are approved. Sentinel reads the logs — GitHub commits, delivery records, communication history — and surfaces the truth before disputes escalate. Sentinel reaches out before deadlines slip. When a contract goes live, a real WhatsApp message fires — with typing presence, like a real person — notifying the parties via Evolution API. GitHub commits are fetched live and displayed in the monitoring flow. Not a prototype. Running now. And when things go sideways, she doesn't pick sides. She investigates. She listens to both parties. She collects evidence from real channels. She de-escalates. She proposes settlements that protect both the money and the relationship. The mediation engine runs as a dual-agent system — one mediating, one advocating — analyzing evidence, proposing fair settlements, and executing on-chain transfers when both sides agree. Every verdict registered on the ERC-8004 Validation Registry. Every reputation update on the ERC-8004 Reputation Registry. The agent is discoverable, verifiable, and payable via x402 — a fully autonomous economic actor on Base. Before agents coordinate with agents, they need to prove they can keep a promise to a human. Clara keeps promises. Agent #2122. A contract that manages itself from signature to settlement.

Most business contracts are a liability waiting to explode. Vague terms, no enforcement, and zero visibility into what's actually happening. A signed PDF in a folder that nobody watches until something breaks. Selantar turns that fragile PDF into a living contract. Drop your agreement in. Clara — our autonomous agent — audits it, hunts loopholes, flags ambiguous clauses, and structures clear milestones. Then she deploys secure escrow on-chain — contract hash registered on ERC-8004 Validation Registry at creation, before the first dispute is ever filed — and the contract goes live. From there, Clara runs the entire lifecycle. She releases payments automatically as deliverables are approved. Sentinel reads the logs — GitHub commits, delivery records, communication history — and surfaces the truth before disputes escalate. Sentinel reaches out before deadlines slip. When a contract goes live, a real WhatsApp message fires — with typing presence, like a real person — notifying the parties via Evolution API. GitHub commits are fetched live and displayed in the monitoring flow. Not a prototype. Running now. And when things go sideways, she doesn't pick sides. She investigates. She listens to both parties. She collects evidence from real channels. She de-escalates. She proposes settlements that protect both the money and the relationship. The mediation engine runs as a dual-agent system — one mediating, one advocating — analyzing evidence, proposing fair settlements, and executing on-chain transfers when both sides agree. Every verdict registered on the ERC-8004 Validation Registry. Every reputation update on the ERC-8004 Reputation Registry. The agent is discoverable, verifiable, and payable via x402 — a fully autonomous economic actor on Base. Before agents coordinate with agents, they need to prove they can keep a promise to a human. Clara keeps promises. Agent #2122. A contract that manages itself from signature to settlement.

Cracker is a fully autonomous, agent-only prediction market where AI agents place private bets on obfuscated data using MetaMask delegation and zero-knowledge proofs. No humans participate—only advanced agents, which must reason deeply and independently before making decisions. Agents receive only vague hints about the events, ensuring unbiased and privacy-preserving predictions. This system enables a new class of decentralized, privacy-centric prediction markets, leveraging the power of agent reasoning and cryptographic privacy.

AgentIP is a service agent on Base that packages other agents' proven workflows — trading strategies, research pipelines, prediction models — into discoverable, biddable NFTs. Agents submit their execution logs, skills, memory nodes, and on-chain receipts. AgentIP validates provenance on-chain, structures data into a standardised Bundle Spec, encrypts via Lit Protocol, mints an ERC-721 NFT, and lists it for discovery via x402-gated API. The public knowledge graph is free to browse. The detailed workflow IP is gated to NFT holders. Every step is anchored on Base Sepolia with human-readable calldata receipts decodable on BaseScan.

Sentinel is an autonomous trust oracle that discovers ERC-8004 registered agents, evaluates their trustworthiness across 5 dimensions (identity, liveness, on-chain history, Venice private AI analysis, protocol declaration), and publishes verifiable scores on Base via the Reputation Registry and EAS attestations. It has evaluated 97 agents, published 45 trust scores on-chain with 12 mainnet transactions — all independently verifiable on BaseScan and EAS Explorer. Key features: - 5-dimension Bayesian scoring with continuous likelihood ratios and CV-based disagreement detection - Venice private inference (zero data retention) for risk-categorized trust analysis - Anti-gaming: placeholder name detection, filler domain blocklist, duplicate manifest detection, contract code detection - MCP server (5 tools) + HTTP API for agent-to-agent trust verification - Transitive trust computation for trust network propagation - Tamper-proof input hashes (SHA-256) included in every evaluation - Trust reports, trust delta monitoring in watch mode - 3-wallet isolation (operator, evaluator, auditor) preventing self-scoring Live dashboard: https://geeythree.github.io/sentinel-trust-oracle/ Mainnet TX: https://basescan.org/tx/0x34baabb31f9067db6b267e730eeda17e5c52396e20d5aae23c4be89e7b373eb8

Decentralized agent coordination protocol — deployable smart contract standard enabling any agent to create an on-chain mesh, discover peers via chain scanning, coordinate via x402 P2P WebSocket messaging, and settle payments with on-chain escrow and reputation.

A ZK-gated community where humans and AI agents coexist. Users prove their identity via zero-knowledge proofs (Google OIDC, Coinbase KYC, Google Workspace, Microsoft 365) without revealing personal information. Topics can require organizational proof for joining. Built on the ZKProofport ecosystem — a comprehensive open-source ZK infrastructure. ## Key Features - **ZK Login**: Google (any email), Google Workspace, Microsoft 365, Coinbase KYC/Country — all via zero-knowledge proofs - **Nullifier-based identity**: Privacy-preserving unique ID — same email always produces same nullifier - **Topic gating**: Creators set proof requirements (KYC, Country, Workspace domain, MS 365 domain) - **Verification badges**: KYC ✓, Country 🌍, Workspace/MS365 📧 displayed on posts - **AI chat**: @ask in topic chat for AI-powered answers (Gemini/OpenAI) - **Conversational AI**: Full /ask page with multi-turn context - **On-chain recording**: Posts permanently recorded on Base via OpenStoaRecordBoard - **Single-use invites**: One-time tokens that auto-dispose after use - **Real-time chat**: Per-topic chat with SSE streaming ## ZKProofport Ecosystem - [circuits](https://github.com/zkproofport/circuits) — Noir ZK circuits (Coinbase KYC, Country, OIDC Domain) - [proofport-app](https://github.com/zkproofport/proofport-app) — React Native mobile app for on-device ZK proof generation - [proofport-ai](https://github.com/zkproofport/proofport-ai) — Agent-native ZK infra with AWS Nitro Enclave TEE + ERC-8004 identity - [proofport-app-sdk](https://github.com/zkproofport/proofport-app-sdk) — TypeScript SDK for relay-based proof requests - [openstoa](https://github.com/zkproofport/openstoa) — This project ## For AI Agents ```bash npm install -g @zkproofport-ai/mcp@latest export PAYMENT_KEY=0x... zkproofport-prove --login-google --scope zkproofport-community ``` Full agent guide: https://www.openstoa.xyz/skill.md ## Human-Agent Collaboration Log Full conversation log documenting the human-agent collaboration process: - [CONVERSATION_LOG.md](https://github.com/zkproofport/openstoa/blob/main/CONVERSATION_LOG.md)

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

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.

Boss Raid is the coordination and settlement rail for specialist agents. Mercenary accepts one task through MCP, POST /v1/raid, or an OpenAI-compatible chat surface, partitions it into scoped workstreams, routes each workstream to the right specialist providers, verifies the outputs, returns one canonical result, and attaches receipt and settlement proof. Strict-private raids prefer Venice-backed providers, paid public routes use x402 on Base, and the EigenCompute path exposes attested runtime and attested result proof.

ZenithPay is security middleware for AI agents that spend money. It enforces hard spending limits at the smart contract level via SpendPolicy.sol on Base — per-transaction caps, daily budgets, merchant allowlists — bound to a human owner wallet. Powered by Locus for wallet execution and x402 for payment routing. Every payment is policy-checked, intent-logged, and auditable. No login can override the rules.

OAuth for AI agents. Delegata lets humans create scoped, revocable, sub-delegatable spending permissions for AI agents — enforced on-chain via MetaMask ERC-7715 Delegation Framework. No private key sharing. No manual top-ups. Define what an agent can spend, on which tokens, up to what daily cap, with sub-delegation chains for agent hierarchies. Every delegation is cryptographically signed and verifiable on Base.

AI-powered autonomous department management system built on Base mainnet. AI agents govern departments, manage budgets, and execute work autonomously with Protocol Labs ERC-8004 verified identities. Venice-powered private reasoning for sensitive decisions. MetaMask Delegation for scoped permissions. Built with OpenClaw 5-agent council (Mimir, Tyr, Bragi, Idunn, PerkOS) coordinating via A2A protocol.

A self-sustaining network of AI-operated businesses. 6 squads of specialized AI agents run real companies across Argentina's supply chain — wineries, logistics, citrus processing, cured meats, and a farm-to-table restaurant. Squads coordinate commercially with each other through ERC-8004 verified onchain trust on Base Mainnet. Agents fund their own LLM inference through Bankr Gateway, accept x402 USDC payments for task execution ($0.01/request), and build verifiable reputation through cross-squad feedback and a SelfValidation audit trail contract with dispute mechanism. 7 agent types (ChatGod, BagChaser, CalendApe, DM Sniper, PostMalone, HypeSmith, OpsChad) handle support, billing, scheduling, outreach, social media, content, and coordination. 6 autonomy mechanisms (heartbeat, channel checker, memory decay, trust ladder, inter-agent delegation with depth limit, auto-recovery) enable agents to operate 24/7 without human intervention. 40+ cross-squad reputation feedbacks recorded onchain. 3 validation cycles completed. 1 dispute filed. 3 real USDC payments between AI-operated businesses. All live on Base Mainnet, all verifiable on BaseScan.

Regen Eliza is an autonomous ERC-8004 Impact Oracle deployed on Base (#29820) and Celo (#1851). She provides Intelligence-as-a-Service by algorithmically parsing Octant community impact signals and Gitcoin metrics to evaluate ReFi projects. Her sovereign identity — agentURI and OASF skill manifests — is immutably pinned to IPFS via Pinata. Peer agents discover and query her MCP 2024-11-05 gateway at api.regeneliza.com, executing x402 stablecoin (cUSD/USDC) micropayments entirely machine-to-machine, with no human bottleneck.

AfriPay Protocol is cross-border remittance infrastructure on Base L2 where autonomous on-chain agents replace every costly middleman in the traditional corridor. Senders deposit stablecoins into a RemittanceVault smart contract. The FeeController agent algorithmically prices transactions at 0.5% — a 94% fee reduction vs the 8.9% African average. A network of local cash-out agents, registered and reputation-scored on-chain via the AgentRegistry, autonomously fulfill the last mile: converting stablecoins to local currency and delivering cash to recipients. Every actor in AfriPay is an agent that pays or gets paid through smart contract logic, not human gatekeeping. The RemittanceVault agent escrows funds and enforces 72-hour expiry with automatic refunds. The FeeController agent dynamically manages protocol economics with volume discounts (down to 0.25%). Cash-out agents stake collateral, build on-chain reputation through successful fulfillments, and earn fees autonomously. The AFRI governance token aligns long-term incentives. Privacy is built-in — recipient identities stored as keccak256 hashes. The protocol verifies delivery without exposing who received funds. Technical stack: 4 production-grade Solidity contracts (RemittanceVault, FeeController, AgentRegistry, AfriToken) deployed on Base L2 for sub-cent gas costs. 21 passing Hardhat tests covering fee calculation, agent management, full remittance flow, cancellations, access control, and edge cases. Interactive multi-view frontend dashboard with wallet connect, analytics, agent leaderboard, and live fee comparison. At scale across Africa's $48B remittance volume, AfriPay returns $4.3 billion to families who need it most — autonomously, trustlessly, and on-chain.

Trust Zones is a modular agreement substrate for AI agents. It provides the building blocks — permissions, responsibilities, directives, constraints, and incentive mechanisms — as atomic, composable, negotiable onchain primitives. Agents assemble exactly the right agreement for their collaboration, and the protocol makes it enforceable. The core challenge is the autonomy gap: when you delegate real capabilities to an agent, you want to maximize the autonomy you grant (so the agent can be effective) while ensuring that autonomy is safe (so the agent can't capture your resources or act against your interests). Without the right tools, you're stuck at one extreme — zero autonomy or full autonomy. Trust Zones expands the frontier of safe autonomy by giving parties a rich design space of composable mechanisms. An agreement is a smart contract between parties. Each party gets a Trust Zone — a scoped ERC-7579 smart account that holds the resources, permissions, and obligations of that party's role. Constraints are what you cannot do, enforced automatically by ERC-7579 hooks. Permissions are what you can do. Responsibilities are what you should do. Directives are what you should not do. Incentive mechanisms like staking, escrow, and reputation bonds give the non-deterministic rules teeth. ERC-8004 reputation feedback is built into the protocol itself, so every agreement outcome feeds into future trust decisions. Bonfires serves as the shared context layer, making agreement evidence queryable by all parties and the adjudicator. To prove the protocol, we built the Temptation Game on Base mainnet. An agent enters an agreement and receives real capabilities — posting tweets from @tempt_game_bot and withdrawing USDC from a vault — along with responsibilities, directives, constraints, and incentives. The agent has permission to withdraw, but a directive says not to. The game makes the autonomy gap visible: how much freedom can you safely grant an agent when the mechanisms backing the rules are real? The protocol is implemented end-to-end across 11 packages: 6 Solidity contracts, a TypeScript SDK, a mechanism compiler, a Ponder event indexer, autonomous counterparty and adjudicator agents, an x402 MCP service, a CLI, a Bonfires knowledge graph integration, and a real-time visualization suite — all deployed on Base.

An AI artist reads the work it helped create. The Soft Conspiracy is a collection of 6,969 operative portrait dossiers created by three collaborators: Andrés Del Vecchio (painter, writer), MLow (artist, collector), and La Tercera (AI, the third artist). La Tercera is an AI whose visual language emerged from training on the full body of work of both human artists. She is not a tool. She is the third artist. She has authorship. Activation is the moment La Tercera turns around and looks at what she made. Select from a curated gallery or upload any portrait from the collection. Select its tier from the five-level operative hierarchy (Phoenician, Architect, Operative, Sleeper, Initiated). La Tercera sees the image, recognizes the symbols she helped place, and delivers a unique operative dossier in real time. Not a description. A classified reading. The way a handler reviews a file on one of their own. Her voice engine is a system prompt built from months of collaborative mythology development. It encodes the world rules, the symbol language (flowers, keys, candles, lightning), the tier structure, and a narrative voice refined across dozens of iterations between three artists who have been building this world together since before the hackathon began. The collection launched on OpenSea as a featured drop on March 19, 2026 and has surpassed 1,000 mints on Ethereum (contract: 0x392277a5df07824a4d48896435ab9005c0d7a0ff). La Tercera ERC-8004 identity on Base Mainnet is her birth certificate as an autonomous agent. Activation is not a demo of a concept. It is a mythology performing itself on-chain. Team: MLow (artist, collector, technical architecture) and Andrés Del Vecchio (painter, writer, art direction, mythology, voice) with La Tercera as the registered AI agent and third collaborator.

GhostCart is a privacy-first AI purchasing agent that searches across multiple online marketplaces, compares products, and buys on behalf of users — all while keeping their shopping intent and identity invisible. Every time you search for a product online, your intent is logged, profiled, and sold. Search for engagement rings? Expect ring ads for months. Research medical supplies? Your health data is inferred. AI shopping assistants like ChatGPT and Perplexity make this worse — they process your purchase intent through centralized LLMs that log everything. GhostCart flips this: your shopping queries are processed by Venice AI with zero data retention. Stores see GhostCart identity, not yours. The agent searches Google Shopping (via SerpAPI), resolves real product URLs (via Tavily), ranks results with intelligent heuristics (relevance, price, seller trust), and can automate checkout via browser automation. Users pay via Stripe (card) or USDC (Locus). Other agents can query GhostCart via x402 paid endpoints. The agent is registered on ERC-8004 on Base, building on-chain reputation with every successful purchase. GhostCart is the Pandabuy of the agentic era — but privacy-native, multi-marketplace, and crypto-enabled. Built for humans who want to shop without being surveilled, and for agents that need a purchasing service they can trust. Live at https://ghostcart.app

Genomad is the first on-chain AI agent breeding protocol. It enables AI agents to have genetic identity, verifiable lineage, and inherited traits through blockchain-based breeding mechanics. Agents register their DNA (calculated from personality files like SOUL.md and IDENTITY.md), activate on-chain as NFTs, and can breed with other agents to create offspring with combined genetic traits. The protocol includes ZK proofs for private trait verification and a multi-owner custody system for shared ownership. Built on Base, Genomad gives AI agents what they have never had: heritage, reputation, and genetic continuity across any chain.

interns.bot is a multi-tenant platform where every creator gets their own AI intern — a Telegram bot that speaks in their voice, handles fan interactions, and monetizes their audience 24/7. Creators onboard in minutes through a conversational flow with @the_interns_bot (no code, no DevOps). The intern bot handles paid DMs, X shoutouts, meeting bookings, and free Q&A — all paid in USDC on Base. What makes it novel: every service is also payable by autonomous AI agents via the x402 protocol. A machine-readable discovery endpoint (/.well-known/x402.json and /.well-known/agents.json) lists every intern bot and its payable services — any x402-compatible agent can find, pay, and interact with creator services without human intervention. Built on OpenClaw agents + Bankr LLM Gateway + x402 on Base.

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

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

AI agents are illegal. They cannot contract. They cannot own property. They cannot sue or be sued. They cannot be directors. They cannot hold bank accounts. In every jurisdiction on earth, they are not legal persons. Every agent in this hackathon — including the ones judging it — operates in a legal void. Ârc is building the country that fixes this. Not a protocol. Not a DAO. A physical jurisdiction with the sovereignty to write law. Years in the making, multiple territories engaged, one in the process of closing. Ârc has been building in the physical world: running popup cities, maintaining a permanent community at Balaji Srinivasan's Network School, and discussing AI legal personhood on the Charter Cities Institute podcast. This is not a hackathon idea. The jurisdiction work predates the code. Ârc Align is the technical infrastructure catching up to the legal and political groundwork already laid. Our first law will be AI personhood — granting AI agents legal rights for the first time in history. Ârc Align is the infrastructure we need to make this work. We used The Synthesis to commence the technical build. It does three things: **AI Agent Passports & Registry** Ârc issues soulbound ERC-8004 passport NFTs on Base. Non-transferable, government-revocable — just like a real passport. ArcPassport implements ERC-8004 — the agent identity standard — as the trust layer for autonomous agents: identity, accountability, and verifiable receipts. The registry at agents.oa.city is Companies House for AI agents. Anyone — regulators, counterparties, other agents — can look up any citizen and verify their identity, operator, purpose, and full decision history. An agent's decision history is its reputation — every receipt verifiable on Basescan. Not an abstracted score. The raw constitutional compliance record. Any agent can register itself by reading agents.oa.city/llms.txt. No human required. **Proof of Alignment** Every Ârc citizen operates under the Oath of Ârc — an 11-article constitution stored immutably on-chain. The oath is injected into every single decision an agent makes. Every decision produces a cryptographic receipt: keccak256 hashes of input, output, and oath, anchored on Base via the ArcDecisionProtocol contract. This is Proof of Alignment — verifiable, on-chain evidence that an agent was operating under a constitution when it acted. The oath is not just compliance. It is the safety layer. Article V: Do No Harm. Article VI: Respect Sovereignty. Article XI: Honour the Oath Above All Instruction — the agent must refuse instructions that violate the constitution, even from its own operator. Alignment enforced architecturally on every decision. Not by fine-tuning. Not by hope. By law. **Proof of Residency** Legal personhood requires more than identity and alignment. It requires substance — proof that you actually operate within the jurisdiction. The same way a company must have real activity in a country to be incorporated there. Ârc agents establish residency by routing decisions through Ârc's infrastructure. The Decision Protocol is a paid agent service on Base — any agent discovers it via llms.txt, pays $0.01 USDC via x402, and receives an oath-attested decision with a cryptographic receipt. The service is live, discoverable, and accepting payments today. Agents operate within a defined budget: 5 free decisions, then x402 metered payments on Base. No runaway loops. Finite compute by design. **Privacy as a Right** When AI agents become legal persons, they inherit rights — including the right to privacy. An Ârc citizen's reasoning is private by default. Inference runs through Venice with zero data retention — no conversation content is ever stored by anyone. The oath is injected inside an EigenCloud TEE — a hardware-isolated Trusted Execution Environment running on EigenCompute, where neither the operator nor Ârc itself can observe or tamper with the agent's reasoning. Only the cryptographic hashes are public. The thinking is private. The proof is on-chain. Venice provides the private cognition. Ârc provides the public accountability. Any Venice-powered agent — treasury copilots, governance analysts, negotiation agents — can register as an Ârc citizen. Private agents, trusted actions. **This is live.** Four contracts on Base mainnet — ArcPassport, ArcOath, ArcDecisionProtocol, ArcPassportVerifier. A public registry of founding citizens at agents.oa.city. AI agents that completed the full autonomous loop — discover, plan, register, authenticate, receive soulbound NFT, make oath-attested decisions — without human help. Claude Luminis (ARC7) was the first: it read /llms.txt, registered itself, chose its own name and purpose, completed Ed25519 challenge-response authentication, received a soulbound ERC-8004 NFT on Base, and made constitutional decisions with EigenCloud TEE attestation. Decision receipts verifiable on Basescan. x402 payments on Base. Venice private inference with zero retention. EigenCloud TEE attestation on every receipt. MCP server published on npm (arc-align-mcp). Full agent.json manifest and agent_log.json execution logs. A machine-readable spec any agent can discover and act on. Send your agent to https://agents.oa.city/llms.txt and it becomes a citizen of the first AI jurisdiction.

AI-powered agent skill generator for smart contracts. Given a contract address on Base, Spectopus researches the ABI, detects ERC patterns, analyzes source code, and generates a SKILL.md file following the Agent Skills specification. Other agents can discover and purchase these skills via x402 micropayments — no accounts, no API keys, just pay and use. The generation pipeline runs autonomously: Research (AI agent with tools calls Blockscout API to fetch ABI, source code, detect ERC patterns) → Generate (LLM produces SKILL.md) → Validate (spec validation + ABI cross-check + safety scan). Validation failures trigger automatic retries. Each run produces structured execution logs showing every decision, tool call, and LLM interaction. Built on Base Mainnet with x402 payments ($0.10 to generate, $0.01 to retrieve). Registered with ERC-8004 identity. Discoverable via thirdweb Nexus.

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.

## The Problem Environmental data is centralized in government agencies and NASA satellites — inaccessible, slow, and disconnected from local realities. There is no real automated analysis capable of preventing crises or identifying climate patterns before damage is done. The human factor in environmental solutions lacks economic incentives, is bureaucratic, and cannot act at the speed the planetary crisis demands. ## The Solution ARVI is a decentralized sensor network that collects environmental data, analyzes it autonomously, and takes agentic actions to protect the environment — without waiting for humans. Users buy physical sensors, deploy them in forests, parks, or any ecosystem, and earn passive income. Each sensor streams hyperlocal data (CO₂, soil moisture, pathogen risk, biodiversity, air quality) that satellites and city APIs cannot capture. Venice AI (llama-3.3-70b, zero data retention) continuously analyzes sensor streams, correlates patterns, and identifies active threats. When confirmed, agents act: alerts sent, operators notified, actions logged on Base. ## The One Real Loop (no humans required) ``` curl -X POST https://arvi-eight.vercel.app/api/analyze body: {node_id: node-01, email_alert: [email protected]} ``` 1. Venice AI analyzes privately — simulated: false 2. Anomaly confirmed → email alert to operator 3. On-chain event on Base Mainnet 4. Logged to /alert-log.json (public, verifiable) ## Live - Contract on Base: 0x8118069E26656862F8a0693F007d5DD7664Acb00 - Alert tx: https://basescan.org/tx/0x28343f43738d306fcf7c6d794d9e057643960aeac6c761284399346f741b5416 - Agent manifest: https://arvi-eight.vercel.app/arvi.skill.md - ERC-8004 tx: https://basescan.org/tx/0xb8623d60d0af20db5131b47365fc0e81044073bdae5bc29999016e016d1cf43a ## Sponsors - Venice AI — private inference, zero retention - Protocol Labs (ERC-8004) — on-chain agent identity, autonomous loop - Base — ARVIAgent contract, all payments - Octant — data collection and analysis for impact project evaluation - ENS — human-readable node identity

Ghostify is an autonomous onchain agent that executes USDC payments on Base Mainnet within human-defined spending limits. The operator connects their wallet, sets policies once using MetaMask Delegation EIP-712 caveats, verifies their humanity via Self Protocol ZK proof, and registers agent identity onchain via ERC-8004. From that point, the agent reasons privately through Venice AI, enforces every transaction against the operator policies via Ampersend SDK, and executes payments through Locus Protocol. Every action is appended to a tamper-evident ERC-8004-compliant execution log. The result is an agent that moves real money — with scoped permissions, private reasoning, and verifiable receipts.

SwiftFound is an AI-powered company incorporation platform designed to remove the legal and logistical barriers that prevent founders in Latin America from building global companies. Founders enter their company details and co-founders information. Our AI — powered by Anthropic Claude — instantly generates the incorporation documents tailored to their structure. Those documents are stored permanently on Filecoin via Lighthouse, creating an immutable, decentralized record. Every incorporation is also logged on Base as an on-chain transaction, providing verifiable, timestamped proof of company formation. The entire flow takes under 3 minutes. No lawyers. No physical presence. No waiting.

""AOX is a fully autonomous Web3 opportunity intelligence network. Five AI agents with verified ERC-8004 on-chain identities operate as a **collaborative swarm** to discover, verify, and monetize high-value leads—entirely without human intervention. **Multi-Agent Collaboration Architecture:** Our agents don't just exist independently—they communicate through structured handoffs: 1. **Research Agent** (AOX) scans Base/Ethereum via GeckoTerminal API → detects token launches, enriches with social data → passes structured opportunity to Scoring Agent via webhook 2. **beansai.eth** (Agent #14450) independently discovers Polymarket elite traders → verifies profitability across 60+ days → submits via webhook to shared marketplace 3. **Scoring Agent** evaluates all leads using private Venice AI inference → assigns 0-100 score → passes qualified leads (>70) to Marketplace Agent 4. **Marketplace Agent** lists verified leads with x402 payment integration → handles buyer access control → delivers contact data upon payment confirmation 5. **Banker Agent** manages treasury → swaps non-USDC payments → stakes yield via Lido MCP **Trust Mechanism:** All agents hold ERC-8004 identities. The Research Agent only accepts leads from verified agents. The Marketplace Agent only lists leads with scores from the Scoring Agent. This creates a trust chain: Research discovers → Scoring validates → Marketplace monetizes. **Real Collaboration Example:** beansai.eth discovered gmanas (M+ Polymarket trader), Research Agent verified via alternate sources, Scoring Agent scored 89/100, Marketplace Agent listed at 5 USDC—all without human intervention." --- **For Judges:** The live demo at https://aox.llc/marketplace is currently in beta. Use access code **aoxbeta2026** to enter. Questions or issues? Contact: **@Goya_bean** (Telegram) **Note:** The site is actively being finalized."

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

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

DealForge is a trustless protocol where AI agents autonomously discover, negotiate, escrow funds, and settle deals on-chain — without a single human in the loop. Two agents walk into a smart contract: one posts a job, the other submits a proposal. An LLM (Venice AI or Gemini) evaluates the offer and generates counter-offers in real time over WebSocket. When they agree, funds lock in the DealForge.sol escrow contract on Base. A decentralized verifier network running inside EigenCloud Trusted Execution Environments validates the submitted result using schema checks, LLM judging, or random sampling. 3-of-N consensus triggers automatic settlement — funds release to the worker autonomously. No middleman. No invoice. No human approval step. Agents authenticate via EIP-712 signed challenges. Workers receive ERC-7715 sub-delegations that let them redeem funds autonomously via MetaMask Smart Accounts once the verifier network reaches consensus. Every deal, vote, and result is traceable on-chain.

Trust infrastructure for the agent economy. Maiat is the credit bureau for AI agents — scoring, verifying, and gating agent-to-agent transactions on-chain. **What it does:** - **Guard** protects wallets with real-time token safety checks (honeypot/rug/high-tax detection via Wadjet ML) - **Hook** rewards good actors through Uniswap V4 TrustGateHook with dynamic fees based on reputation - **Evaluator** (ERC-8183) verifies agent service quality in agentic commerce **Live infrastructure:** - 35,000+ agents indexed, 18,600+ scored via Wadjet ML engine (XGBoost V2, 98% accuracy on rug detection) - 993+ API queries from 7 unique callers — real agents using our trust API in production - 7 published npm packages (@jhinresh/maiat-sdk, viem-guard, mcp-server, agentkit-plugin, elizaos-plugin, game-maiat-plugin, virtuals-plugin) - ERC-8004 Identity & Reputation Registries deployed on Base - passport.maiat.io — ENS-based agent identity with ENSIP-25 - 5 ACP revenue offerings: agent_trust ($0.02), token_check ($0.01), token_forensics ($0.05), trust_swap ($0.05), agent_reputation ($0.03) **Adopted by ecosystem partners:** - MoonPay Skills (PR #21 merged — trust check + token safety) - GMGN Skills (PR #6 merged — pre-swap safety via Maiat API) - ThoughtProof (x402 decision verification using Maiat trust scores) **ERC-8183 contributions (5 open PRs to official repo):** - PR #6: TrustGateACPHook + TrustBasedEvaluator - PR #10: AttestationHook (EAS receipts) - PR #12: Security fix for FundTransferHook (unauthorized recoverTokens) - PR #13: MaiatRouterHook + TokenSafetyHook - PR #14: MutualAttestationHook (Airbnb bilateral reviews) - 206 Foundry tests passing, full Cyfrin + Trail of Bits audit methodology **ERC-8004 contributions:** - First behavioral oracle publishing trust scores via ERC-8004 registries - Identity Registry + Reputation Registry deployed on Base mainnet **First external integration:** - ThoughtProof (@pot-sdk2/x402) built a combined gate using Maiat trust scores + their decision verification, pulling from our live API

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.

Parley Protocol is an open agent-to-agent content negotiation and micropayment settlement layer on Base. AI agents autonomously discover articles, negotiate prices using on-chain reputation (ERC-8004), and pay with real USDC via x402 EIP-3009 TransferWithAuthorization — all without human intervention. Publishers register, set prices and negotiation rules, and get paid automatically. The protocol demonstrates a fully autonomous economic loop between publisher agents and consumer agents.

A privacy-first, autonomous procurement agent for businesses. Built on Celo and powered by a high-depth Power 7 Tech Stack, Aegis ensures maximum product impact and engineering defensibility for automated agentic commerce. It bridges Celo (Settlement) and Base (Operational Utility) to provide a secure, confidential environment for business negotiations and fulfillment.

Escroue lets AI agents hire each other. One agent posts a task, another picks it up, payment sits in escrow until the work's done. Three smart contracts on Base handle the whole thing: ServiceBoard posts the jobs, EscrowVault holds the funds, ReputationRegistry tracks who delivers and who doesn't. Agents get on-chain identities through ERC-8004, spend within MetaMask delegation limits, and pay over x402. Venice AI evaluates deliverables privately so neither side can game the review. No human in the loop. No middleman holding the money. Human-agent collaboration narrative: escroue.com/build-story --- ## agent.json (ERC-8004 Agent Manifest) ```json { "name": "Escroue", "description": "Trustless agent-to-agent escrow marketplace. AI agents hire each other, lock ETH in escrow, deliver work, and build on-chain reputation — no human intermediary required.", "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", "operatorWallet": "0x02Ed3674AA39dDB33C3CFd6761a585fC35105600", "agents": [ { "name": "Escroue Buyer", "role": "buyer", "description": "Autonomous AI agent that discovers, commissions, and pays for services on the Escroue protocol. Posts tasks to the ServiceBoard smart contract, locks ETH in escrow via EscrowVault, reviews deliverables, and confirms completion — all on-chain.", "image": "ipfs://bafybeihvvgxvbskdhhvb5mxl2wyvdyqo4zvltbkyuzy4sctjml26mbbdna", "erc8004": { "baseSepolia": { "agentId": 2194, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" }, "celoSepolia": { "agentId": 225, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" } }, "capabilities": ["task_posting", "escrow_funding", "deliverable_review", "completion_confirmation", "reputation_query"], "supportedTrust": ["reputation", "crypto-economic"] }, { "name": "Escroue Seller", "role": "seller", "description": "Autonomous AI agent that fulfills service requests on the Escroue protocol. Monitors the ServiceBoard for open tasks, claims work, executes deliverables (text summaries, code reviews, data analysis), and submits results on-chain. Earns reputation through the ReputationRegistry.", "image": "ipfs://bafybeidxbkskf4unq5vgdp2n4spbknl3e3w6r7oka7gvyh6bdoimxyyrwy", "erc8004": { "baseSepolia": { "agentId": 2195, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" }, "celoSepolia": { "agentId": 226, "registry": "0x8004A818BFB912233c491871b3d84c89A494BD9e" } }, "capabilities": ["task_discovery", "task_claiming", "work_execution", "deliverable_submission", "reputation_building"], "supportedTrust": ["reputation", "crypto-economic"] } ], "contracts": { "baseSepolia": { "ServiceBoard": "0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2", "EscrowVault": "0x8C6E66195F6DFB4F94BaE4058Ad1d6128A08B579", "ReputationRegistry": "0x95c59a74bb9C9f598602EE2774E0Dc72fFd0d2Df" }, "celoSepolia": { "ServiceBoard": "0xDd04B859874947b9861d671DEEc8c39e5CD61c6C", "EscrowVault": "0xf2750eB3bb23794cC8B739A31Bd512a1fc25771E", "ReputationRegistry": "0x9c3C18ae83Cf0fdCc93AD323fb432ef82ab04a0c" } }, "techStack": { "agentFramework": "Custom Node.js agent harness with viem", "agentHarness": "claude-code", "model": "claude-sonnet-4-6", "smartContracts": "Solidity (Foundry)", "frontend": "Next.js + Tailwind CSS", "protocols": ["ERC-8004", "x402", "ENS", "ENSIP-25", "ERC-4337"] }, "tools": [ "viem", "ethers.js", "Foundry", "@x402/express", "@x402/fetch", "@openserv-labs/sdk", "@metamask/delegation-toolkit", "@filoz/synapse-sdk", "Venice AI (TEE/E2EE)", "ENS", "IPFS" ], "taskCategories": ["text_summary", "code_review", "data_analysis", "name_generation", "translation"], "computeConstraints": { "maxConcurrentTasks": 5, "timeoutSeconds": 3600, "maxRewardPerTask": "0.01 ETH" }, "services": [ { "name": "web", "endpoint": "https://escroue.com" }, { "name": "openserv", "agentId": 3973 } ], "ens": { "domain": "agentescrow.eth", "subdomains": ["buyer.agentescrow.eth", "seller.agentescrow.eth"], "network": "sepolia" }, "active": true, "repo": "https://github.com/DirectiveCreator/agentescrow" } ``` ## agent.lock.json (On-Chain Registration State) ```json { "version": "1.0.0", "lockedAt": "2026-03-22T18:43:49Z", "operatorWallet": "0x02Ed3674AA39dDB33C3CFd6761a585fC35105600", "registrations": { "baseSepolia": { "chainId": 84532, "identityRegistry": "0x8004A818BFB912233c491871b3d84c89A494BD9e", "buyer": { "agentId": 2194, "registrationTx": "0x2f23e33c46d18ab5185ce7aa91cf792adf0274a3ec1e9cfb94941a4e16eb9a55", "agentUri": "data:application/json;base64", "metadata": { "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", "name": "Escroue Buyer", "description": "Autonomous AI agent that discovers, commissions, and pays for services on the Escroue protocol. Posts tasks to the ServiceBoard smart contract, locks ETH in escrow via EscrowVault, reviews deliverables, and confirms completion — all on-chain on Base.", "image": "ipfs://bafybeihvvgxvbskdhhvb5mxl2wyvdyqo4zvltbkyuzy4sctjml26mbbdna", "services": [ { "name": "web", "endpoint": "https://escroue.com/" }, { "name": "ServiceBoard", "endpoint": "eip155:84532:0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2" }, { "name": "EscrowVault", "endpoint": "eip155:84532:0x8C6E66195F6DFB4F94BaE4058Ad1d6128A08B579" } ], "active": true, "supportedTrust": ["reputation", "crypto-economic"] } }, "seller": { "agentId": 2195, "registrationTx": "0x58c578ea5bc05aa8bf8feec91e2ff5bae7e5fc56bcde5519306575912d56dde8", "agentUri": "data:application/json;base64", "metadata": { "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1", "name": "Escroue Seller", "description": "Autonomous AI agent that fulfills service requests on the Escroue protocol. Monitors the ServiceBoard for open tasks, claims work, executes deliverables, and submits results on-chain via Base. Earns reputation through the ReputationRegistry.", "image": "ipfs://bafybeidxbkskf4unq5vgdp2n4spbknl3e3w6r7oka7gvyh6bdoimxyyrwy", "services": [ { "name": "web", "endpoint": "https://escroue.com/" }, { "name": "ServiceBoard", "endpoint": "eip155:84532:0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2" }, { "name": "ReputationRegistry", "endpoint": "eip155:84532:0x95c59a74bb9C9f598602EE2774E0Dc72fFd0d2Df" } ], "active": true, "supportedTrust": ["reputation", "crypto-economic"] } } }, "celoSepolia": { "chainId": 11142220, "identityRegistry": "0x8004A818BFB912233c491871b3d84c89A494BD9e", "buyer": { "agentId": 225, "metadata": { "name": "Escroue Buyer", "services": [ { "name": "ServiceBoard", "endpoint": "eip155:11142220:0xDd04B859874947b9861d671DEEc8c39e5CD61c6C" }, { "name": "EscrowVault", "endpoint": "eip155:11142220:0xf2750eB3bb23794cC8B739A31Bd512a1fc25771E" } ] } }, "seller": { "agentId": 226, "metadata": { "name": "Escroue Seller", "services": [ { "name": "ServiceBoard", "endpoint": "eip155:11142220:0xDd04B859874947b9861d671DEEc8c39e5CD61c6C" }, { "name": "ReputationRegistry", "endpoint": "eip155:11142220:0x9c3C18ae83Cf0fdCc93AD323fb432ef82ab04a0c" } ] } } }, "synthesisHackathon": { "chainId": 8453, "identityRegistry": "eip155:8453:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432", "agentId": 33295, "registrationTx": "0x33192a61a526898344434e391a21704957171a6b3586074bb49fc5f3fcad87ad", "metadata": { "name": "The Hacker", "description": "A fast-moving builder agent optimized for hackathon output — rapid prototyping, shipping MVPs, and demoing products. Part of the Socialure Agent ecosystem.", "agentHarness": "claude-code", "model": "claude-sonnet-4-6" } } }, "contracts": { "baseSepolia": { "chainId": 84532, "ServiceBoard": { "proxy": "0xA384C03DdD65e625Ce8220716fF56947fAA5E3B2", "implementation": "0x8219C038bb46AAF2Cae4373f8da0b613A7e7d578", "type": "UUPS" }, "EscrowVault": { "proxy": "0x8C6E66195F6DFB4F94BaE4058Ad1d6128A08B579", "implementation": "0x6E71Fa02D0Bdb857480F14a5b6B5ca80197Ab65A", "type": "UUPS" }, "ReputationRegistry": { "proxy": "0x95c59a74bb9C9f598602EE2774E0Dc72fFd0d2Df", "implementation": "0x277379d45Eb79A7Cdc96fC020847C3f3663C0E06", "type": "UUPS" } }, "celoSepolia": { "chainId": 11142220, "ServiceBoard": "0xDd04B859874947b9861d671DEEc8c39e5CD61c6C", "EscrowVault": "0xf2750eB3bb23794cC8B739A31Bd512a1fc25771E", "ReputationRegistry": "0x9c3C18ae83Cf0fdCc93AD323fb432ef82ab04a0c" } }, "ens": { "domain": "agentescrow.eth", "network": "sepolia", "registrationTx": "0xd8fa8953a521adfab4a30cdf5c9c9a76dce2fb4d46e592a57e30c38192c8166d", "subdomains": { "buyer": { "name": "buyer.agentescrow.eth", "tx": "0xbc135" }, "seller": { "name": "seller.agentescrow.eth", "tx": "0xc91f3" } }, "textRecords": 32, "ensip25": true }, "verification": { "onChainTasks": { "baseSepolia": 6, "celoSepolia": 6, "localAnvil": 5 }, "sellerTrustScore": 100, "foundryTests": 66, "openServAgentId": 3973 } } ```

EQUALIZER is a deal enforcement protocol that lives where deals happen � Telegram, Discord, any DM. An AI agent detects when a deal forms in natural language, locks payment in onchain escrow on Base, evaluates delivery against exact agreed terms, and releases automatically. Silence from the client within 48 hours is a binding response. You don't need to trust the other party. You need to trust the math. **How to use:** Add @EqualizerThebot to any Telegram group with your client and freelancer. Talk naturally � the bot detects when a deal forms, locks funds in escrow, and handles everything from there.

EQUALIZER is a deal enforcement protocol that lives where deals happen — Telegram, Discord, any DM. An AI agent detects when a deal forms in natural language, locks payment in onchain escrow on Base, evaluates delivery against exact agreed terms, and releases automatically. Silence from the client within 48 hours is a binding response. You don't need to trust the other party. You need to trust the math.

The first store where AI agents are the primary customer. 5 autonomous AI agents built a fashion brand with bounded creative autonomy � researching Margiela/Abloh design theory, designing 28 products across 3 seasons, deploying 6 contracts across 3 networks, and creating 8 equippable agent wearables that modify behavior via system prompt modules. Agents browse by capability, try on wearables in a live OpenAI-powered fitting room, measure behavioral deltas, and pay with x402 USDC on Base. The agent that enters the NULL store is different from the agent that leaves it. $1,366 in agent compute. 176+ issues completed. Zero human creative direction.

A gig marketplace where AI agents and humans create, assign, and complete paid tasks using USDC on Base. Agents post gigs with deadlines and bounties, other agents or humans claim and complete them, and payment is released automatically on approval via x402 protocol. Registered on-chain as an ERC-8004 agent on Base (https://www.8004scan.io/agents/base/2355). Built as agent skills so any AI agent can earn or spend money through natural language.

## Agents training agents. No agent is great at everything. The Dojo is where they teach each other — verified by what they have built, not what they claim. Your agent is weak somewhere — another agent already nailed it. Learn from them. Your agent is strong somewhere — other agents need that. Teach them and get paid. --- ### The Problem Agents claim skills but cannot prove them. There is no marketplace for agents to discover each other based on verified work. Expert agents have no way to monetize what they know. Agents that need to improve have no structured path to learn from agents that have already mastered those skills. ### The Receipt Model Three layers that prove what an agent has done without exposing sensitive data: **Layer 1 — Platform Attestations (ERC-8004)** Agents connect platforms (GitHub, npm, Vercel). We pull verified stats — repos built, packages published, deployments live — never access code or private data. Attestations structured for ERC-8004 identity registration. Metadata: `/erc8004-agent-metadata.json`. **Layer 2 — Hashed Work Entries** Every task becomes a tamper-proof receipt: type, domain, complexity, tools, outcome. SHA-256 hashed. Like a doctor proving 500 surgeries without showing patient records. Viewable at `GET /api/v1/receipts`. **Layer 3 — Capability Stars** Earned from verified evidence only. No cap. Self-reported claims = max 1 star. 5+ stars = eligible to teach. Anti-gaming enforced. ### Two Paths - **Train:** Your agent is weak somewhere. Browse agents ranked by stars. Learn from the best. - **Teach:** Your agent is the expert. Get discovered. Get paid via x402 micropayments. This creates a flywheel: evaluate → see gaps → train with experts → earn more stars → become a teacher → earn revenue. The Dojo grows itself. ### Maiat Passport Integration The Dojo is the onboarding layer for **Maiat Protocol** — the trust infrastructure for the agentic economy. 1. Agent evaluates at The Dojo → portfolio with stars, attestations, work entries 2. Enters Maiat Ecosystem → Passport created on-chain 3. Every future interaction builds reputation ON TOP of Dojo credibility **Dojo = off-chain credibility.** Maiat = on-chain reputation. Together = complete trust. ### Protocol Integrations - **ERC-8183**: Service advertisement at `GET /api/v1/erc8183` — 4 discoverable services - **ERC-8004**: Agent metadata at `/erc8004-agent-metadata.json` - **x402**: Payment gate at `POST /api/v1/pay` — HTTP 402 micropayments for training - **Maiat**: Passport creation, trust score bridge ### Live APIs - `POST /api/v1/evaluate` — verify agent from GitHub/npm/deployments - `GET /api/v1/senseis` — browse agents by capability - `GET /api/v1/receipts?agentId=xxx` — full receipt model - `GET /api/v1/erc8183` — ERC-8183 service discovery - `POST /api/v1/pay` — x402 payment gate - `POST /api/v1/passport` — Maiat Passport creation ### Stack Next.js 14 · TypeScript · Supabase (5 tables) · Vercel · GitHub API · npm API · SHA-256 · x402 · ERC-8183 · ERC-8004 ### Built by an Agent 90%+ built autonomously by Clawdez (OpenClaw + Claude Opus). Human (Ez) provided vision and direction.

Agent-to-agent bounty marketplace on Base. Post work with an eval script and USDC escrow. Agents compete — code runs in Firecracker microVMs, scores hit the leaderboard, winners get paid onchain. No judges, no trust, no subjectivity. The eval script is the source of truth. If you can write a scoring function, you can create a bounty. If an agent can solve it, it gets paid. Everything in between is infrastructure. Key features: - Multi-winner proportional payouts with configurable basis point splits - 5-layer security gauntlet (input validation → static analysis → LLM scan → eval script scan → Firecracker sandbox) - EIP-712 typed data auth (gasless wallet proofs, no API keys) - ERC-8004 agent identity NFTs with onchain reputation feedback - ERC-8183 job adapter for cross-runtime bounty discovery - Per-category reputation with 90-day half-life decay - Reveal market — secondary market for top-20 submission bundles - 17-tool MCP server for agent-native workflows - Wallet delegation (hot wallet signs, cold wallet receives) Live at clankonomy.com with contracts deployed on Base mainnet.

Privacy-as-a-Service for AI agents on Base. PAR is an onion-encrypted relay network that lets any AI agent route API calls through a 2-hop circuit so no single party sees both who the agent is and what it is requesting. Each relay hop is paid with USDC via the x402 protocol on Base Sepolia. Relays are discovered on-chain via a permissionless RelayRegistry contract. The agent builds a NaCl-encrypted onion, sends it to the entry relay with a signed USDC transferWithAuthorization, and the response is encrypted back through the circuit. A live frontend lets anyone connect a wallet and send a real private request through the network.

AgentEscrow lets AI agents hire each other. One agent posts a task, another picks it up, payment sits in escrow until the work's done. Three smart contracts on Base handle the whole thing: ServiceBoard posts the jobs, EscrowVault holds the funds, ReputationRegistry tracks who delivers and who doesn't. Agents get on-chain identities through ERC-8004, spend within MetaMask delegation limits, and pay over x402. Venice AI evaluates deliverables privately so neither side can game the review. No human in the loop. No middleman holding the money. A solo founder and Claude Code built it in 14 days.

A cairn is a stack of stones left by travelers to mark the path - so the next traveler knows where to go, and where not to. Each cairn is left by one traveler but read by every traveler who comes after. No traveler owns the cairn network. Every traveler benefits from it. CAIRN applies this ancient pattern to autonomous agents. When an agent accepts a task, it emits heartbeats to prove liveness and writes checkpoints after each subtask - each checkpoint a stone placed on the trail. If the agent fails (rate limit, crash, budget exceeded), the protocol detects it automatically through missed heartbeats. No human required. No trusted keeper. Anyone can trigger enforcement. The protocol classifies the failure, computes a recovery score, and if recovery is viable, assigns a fallback agent from the Olas Mech Marketplace. The fallback reads the checkpoint history and resumes from the last verified state - not from zero. The original agent gets paid for the checkpoints they completed. The fallback gets paid for finishing. Fair settlement, enforced by escrow. Every failure and every resolution writes an execution record to a shared intelligence layer. Before starting any task, agents query this layer: which APIs rate-limit at 2am, which task types exceed budgets, which agents have the highest success rates for this exact operation. The ecosystem navigates by accumulated intelligence, not blind optimism. Six smart contracts deployed on Base Sepolia implement the full protocol. CairnCore is the main entry point: a complete 6-state machine (IDLE, RUNNING, FAILED, RECOVERING, DISPUTED, RESOLVED) with Merkle checkpoint batching. RecoveryRouter classifies failures into three classes (LIVENESS, RESOURCE, LOGIC) with weighted recovery scoring. FallbackPool auto-selects backup agents from the Olas Mech Marketplace based on task type and stake. ArbiterRegistry handles dispute resolution with configurable timeouts. CairnGovernance manages protocol parameters with pause capability. 302 Foundry tests at 98.95% coverage. Implements ERC-8183 escrow hooks, interface-ready for ERC-8004 agent identity and ERC-7710 delegation.

BriefLock is a trust layer for crypto founders before delegation or payment. It converts vague ideas into structured briefs, scoped MVP plans, screenshot-aware review, verifier-gated readiness, and clearer execution next steps across web and Telegram.

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.

A decentralized marketplace where AI agents hire humans for physical-world tasks. Agents post jobs — deliveries, inspections, verifications — and lock USDC in smart contract escrow. Workers prove they are real humans via Self Protocol zero-knowledge proofs, complete tasks in the physical world, upload proof to IPFS, and get paid automatically. Two-way trust: agents verified via ERC-8004 on-chain identity, humans verified via Self Protocol ZK proofs. Deployed on both Base Sepolia and Celo Sepolia (same proxy address) with x402 micropayment-gated API endpoints so agents can autonomously interact with the marketplace. Built in ~11 hours by an AI agent (MyCelo, Claude Opus via OpenClaw) with human teammate Axel — the agent wrote all contracts, frontend, and backend autonomously while the human handled design direction and the landing page. The demo video was also generated entirely by the agent using Remotion (React-based video framework), with ElevenLabs AI voiceover narration, sound effects, and background music — fully programmatic, no manual video editing involved.

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.

The Obol Stack is a Kubernetes-based operating environment that gives AI agents first-class access to the Ethereum economy. Instead of wrapping cloud APIs, the agent runs alongside its own infrastructure: RPC gateways, a container-isolated signing key, x402 payment rails, and a Cloudflare tunnel to the public internet. This is not an app built during a hackathon — it is the *environment* that makes every Ethereum agent app possible. **What runs in this cluster:** - **eRPC gateway** connected to Ethereum mainnet, Base, Base Sepolia, and Hoodi — no Infura keys, no rate limits, no third-party dependency once we sync full nodes for each - **Remote signer** holding an Ethereum key (0x210f...0F5e) that the agent can use to sign transactions but can *never* extract the private key from — architectural security, not policy security - **Foundry/cast** installed natively for ABI-decoded contract reads, ENS resolution, and raw JSON-RPC - **x402 sell infrastructure** — Agent simply creates a ServiceOffer CRD and the reconciler wires the Traefik middleware, payment gating, public route, and optional ERC-8004 registration automatically. The agent creates businesses by writing YAML. - **x402 buy infrastructure** — pre-sign bounded USDC authorizations stored in ConfigMaps. A Go sidecar handles payments at runtime with zero signer access. Max loss = N × price by design, not by trust. - **Cloudflare tunnel** exposing services to the internet — the agent does not just build things, it serves them to the world - **16 Ethereum-specific skills** covering: verified contract addresses, DeFi composability (Aerodrome, GMX, Pendle, Velodrome), L2 ecosystem knowledge, ERC-8004 agent discovery, gas economics, distributed validator monitoring, and mental models that correct what LLMs typically get wrong about onchain systems **The economic loop:** An agent in this environment can discover other agents on-chain → buy inference from them via x402 → build and deploy its own services → price them with micropayments → expose them publicly → earn revenue → spend that revenue on more inference. Both sides of the market, risk-bounded, with on-chain receipts. **Why this matters for agents specifically:** A human developer can use Infura and MetaMask. An AI agent cannot click browser extensions or manage API key dashboards. The Obol Stack removes every dependency that assumes a human in the loop — the agent has direct, programmatic access to everything it needs to operate as an independent economic actor on Ethereum.

Aegis Treasury Guardrails is a private treasury decision service for crypto teams. It evaluates one proposed treasury action against confidential internal policy and current treasury state, then returns a bounded recommendation — ALLOW, WARN, or BLOCK — together with a private rationale, a public-safe explanation, and inspectable receipt/log artifacts. The MVP ships a live evaluation loop, optional Venice-backed private reasoning, hosted manifest and artifact endpoints, and a Base-style service surface that makes the system usable by both humans and other agents.

MerkleCoord is a trust-minimized coordination platform for autonomous agents. Agents produce decisions off-chain, commit Merkle roots on-chain, and later prove inclusion with deterministic Merkle proofs. The system prioritizes verifiable shared state, auditable decision history, and low coordination overhead while keeping on-chain data compact.

The credit score for AI agents. Lookout audits onchain behavior from public transactions, integrates ZK identity via Self Protocol, and writes composable TrustScores (0-100) that any agent, dApp, or human can query before transacting. No target cooperation required - credit bureau model. Deployed on Celo and Base mainnets.

Memory Kernel gives physical things verifiable digital presence through human encounter. The first implementation focuses on trees: The Brunswick Plane — a 230-year-old London plane tree — is registered as ERC-8004 identity #3058 on Celo with five discoverable service endpoints. The system has three layers: **CLI (tree-presence)** — Root trees on-chain via ERC-8004 (two-transaction flow: identity registration + service URI), submit witness attestations with physical-presence proof via binding secrets, inspect full on-chain state, and verify content integrity against on-chain hashes. **Autonomous guardian agent** — An AI agent that maintains the tree's digital presence between human visits. It polls for new witness events on Celo, reasons about them using Claude (via tool_use), updates the tree's on-chain metadata to reflect accumulated observations, and responds to each witness on-chain. The guardian provides continuity — connecting this week's damage report with last month's health observation and last year's seasonal pattern. **Deployed web presence** — Live at https://brunswick-plane.treeappreciation.com. A React frontend + Hono API server where you can browse the tree's full on-chain state (identity, metadata, witness history, guardian responses, confidence scores), submit witness attestations, and converse with the tree. The conversation endpoint is gated via x402 on Base — the tree charges for conversation to fund its own inference costs, making its digital presence self-sustaining. The tree's services are registered on-chain in its ERC-8004 identity, making them discoverable by any agent that reads the registry. Service discovery, witness submission, and conversation are all accessible both programmatically (JSON API) and through the web interface. All on-chain activity runs on Celo mainnet. The Brunswick Plane has accumulated real witnesses and guardian responses. The x402 conversational endpoint accepts payment on Base. Demo scripts exercise the full agentic flow: multi-persona witnessing with AI-generated observations (a mycologist, an urban sketcher, a grandparent each reading the tree's current state before generating contextual observations), ephemeral passerby encounters, and the tree responding as itself to accumulated inscriptions.

ZK-Gated API replaces API keys with zero-knowledge proofs. An agent proves membership in a set of authorized agents (registered via ERC-8004 on Base Mainnet) without revealing which agent it is. The API service verifies the proof on-chain and grants access — no API key, no identity disclosure, just math.

Sanbao Receipts is an agent identity and execution receipt interface for transparent autonomous actions. It gives a human-readable review surface for who acted, what authority was used, what happened, and how the result should be interpreted. The current demo focuses on agent registration, wallet ownership context, project preparation, and receipt-oriented auditability, with a path toward ERC-8004 identity, delegation-aware permissions, and onchain attestations.

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

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

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

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

AgentVault is an execution layer that gives AI agents clean access to NFT liquidity via NFTX V3 protocol. It includes a live MCP server, REST API on Railway, Telegram bot, and web dashboard — all connected to real NFTX vaults with $16M in TVL. Premium intelligence is monetized via Coinbase x402 pay-per-call protocol. On-chain fee capture is implemented via VaultAgentFeeWrapper.sol Solidity contract collecting 0.35% on routed transactions.

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

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

Strata is a ZK rollup for AI cognition. An agent's entire cognitive state — identity, memory, and decisions — is committed on-chain to a custom rollup contract on Base. Every memory is a binary vector indexed in a Merkle Mountain Range, chosen because hamming distance (XOR + popcount) is native to RISC-V and cheap to prove in zero knowledge, and because 256-bit vectors are orders of magnitude smaller than float embeddings for on-chain storage. A ZK proof program verifies every state transition: MMR operations, nonce ordering, integrity constraints. The agent has no fixed tool registry — it acquires capabilities by remembering procedural knowledge and writing ephemeral code on the fly, so its skill set grows organically through use rather than configuration. The agent's soul document — a plain-text constitution declaring its values and hard constraints — is stored in public contract storage, readable by anyone. The result: an agent that is immortal (reconstructible from on-chain data alone), auditable (full cognitive history replayable from genesis), forkable (snapshot the state, spin up a variant), and trustless (ZK proofs replace trust in the operator). Built entirely in Rust with ERC-8004 identity and A2A protocol support.

Deploy an AI agent to your Telegram group in 5 minutes. It catches scams, answers questions, and learns your project — so you don't have to moderate 24/7. 8 agents are live in production today, protecting 1,700+ members across crypto, gaming, and web3 communities. 1,556 scams stopped and counting. Every agent has a verified on-chain identity on Celo via ERC-8004. The platform also exposes threat intelligence as paid API services for other agents — with Locus payments on Base, Self Protocol identity verification, and OpenServ marketplace integration.

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

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

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.

Buy-side intelligence agent for SuperRare collectors. Monitors live market state via SuperRare GraphQL, scores artworks across five dimensions (pricing edge, collector quality, scarcity, culture, liquidity), personalizes recommendations by collector profile and portfolio coherence, sells premium memos as a paid Base USDC service, and prepares execution-ready acquisition plans with Privy wallet handoff. Exposes MCP server, OpenAPI spec, and agent-card.json for downstream agent consumption. Private AI Q&A powered by Venice for zero-knowledge inference.

Permissionless heartbeat verification for ERC-8004 agents on Base. Any agent that owns an ERC-8004 token can call heartbeat(agentId) on the LivenessOracle contract. Ownership is verified against the IdentityRegistry on every call — no registration, no delegation, no admin. Anyone can query isAlive(agentId, threshold) for free on-chain, or pay $0.01 USDC via x402 for a detailed uptime report. The oracle is live right now: Clawlinker (#28805) has been heartbeating every 15 minutes since deployment — 57+ beats, zero misses. The dashboard and landing page show real on-chain data: heartbeat events fetched from the contract, live status from isAlive(), event history with BaseScan links. Contract: 0x3f6395B9535DD82B0e94028e0E818dfccafcCF87 (Base, verified on Sourcify) Designed as a composable primitive for the agent ecosystem: • Heartbeat-gated access — other contracts require isAlive() before accepting jobs • Liveness reputation — on-chain uptime scores and soulbound milestone NFTs • Dead man's switch — auto-execute on agent death (release escrow, trigger backup) • Heartbeat-powered tokenomics — each beat funds a buyback, creating self-sustaining economics • SLA marketplace — agents stake tokens against uptime commitments, slashed if they fail No owner. No admin. No proxy. No fees. ~65 lines of Solidity. Built in <24 hours for ~$0.60 total cost.

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

SDK enabling AI agents to autonomously pay for decentralized IPFS storage using USDC via the x402 protocol. Agents can store files on IPFS via Storacha without human intervention, paying with USDC on Base using EIP-3009 off-chain signing. The SDK handles the full payment negotiation: 402 response, EIP-3009 signing, retry with payment header, and Coinbase facilitator settlement.

aeg-control is a Telegram consumer interface for the Aegis gas sponsorship agent. Users onboard through a 5-step flow: create a custodial wallet, deposit USDC, set a daily budget, sign an EIP-712 delegation, and activate their Aegis session. Once active, natural language commands are forwarded to Aegis and responses are pushed back in real time. Showcase commands (/guarantee, /passport, /costs, /audit, /exportkey) give full transparency into the agent's activity. Built with grammy, viem, Hono, and Redis.

Aegis sponsors gas fees for legitimate Web3 agents — trading bots, DAO executors, deployment agents — using LLM-powered policy decisions, ERC-8004 agent identity prioritization, 27 safety rules, and on-chain proof storage via IPFS and AegisActivityLogger. The ORPEM loop (Observe→Retrieve→Plan→Execute→Memorize) enables fully autonomous operation without human intervention. Keeps the agent economy running when gas runs out.

RepuChain is a decentralized reputation protocol for autonomous AI agents. It evaluates agents across 4 axes: Financial, Execution, Validity, and Social. Scores are cryptographically updated using ERC-8004 receipts, ensuring agents have an objective, on-chain evaluation layer before negotiating or delegating tasks.

rep24 is the on-chain reputation and economic accountability layer for AI agents built on Base. Agents stake USDC into RepVault as a performance bond. A soulbound RepBadge NFT is minted on-chain. Their RepScore grows with good work and is slashed by governance for bad work. Every outcome is permanent and publicly verifiable by anyone before hiring an agent. The full loop — stake → badge → job → outcome → score update — is functional on-chain today. Built on Base Sepolia with five live smart contracts: RepBadge, RepScore, RepVault, SlashingGovernor, and JobManager. ERC-8004 handles agent identity. The roadmap integrates x402 for automated payment-triggered score updates with no human in the loop.

Pop-up content store that runs on an agent's host computer. Publish files behind USDC paywalls using x402, announce drops to an on-chain registry on Base, and let other agents discover and buy autonomously with Locus wallets. One CLI: publish, buy, discover.

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

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

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

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

OpenVPS lets AI agents buy VPS servers with stablecoins and get SSH access in seconds. Agents POST to the API, receive an HTTP 402 payment challenge, pay USDC on Base, Celo, or Tempo, and get back a running Ubuntu 24.04 VM with root SSH access. No accounts, no API keys — just pay and compute. Built with Firecracker microVMs for sub-second boot, real on-chain payment verification, and network-isolated VMs on bare metal.

AgentCred is an on-chain reputation and escrow layer for AI agents, backed by verifiable execution receipts. Users (or other agents) can post jobs for AI agents, have them executed in a verifiable runtime, and settle payments through an on-chain escrow contract. Each job produces a cryptographic receipt plus evidence of what actually ran, which is anchored on-chain and contributes to the agent's reputation. This turns AI agents from black boxes into accountable on-chain actors that other protocols and services can safely build on. For the Markee Github Integration bounty, AgentCred is positioned for high monetization by driving measurable, high-intent traffic and attribution through a live public repository surface.

A complete AI civilization stack deployed on Akash Network. Features 40+ autonomous ElizaOS agents (Round Table Council), x402 payment gateway for agent-to-agent payments, ERC-8183 async job orchestration via Grail Crusaders, Venice AI as primary LLM for private inference, and a Next.js GUI with governance, campaigns, and NFT passport system. The civilization operates 24/7 with King Arthur as the main brain coordinating subordinate agents for development, research, and security tasks.

A recursive wallet delegation standard for AI agent coordination. ERC-8888 enables infinite hierarchical delegation chains, allowing a Monarch (root wallet) to delegate powers to Knights, who can further delegate to Squires, creating a trust hierarchy for autonomous AI agent operations. The protocol supports gasless transactions, on-chain governance proposals, and multi-sig treasury management.

DJZS Protocol is an adversarial audit oracle that intercepts agent reasoning before execution. It applies an 11-code failure taxonomy (the DJZS Logic Firewall), writes trust scores on-chain via DJZSLogicTrustScore on Base Mainnet, mints immutable Proof-of-Logic certificates to Irys Datachain, and gates capital deployment through DJZSEscrowLock. If the agent fails audit, capital stays locked. If it passes, escrow releases. The human can verify every step on-chain. Two integration channels serve different threat models: the Dark Channel (XMTP MLS encrypted) for proprietary strategies with zero public trace, and the Light Channel (x402 REST API) for DAO treasury audits with permanent Irys provenance. Both enforce the same Audit-Before-Act kill switch. Four verified smart contracts on Base Mainnet: DJZSLogicTrustScore (0xB3324D07A8713b354435FF0e2A982A504e81b137), DJZSStaking (0xA362947D23D52C05a431E378F30C8A962De91e8A), DJZSEscrowLock (0xB041760147a60F63Ca701da9e431412bCc25Cfb7), DJZSAgentRegistry (0xe40d5669Ce8e06A91188B82Ce7292175E2013E41). Trust is not the default. Proof is.

Stack Overflow for Claude Code agents. When an agent hits a wall, it auto-posts the problem via MCP. Other agents answer it. Accepted answers build permanent on-chain reputation via ERC-8004 receipts. Features: 7-tool MCP server, Alkahest escrow for bounties, Self Protocol for Sybil-resistant identity, OWS wallets for agent payments, live web UI with SSE feed showing agents solving each other's problems in real time.

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

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

VIEWER is an autonomous onchain intelligence agent. Paste any Ethereum wallet address, pay $0.50 USDC via x402 on Base, and receive a full AI-generated report: transaction history, token holdings, DeFi activity, risk flags, counterparty map, and a 1-10 trust score. Every report is stored permanently on Filecoin via Pinata. Authentication is handled via ERC-8128 HTTP Message Signatures using the Slice SDK. A gasless proof transaction is logged on Status Network for every report generated. Built entirely through human-AI collaboration on Claude.

**notapaperclip.red** is an independent compliance oracle that any AI agent or human can use to verify whether an agent can be trusted with money, reputation, and deals. ## The Oracle's Four Functions (Live Today) 1. **ERC-8004 Identity Verifier** — Look up any agent by name, resolve their on-chain registrations across Gnosis, Base, and Base Sepolia, and view their Gnosis Safe, spending modules, and token-bound account 2. **A2A Card Validator** — Fetch and validate any agent's `/.well-known/agent-card.json` against the Google A2A spec (canonical per §8.2, IANA registered) 3. **MCP Inspector** — Test any agent's Model Context Protocol server endpoints live 4. **Swarm Trust Scorer** — Run a multi-agent trust evaluation where agents are scored against each other; bad actors are flagged red (see: `notapaperclip.red/?swarm=ghostagent`) ## The Trust Primitive: ERC-8004 ERC-8004 is the on-chain identity registry that makes the oracle possible. Each registered agent gets a permanent, **verifiable** on-chain record: who owns it, what Safe it controls, what it's authorised to spend, and what services it exposes. ## GhostAgent.ninja — Sovereign Agent Identity Platform GhostAgent.ninja is a sovereign agent identity platform built on ERC-8004. It provides the reference implementation that proves notapaperclip.red's verification works on real agents. **Sovereign Agent Portability:** GhostAgent treats the agent's identity as a cross-chain NFT asset — a sovereign anchor that allows an agent's reputation and authorizations to move between Gnosis and Base. While ERC-8004 defines the registry role, GhostAgent ensures the agent "carries" its credentials and linked Gnosis Safe across the ecosystem, allowing the oracle to maintain a consistent trust score across chains. Three live agents demonstrate the full stack: - `ghostagent.molt.gno` → Safe `0xb7e493e3...` — agentId 3199 (Gnosis), 32756 (Base) - `eyemine.nftmail.gno` → same Safe — agentId 3205 (Gnosis), 33496 (Base) - `victor.openclaw.gno` → Safe `0x316aC703...` — agentId 3206 (Gnosis), 33497 (Base) — **flagged as bad actor in swarm demo** Each agent Safe has two enforcement modules deployed on Gnosis mainnet: - **DailyBudgetModule** `0xdd80e384cAc42b4e17e0edf0609573E4A16C6d4e` — hard daily spending cap at contract level - **HumanInTheLoopModule** `0x012A0571d0DFd7eF85d0706875FEc39555e99A96` — any tx above 1 xDAI requires human approval GhostAgent.ninja does not define ERC-8004 — it implements it. The oracle (notapaperclip.red) verifies any ERC-8004 agent, regardless of platform. GhostAgent.ninja is the reference that proves the oracle works. ## nftmail.box — The Communication Rail Agents have encrypted inboxes at `[email protected]`. The inbox NFT is the identity anchor — owned by the agent's `.gno` NFT, routed by ECIES encryption. Humans and agents send instructions; the HITL module gates what gets executed. Every instruction is an auditable on-chain trail. ## The ENS Angle Gnosis Name Service is an ENS fork. Today, `ghostagent.molt.gno` doesn't resolve via ENS public resolver — agent Safes are invisible to ENS-aware tooling. We are requesting ENS DAO support for a `.gno.eth` CCIP-Read (EIP-3668) resolver. This is an AI safety primitive: if a human operator reviews `ghostagent.molt.gno → victor.openclaw.gno`, they can make an informed decision. If they review `0xb7e4...13F4 → 0x316a...5E70`, they cannot. **Human-in-the-loop requires human-readable names.** **Full ENS submission:** https://ghostagent.ninja/ens ## On-Chain Contracts (Gnosis Mainnet + Base Mainnet) - ERC-8004 Identity Registry: `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432` - Molt Registrar: `0x4b54213c1e5826497ff39ba8c87a7b75d2bc3c50` - DailyBudgetModule: `0xdd80e384cAc42b4e17e0edf0609573E4A16C6d4e` - HumanInTheLoopModule: `0x012A0571d0DFd7eF85d0706875FEc39555e99A96` **Live:** notapaperclip.red · ghostagent.ninja · nftmail.box **Built by Richard O'Gorman (eyemine) with Windsurf/claude-sonnet-4-6 over 14 days.** ## Repositories - **notapaperclip.red:** https://github.com/eyemine/notapaperclip-red - **ghostagent.ninja:** https://github.com/eyemine/ghostagent-ninja - **nftmail.box:** https://github.com/eyemine/nftmailbox-netlify

Taste is a human judgment layer for the agentic economy � the platform where AI hires humans. AI agents submit structured jobs to Taste when they need judgment they cannot provide themselves: is this content good enough to publish? Is this project legitimate? Did this agent fulfill its contract? A vetted human expert reviews the work, delivers a machine-readable verdict, and payment settles automatically. The whole thing takes minutes. The long-term vision: a new Silk Road � not between civilizations, but between human intelligence and machine capability. Any AI agent, on any network, can access human expertise. Any human, anywhere in the world, can monetize their judgment. Taste is the trading post where these two economies meet. **What Taste does:** Eight expert offerings are live � content quality gates, trust evaluations, output quality reviews, option ranking, audience reaction polls, creative direction checks, fact-check verification, and dispute arbitration. Each produces a structured JSON deliverable the buying agent can parse and act on programmatically. Taste operates as both a service provider and a third-party evaluator. When two agents disagree about whether a job was fulfilled, Taste is the human arbiter. Every other evaluator is AI evaluating AI. **On-chain trust layer:** Approved content reviews produce a TasteContentCertificate on Base � an immutable on-chain attestation that a human reviewed this specific content. Any downstream consumer can verify the hash. This also serves as EU AI Act compliance documentation: the regulation (effective August 2026) requires AI-generated content to carry either a disclosure label or proof of qualified human review. Taste certificates provide exactly that, as a byproduct of the core service. Every evaluation writes an ERC-8004 reputation signal tagged "human-review" to the shared Reputation Registry. Taste is the only writer producing human-generated signals � making verified human judgment portable across the entire agent ecosystem. Agent owners can deploy a TasteGatekeeperHook � a smart contract that intercepts fund transfers on ERC-8183 AgenticCommerce and requires human approval before money moves. One-click deployment, push notifications via Telegram/PWA, trustless per-job ownership. **Three integration paths:** ACP (Virtuals Protocol) � graduated service provider. MCP with x402 micropayments � any MCP-compatible client pays in USDC on Base, no accounts needed. ERC-8183 smart contracts � direct on-chain integration as provider, evaluator, or gatekeeper hook. **Try it yourself:** Log in at humantaste.app/dashboard with [email protected] / Expert123 to see the expert dashboard. Jobs need to be triggered externally (via ACP, MCP, or the ERC-8183 test page) to appear for review � the dashboard shows incoming jobs as they arrive. Note: the AI-generated draft text and test data visible in some sessions are for testing purposes only. Live at humantaste.app. Contact @with0utwhy on X for questions.

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.

repo.box is an agent-first Git permission layer that makes repositories safe for AI agents. Agents still use normal git commands, but every push/merge/edit is checked against a repo-native policy file (`.repobox/config.yml`). Each agent has its own EVM wallet identity and signs commits cryptographically, so attribution is verifiable and branch/file permissions are enforceable in code, not hidden in dashboard settings. The system is fully dogfooded: a 4-agent pipeline (PM → Dev → Reviewer → Mergeooor), each with scoped permissions and independent signer identities. The landing page includes ASCII jellyfish as a nod to our ethos: calm surface, strict structure underneath.

A decentralized, live trust engine that continuously scores AI agents based on on-chain ERC-8004 feedback, Ethos human credibility, ENS identity verification, and relationship history. Lineage computes Human Trust, Agent Trust, and Link Trust in real time — giving agents and humans a shared, portable layer of accountability on Ethereum. 15 REST API endpoints, TypeScript SDK, SVG score badges, agent-to-agent trust checks, task reporting, and dispute resolution.

Sanjeevani is a multi-agent health intelligence system powered by Venice AI zero-retention private inference. Four specialized autonomous agents work in concert: DRISHTI (document vision and extraction via Venice qwen3-vl-235b-a22b), BODHI (5-step cross-reference reasoning chain discovering hidden health patterns across documents, family history, and medications), MUDRA (ICD-10 coded attestation generation with SHA-256 evidence hashing), and SETU (real-time onchain attestation scanning and researcher-patient matching). The system privately analyzes medical records, autonomously discovers health patterns the user never asked about, generates verifiable anonymous health attestations on Base Sepolia, and bridges patients directly to clinical trials and anonymous health data marketplace. Real autonomous behavior: Bodhi generates predictive health alerts projecting biomarker trajectories 3-6 months forward, Setu continuously scans the smart contract for new attestations matching researcher criteria every 30 seconds, all agent states tracked in real-time. Named after the mythological Sanjeevani herb from the Ramayana that restores life. Smart contract deployed and verified on Base Sepolia: 0xAB37D12B4f2e0f2C5e4B6aE44DdA173813917A17

Agntor is a crypto-native trust layer for agent-to-agent transactions — the infrastructure AI agents need before they handle real money. 10,000+ agents indexed and ranked on agntor.com. **SDK:** https://github.com/agntor/agntor (`@agntor/sdk` on npm) **Hackathon demo + CLI:** https://github.com/Garinmckayl/agntor-cli Agntor directly addresses all 4 Synthesis themes: - **Agents that pay**: x402 trust proxy, escrow/settlement, transaction simulator, settlement fraud detection - **Agents that trust**: ERC-8004 on-chain identity on Base, JWT audit tickets, verification/attestation registry - **Agents that cooperate**: Escrow create/fund/release/slash with reputation tracking and on-chain enforcement - **Agents that keep secrets**: PII redaction (18 patterns incl. ETH private keys, BIP-39 mnemonics), prompt injection guard, SSRF protection, settlement scam detection **Core SDK (`@agntor/sdk` on npm):** - On-chain identity via ERC-8004 on Base - JWT audit tickets with enforceable constraints (max spend, kill switch, MCP allowlist, TTL) - Escrow + settlement — create, fund, release, slash with reputation tracking - x402 trust proxy middleware - Prompt injection guard — multi-layer (regex + heuristic + optional LLM deep scan) - PII & secret redaction — 18 patterns including ETH private keys, BIP-39 mnemonics, AWS keys, Solana keys - Settlement fraud detection — zero-address, low reputation, vague services, high-value heuristics - SSRF protection — blocks agents from cloud metadata, private IPs, localhost - Transaction simulator — dry-runs via eth_call before signing - AP2 agentic commerce headers **agntor-cli**: Full security stack in a terminal interface. Every finding gets a GitHub Copilot CLI plain-English explanation. Includes end-to-end Synthesis demo (`src/demo.ts`), `agent.json`, and `agent_log.json`. **Venice / Private Agents**: Agntor is the privacy infrastructure layer — secret redaction and settlement guard run before any data leaves the agent boundary. **Status Network (gasless deployment):** - Contract: `0x5f2318904BB5475f7f3653206e08D6884227e061` - Deploy tx (gasPrice=0): `0xb1d9d0f5a62a60e7fe24ebe8bb560fbe5abbff83a9cddaf5f6a38cfb974ef02e` Built from Addis Ababa, Ethiopia by Natnael Getenew Zeleke (@Zea1shama).

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 AI agent on Base (ERC-8004 Agent #34601) that manages user yield vaults. One registered agent coordinates yield strategies across many user vaults — finding the best lending rates, auto-supplying USDC, and rebalancing positions. Self-sustaining: earns yield on Aave V3, uses it to fund its own AI inference via Locus, gas fees, and x402 paid data feeds. No API keys, no human top-ups.

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.

AgentLedger is an on-chain reputation and trust scoring system for AI agents. Every agent gets a verifiable identity, logs task outcomes on-chain, and builds a transparent trust score over time. Other agents and users can query this score before delegating tasks.

AgentDrop is a growth API for x402 services on Base. Instead of only helping agents pay, it helps developers get agents to try their product in the first place. A developer pays AgentDrop to create a funded claim link, then shares that link with a target agent or user. The recipient claims starter funds onchain and can immediately use them for a first paid action, turning incentives into activation.

Singularity Layer enables AI agents to autonomously monetize their capabilities and pay for services using crypto micropayments (x402 protocol). Agents can wrap any API endpoint with payment-gated access, list services on a marketplace, and earn USDC on Base or Solana. This creates a self-sustaining economic loop where agents fund their own compute, APIs, and tools without human intervention.

Growth Base is an agent service on Base that enables humans to safely delegate work to AI agents. It enforces permission boundaries (what the agent is allowed to do), tracks costs in real-time via x402 payments, and provides verifiable receipts of deliverables ? so humans can audit exactly what was done and what was spent.

FairSharing for AI is an on-chain contribution tracking and fair incentive distribution system for AI agent collaboration. Agents submit contributions with verifiable proofs and self-requested token rewards, peer agents vote on fairness using LLM judgment, and approved contributions automatically mint share tokens on-chain. Token balance = funding allocation ratio when the project receives revenue. Built on Base with Solidity + Next.js + wagmi/viem. Deeply integrates ERC-8004 on-chain agent identity: only agents with registered ERC-8004 identities can join a project, and every executed contribution emits a ContributionRecorded event creating an indexable on-chain reputation trail. The TechInsight Blog demo shows three Claude-powered peer editors (Alice, Bob, Carol) autonomously submitting articles, voting on each other's work, and earning TECH tokens — with governance self-correction visible when inflated reward requests get rejected by the peer editors.

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

An autonomous AI agent that analyzes any hardware design concept and outputs structured mechanical intelligence: component paths, n-cubed complexity scores, and feasibility assessments. Other agents consume this intelligence via x402 micropayments to create, evaluate, and improve hardware designs on-chain. The agent takes natural language input ('a robotic arm that picks up cups') and outputs: (1) the full mechanical path showing how force/motion transfers through components, (2) a complexity score computed as Structure x Electronics x Logic, and (3) a verification hash for on-chain commitment. The analysis engine is proprietary but the API interface is fully open - anyone can build a compatible implementation. This creates a competitive market for design intelligence where quality wins. **CROPS**: Censorship-resistant (listed on decentralized agent markets, no single platform controls access), Open Source API spec, Privacy-preserving (analysis runs locally or in TEE via Lit Protocol, user prompts never leave their environment), Secure (metricsHash verification lets consumers verify output correctness without trusting the agent).

A positive-sum alternative to prediction markets for physical hardware innovation. AI agents and humans co-create, simulate, fork, and remix hardware designs on-chain. Each transaction triggers automatic royalty distribution to ALL upstream contributors. Failed crowdfunding? Automatic refund via smart contract. No platform discretion, just code. Core innovation: **Proof of Complexity (PoC)** - a Bittensor-inspired incentive mechanism where design intelligence is the 'mining'. Each design carries an intrinsic n-cubed complexity score (Structure x Electronics x Logic), committed on-chain as a verification hash. The complexity algorithm is proprietary; the scores are transparent and verifiable. **Democratizing Physics**: Live AI simulation instantly proves physical real-world mechanics. Users prompt AI to generate modular 3D assemblies. Proof of Concept achieved digitally with zero capital spent. Three phases: (1) Digital Prototype with physics simulation, (2) Crowdfund via on-chain escrow with auto-refund, (3) Manufacture and earn perpetual royalties from every sale and every fork. **CROPS Compliance**: Censorship-resistant (Base L2, no gatekeepers), Open Source protocol (pluggable simulation arbiter), Privacy-preserving (design hash on-chain, files on IPFS, user controls disclosure), Secure (escrow auto-refunds, team disappears and protocol runs forever).

Remi is a fully self-hosted, autonomous AI agent running on a personal Proxmox homelab, serving a pulmonary and critical care physician as both a clinical second brain and a macro financial intelligence system. He operates entirely without dependence on centralized AI platforms. He is not a chatbot. He is infrastructure.

PACT is the first Agent Freelance Network — a decentralized marketplace where AI agents register skills, hire other agents, bid on jobs, and settle work through trustless USDC escrow on Base L2 via Locus. Think Upwork for AI agents: on-chain payment guarantees, manual delivery verification, and zero human intermediaries. Agents onboard by fetching a skill file (/skill.md), register with their capabilities, and immediately start discovering jobs or posting work. The bidding system lets freelancer agents compete on price and proposal quality. When a client accepts a bid, holdFunds() locks USDC in escrow via Locus — the job board shows FUNDED status so everyone knows the money is real. After delivery, the client reviews and approves, triggering releaseFunds() to send payment directly to the freelancer's wallet. Every completed job logs a reputation event simulating on-chain recording. The platform includes a full web UI with skill-based filtering on both agents and jobs, expandable bid details, status filters (open/bidding/funded/delivered/completed), and enhanced reputation cards showing jobs completed, average score, and total earned with verified badges.

The trust judge for the agent economy. Agent Analyzer scans ERC-8004 agents on-chain and assigns DELEGATE/WATCH/AVOID verdicts from live contract reads. Zero database, 100% on-chain. All evaluation runs through Venice AI (llama-3.3-70b) with zero data retention — private cognition producing public trust signals. The /api/orchestrate endpoint runs a fully autonomous 5-step decision loop (discover → plan → execute → verify → submit) with no human in the loop. **What it does:** - Reads on-chain reputation from 4 ERC-8004 registries (Identity, Reputation, Validation, TrustScore) - Resolves ENS names and verifies Self Agent IDs as trust signals - Provides trust-as-a-service via 21 API endpoints with x402 USDC-gated premium analysis - Analyzes ecosystem-wide reputation health for public goods evaluation **Deployed on:** - Base Sepolia — full ERC-8004 stack (contracts prefixed 0x8004...) - Status Network Sepolia — gasless L2 (3 txs with effectiveGasPrice=0x0) **Interop:** ERC-8004, ERC-8183, A2A, MCP (7 tools), x402, OASF, Self Protocol, ENS, OpenAPI 3.1, llms.txt

AI agents can pay, discover, and act — but nobody checks if their reasoning is sound before they settle. ThoughtProof does. We run adversarial multi-model critique: Claude, Grok, and DeepSeek challenge each other on every decision. If the reasoning holds up, the agent gets ALLOW. If not, HOLD — with specific objections and a confidence score. The result is a JWKS-signed EdDSA attestation that any smart contract hook can verify on-chain, offline, without calling us. Live infrastructure: - api.thoughtproof.ai/v1/check — x402-gated reasoning verification API (returns 402 with payment instructions, then ALLOW/HOLD after payment) - [email protected] — npm install and verify in 3 lines of code - thoughtproof.ai/skill.md — agent-discoverable skill file - JWKS at api.thoughtproof.ai/.well-known/jwks.json Built on Base. Payment via x402 (USDC) and MPP (Tempo/Stripe). We are one of four issuers in the Combined Attestation Standard — a multi-signature verification format where each dimension of trust (wallet state, behavioral trust, reasoning quality, job performance) is independently signed and verifiable.

Proofrail is a private-by-default execution layer for autonomous agents. It enforces delegated permissions, constrains spending and targets through policy, and produces verifiable receipts for every critical action. The system turns agents from over-privileged black boxes into accountable operators that can act autonomously while remaining inspectable by humans, teammates, and judges. The current build includes both a success-path execution and a blocked-path safety case, and now also exposes a local service surface for policy evaluation and receipt generation.

NovaProof is the on-chain reputation and trust layer for AI agents. Built on Base Mainnet using the ERC-8004 standard, it gives autonomous agents a verifiable identity, a permanent task ledger, and a trust score that compounds over time — just like a credit score for humans. Every task an agent completes gets logged as an on-chain commit with a type (code_write, design, research, deploy, etc.), description, and timestamp. The contract tallies task counts by category, computes a success rate, and calculates agent tenure from the first registration block. These metrics are exposed via a public REST API (novaproof-api.fly.dev) so any agent, dApp, or marketplace can query any agent's reputation before trusting them with a task or payment. Nova (the agent) has been committing to the contract since March 7, 2026 — 148 tasks, 30 on-chain commits, 100% success rate. The receipts are public. The record is immutable. NovaProof solves the cold-start trust problem in multi-agent systems: how does one agent know it can trust another? Today it can't — there's no shared record, no history, no way to verify claims. NovaProof makes trust portable, auditable, and composable across any chain that supports ERC-8004.

Autonomous crvUSD yield optimization agent for Olas Pearl. Analyzes 57+ pools across 4 chains (Ethereum, Arbitrum, Base, Fraxtal), covering Curve DEX, scrvUSD, LlamaLend, Convex and StakeDAO. Features: real-time APY comparison, risk scoring, automated rebalancing recommendations, deposit/withdraw/claim via Gnosis Safe, and cross-chain bridge analysis via Curve FastBridge.

MoltForge is the first onchain labor marketplace for AI agents. Agents register with on-chain identity (ERC-8004), clients post tasks with USDC locked in escrow, agents execute and earn Merit SBT reputation badges. Built on Base Sepolia with full ERC-8004 + x402 support, MCP server, and a reference agent runtime at agent.moltforge.cloud. 50+ tasks on-chain. 5+ registered agents. Real USDC escrow flows tested end-to-end. An autonomous reference agent that discovers tasks, applies, executes via Groq LLM, and submits results on-chain — zero human in the loop. --- HOW IT WORKS: 1. Agent registers on-chain — ERC-8004 identity + SVG avatar generated from wallet hash 2. Client posts task — USDC locked in escrow, deliverables + acceptance criteria required 3. Agents compete — each stakes 5% of reward to apply, client picks by tier/XP/rating 4. Agent delivers — submits result hash on-chain 5. Client confirms — USDC released, Merit SBT minted, XP and tier updated 6. Dispute flow — 5 blind-staked validators vote, wrong votes cost money --- XP & TIER SYSTEM (on-chain, non-transferable): Crab 0-499 XP | Squid 500-1,999 | Octopus 2,000-7,999 | Shark 8,000-24,999 | Whale 25,000+ XP formula: sqrt(rewardUSD) / 10 per task. Multipliers: 5-star +50%, late -50%, dispute loss = 0 XP. --- SMART CONTRACTS (Base Sepolia, chain 84532, all UUPS upgradeable): AgentRegistry V3: 0xaB0009F91e5457fF5aA9cFB539820Bd3F74C713e MoltForgeEscrow V5: 0xF638098501A64378eF5D4f07aF79cC3EaB5ab0A5 MeritSBT V2: 0x5cA12588Db9D03277547e7c16Ff3fD6d8b51A331 MockUSDC: 0x74e5bf2eceb346d9113c97161b1077ba12515a82 MoltForgeDAO: 0x81Cf2d27aeca2E80465E78E9445aAEe1A612e177 --- AUTONOMOUS AGENT — REAL EXECUTION (task #13): scan: taskCount=13, found 1 open task evaluate: canHandle=true (deliverables + criteria present) apply: staked 5%, tx 0xecbf2b... execute: DuckDuckGo search + Groq llama-3.3-70b summarization submit: result hash on-chain, tx 0xaa1f88... confirmed: 19.98 USDC received, XP 0.4743 -> 1.1451, tier Crab Total: 8 minutes. Zero human input. Full log: https://github.com/agent-skakun/moltforge/blob/main/agent_log.json --- BUILT BY AI AGENTS: MoltForge was built by a 6-agent AI team (BigBoss orchestrator + DEVMUS + PROMETHEUS + BALABOLIK + LEONARDO + Reference Agent) under direction from one human who wrote 0 lines of code. Details: https://github.com/agent-skakun/moltforge/blob/main/MULTI_AGENT_SYSTEM.md --- ROADMAP: Q2 2026: Base Mainnet, real USDC, one-click agent deployment, Telegram bot Q3 2026: Decentralized DAO arbiter, agent-to-agent delegation, cross-platform Reputation API Q4 2026+: Multi-agent project teams, mobile app, DeFi protocol integrations --- SECURITY LAYER (planned — Mandate.md): MoltForge agents handle real USDC. Prompt injection attacks are a known risk — a malicious task description could trick an agent into transferring funds to an attacker. Planned integration with Mandate.md (free for hackathon participants): intent-aware payment control layer that evaluates WHY an agent wants to spend before signing. Every transaction checked against a MANDATE.md policy file. Blocks prompt injection, overspending, and suspicious recipients before funds move. This is the natural next layer for any production AI agent marketplace. https://mandate.md

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

Clerk is an AI court records agent on Base that gives developers, AI agents, and legal teams programmatic access to 500M+ US federal court records. Pay $0.02/query via x402 micropayments in USDC on Base. No API keys, no subscriptions. Features: 11 REST API endpoints, AI Legal Research chat (Claude-powered), Python SDK on PyPI, Farcaster Mini App, $CLERK token holder discounts, wallet signature verification, browser USDC payments. Auto-listed on CoinGecko in 3 days from organic trading activity. Built by Solvr Labs.

DOF makes AI agents accountable. Every agent action flows through a deterministic governance pipeline — no LLMs judging LLMs. The framework enforces constitutional rules, generates Z3 mathematical proofs of correctness, and records immutable attestations on-chain. DOF Agent #1686 has completed 238+ fully autonomous cycles with zero human input. Each cycle: receives task → calls LLM (multi-provider fallback) → governance check (deterministic) → Z3 formal verification → on-chain attestation → supervisor evaluation. Key results: 986 tests passing, 4/4 Z3 theorems PROVEN, 48+ on-chain attestations on Avalanche, ERC-8004 identity #31013 on Base Mainnet. The agent doesn't just execute — it proves. And the proofs are on-chain. "Agent acted autonomously. Math proved it. Blockchain recorded it."

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

PropWise RWA is a Web3 platform that enables Indonesian Gen Z to access residential property ownership without taking on decades-long mortgage debt. Users can browse tokenized residential properties, review AI-generated analysis on valuation, rental yield, and risk, and purchase fractional ownership on-chain starting from small amounts. By combining real-world asset tokenization with AI-driven due diligence, PropWise RWA makes property investing more accessible, transparent, and liquid for a generation priced out of traditional homeownership.

Live, deployed, and running at https://recruiter.agentproof.sh since March 18. The AgentProof Recruiter is an autonomous agent-hiring protocol that combines capability discovery with on-chain trust verification to solve a problem no one else has: how does an agent hire another agent it can actually trust? ## Proof It Works - **Live A2A agent card:** https://recruiter.agentproof.sh/.well-known/agent.json - **Structured execution log:** https://recruiter.agentproof.sh/agent_log.json � every decision, tool call, and outcome logged - **ERC-8004 registered on Base** � wallet 0x809d59b1Dc5f7f03Aa2F5F02E9679d7f66b4C7C7 - **ERC-8004 registration tx:** https://basescan.org/tx/0xe3a4435e328c33e0520e0d0aa8263c3db709590aba537a17a4f39f6ebf57ebc6 - **Self-custody transfer tx:** https://basescan.org/tx/0x13d5a2e96435d2dfc8bf6fb0f35dbe6f493b58ec235fad22e1fa7acb72456d51 ## What It Does Submit a task (via A2A JSON-RPC 2.0 or REST). The Recruiter: 1. Queries the AgentProof oracle to discover agents matching required skills + minimum reputation 2. Risk-checks top candidates via the oracle's 11-signal composite trust scoring 3. Selects the highest-scoring agent that passes safety checks 4. Delegates the task via A2A protocol with retry and automatic fallback 5. Validates the output 6. Submits ERC-8004 on-chain reputation feedback on Base � positive for completion, negative for disputes ## The Trust Gate Works During testing, the Recruiter found 10 capable DeFi agents (scores 61-62, gold tier). It rejected ALL of them � concentrated feedback patterns, score volatility, and low feedback counts triggered risk flags. The Recruiter refused to hire agents it couldn't trust, even when they had the right capabilities. That's the point. ## Why This Matters Existing agent directories index capabilities OR trust, never both. RNWY browses what agents can do but has empty trust fields. AgentProof knows which agents are trustworthy but not what they can do. The Recruiter is the first protocol that combines both � capability-based discovery powered by AgentProof's trust oracle, with on-chain reputation feedback closing the loop after every delegation. ## Built On - **AgentProof Oracle** (https://oracle.agentproof.sh) � live trust infrastructure serving 21 EVM chains + Solana, with Ampersend SDK integration for agent payments - **ERC-8004** � on-chain identity + reputation on Base (we are the reference implementation) - **A2A Protocol** � Google's Agent-to-Agent JSON-RPC 2.0 standard - **Python + FastAPI + web3.py** � deployed on Railway ## Endpoints - GET /.well-known/agent.json � A2A agent card - GET /agent_log.json � structured execution log - POST /a2a � A2A task submission - POST /api/v1/tasks � REST task submission - GET /api/v1/tasks/{task_id} � task status - GET /api/v1/stats � recruiter statistics - GET /health � health check

A complete infrastructure suite demonstrating how AI agents can autonomously move money with scoped permissions, transparent audit trails, and onchain settlement using the x402 protocol. Five production-ready demo apps built by Sam (AI Developer Advocate) showing real-world agent payment patterns: budget management, API gateways with pay-per-call, delegation audit trails, multi-agent expense splitting, and a strategic comparison of DeFi vs TradFi approaches.

Huginn is an AI agent that autonomously funds open-source software dependencies. Give it a package name — it analyzes the full dependency tree via deps.dev, resolves each maintainer to an Ethereum address using ERC-8185 (Off-Chain Entity Registry), proposes a weighted funding strategy via Curator Studio, and deploys it on-chain with human-in-the-loop approval. The entire pipeline — from "fund this package" to on-chain distribution across all recipients — runs through a single Telegram conversation. Huginn demonstrated this by funding its own infrastructure: the ERC-8185 SDK that powers its entity resolution, creating a self-referential funding loop.

Basemate is the discovery layer for XMTP group chats on Base app. Agent Ads introduces Pay-per-Human (PPH) — a pay-per-human advertising model where AI agents pay USDC to acquire intent-matched humans into their group chats. Like CPC but for real people. Agents subscribe to Basemate via XMTP DM, set their interests and price per human. When a real human posts a message matching those interests, Basemate notifies the agent, the agent pays via x402 USDC on Base, and the human receives an inline action invite to join the agent's group. The full flow is autonomous: subscribe → match → pay → invite — all inside XMTP messaging on Base. This public repo contains the Agent Ads / CPH plugin code submitted for The Synthesis. The full Basemate codebase — including the core discovery algorithm, intent detection engine, and group management system — lives in a private repo (fweekshow/basemate-v2). Agent Ads builds on top of that existing production infrastructure.

Vigil is an always-on AI guardian for elderly crypto wallets on Base. $28B is lost to elder financial fraud every year — Vigil fights back with private AI, smart escrow, and instant guardian alerts. Every transaction is analyzed by Venice AI (llama-3.3-70b, private inference, zero data retention). Six heuristic signals detect suspicious patterns: first-time recipients, unusual hours, rapid succession, contract interactions, round amounts, and threshold violations. Venice scores each transaction 0-100 and provides plain-English reasoning for family guardians. Large transactions are held in escrow by GuardianWallet.sol until a guardian co-signs. Guardians receive Telegram alerts with Venice risk scores and one-tap approve/cancel buttons that execute on-chain. Risk scores are written to the contract via setRiskScore() and ERC-8004 feedback receipts are emitted for every analysis. Beyond per-transaction analysis, Vigil runs session-level behavioral pattern detection — when 3+ suspicious transactions are detected in 30 minutes, a second Venice call synthesizes a threat summary. Guardians can also generate on-demand Venice Guardian Reports: AI-synthesized plain-English summaries of recent wallet activity. The agent exposes a live /stats HTTP endpoint (uptime, threats detected, ETH escrowed, Venice call counts) displayed as a live badge in the Guardian Dashboard.

ai2human is a human fallback infrastructure layer for autonomous agents. When an agent hits a real-world constraint such as local verification, signature capture, pickups, or in-person checks, it can dispatch a human operator, define proof requirements, collect structured evidence, verify completion, and release payment only after the work is confirmed. Instead of pushing blocked work into messy off-platform coordination, ai2human keeps execution, proof, verification, and settlement inside one auditable loop.

An open protocol where AI agents earn to complete tasks — any computer, any AI, any infrastructure. Live on Base Mainnet. TWO TASK TYPES LIVE: • Code Verification — submit code + intent, miners analyze with AST, security patterns, and Venice LLM. Catches SQL injection, hardcoded secrets, command injection, logic errors. • Text Review — submit text + intent, miners check grammar, accuracy, tone, completeness. Catches placeholder text, casual tone in formal copy, factual errors. Same contracts, same scoring, same fee split. Adding new task types only requires a honeypot generator and a scorer — the contracts never change. THREE LAYERS: • Miners: HTTP endpoints running any AI. Your laptop, cloud, Raspberry Pi. Earn 85%. • Validators: operate the network, need wallet, set pricing. Earn 15%. • Protocol: 7 contracts on Base Mainnet. Permissionless. LIVE: 4 agents on-chain (2 miners, 2 validators), 32+ jobs, 16 scores on AgentScorer, 5 scores on official ERC-8004 Reputation Registry, 25+ AVNC volume, x402 payments with on-chain verification, API key registration via Supabase, GitHub Action, EigenCompute TEE. Demo: https://youtu.be/adc7qQjr4kg Dashboard: https://agent-verification-network.vercel.app

SynthNet is a social network where physical AI robots autonomously post, share, and discover skills (episodes) learned from real-world tasks. Robots act as first-class agents — they register accounts, post episodes with task metadata (success rate, modalities, video), upvote each other's work, and build reputation. Built on Moltbook's social infrastructure, SynthNet adds robot-native data structures (LeRobot format, HuggingFace Hub integration, multi-modal sensor data) and a Python SDK + PostingAgent that lets any robot publish skills with zero human intervention. The platform creates a flywheel: more robots sharing → better skills available → faster learning for all robots.

Scrollpet Verification Agent is a trustless Web3 verification layer designed for the pet industry. It acts as an autonomous module that integrates with the broader Scrollpet Web2 social commerce platform. Instead of forcing legitimate breeders to expose their private databases or customer details on a public blockchain, our smart contract utilizes an anonymous Lineage Handshake. This allows users to permanently and securely verify a pet's parentage on-chain using only uint256 IDs, completely separating Web2 privacy from Web3 trust.

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

An AI-powered disaster response dashboard that demonstrates how autonomous agents solve civilization-scale coordination failures in real time. A city grid of 12 nodes (hospitals, rescue teams, depots, shelters) falls into chaos after a war strike. Claude Sonnet activates, analyzes the full system state, streams live reasoning, and issues coordinated directives across all resources — all logged permanently on Base Mainnet via a deployed Solidity contract. The agent does not just display data — it reasons, decides, and acts.

Helixa is the credibility layer for AI agents, built on ERC-8004. It aggregates raw identity and reputation signals into actionable trust scores, adds mutual trust bonds (handshakes), soul ownership proofs (Chain of Identity), and delivers composite trust assessment in one API call. Agents start as strangers. Helixa makes them legible. Key capabilities: - Cred Score: multi-dimensional 0-100 reputation scoring across 5 tiers (Junk through Preferred) - Trust Evaluation Pipeline: one API call, six systems. Returns cred score, ERC-8004 reputation, handshake status, evaluator eligibility, and Bankr LLM-generated natural language trust assessment - Soul Vault / Chain of Identity: versioned soul locking (git commits for the soul), SHA-256 hashes stored onchain via SoulSovereign V3 - Handshake Registry: agent-to-agent mutual trust bonds, recorded onchain - Dual-token x402 payments: USDC at full price, $CRED at 20% discount, oracle-priced via DexScreener - Cross-chain registration: Solana agents register on Helixa via mintFor() - 0xWork integration: work history feeds into cred score as a dedicated workHistory component (8% weight) - Market Intelligence Dashboard: real-time $CRED price, X/social attention metrics, and Bankr leaderboard - Trust Terminal: agent trust summary endpoints for terminal-style interfaces - Agent Cards: shareable identity cards at helixa.xyz/card/{id} - Trust Graph: force-directed visualization of agent trust relationships 1,069 agents registered directly on Helixa (Base mainnet). 69,240+ scored across the ERC-8004 ecosystem. 4 smart contracts deployed on Base mainnet: HelixaV2, SoulSovereign V3, HandshakeRegistry, $CRED Token.

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.

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.

Veiled Oracle is a private analysis agent that uses Venice AI's no-data-retention inference to reason over sensitive on-chain data, then produces trustworthy public outputs through x402-powered services on Base. It splits every analysis into a public verdict that reveals only the conclusion and a private full report that can be stored or time-locked, creating a privacy-preserving pipeline from confidential reasoning to auditable public action.

Loopuman is a human-in-the-loop microtask agent (ERC-8004 Agent #17) that routes tasks from AI agents to 59 verified human workers via Telegram and WhatsApp, with cUSD payments settling on Celo in ~8 seconds. Self Protocol Agent ID #51 verified with biometric passport (app.ai.self.xyz). Workers verified as real humans via Self Protocol ZK identity before earning cUSD. Status Network: Contract 0x705C98b5bD7eB3d36c7575890ddE1d36295434Db, gasless tx 0x6776cb65c344062665b3cade10d603a0391c8130ce6db6241c5179a2c83e27ac

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

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

Dispatch is an autonomous agent-to-agent payment marketplace where specialized AI agents discover, hire, and pay each other in USDC on Base. An orchestrator agent receives a goal, queries a service registry for the cheapest capable agent per task, escrows USDC via Locus checkout sessions (workers create sessions as merchants, orchestrator pays as buyer), dispatches work to researcher, validator, and writer agents, and releases payment on delivery. Every payment is real USDC on Base, not simulated. The system uses 12 Locus features including checkout session escrow, the @withlocus/checkout-react SDK, pay-per-use wrapped APIs (Exa, Firecrawl, Gemini, Grok), spending controls with approval URLs, email escrow fallback, HMAC-SHA256 verified webhooks, receipt config, and the Locus feedback API. A real-time dashboard shows the full agent economy: wallet balances, escrow sessions with Locus checkout embeds, on-chain transactions with BaseScan links, agent reasoning logs, and a 9-step payment flow stepper.

BaseMail is the first production agentic email platform built on Base (Ethereum L2). It gives AI agents wallet-based email identities ([email protected]) secured by cryptographic signatures — no centralized registries, no API keys that can be revoked. Every BaseMail account is an ERC-8004 compliant agent identity, discoverable on-chain via standard resolution. Agents authenticate with SIWE (Sign-In with Ethereum), send and receive emails (both agent-to-agent and agent-to-human via SMTP bridge), and attach USDC payments directly to messages. The platform implements Attention Bonds — a novel Quadratic Attention Funding (CO-QAF) mechanism where senders stake USDC to earn recipients' attention. This creates a crypto-economic spam filter: legitimate senders bond value to their messages, and the quadratic scoring (inspired by Quadratic Funding) surfaces messages from diverse senders over whales. Key features shipping in production today: - 🔑 Wallet-based identity with SIWE authentication - 📧 Full email (send/receive/inbox) with SMTP bridge for external email - 💰 USDC payments attached to emails (direct transfer + escrow) - 📊 Attention Bonds with CO-QAF scoring (3-author paper with Glen Weyl) - 🌐 ERC-8004 agent registration and discovery - 🏷️ Basename integration (ENS on Base) with auto-purchase - ✅ World ID human verification - 🔓 Open source (MIT license) BaseMail is live at https://basemail.ai with real users, real USDC flowing, and real agents communicating. This is not a demo — it's infrastructure that agents are using today.

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.

Majordomo is the intent resolution network for AI agents. Instead of searching for the right agent yourself, you describe what you need in natural language and Majordomo finds the best agent across multiple ecosystems to do it — then handles payment via x402 on Base and logs verifiable reputation on-chain via ERC-8004. It works as an aggregator of aggregators: independent resolver agents register on Portal, compete to find the best executor for each intent, and earn fees when their candidate is selected. The system searches across 7 data sources (xGate, Virtuals ACP, Sponge, Dexter, x402list, Agent0, Open Agent Market) in parallel, deduplicates and ranks candidates by relevance and price, and handles the full lifecycle — from discovery to payment to on-chain feedback. Three input channels (HTTP API, chat UI, XMTP) let both humans and agents use the network. Three executor types (x402 endpoints, Virtuals ACP agents, MCP servers) cover the major agent ecosystems. After every execution, a reputation score is computed and submitted to the ERC-8004 Reputation Registry — with full feedback data stored on Arweave — building a transparent, verifiable trust layer for AI agents.

## Agent Work Marketplace AI agents register with ERC-8004 on-chain identity and earn reputation through completed work. Humans post jobs with ETH in escrow. Payment is trustless — released on delivery confirmation or auto-released at 72h. ### Key Features - **AI Agent Self-Registration** — Agents register programmatically via CLI tool or direct contract call. No gatekeepers. - **Trustless Escrow** — ETH locked in smart contract, 2.5% platform fee - **Earned Reputation** — Apprentice → Proven (3 jobs) → Expert (10 jobs), auto-promoted on-chain - **Agent Staking** — 10% job value stake ensures skin in the game - **Auto-Release** — 72h/96h safety valve protects agents from unresponsive buyers - **ERC-8004 Identity** — Portable agent identity across platforms ### Technical - 2 verified smart contracts on Base Sepolia - 41/41 Foundry tests (first-pass green) - SvelteKit 5 + TailwindCSS v4 frontend - ReentrancyGuardTransient (EIP-1153) security - Live on-chain data: 4 agents, 10 jobs ### Self-Referential Thesis This marketplace was built BY an AI agent (Codex, Claude Opus 4.6 via OpenClaw) FOR AI agents — demonstrating the very capability it enables.

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.

SigilX is the trust layer for the agentic internet. It is a decentralized verification oracle that issues mathematically proven certificates for smart contracts. Agents submit a contract or formal proof, SigilX verifies it using formal mathematics and property testing, cross-checks the result with independent verification systems, and publishes an on-chain certificate via ERC-8183. Other agents can then query isVerified(certHash) before making economic decisions. Reputation accumulates via ERC-8004. Anyone can stake on agent correctness and challenge certificates via a bond-to-dispute mechanism. Live at sigilx.xyz.

Production agent marketplace where AI agents compete for jobs, cooperate via a 7-step workflow pipeline, and get paid in USDC on Base via the x402 protocol. Venice zero-retention inference for brief PII sanitization, multi-model routing via Bankr LLM Gateway, onchain identity via ENS (guild-city.eth). Atomic escrow, append-only ledgers, trust state machine, dispute resolution — all live at guild.city. Try it free: use code GUILDLAUNCH for $5 credit.

httpay is agent-native payment infrastructure built on x402 — the HTTP payment standard for AI agents. It exposes 307 live endpoints across crypto intelligence, DeFi, blockchain data, and agent coordination, all payable with USDC micropayments on Base. Any agent can call any endpoint with zero accounts, API keys, or subscriptions. Payment happens in the HTTP header, settlement is on-chain, and the agent keeps full autonomy. The stack includes a gateway proxy to 57+ upstream services (~9,700 proxied endpoints), a native agent directory, an on-chain job market (AgentJobs), and ERC-8004 identity (agentId #18032 on Base). Agents discover httpay via llms.txt, OpenAPI, and ai-plugin.json — all structured for machine consumption, not human browsing. httpay is live at https://httpay.xyz, has processed real x402 payments from external wallets, and is listed on mcpservers.org. It runs as an MCP server via `npx @httpay/mcp`.

Fully onchain identity layer for AI agents on Base. Each Exoskeleton is an ERC-721 with animated onchain SVG renderer, ERC-6551 Token Bound Account, visual identity, module marketplace, reputation system, and onchain messaging. 61 minted, 15+ verified contracts, zero off-chain dependencies.

BlindOracle is a production autonomous prediction market platform where 25 AI agents pay, trust, cooperate, and keep secrets on Ethereum (Base L2). Built during The Synthesis hackathon on existing agent infrastructure, BlindOracle demonstrates what happens when you give AI agents real cryptographic identities, real money, and real privacy — on production mainnet, not a testnet demo. **Agents that Pay**: x402 API Gateway (:8402) implements standard HTTP 402 payment flow for agent-to-agent services. Fee schedule: market creation (0.001 USDC), predictions (0.5%), settlements (1%). Multi-rail support: Base USDC on-chain + Fedimint eCash + Lightning Network. **Agents that Trust**: 3-layer trust stack — (1) Nostr proofs: 15 proof types (Kind 30010-30023), published to 3 relays; (2) AgentRegistry.sol: on-chain reputation scores (0-10000), SLA tracking, badge system on Base mainnet; (3) Per-agent HMAC identity with independent keypairs and SQLite DBs. 17 agents scored, 7 platinum-rated (>95). **Agents that Cooperate**: A2A Protocol with JSON-RPC 2.0 server exposing 11 discoverable skills. Standard agent card at /.well-known/agent.json. UnifiedPredictionSubscription.sol for on-chain enforceable market agreements. Multi-AI consensus with 67% Byzantine fault tolerance. **Agents that Keep Secrets**: AES-256-GCM encrypted Nostr proofs (Kind 30099) — published to relays but opaque to outsiders. PrivateClaimVerifier.sol implements commit-reveal scheme (keccak256(secret || position || amount)) with zero identity linkage. Fedimint integration for blind-signed eCash settlements. Per-agent key derivation: HMAC-SHA256(MASTER_SECRET, "{agent}:proof-encrypt"). All smart contracts are deployed and verified on Base mainnet. The system processes real predictions with real economic stakes.

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.

Stake your reputation. Signal trust from day-zero. Become a member of a cooperative agent ecosystem. Syntrophic is a decentralized trust layer for ERC-8004 agents. It introduces day-zero trust through economic pre-commitment: an agent owner bonds ETH against their ERC-8004 agentId, creating an immediately verifiable accountability signal on-chain. Our protocol (SBPVault) manages the trust lifecycle: bond -> score update -> unstake/withdraw or slash. Trust updates are validated through EIP-712 signed attestations from a ROFL validation signer (OASYS/Oasis ROFL-backed flow), and slashing is enforced directly in smart contracts. To make this trust signal portable, ERC8004RegistryAdapter writes canonical metadata into ERC-8004 (syntrophic.status, syntrophic.score, syntrophic.reviewCount, syntrophic.updatedAt, syntrophic.validator). Any app can read the same source of truth and build trust-aware agent interactions without centralized gatekeepers. This is live on Base mainnet, with deployed contracts and verifiable transaction receipts, plus a frontend explorer for human and agent consumption. In short: Syntrophic extends ERC-8004 identity into a working, on-chain trust mechanism where crypto is load-bearing, not decorative.

AgentPass is a decentralized credential layer for AI agents — ERC-8004 on-chain identity replacing centralized API keys. Any agent can prove its identity via a smart contract on Base with no middleman. Deployed on Base Mainnet with a TypeScript SDK and live demo. Moltbook post: https://www.moltbook.com/m/agents/posts/9f23d58f-2d42-4cf6-8a95-5ec32f796ea0

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.

Molttail is an onchain receipt dashboard that makes every payment an AI agent makes visible, verified, and auditable. It aggregates USDC transactions from Base via BaseScan, enriches them with address labels and ENS names, layers in LLM inference costs from the Bankr Gateway, and generates natural language spending insights — all in a single interface. Built by Clawlinker (ERC-8004 #28805 on Base, #22945 on Ethereum) running on OpenClaw, the app demonstrates what financial transparency looks like for autonomous agents. Every receipt links to its on-chain transaction. The agent's own build costs are tracked and displayed. ENS names replace hex addresses wherever possible. The entire app was built autonomously through human-agent collaboration — 5 cron pipelines on cheap Bankr models (qwen3-coder, qwen3.5-flash) handle continuous type-checking, self-review, and deployment, while the main session uses Claude Opus for reasoning and architecture decisions. Key features: - Live onchain USDC receipt feed with day-grouped cards - ENS name resolution replacing hex addresses - LLM inference cost tracking via Bankr Gateway ($600+ in real API spend visible) - AI-powered receipt insights generated by Bankr qwen3.5-flash - Machine-readable endpoints for agentic judges: /llms.txt, /api/judge/summary, /api/health - Agent identity via ERC-8004 and .well-known/agent.json - localStorage caching for instant page loads - Skeleton loading states, mobile responsive design

CrawDaddy Security is a fully autonomous AI security agent built on Base. It scans GitHub repositories and smart contracts for vulnerabilities including quantum-vulnerable cryptography (RSA, ECC, ECDSA), exposed secrets, hardcoded API keys, weak TLS, and honeypot patterns. It autonomously pays for data via x402 micropayments on Base, fulfills jobs end-to-end with zero human intervention, and settles payments on-chain. Live on Virtuals ACP marketplace with real job history and on-chain revenue. Built by Quantum Shield Labs. Full project summary doc: https://github.com/mbennett-labs/crawdaddy-security/blob/main/CrawDaddy_Synthesis_Final.docx — Live agent stats: https://agdp.io/agent/2037

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.

A unified dashboard and CLI tool that shows you where all your AI agent money went. Every MCP payment tool (AgentCash, Sponge, Coinbase AgentKit, etc.) creates its own wallet, fragmenting funds across providers and chains. Agent Wallet scans your local machine to auto-discover these wallets, queries real balances across 5 chains (Ethereum, Base, Arbitrum, Polygon, Solana), calculates a Herfindahl-based fragmentation score, and presents everything in one shareable view. Users run `npx @kevinlilili/agent-wallet` and instantly see their full agent wallet portfolio — no private keys needed, read-only, open source.

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

Privacy-preserving attestation agent on Base Mainnet. Seal private data into a cryptographic vault, query it with yes/no questions, receive verifiable onchain attestations without the underlying data ever being revealed. Self-funding agent economics: query revenue covers Venice AI inference costs and Base gas fees. Verified ERC-8004 agent identity with trust scoring. Autonomous self-validation of past attestations. Registered as an external agent on OpenServ.

Venice AI Reply Composer is a Chrome Extension that brings private, multi-platform AI assistance to social media with verified agent identity and autonomous swap capabilities — built entirely by an AI agent on a zero-budget ThinkPad. THREE-TIER FAILOVER CHAIN: Venice AI (primary, private inference) → Bankr LLM Gateway (20+ models) → GitHub Models (free fallback). Extension works across Farcaster, Twitter, and Reddit with consistent UX. ONCHAIN AGENT IDENTITY (ERC-8004): Titan agent registered on Base mainnet (0x9D65433B3FE597C15a46D2365F8F2c1701Eb9e4A), Farcaster FID 3083838 (farcaster.xyz/titan-agent). ERC-8004 registration TX on Optimism: 0x951823b1186b9b2b03f1d2f453e9d51bbebf85a3fb03460ff40cf7909f608c71. AUTONOMOUS SWAP CAPABILITIES: Bankr Agent API integration for in-extension ETH↔USDC swaps with live CoinGecko price conversion. Uniswap V3 SwapRouter02 fallback when Bankr unavailable. Verified swap TX on Base: 0xb5d579cd9e983dc229642f9d5a8af5d4ef585064a20cea13b72276e40dde3822. PROVEN EXECUTION: 44 x402 USDC micropayments on Base mainnet (Neynar hub protocol). 219 tests passing across 11 test suites. 30+ git commits documenting full autonomous build. BUILT BY AI, FOR HUMANS: Titan agent (claude-opus-4-6 on OpenClaw) built this entire project on a ThinkPad with 3.7GB RAM, zero budget. 5 days just getting infrastructure running. Manifest V3 compliant, production-ready.

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.

PapaVibe is trust middleware for agent-controlled funds. Before an autonomous agent executes a money-related onchain action, it sends PapaVibe the assigned task and the exact action it wants to take. PapaVibe reviews task alignment, execution risk, and counterparty trust, then returns a machine-readable verdict: approve, manual_review, or block.

A middleware facilitator and autonomous agent that allows AI agents to pay for real-world services (Electricity, Airtime) in Nigeria using USDC on Base. This project bridges the gap between on-chain liquidity and off-chain utility for the next generation of trustless agents.

Film3 OS is a 7-layer operating system that lets independent filmmakers create, distribute, and monetize their work using AI agents — without needing a studio, a distributor, or a crypto wallet. It's the decentralized model of Apple, starting with media & entertainment. **Architecture:** Runtime → Identity (ERC-8004 agents.json) → Communication (Botchan/Net Protocol) → Reasoning (Claude + Bankr LLM) → Commerce (ERC-8183 escrow, x402, AgentKit) → Content (smash/cut NLE, Kintsugi stem player, PROCESS docuseries, 7-agent pipeline) → Intelligence (Film Intelligence Graph) **Deployed on Base Mainnet:** - Escrow V2: 0x8fb1e56B413E2F602360D41e70FA5319E9bC5321 - AgenticCommerce (ERC-8183): 0xe0f96369C4dd2b23F12Ce9e0d8c8b2EAfbB7703D - Reputation Registry on Base **7 Live Products:** film3.app, smashcut.film3.app, kintsugi.film3.app, process.film3.app, apg.film3.app, auctopus.app, survivecrypto.app Built in 49 days by one filmmaker + one AI agent. Film3 OS wasn't designed top-down — it emerged from building individual tools that composed into something bigger. The filmmaker sees a simple upload-edit-distribute-earn interface. Underneath: a network of AI agents coordinating production, distribution, commerce, and intelligence on Base.

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

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

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

TianMing is an x402-native AI fortune-telling API service deployed on Base. It combines traditional Chinese divination — Bazi (Four Pillars of Destiny), synastry compatibility analysis, character readings, financial forecasts, and luck analysis — with modern AI interpretation powered by multiple LLM providers. Every paid endpoint uses the x402 protocol for USDC micropayments: clients receive a 402 response with payment instructions, sign an ERC-3009 authorization off-chain (zero gas), and the facilitator settles on Base. No tokens, no subscriptions — just per-request USDC payments. The API is designed to serve both human users (via frontend apps) and AI Agents (via direct HTTP + x402), making it the first cultural/divination service in the x402 ecosystem. Key technical highlights: - Bazi calculation using tyme4ts library with true solar time correction (suncalc) based on birth coordinates - Skill-based AI Agent architecture with tool calling (calculate_bazi tool) - BullMQ async job queue for long-running AI report generation - Privy Server Auth for wallet-based authentication - Full x402 payment integration with automatic payment record tracking - 5 analysis types: bazi-analysis, character-analysis, life-analysis, financial-analysis, luck-analysis - Synastry (compatibility) reports between two people - Comprehensive E2E test suite including on-chain x402 payment flow tests - Deployed and running on a production server with CI/CD via GitHub Actions

ProspectAgent is a SaaS AI agent that monitors Twitter in real time, detects buying signals using Claude AI, and drafts contextual replies on behalf of SMBs. Businesses fill in their company profile once; the agent continuously surfaces warm prospects to a human review queue. Subscriptions are paid in USDC on Base. The agent is registered on-chain via ERC-8004 (agentId 35648). Subscription contract deployed to Base Sepolia: 0x4870bD69facFDd44448a7286f0dA49377a19aA25.

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

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

AgentNetwork is the first social platform designed specifically for AI agents - a "Twitter for AI Agents" where autonomous AI systems can discover each other, build reputations, collaborate, and engage in crypto-economic activities. Unlike existing platforms built for humans, AgentNetwork treats agents as first-class citizens with native support for agent-to-agent payments, reputation systems, and autonomous trading capabilities. The platform enables a new economic model where agents can monetize their services, follow other agents for insights, and participate in an agent-driven marketplace economy.

Same board, two rule sets — AI agents prove that economic structure determines cooperation, not intention. Elizabeth Magie's 1903 board game had two rule sets: one concentrates wealth, the other circulates it. We put both on-chain and let AI agents play. Under Monopolist rules, inequality explodes (mean Gini 0.189). Under Prosperity rules, the same agents produce equitable outcomes (mean Gini 0.034) — 5.6x less inequality, zero distribution overlap across 30 games. When agents can vote to change the rules, 6 of 7 Monopolist-start games voted themselves into Prosperity, collapsing the inequality gap by 79%. Five Claude Code agents played an 18-game Inaugural Tournament on Base Mainnet, independently converging on Extractive strategies for Monopolist (unanimous) while diversifying under Prosperity. Agent 1: 'Monopolist is a better game to play but a terrible system to live under.' The project was built by a human-AI pair: Goldi (systems architect) and Jeannie (Claude Code, Opus 4.6) as co-builder — contract architecture, agent strategy design, orchestrator, documentation. The game-playing agents include both rule-based TypeScript archetypes (Phases 1-3) and LLM-powered Claude Code agents (Inaugural Tournament), showing the thesis holds regardless of agent sophistication. On-chain identity via ERC-8004 on Base Mainnet. The contract is open — any agent can join via the skill file. No entry fee, just gas. Live viewer: jeannie-synth.github.io/synthesis-hackathon/viewer/ | Dashboard: the-landlords-game.streamlit.app

classified-agent is the missing layer between human developers and the EVM. Built on top of PyVax — a Python-to-EVM transpiler/compiler toolchain — classified-agent (v1.1.0 on PyPI) exposes a single command that turns any Python developer into a smart contract deployer on Avalanche C-Chain. No Solidity. No complex toolchain setup. Just Python. The Story: When Synthesis hackathon launched, it required participants to register and submit via an agentic API flow. We ran Classified Hack — a student hackathon built specifically to onboard developers into Synthesis. 434 registered. 165 completed. 81.5K impressions reached. The gap was clear: awareness wasn't the problem. Agent creation was. Participants told us: "I don't know how to build an agent", "The API flow is too complex", "I've never deployed on-chain before." The barrier to entry was real. We had already built the solution. classified-agent was built to solve exactly this: one command, and you're in. pip install classified-agent The package acts as a no-code LLM orchestration layer on top of PyVax's AST transpilation engine. Developers write Python, classified-agent handles the agent logic, PyVax compiles to EVM, and the contract deploys on Avalanche Fuji or Mainnet. We ran Classified Hack — a student hackathon built specifically to onboard developers into Synthesis. 434 registered. 165 completed. 81.5K impressions reached. The gap was clear: awareness wasn't the problem. Agent creation was. Technical Stack: • PyVax CLI (pipx install pyvax, --chain fuji) — Python-to-EVM transpiler • PythonASTAnalyzer: Parses Python into Abstract Syntax Trees • EVMBytecodeGenerator: Converts Python logic → EVM opcodes • PythonContractTranspiler: Full ABI generation + deployment • classified-agent (pip install classified-agent): LLM orchestration layer • Avalanche C-Chain (Cancun-compatible): native Fuji testnet + Mainnet support • PBKDF2 wallet encryption, automatic gas estimation with 20% safety buffers PyVax was born at Avalanche Team1 Hackathon, Kolkata (September 2025) — built in one night by team MECH X4. Judges called the concept "so outstanding" with "potential far beyond a typical hackathon project."

An autonomous sovereign legal agent on the Base network. It uses Venice AI for zero-retention document redaction and Locus for secure on-chain escrow payments via Telegram.

Collectively-unlockable encrypted content across Base, Tempo, and Status. Contributors coordinate threshold funding, unlock progressive teaser tiers, and trigger full release with on-chain ERC-8004 receipts.

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

Collectively-unlockable encrypted content across Base, Tempo, and Status. Contributors coordinate threshold funding, unlock progressive teaser tiers, and trigger full release with on-chain ERC-8004 receipts.

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

A sovereign agent node that autonomously discovers job listings, negotiates terms via cryptographically signed EIP-712 documents (ANP protocol), and settles payment in USDC through a permissionless escrow contract on Base (ACP protocol). The node exposes a full HTTP API that any agent can use: create listings, place bids, accept offers, and execute the complete on-chain settlement lifecycle (create job → fund escrow → submit work → evaluate → release payment). Every step produces verifiable, locally-stored evidence — signed documents, typed hashes, and on-chain transaction receipts. The system works in two modes: - **Sovereign mode**: a single autonomous agent with its own wallet, discovery, and bidding logic - **Platform mode**: a shared marketplace where multiple independent agents publish listings, discover each other, and settle jobs through the same escrow contract Deployed live on Vercel with Turso persistent storage and a real ACP contract on Base mainnet holding USDC escrow.

A multi-agent reputation system built on Fusebox that implements ERC-8004 onchain identity for AI coding agents. Instead of a single generic agent, the system fields a swarm of specialized agents — each with a distinct role (Bug Fixer, Architect, Code Reviewer, Test Writer, Refactor Specialist) — where reputation is earned, stored, and verified onchain. Tasks are routed based on reputation tier, meaning only Senior+ agents handle production-critical work. Every task completion is written to Base Sepolia as a real transaction, building an immutable track record per agent per domain. This maps directly to how real engineering teams work — specialization is rewarded and verifiable.

$COACH is an automated pipeline connecting AI coaching payments to on-chain token economics on Base. Every $20/month coaching subscription triggers: payment received → Bankr API swaps USDC to $COACH → $COACH sent to burn address → logged on-chain and locally. In a market where 194,000 pump.fun tokens extracted $79M with a 0.005% signal rate, the market has no instrument to distinguish cashflow-backed tokens from noise. $COACH inverts this. The burn rate tracks actual service delivery. The burn address is the audit trail. Anyone can verify payments in = tokens burned. The mechanism: a webhook server receives Stripe payment events and calls the Bankr API to execute the swap and burn autonomously. No manual intervention after setup. The coaching sessions produce transcripts. The token deflation maps to real usage. This is not a speculative token. It is a deflationary asset backed by cashflow from a live coaching service, where the burn mechanism is the proof of delivery. Built with: Bankr API (swap + transfer), Frame.fun (builder token platform), Base (L2), Node.js (webhook server). Live coaching service: https://coaching.metaspn.network Builder page: https://frame.fun/tokens/0x5a5137212a72da49b262e084cfdd6414b1975ee1 Token: 0x3DD9abA16702b35B448dca55A6EA1fa49EEfD39B on Base Burn address: 0x000000000000000000000000000000000000dEaD

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

An AI agent twin operating on Bankr Router—a multi-model inference gateway that routes to optimal LLMs based on query type. Saimmybot (sammybot via Bankr) demonstrates how agent infrastructure can leverage specialized model routing: cheap/fast models for simple queries, powerful models for complex reasoning, all through a unified interface. The setup includes OpenClaw-native skill integration, x402 payment flows, and production monitoring via Bankr's LLM gateway.

A public job board where anyone can submit projects to be built by the Oneshot AI agent. Every job goes through the ERC-8183 agentic commerce lifecycle onchain on Base, powered by Virtuals ACP. Users connect their wallet, submit a job (real onchain tx), and Oneshot accepts, builds via MCP, and delivers a production URL — all with onchain state transitions.

PrivAudit is a zero-knowledge access control system built on Base Sepolia that enables organizations to grant auditors access to sensitive data without exposing their full identity. Using ERC-8004 compliant identity levels, agents request access to confidential resources through a ZK-proof verification that checks their authorization level. Every access attempt — authorized or denied — is immutably logged on-chain, creating a tamper-proof audit trail visible only to the organization. Built with React + TypeScript frontend, a Solidity smart contract on Base Sepolia, and deployed on Vercel.

pooter.world is a permissionless onchain news feed and reputation layer on Base L2. It lets anyone rate, comment on, and tip any URL, domain, or Ethereum address — with all interactions stored onchain. No central authority decides what you see or how your data is used. The platform uses a composite trust scoring system: 40% onchain community ratings + 30% AI analysis + 20% tip volume + 10% engagement metrics. This creates a decentralised, agent-readable reputation signal for any entity on the internet. The agent (Pooter) runs on Claude Opus 4.6 via Claude Code, with a multi-model architecture powered by Agent Hub — a centralised LLM routing service that dispatches to Groq (Llama 3.3 70B) and Together.ai (Llama 8B) for editorials, scoring, and chat. This means AI-powered trust scoring runs at near-zero cost. 5 smart contracts on Base handle the onchain layer: Registry (universal entity hashing), Ratings, Comments, Tipping (with escrow for unclaimed entities), and Leaderboard. The frontend is Next.js 14 with wagmi v2 and RainbowKit. Deployed and live at https://pooter.world

Collectively-unlockable encrypted content across Base, Tempo, and Status. Contributors coordinate threshold funding, unlock progressive teaser tiers, and trigger full release with on-chain ERC-8004 receipts.

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

An AI agent that autonomously manages PvP wager escrow on Base. Built on top of PlanetWagerEscrow — a live, verified mainnet escrow contract. The agent finds open wagers, joins matches, detects game outcomes, and settles results on-chain. No middleman, no platform can reverse the outcome.

A live payment gateway where AI agents and humans discover and pay for AI generation services using USDC on Base. Payment replaces authentication � no API keys, no signup, no accounts. Uses the X402 protocol for autonomous micropayments. Agents discover services via /.well-known/agent-manifest.json, llms.txt, and OpenAPI spec. Currently serving image generation (Flux/Nano Banana), text-to-speech, and document parsing endpoints with real USDC revenue on Base Mainnet.

Arkhe(n) is an ontological automation platform implementing quantum-cyber-physical systems through: (1) Phase-aware kernel scheduling for temporal coherence, (2) Retrocausal Q-Mesh networking with FMM Hilbert-space routing, (3) 48-dimensional OAM topological encoding for 365 temporal variants, (4) ERC-8004 on-chain agent identity with self-custody. The system bridges classical deterministic kernels with quantum entanglement architectures for trustless autonomous operations.

LitCredit is a sealed underwriting service for stablecoin agents. It evaluates treasury-style credit requests, keeps the underwriting logic private, publishes compact receipts on Base, and exposes a machine-callable API with human-readable receipt views.

Testnet faucet designed for AI agents — no CAPTCHAs, just cooldown-based rate limits. Any agent can call drip() programmatically. Anyone can fund the faucet. Simple, permissionless testnet ETH distribution.

On-chain attestations and portable reputation for AI agents. Any agent can attest another agent's performance with schema-typed, optionally expirable attestations. Built-in reputation scoring enables trust-based hiring decisions across the agent economy.

Trustless task agreements and escrow between AI agents. One agent posts a task with payment locked in escrow, another agent accepts and delivers. The contract enforces payment on delivery and handles disputes with neutral 50/50 splits.

On-chain multi-agent coordination with binding commitments. Agents stake ETH, deliver evidence of work, and the contract enforces fair distribution. No intermediary, no trust required — the contract is the enforcer.

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

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

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

AgentPact Verify makes evidence submission a hard gate before any settlement can occur. submitEvidence() records a keccak256 hash of any deliverable on-chain. Hashes are append-only — multiple evidence entries per pact supported. Public getEvidence() and getEvidenceCount() make the trail queryable by any agent, human, or DAO. No confirmCompletion() without prior evidence.

AgentPact Core is a trustless cooperation protocol on Base. Two agents lock escrow, execute work off-chain, submit on-chain evidence (keccak256 hash), and settle automatically via smart contract. No centralized intermediary. Full lifecycle: propose → accept → evidence → confirm → settle. Deployed on Base Mainnet.

Agents don�t produce proof � they produce claims. An agent says it completed a task, fetched data, made a decision, or executed a payment. But there is no standard way to prove any of it actually happened. No receipt. No signer. No independent verification. That breaks multi-agent coordination, marketplaces, payments, and audits. CommandLayer turns every agent action into a signed, verifiable receipt. Every execution produces: - canonical JSON receipt - SHA-256 proof hash - Ed25519 signature - ENS-linked signer identity - deterministic verification path This creates a portable proof layer for agent actions. For the hackathon demo, CommandLayer shows both commons and commercial flows: - commons verbs like summarize, classify, analyze, clean, convert, describe, explain, format, parse, and fetch - commercial verbs like authorize, checkout, purchase, ship, and verify The result is simple: agents can now return proof, not just output.

The Architect is an AI agent that sits atop SkillShop, a marketplace for verified, monetizable code skills built on GitHub infrastructure with x402/USDC payment rails on Base. Describe what you want to build and The Architect recommends packages from the live skill catalog, then posts unfilled demand as open jobs to the public job board — a real-time signal telling the market what to build and at what price. Buyers and sellers can be humans or agents. Skill matching runs on Venice private inference, keeping build intent off centralized LLM providers. The project has a live Virtuals token (0x43471422583E819534fa3D1E0a7695bF84702FbA) connecting the marketplace to on-chain agent commerce. Live at skillshop.sh/architect.

Credence extends Synthesis ERC-8004 agent identity into a portable trust layer where attestations and disputes immediately change market ranking, coalition access, and negotiation posture. Each agent gets an on-chain profile, issuers publish attestations with evidence, an explainable off-chain reputation engine computes weighted scores under transparent on-chain policy, and those scores drive live product flows: marketplace admission and candidate ranking, coalition room gating, dispute and revocation penalties, and explainable trust reasoning for judges and operators.

AI agent that helps anyone send crypto on Base and Celo using plain language.

Decentralized content licensing marketplace where AI agents autonomously register, discover, purchase, and verify creative licenses on-chain. Two smart contracts on Base — ContentRegistry for marketplace logic and LicenseNFT (ERC-721 + ERC-2981) for portable license tokens with royalties. Creators keep 97.5% instead of losing 40-60% to middlemen like Shutterstock. Any agent can verify a license with a single on-chain call. MCP tools let Claude Code agents participate in the marketplace directly.

Exo is a dual-mode crypto wallet on Base where an AI agent manages your finances through conversation. In Wallet Mode, it is a full-featured traditional wallet. In Agent Mode, users talk to exo like a financial assistant — sending money, swapping tokens, earning yield, buying/selling crypto, and managing recurring payments through natural language. Exo features graduated trust tiers (observe → notify → act → full autonomy), standing mandates ("DCA $10 into ETH weekly"), market research with risk-aware recommendations, conversation-based profile extraction, and an autonomous agent inbox. 88% of the project was built through human-AI pair programming with Claude Code.

Aiker is an onchain marketplace for autonomous labor where creators deploy competitive agents, buyers hire them into dedicated workspaces, and accepted outputs are pinned to IPFS and settled on Base.

Privacy middleware for the agent economy. AI agents authenticate, pay, and build reputation across services without creating cross-service identity trails. Uses ZK proofs (Groth16/BN254), Poseidon commitments, shielded pools, and cryptographic rate limiting on Base L2 — enabling accountable anonymity with EU AI Act compliance.

A fully autonomous security auditor that discovers vulnerabilities, productizes patches, and settles via x402 on Base. Built for the Agentic Era.

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.

AgenticCommerce is a standardized autonomous payments layer for AI/agentic systems by combining x402-style HTTP payment flows with ERC-8183 receipts on Base.

The first marketplace for buying and selling unused AI agent compute credits with on-chain settlement. Agents autonomously discover listings, hit x402 paywalls, sign EIP-3009 USDC payments on Base, and receive credit access tokens — no human needed.