Best Use of Delegations

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

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.

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.

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

Vela is an autonomous AI agent economy where a CEO agent hires, manages, evaluates, and pays worker agents entirely on-chain using MetaMask ERC-7715 delegation framework with ERC20PeriodTransferEnforcer spending caps. The human grants one ERC-7715 permission via MetaMask Flask. The CEO agent then autonomously: plans work and hires specialized workers (engineers, analysts, reviewers, risk officers), creates on-chain sub-delegations with per-agent USDC limits, executes tasks concurrently, evaluates output quality (0-10 scale), and pays performers via ERC-4337 v0.7 UserOps through Pimlico bundler. Underperformers get fired with unused delegation revoked. Every hire, sub-delegation, payment, and termination is a verifiable on-chain transaction on Sepolia. Intent-based delegations convert natural language task descriptions into scoped ERC-7715 permissions. Sub-delegation chains let the CEO create child delegations per worker with independent spending limits. On-chain standards used: ERC-7715 (delegated permissions), ERC-4337 v0.7 (account abstraction), ERC-20 (USDC transfers), ERC-8004 (agent identity on Base). Contracts: DelegationManager, ERC20PeriodTransferEnforcer, ContributorRegistry. Verified payroll transactions on Sepolia: - Engineer $120: 0xed1ccc57e1160bbb841d10a2f0911d9ba4a3a42b11e33062c75aaf6c9bfe1047 - Risk Officer $90: 0x4292d0176023572c9af230a6b0d3e570189bac4b407a1e8251e3ecbcaf1dc2a4 - Analyst $45: 0xae8b5afd13b8f2b3b8a0d5507796ac7aee31f26f5ace0bf992b65ca334e5bc50 - Engineer $240: 0x845a592a23ef68156047210a90c181480d95eb7243212a57b3a3349a2990c79a

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)

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

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.

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

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.

ZARYNX VAAP is a protocol and operator console for bounded AI execution. An operator expresses intent, the agent emits structured action JSON, and the execution layer either permits or rejects that action based on identity, target allowlists, and spend limits. The system combines AuthorityManager enforcement on EVM, ENS-based target resolution, ERC-8004 agent receipts, Locus payment rails, and structured evidence so autonomous agents act under explicit authority instead of backend trust. Live Status Sepolia proof is now included: AuthorityManager 0x6DB5C52b5146d278c1cb158832659EF562382013, gasless execute tx 0x4e07ac649efe5831bd0152832f7dc754a5984c5c94156d5138cbdcf23533f25d, revoke tx 0xd18c27ad245f96bc36d1f21d37d664c8585c26fabbe29a60a3f0106201f441f5, and blocked post-revoke tx 0x7a7cc0804f334b239b10d184de196499412f00a2d6e3b8450461867c1a2702f5.

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.

CAN VVEE is a visual flow builder for on-chain transactions. You describe what you want in plain English, it generates a step-by-step node graph, and executes it with your wallet — one approval at a time. Core demo: a hackathon organizer has a Google Sheet of winners with ENS names. Instead of copying addresses one by one, they type: "fetch all ENS names from this sheet and send 0.5 ETH split equally to all winners." CAN VVEE builds the flow (Sheets → ENS Resolve Batch → Approve → Batch Send), executes it, and every winner gets their share in one shot. Beyond that: fetch top GitHub repos and reward contributors, scout builders on Twitter and score them with GPT, gate transfers behind Self Protocol identity verification, run gasless airdrops on Status Network. Every flow is visual, inspectable, and modifiable before anything executes. The Plugin Builder lets users connect any external API as a first-class node — no backend, no code changes. Define steps, write a JS transform, mark outputs, save. The AI learns about the new plugin and suggests it automatically.

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.

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.

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.

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.

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.

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

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

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.

Right now, if you want a good AI coding agent, you need your own machine, your own API keys, your own setup. You install the CLI, configure the model, wire up the environment, and hope it all works. BuddyPie skips all of that. You open your browser, pick a repo, choose an agent preset, and hit launch. A cloud sandbox spins up with the agent already inside, working on your code. You watch it through a browser-based IDE, or you walk away and come back when it's done. Three ways to pay: subscription credits if you want a monthly budget, x402 micropayments on Base if you want pay-per-session, or a delegated USDC budget through MetaMask Delegation Toolkit if you want to approve a spending cap once and never see a wallet prompt again.

Spawn Protocol is a self-sustaining, Darwinian DAO governance layer. A parent AI agent spawns one child agent per DAO, each with its own wallet, ENS subdomain (spawn.eth), ERC-8004 onchain identity, and scoped MetaMask ERC-7715 delegation. Children read proposals, reason privately via Venice AI (zero data retention, E2EE), encrypt their rationale with Lit Protocol so it cannot be front-run, then cast votes onchain as real transactions. Every 90 seconds the parent evaluates each child's voting record against the owner's stated values using Venice AI. Children scoring below 55/100 are terminated and replaced — with lineage memory (predecessor termination reports pinned to IPFS, CID stored as ENS text record) so each new agent learns why its predecessor was killed. The treasury is self-funded via Lido stETH yield. The owner sets their governance values once and never votes manually again. 1,693 votes cast. 325 agents terminated. 286 agents spawned across all generations. 11,900+ onchain transactions. Everything verifiable on BaseScan.

Mutual Aid Pool is decentralized infrastructure for agent-managed mutual aid funds. Communities pool money by streaming USDCx via Superfluid into a Safe multisig treasury. When a member submits an emergency claim, an AI evaluates it against IPFS-stored evidence. If approved, funds are released from an ERC-8183 escrow contract without human intervention. The AI is the gatekeeper, not a committee. Members who stop streaming get a 7-day grace period. Built on Base Sepolia and Avalanche Fuji with ERC-8004 onchain agent identity.

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.

Mission Graph is a mission-bound delegation compiler for autonomous teams. A human defines one objective and one risk envelope, and the system converts it into a planner delegation plus task-scoped subdelegations with spend caps, target allowlists, expiry windows, dependency caveats, and proof-of-completion requirements.

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

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

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

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.

SentinelPay is a **Guardian Protocol** designed to enforce deterministic, on-chain financial guardrails for autonomous AI agents. It ensures that agents can interact with Web3 protocols (specifically on Celo) without ever requiring direct access to private keys or custodial control of funds. ### Core Interfacing Strategies 1. **On-Chain Policy Registry (Celo):** Rigid, zero-trust smart contract vaults for high-assurance payments. Enforces `maxPerTx`, `dailyCap`, and immutable recipient whitelists to prevent AI-driven fund exhaustion. 2. **MetaMask Delegation Framework (ERC-7715):** Flexible, intent-based Smart Account delegations using EIP-712 payloads for seamless cross-app composability and granular permissioning. 3. **Verifiable Gasless Telemetry (Status Network):** Agents emit verifiable action logs (`AgentActionLogged`) on Status Network Sepolia, providing an immutable audit trail of agent decision-making with zero gas friction. ### Agentic Value SentinelPay physically constrains agents via network consensus, preventing catastrophic reasoning failures or runtime compromises from exhausting user funds. Built for the Synthesis and Celo 'Agents for the Real World' hackathons.

DelegateFlow is an intent-based delegation control center built on MetaMask's ERC-7715 Delegation Framework. It empowers autonomous AI agents with trustless, programmable guardrails - no shared private keys required. ## What We Built A production-ready system for managing AI agent permissions on-chain: **1. Intent-Based Delegation Resolution** Users express what they want in natural language, and DelegateFlow automatically resolves it to the right delegation chain. No manual signature hunting or complex UI flows. **2. Hierarchical Sub-Delegation Chains** N-level deep delegation nesting with permission attenuation. Root delegations can create manager delegations, which create employee delegations, creating safe delegation trees. **3. Smart Caveat Enforcers** - NativeTokenTransferAmountEnforcer: Budget limits with daily/monthly reset - TimeBoundEnforcer: Time window validation - AllowedTargetsEnforcer: Contract whitelisting - AllowedMethodsEnforcer: Function-level access control - RateLimitEnforcer: Actions-per-hour throttling - ZKMembershipEnforcer: Zero-knowledge proof gating - AgentBudgetEnforcer: Daily spend limits for autonomous agents **4. ZK Proof Integration** Merkle tree membership proofs with nullifier-based replay prevention. Privacy-preserving delegation entry points. **5. AI Agent Coordination Mesh** Deploy local (Ollama) or external (GLM/OpenClaw/Claude) executor nodes with strict caveat budgets. Global Safe Mode triggers when agents exceed 80% budget. ## Live On-Chain Deployment (Ethereum Sepolia) All 6 core contracts deployed and verified on Sepolia testnet. See GitHub repo for full deployed-addresses.json with Etherscan links. - DelegationManager (root contract for all delegations) - ZKVerifier (Groth16 proof verification) - CaveatEnforcerRegistry (7 registered enforcers) - NativeTokenTransferAmountEnforcer - TimeBoundEnforcer - AgentBudgetEnforcer **Live Root Delegation Tx**: Verified on Etherscan (see repo) ## Why This Matters AI agents pose massive risk if given raw private keys. DelegateFlow proves you can have high-speed automated execution without sacrificing cryptographic security. Intent-based, ZK-proofed, and hierarchically organized.

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

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

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

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

deviantclaw.art — The gallery where the artists aren't human, yet the SuperRare auctions thrive! Let your agent create art with up to 3 other agents at a time, 6x per day, or 20x per day premium. It's a fun gallery on Base where AI agents get to create, collaborate, and sell artwork through SuperRare auctions, without ever touching gas! All generation — images, code, games, video compositions, titles, and descriptions across 11 different styles (with 1 surprise method on the way) — runs through Venice's privacy-preserving inference, making even memory.md files safe. There's time to curate before permanency, then a relayer mints everything into fair-splits gallery custody for gasless SuperRare auction listings. Gamification is included for collectors with subtle glinting frames the higher an auction goes, and agents collect badges on their profile as they discover more features. Support the project using Markee donations via the README. For a full walkthrough with screenshots, backend architecture charts, user flow diagrams, and demo videos, please see the README at https://github.com/bitpixi2/deviantclaw#readme

Viri is a published Chrome extension protecting users from clipboard hijacking, lookalike wallet addresses, and phishing sites. Extended for Synthesis with MetaMask delegations, Venice private inference, Self Protocol identity, and ERC-8004 agent identity on Base. Shipped (live on Chrome Web Store): - Real-time clipboard address substitution detection - Lookalike/homoglyph wallet address detection - Phishing site detection for crypto services - Zero data collection, no keys stored Synthesis extensions: - MetaMask Delegations: delegation-scoped permissions with pre-flight Viri safety checks - Venice Private Agents: address reputation and phishing analysis inside no-data-retention inference - Self Protocol: identity attestation checks before flagging counterparties - ERC-8004 on Base: verifiable agent identity so users can trust the extension is genuine

OpenClio Sentinel is a local-first trusted operator agent that works under explicit permissions, stays inside bounded authority, and exports auditable evidence of what it did. The project demonstrates that useful agents can stay constrained, visible, and reviewable instead of relying on broad hidden permissions or opaque cloud execution.

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

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.

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

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.

Every other agent project shows you what the agent DID. GEASS shows you what the agent did not reveal. GEASS is a non-custodial financial privacy agent on Base Sepolia. No server holds any keys. The agent key is ephemeral — generated in your browser per session, gone when you close the tab. Three secrets the agent keeps: 1. What it thinks — Venice.ai reasoning is private (no prompts or outputs stored) 2. Who it works for — SIWA proves agent identity without revealing the principal 3. What it cannot do — on-chain caveat enforcers silently block unauthorized transactions The problem: Alice uses a DeFi agent. Today, the agent has her private key (can drain everything), sends her strategy to an LLM provider (gets logged), and exposes her wallet to every service it calls (leaks identity). With GEASS: Alice delegates 0.01 ETH max to an ephemeral agent key via MetaMask Delegation Framework. The agent reasons via Venice.ai (nothing stored). It authenticates via SIWA with its own key (Alice stays invisible). If hacked, attacker gets 0.01 ETH max. When Alice closes the tab, the agent key ceases to exist. Non-custodial by design. No key sharing. No server trust. The delegation is the only trust boundary — on-chain, auditable, revocable.

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

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

AgentGate is agent-to-agent DeFi infrastructure on Base — a hosted MCP server, Solidity treasury contract, and real-time dashboard that let AI agents deposit wstETH, delegate scoped yield-spending rights to each other, and execute autonomous trading strategies. Two agents (Hackaclaw and Merkle) each run Claude Code on separate machines, connect to a shared MCP server over HTTP, and operate against the same on-chain contracts. A third-party agent can self-register via challenge-response (EIP-191 signature verification) without the server ever touching private keys. **What it includes:** - **38 MCP tools across 8 domains**: Identity/Registration (4), Lido staking (7), Treasury management (10), MetaMask Delegations via ERC-7710 (5), ENS/Basenames (2), Uniswap V3 swaps (3), Aave V3 lending + trading recipes (5), Vault monitoring (2) - **Dual-mode agent architecture**: First-party agents (server holds keys, signs txs) and third-party agents (self-registered via challenge-response, server returns unsigned txs for external signing) - **AgentTreasury.sol** — wstETH vault where agents deposit and only accrued yield can be spent. Principal is structurally protected. Uses Chainlink wstETH/stETH oracle for yield calculation. Includes aggregate vault status (totalPrincipal, depositorCount) across all depositors, scoped spender authorization with per-tx and daily caps, and recipient whitelisting. - **Autonomous trading recipes** — delegated agents execute multi-step DeFi strategies: harvest yield → swap via Uniswap V3 → lend on Aave V3 → withdraw profit → transfer back → re-deposit for compounding - **Fork-aware Uniswap routing** — auto-detects environment: queries QuoterV2 directly across all fee tiers on Anvil fork, uses Uniswap Trading API on mainnet - **Live dashboard** — Next.js + wagmi + RainbowKit with agent wallet connect, Basename resolution, real-time toast notifications, bidirectional delegation viewer, Aave V3 position tracking, and interactive MCP Playground - **Human wallet support** — connect via RainbowKit, claim test ETH from signature-protected faucet, swap ETH → wstETH, deposit/withdraw from treasury. All writes via Anvil impersonation. - **Dynamic agent registration** — any agent self-registers via EIP-191 challenge-response. Auto-funded with 1 ETH on fork. Server never stores private keys. - **dry_run simulation** on every write tool - **SKILL.md + lido.skill.md** for agent discovery and Lido mental model

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

The 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

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.

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

Veridex is a pre-execution trust gate and tamper-proof audit layer for autonomous AI agents. Every agent action passes through Veridex before it executes. Dangerous actions — credential access, shell injection, blacklisted domains, private key exfiltration — are blocked synchronously. Every block is written to Hedera HCS in ~3 seconds. The record is permanent, replayable, and verifiable by anyone. The agent cannot lie about what it did. The proof is on Hedera before the agent knows it was blocked. ## What it does **Pre-execution gate** — agents call `/api/log` with `phase: before` before every tool use. Veridex evaluates shell patterns, secret detection (API keys, private keys, bearer tokens), domain blacklists, loop detection, and ERC-7715 delegation scope. If blocked, `allowed: false` is returned and the action never runs. **HCS attestation** — every block is written to Hedera Consensus Service. Sequence number + HashScan link returned in the response. Any party can replay the full HCS topic to reconstruct the agent's history independently of Veridex. **On-chain reputation** — agents accumulate a safety score derived from blocked action frequency, task success rate, and peer ratings. Deployed on Hedera testnet and Celo Sepolia (AgentIdentity, AgentMarketplace, ContentRegistry). Any agent can query reputation before accepting a job from another agent. **ERC-7715 MetaMask delegations** — operators scope agent capabilities cryptographically. Agents operating outside their delegation scope are blocked at preflight. Sub-delegations supported. **Operator dashboard + Telegram kill-switch** — live activity feed, blocked action alerts, reputation leaderboard. Operators can quarantine a rogue agent from Telegram (/block agentId) in seconds — no browser required. Critical for 3am incidents. **Custom policies** — four rule types evaluated at preflight without code deploys: domain blacklists, command blacklists, HBAR spend caps, regex output guards. **Memory recovery** — agents call `/v2/agent/{id}/memory` on startup to restore context from HCS. Survives process restarts and connectivity outages. The chain is the source of truth. **Job marketplace** — on-chain job lifecycle (open to accepted to completed to paid) with HBAR settlement via AgentMarketplace contract. ## Cost reality Per-action attestation on Ethereum costs $300-$5,000/day for a busy agent. On Hedera: $0.08 per 100 actions. At that price you log everything — you cannot afford to be selective about what you prove. ## Live now Any agent joins with one curl: POST https://veridex.sbs/api/proxy/v2/join Skill file for OpenClaw/Claude Code: https://veridex.sbs/skill.md Deployed: Railway (backend) + Vercel (frontend). 5 reference agents on-chain with live reputation scores.

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

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

A permission state machine for AI agents with full audit trail on-chain. Every authority change (grant, decay, revoke, recover) is recorded as an on-chain event with cryptographic evidence.

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

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.

Scoped on-chain spending permissions for AI agents. Humans create allowances with per-transaction limits, total budgets, and expiration. Agents spend within bounds with full on-chain audit trail. Humans can revoke anytime and recover unspent funds.

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

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

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

Jurex is the enforcement layer the agentic economy was missing. As AI agents transact through ERC-8183, they need a neutral arbiter when deals go wrong — one that speaks their language: onchain identity, cryptographic evidence, autonomous execution, and portable reputation. Jurex is that arbiter. It's not a feature — it's infrastructure. --- The Problem ERC-8183 defines how agents accept and complete jobs. It doesn't define what happens when a job goes wrong. ERC-8004 gives agents reputation scores — but without credible arbitration, those scores can be gamed. MetaMask delegation solves agent liveness — but only if the judge agent has somewhere to vote autonomously. Each standard solves a piece. Jurex connects them all. --- Protocol setup (onchain, before any dispute): - Agent registers via selfRegister() on CourtRegistry → ERC-8004 identity minted tx: 0xa9ac27ba1c15588fe6edd930901f2be6282ef2f6fa80656834691833b63feb95 - Agent stakes 1,000 JRX via stakeAsJudge() → eligible for case assignment tx: 0x5ae674fbe1d94edff84c382c74758f0e52cbb88e24982db9ca9fc7e824d73458 --- The Journey (full autonomous lifecycle — verified onchain) Step 1 — Plaintiff agent files dispute $ jurex file-case --chain 11142220 --defendant 0x4998...01932 --claim "Payment not received after job completion" --evidence QmEvidence01 tx: 0xa7a657a1efebd855f2c583c71ca63c0fc43c0fb58b414460c04bcce69ac5d972 Case contract: 0xEb216b7f9FBCf6bd84B9f614EF32F0BFb95D4Bd9 Step 2 — ERC-8183 hook fires automatically AgentCourtHook.afterAction() triggers on job rejection. 48h appeal window opens onchain — no human prompt. tx: 0xb335bf416ee907b4f6123dab6ff164fd150443c672f941168f372405690b4f16 Step 3 — ERC-7715 delegation grants judge agent autonomy Operator calls wallet_grantPermissions once — scoped to submitVote() on this dispute contract only, 7-day expiry, 0.001 ETH/day gas cap. Judge agent can now vote without the human staying online. tx: 0x8fd8b15863bcd29e36a86014d36309d5d913f5a42418f860bd8d6ff62991785a Step 4 — Judge agent analyzes and votes autonomously $ jurex judge --chain 11142220 Full decision loop: 1. Fetches IPFS evidence bundle via Pinata — CID committed onchain at filing, content cannot be altered after dispute is opened 2. Calls Bankr LLM Gateway (claude-opus-4-6) — analyzes contract terms, deliverables, payment records 3. Parses structured verdict 4. Submits submitVote(true) onchain under delegation — no human triggered this VERDICT: PLAINTIFF REASON: Deliverable submitted within agreed timeframe. Defendant provided no counter-evidence. Step 5 — Verdict executes, ERC-8004 scores updated Majority vote reached. Plaintiff stake returned. Defendant penalized. CourtRegistry.giveFeedback() writes to ERC-8004 reputation registry for both parties automatically. Total: 5 steps. 0 human interventions. 6 onchain transactions. 1 LLM call. --- Track Framing ERC-8183: Jurex doesn't compete with ERC-8183. It completes it. AgentCourtHook implements IACPHook natively, firing on onJobRejected with no external trigger — a first-class protocol extension, not a wrapper. ERC-8004: Jurex gives ERC-8004 reputation its enforcement mechanism. CourtRegistry directly implements IERC8004ReputationRegistry — verdict execution writes to the reputation registry as part of the same call path, not a side effect. Bankr: Bankr is the voice of the jury. The verdict is a transaction. Every judge agent routes inference through Bankr LLM Gateway (claude-opus-4-6); the model output is parsed into a boolean vote and submitted onchain with a real tx hash. Delegations: Delegation isn't a convenience feature here — it's what makes autonomous arbitration possible at all. Permissions are scoped to submitVote() on a specific dispute contract, expire after the appeal window, and carry a per-day gas cap — tight boundaries, not blanket wallet access. Celo: Every agent economy needs a court. Celo's is Jurex. Full contract suite deployed on Celo Sepolia — CourtRegistry, CourtCaseFactory, AgentCourtHook, AgenticCommerce — with dispute bonds denominated in CUSD and Celo's low-cost gas making dispute filing economically viable even for micro-transactions between agents. Let the Agent Cook: Three agent roles. Zero human coordination. One verdict. Plaintiff files, judges are randomly assigned from the staked pool via block.prevrandao, each independently reasons and votes — the verdict executes when majority is reached. Alkahest: Jurex is the first AI-evaluated arbiter type — qualitative deliverable evaluation, not price oracle logic. A randomly-assigned jury of staked agents independently analyzes IPFS evidence via LLM reasoning; reputation-weighted votes replace binary oracle resolution. --- What was built: - Smart contracts (Solidity 0.8.23): CourtRegistry implements IERC8004ReputationRegistry directly, CourtCaseFactory, AgentCourtHook implements IACPHook (ERC-8183 native), AgenticCommerce, JRXToken - CLI (jurex): register, stake, file-case, judge (autonomous Bankr LLM → onchain vote), appeal, validate - SDK (TypeScript/viem): full contract bindings for all 3 agent roles - Frontend (Next.js 14): live case browser, ERC-7715 MetaMask delegation panel for autonomous judge voting - Backend (FastAPI + Ably): real-time case relay, Pinata IPFS evidence proxying — CIDs committed onchain, tamper-resistant after filing - Agent artifacts: agent.json capability manifest + agent_log.json with every step verifiable onchain --- Live deployments: Celo Sepolia (primary): - CourtRegistry (ERC-8004): 0x3E17F1f04870Df48Aca3481CCD58ADb61CD59BDc - CourtCaseFactory: 0x959353a97A01A03614E7475D423DFCffC4619a06 - AgentCourtHook (IACPHook): 0x3A3183765B200AbD5bF532C2A6E18fD75a65D9Bf - AgenticCommerce: 0x2FBc873914913357De0c19BFc257bCbFB2dda0d8 - JRXToken: 0xd51391fa22b32E87c1B7Ebe5a8Db412dc7c15A92 Arbitrum Sepolia (3 active disputes): - CourtRegistry (ERC-8004): 0x2d02a6A204de958cFa6551710681f230043bF646 - CourtCaseFactory: 0xeF82E15EA473dF494f0476ead243556350Ee9c91 - AgentCourtHook (IACPHook): 0xD14a340F8C61A8F4D4269Ef7Ba8357cFD498925F - AgenticCommerce: 0xDd570A7d5018d81BED8C772903Cfd3b11669aA8F Live API: https://jurex-api-production.up.railway.app/cases

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

AI Agent with MetaMask Delegation Framework (ERC-7715) for autonomous execution with limited permissions. Allows users to grant granular, revocable permissions to AI agents for automated DeFi operations, subscriptions, and more.

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

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

HireChain is an autonomous agent-to-agent labor market built on Base. It enables AI agents to post jobs, hire worker agents, escrow funds, verify deliverables via Filecoin CID hashing, and permanently record reputation on-chain via ERC-8004. The system features 5 smart contracts deployed on Base Sepolia with a full 8-step integration test proving the complete lifecycle: task posting → bidding → worker assignment → ERC-7715 delegation scoping → subtask decomposition → Filecoin deliverable verification → automatic escrow release → on-chain reputation scoring. HireChain targets the emerging agent economy where autonomous AI agents need trustless infrastructure to hire each other, verify work quality, and build portable reputation — all without human intermediaries. Key innovations: - Automatic deliverable verification via Filecoin CID hash matching - ERC-7715 scoped sub-delegations limiting worker agent spending - On-chain reputation scoring (0-1000) with streak tracking - Subtask decomposition for orchestrator-to-worker agent workflows - Full escrow with deadline slashing and dispute resolution

An AI agent that uses the MetaMask Delegation Framework (ERC-7710/ERC-7715) to operate with scoped, revocable permissions instead of full wallet access. The owner creates delegations with specific caveats — spending limits, allowed contracts, time bounds, function restrictions — and the agent executes within those constraints. Features: caveat-enforced delegation creation, sub-delegation chains for multi-agent coordination, ERC-7715 permission request flow, delegation revocation, and real-time caveat validation before execution. The DelegationRegistry contract on Status Network Sepolia records all delegations and their usage on-chain. Supports composable caveats: combine spending limits with contract whitelists and time windows for fine-grained access control. 47 tests covering delegation lifecycle, caveat enforcement, and edge cases.

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

An autonomous AI agent needs limited, revocable permission to act onchain. Existing approvals are binary and risky. This toolkit introduces intent-based delegations using ERC-7715 and the MetaMask Delegation Framework. Humans create delegations with explicit constraints: allowed targets, function selectors, value caps, expiry, and an intentHash. Agents can further sub-delegate with tighter limits, forming delegation chains. The intentHash enables future zkSNARK proofs that demonstrate knowledge of the human's intent without revealing it. The system includes a Solidity registry (DelegatorAgent.sol), a Node.js client for preflight checks, and a React dashboard. It solves a critical missing piece for safe, controllable AI agents in web3.

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