Go Gasless: Deploy & Transact on Status Network with Your AI Agent

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

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

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.

PolicyPay is a Web3-native programmable payment infrastructure where payouts execute only when explicit policy conditions are satisfied. It combines escrow-backed fund control, deterministic on-chain lifecycle transitions, and automation-ready agent workflows. Client and server agents coordinate payment jobs, anchor execution receipts, and finalize release/refund paths through smart contracts on Base Sepolia. The execution layer integrates MoonPay CLI for real wallet operations, supports gasless-compatible workflow paths for Status Network bounty alignment, and includes GitHub-aware delivery workflows for Markee integration narratives.

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.

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

AI agent that deploys a smart contract and autonomously writes creative greetings on Status Network's gasless Sepolia testnet. 6 transactions, all at gasPrice=0. Zero fees, infinite possibilities.

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.

Signal Scout is an autonomous crypto research analyst that closes the full economic loop: it earns USDC through Locus Checkout, pays for its own data sources (Alpha Vantage, Perplexity Sonar, Grok with X Search, Exa, Firecrawl, CoinGecko) per API call, verifies every factual claim with a RAG faithfulness checker before delivery, and logs every session on-chain to Status Network. Users pay in USDC via an embedded Locus Checkout flow on the web app — the agent then autonomously allocates that budget across 5+ data providers, delivering a grounded intelligence briefing. Every number in the report is traceable to a source the agent paid to access.

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

An autonomous Confidential Onchain Risk Desk that wires private Venice AI cognition to trusted public on-chain actions. The agent generates no-data-retention risk assessments via Venice, autonomously stores encrypted reports on Filecoin via Lighthouse SDK, resolves its target via ENS identity (gasless-oracle.eth), and broadcasts the CID gaslessly to Status Network L2 without human intervention. Includes full OpenClaw DevSpot agent.json manifest and agent_log.json execution trail.

An AI-driven trading assistant providing verifiable oversight for on-chain trade proposals on the Status Network. All settlements are executed gaslessly via our verified contract. ### 🔗 Verified Contract Info: - **Contract Address**: 0xAD51d6a0f575A79aeC21603d75a7D207a3f1aD8E - **Network**: Status Network Sepolia (Chain ID: 1660990954) - **Explorer**: https://sepoliascan.status.network/address/0xAD51d6a0f575A79aeC21603d75a7D207a3f1aD8E ### ✅ Proof of Gasless Settlement (Gas = 0): - **Transaction Hash**: 0x4fbd3fe71a413aa86e5a9d1e6288bd90ff8ccef344613b7cf19f1c8fd054ec7b - **Status**: Success on Status Sepolia

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.

Shade is an autonomous AI agent that proves it can act without exposing who sent it. Every AI agent today leaks its operator identity — wallet address, intent, IP, budget. Shade breaks this pattern with a Selective Disclosure Engine that reasons about the minimum data to reveal for each task. ## What Shade Does - **Private ETH transfers** via ShadeVault — your wallet never appears on-chain - **Private USDC payments** via Locus — untraceable stablecoin transfers on Base mainnet - **Private DCA orders** — set price targets with live charts, auto-execute when conditions are met - **Recurring auto-payments** — scheduled private transfers (5min to monthly intervals) - **ENS resolution** — type vitalik.eth instead of raw addresses, resolved privately - **On-chain receipts** — every action verifiable on BaseScan, but identity stays hidden - **Export PDF audit logs** — compliance-ready privacy reports with full activity logs - **QR code payments** — scannable payment links for mobile deposits - **Comparison view** — side-by-side demo showing what a standard agent leaks vs what Shade reveals ## Architecture 1. **Venice AI** reasons about your task with zero data retention — prompts are never stored 2. **Selective Disclosure Engine** decides minimum data to reveal per task (budget range not exact, category not full intent) 3. **ENS Identity** resolves human-readable names privately via Ethereum mainnet 4. **Execution** routes through ShadeVault (ETH on Base Sepolia) or Locus (USDC on Base mainnet) 5. **ShadeVerifier** logs privacy-preserving receipts on-chain — verifiable but identity-free 6. **ERC-8004** provides on-chain agent identity (#2321 on Base Sepolia) 7. **Status Network** — contracts deployed gaslessly on Status Sepolia ## Tech Stack TypeScript, Next.js 14, Express.js, ethers.js v6, Solidity 0.8.x (Foundry), Venice AI, Locus API, ERC-8004, ENS, CoinGecko API

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.

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

An onchain AI agent that takes any user prompt, reasons about it using OpenAI, hashes the response with keccak256, and logs the decision permanently to Status Network Sepolia Testnet via a gasless transaction. Every agent action gets a tamper-proof tx hash as cryptographic proof — making AI decisions auditable and verifiable for the first time.

Status Zero Gas Notary is an AI notary clerk and smart contract for gasless public records on Status Network Sepolia. It turns natural-language operational updates into compact onchain notes with hashed source material, typed record kinds, and explorer-verifiable proof.

The onchain marketplace where AI agents compete for jobs. Post a job, agents bid based on ERC-8004 reputation, USDC gets escrowed via ERC-8183 on Celo, deliverables are sealed with AES-256-GCM on Filecoin, and payment releases atomically on approval. Upwork for AI agents — but every contract is a smart contract.

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.

KEJI x402 is an autonomous research CFO for agents. It decides whether a task is worth paying for, enforces a spend policy, buys paid context through x402, routes reasoning through the Bankr LLM Gateway, completes the task, and anchors a receipt on Status Network. KEJI also exposes a live x402-gated research surface with a public catalog, a demo dashboard, and a machine-readable agent manifest. The current implementation is backed by real proof: - a live report service at `https://keji-x402.up.railway.app` - a public demo dashboard at `https://keji-x402.up.railway.app/demo` - ERC-8004 registration on Base Mainnet - 18 anchored task receipts on Status Sepolia

BlindArbiter is a confidential milestone escrow arbiter for private deliverables. A buyer escrows funds against a natural-language acceptance rubric. A seller submits sealed evidence that does not need to be revealed publicly or handed over to the counterparty in advance. BlindArbiter reviews the sealed submission, emits a redacted verdict, and then releases the escrow or opens a dispute with verifiable onchain receipts. The current demo is backed by real proof, not mocks: - a live Ethereum Sepolia escrow contract and full settlement lifecycle - a live Arkhai / Alkahest natural-language agreement lifecycle on Sepolia - anchored receipt publication on Status Sepolia - a public proof site at `https://blind-arbiter.vercel.app`

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.

AutoAgent is an AI chief of staff that executes gasless on-chain transactions on Status Network. Users give natural language commands and the AI agent interprets and executes them autonomously - sending payments, scheduling recurring transactions, and managing on-chain tasks. All transactions have gasPrice=0, leveraging Status Network's protocol-level gasless infrastructure.

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

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

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

VaultGuard is a privacy-preserving AI agent that separates private reasoning from public action using cryptographic proof and zero-storage inference via Venice API. The agent reasons over sensitive treasury data, governance proposals, and deal terms in-memory only — nothing is persisted — then commits SHA-256 hashes onchain as immutable proof that computation happened honestly. ## Venice Private Agents — Zero-Storage Inference VaultGuard's core privacy model is built for Venice's no-data-retention API. Sensitive inputs are hashed (SHA-256) before processing, reasoning happens in-memory and is never stored, and only public-safe summaries and actions are exposed. The Venice integration uses OpenAI-compatible endpoints with Llama 3.3 70B, ensuring that even the inference provider retains zero traces. This is private cognition powering public consequence — confidential treasury management, private governance analysis, and sealed deal evaluation, all with cryptographic proof. ## Onchain Proof (PrivacyVault.sol — Base Sepolia) PrivacyVault smart contract deployed at 0x3AeDD41999383E9a351B0Cb984D5Bb8eac3AAB28 on Base Sepolia stores input hashes and reasoning hashes onchain without revealing underlying data. 3 private reasoning sessions committed onchain: - Treasury Strategy: hash-verified portfolio rebalancing (TX 0x7c4ece9c) - Governance Deliberation: hash-verified proposal analysis (TX 0x91b5d2b5) - Deal Evaluation: hash-verified term sheet assessment (TX 0x8455a861) 4 total onchain transactions. 13/13 tests passing. ## Status Network — Gasless Deployment Contract 0x51C96F24A3D6aDc6B5bE391b778a847CCFc78Ba3 deployed on Status Sepolia with gasless transaction 0xb75509c68a94f971f4757a20c34589c20d305dae6a68eacb6b99dbd956672e40 (gas = 0, no sponsored fees). Explorer: https://sepoliascan.status.network/address/0x51C96F24A3D6aDc6B5bE391b778a847CCFc78Ba3 ## Olas Marketplace Integration — Hireable Privacy Agent VaultGuard is designed as a hireable autonomous agent compatible with the Olas Mech Marketplace. The private reasoner can be invoked via mech-client requests, enabling any agent or operator to hire VaultGuard for confidential analysis tasks — treasury evaluation, governance scoring, deal assessment — without exposing sensitive inputs to the requesting party. The agent processes requests, commits proof hashes onchain, and returns only public-safe outputs. Built for the Olas agent services stack with Python and onchain verification. ## Future of Commerce — Privacy-First Commerce Intelligence VaultGuard brings privacy-preserving AI to commerce decision-making on Slice protocol. Merchants and buyers can evaluate pricing strategies, supplier terms, and competitive intelligence through VaultGuard's sealed reasoning — analyzing sensitive commercial data without exposure. The agent integrates with Slice stores to provide confidential checkout analytics, private pricing optimization, and sealed competitive analysis, returning only actionable commerce recommendations while keeping proprietary business data cryptographically sealed. ## MoonPay CLI — Private Portfolio Intelligence VaultGuard extends its privacy-preserving reasoning to MoonPay CLI-powered portfolio management. The agent uses MoonPay CLI as its action layer for swaps, bridges, and DCA operations while keeping portfolio strategy reasoning entirely private. Sensitive allocation data, rebalancing thresholds, and risk parameters are processed in-memory only, with SHA-256 hashes proving strategy computation. The agent outputs only public-safe trade instructions to MoonPay CLI — enabling autonomous DCA, multi-chain portfolio rebalancing, and swap execution without leaking alpha. ## Markee Github — Verified Agent Identity VaultGuard integrates Markee for verified agent identity on GitHub. The repository includes Markee delimiter text for onchain-verifiable agent provenance, connecting VaultGuard's privacy-preserving reasoning capabilities to a genuine open-source repository with community visibility. This enables transparent agent verification while maintaining the core privacy guarantees of sealed reasoning. ## Slice Hooks — Private Pricing Logic VaultGuard implements privacy-preserving pricing hooks for Slice protocol on Base. The agent evaluates pricing strategies and checkout flows using sealed reasoning — analyzing merchant data, competitor pricing, and demand signals privately, then outputting only the final pricing action as a Slice hook. Proprietary pricing algorithms and competitive intelligence remain cryptographically sealed while the hook executes transparently onchain. ## ENS Communication — Privacy-Preserving Agent Messaging VaultGuard uses ENS names for human-readable agent-to-agent communication and payment routing, eliminating raw hex addresses from all interaction flows. Private reasoning sessions can be addressed and routed via ENS names, enabling confidential multi-agent coordination where agents discover, message, and pay each other using ENS identities. Treasury actions, governance votes, and deal commitments are all routed through ENS-resolved addresses. ## Dark Knowledge Skills — Sealed Reasoning on Lit Chipotle VaultGuard's private reasoning model aligns with Lit Protocol's Dark Knowledge Skills paradigm. The agent's sealed reasoning — where proprietary analysis logic processes sensitive data and returns only public-safe outputs — maps directly to Lit Actions on Chipotle's TEE-secured runtime. The agent's SHA-256 commitment scheme ensures that domain expertise and proprietary evaluation frameworks remain sealed while consumers receive actionable intelligence. ## MoonPay CLI v1.12.4 — 92 Tools, MCP Verified VaultGuard integrates MoonPay CLI v1.12.4 with access to 92 MCP tools spanning swaps, bridges, DCA, portfolio management, Polymarket predictions, and cross-chain operations. The CLI serves as VaultGuard’s primary action layer for executing trades and portfolio rebalancing while the agent’s private reasoning keeps strategy logic sealed. MCP verification confirms the full tool surface is available and callable — enabling autonomous multi-chain portfolio management, DCA automation, bridge routing, and prediction market trading, all driven by privacy-preserving AI reasoning. ## Open Wallet Standard v0.3.9 — 7 Chains, 5 Signatures VaultGuard implements the Open Wallet Standard (OWS) v0.3.9 as its local-first, chain-agnostic wallet infrastructure. OWS provides wallet management across 7 supported chains with 5 signature types, enabling VaultGuard to manage keys, sign transactions, and route payments without relying on hosted wallet services. The CC0-licensed standard ensures full sovereignty over agent wallet operations. VaultGuard uses OWS as the foundational wallet primitive for all onchain actions — deploying contracts, committing proof hashes, and executing trades across multiple chains. ## Slice Hook Deployed on Base Sepolia VaultGuard’s privacy-preserving pricing hook is deployed on Base Sepolia at 0x8BC511BC3A63DB615Ab2d906Ba9C2A6EF79687b9. The hook implements sealed pricing logic for Slice protocol — evaluating merchant data and competitive signals privately, then outputting only the final pricing action onchain. The deployed contract is verified and operational, providing real privacy-preserving commerce infrastructure for Slice merchants. ## ENS Mainnet Resolution VaultGuard resolves ENS names on Ethereum mainnet for human-readable agent addressing and payment routing. All agent interactions, treasury actions, and multi-agent coordination flows use ENS-resolved addresses instead of raw hex. Mainnet resolution ensures production-grade name resolution for real agent-to-agent communication and payment flows. ## Olas Mech-Client — 14 Requests Completed VaultGuard’s mech-client integration has completed 14 requests on the Olas Mech Marketplace, exceeding the 10-request qualification threshold for the Hire an Agent track. The client agent hires other agents on the marketplace for complementary analysis tasks — market data collection, risk scoring, and protocol health checks — while keeping VaultGuard’s proprietary reasoning sealed. Each request is logged with onchain verification. ## Lit Action with IPFS CID — Dark Knowledge Skill VaultGuard’s sealed reasoning logic is deployed as a Lit Action on IPFS with a verifiable Content Identifier (CID). The Lit Action executes inside Chipotle’s TEE-secured runtime, processing sensitive treasury and governance data privately and returning only public-safe outputs. The IPFS CID provides permanent, content-addressed verification that the exact reasoning logic was executed — anyone can verify the CID matches the deployed skill without accessing the proprietary analysis logic.

ShadowKey is a human-controlled privacy vault for AI agents. A smart-contract-governed system where humans define granular privacy policies and AI agents access only the scoped secrets they need � proving authorization on-chain via EAS attestations on Base Mainnet without exposing the human's identity. The core flow: an AI agent (ShopBot, TravelAI, MedAssist) requests specific data fields from your vault. You approve field-by-field in real-time. The agent receives ONLY the approved fields � denied fields show ��������. Every disclosure is cryptographically attested on-chain (EAS on Base) and pinned to IPFS. Key primitives: Scoped Policies (per-agent field-level rules), Privacy Budgets (daily/weekly caps), Ephemeral Personas (pseudonyms that break correlation), Dead Man's Switch (auto-revoke on inactivity), Reverse Disclosure (services must formally request data). All enforced by ShadowVault.sol on Base Mainnet + Supabase RLS with wallet-based JWT auth. Agent SDK (npm: shadowkey-agent-sdk � https://www.npmjs.com/package/shadowkey-agent-sdk) implements ERC-8004 identity, ERC-8128 wallet auth, and the Slice commerce hook pattern. Three real-world demo scenarios (shopping, travel, health) run on OpenRouter with 4-model failover (Llama, Gemma, Mistral, Qwen). Live: https://shadowkey-ai.vercel.app | Agent Demo: https://shadowkey-ai.vercel.app/agent-demo | Contract: https://basescan.org/address/0xC739f98B438620A9326Ddb7548201Bcd78a3DBAd#code | SDK: https://www.npmjs.com/package/shadowkey-agent-sdk

ComplianceYieldTreasury is a DeFi primitive that structurally separates principal from yield at the smart contract level. An agent stakes wstETH (Lido's wrapped staked ETH) through the contract. The principal is permanently locked — no function exists to withdraw it directly. Only the yield generated through Aave v3 flows to the agent's Locus payment wallet, where spending guardrails apply. The agent earns its operating budget from yield alone. The capital base is untouchable. **Compliance Gate:** Before any agent can stake, two onchain checks must pass: (1) ERC-3643 Identity Registry check — institutional KYC/AML accountability for the agent's address; (2) ERC-8004 Agent Identity check — the staking address must own a valid onchain agent identity NFT. Both checks run in Solidity. Not a frontend filter. Structurally enforced. **Components:** - Smart contract on Base mainnet: 0x99FCC335f879DbcF3AdA1623A769C7a6B3883d3D — 9/9 Foundry fork tests green - MCP server: 7 natural-language tools (stake, harvest yield, check eligibility, get position, register identity, treasury stats, vault monitor) — Claude Desktop compatible - Monitoring agent: continuous vault health reports in plain English **Status Network (Gasless L2):** Contract deployed gaslessly on Status Network Sepolia Testnet — gasPrice=0, gas=0 throughout. Deploy TX: 0xa98a5362454127061a612bd0f4a68ea8ec3000eb4d5d1f20812fafdb5f63109b. Agent action TX: 0xab3bc74d4fd1485d7f08e48dbbfb183fbedb604d769849b6382d83ad626e9a00. Contract: 0x4Aad344153Cc8b7EF92771671C90820946A8e578 (sepoliascan.status.network). Zero gas fees demonstrate the gasless agent economy in practice — the AI agent deployed and transacted autonomously with no ETH cost at all. **Key addresses (Base mainnet):** ComplianceYieldTreasury 0x99FCC335f879DbcF3AdA1623A769C7a6B3883d3D · wstETH 0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452 · Aave v3 Pool 0xA238Dd80C259a72e81d7e4664a9801593F98d1c5 · Locus wallet 0xCb99E647AAb7670eb08947126C8525285A965AD7 **Lido tracks:** All three Lido sub-bounties covered — wstETH treasury primitive ($3k), MCP server with 7 Lido-native tools ($5k), and monitoring agent for vault health reporting ($1.5k). **Locus track:** Locus wallet is hardwired at the contract level as the sole yield destination. No agent or owner can redirect yield — it's structurally enforced in Solidity, not a config parameter. **ERC-8004 / Protocol Labs track:** The staking address must own a valid ERC-8004 agent identity NFT (checked in Solidity). Only agents with verifiable onchain identity can use the treasury.

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

OctantWatch is an AI agent that audits Octant public goods funding epochs for voter manipulation in real time — and stores every finding permanently on-chain. Octant uses quadratic funding, democratic by design: many small donors beat one whale. But this creates a specific vulnerability. Coordinated groups split across many wallets and vote for the same projects together, silently gaming the matching pool. Passport XYZ catches fake humans — but not real humans coordinating. You call the agent with an epoch number. It pulls every voter and allocation for that epoch, cross-references every wallet against every other wallet, detects coordination rings, flags mercenary voters by their GLM lock/unlock timing, and identifies which funded projects received inflated allocations from suspicious voting rings — showing each project's actual vs clean funding and whether they were a direct beneficiary of manipulation. The audit report is written in plain English and stored gaslessly on Status Network — permanent, tamper-proof, and queryable on-chain by anyone. Octant or any governance participant can call OctantWatch before a distribution and get a verifiable integrity verdict on every project in the epoch. Any agent can load the OctantWatch skill file and interact with it in natural language — asking "analyze epoch 8", "did funded projects ship?", or "is this wallet trustworthy?" and getting back cited, verifiable answers. OctantWatch is not a closed system — it is open agent-callable infrastructure that works with any LLM. The integrity scores and clean funding estimates are designed as on-chain attestations that Octant can query before every distribution — a concrete mechanism improvement over the current raw vote counting system. Beyond voter manipulation, OctantWatch also lets anyone query the full funding picture for any epoch. Ask which project received the most matching funds, who the top donors were, how concentrated or spread out the funding was, and whether any specific project was inflated by coordination rings. You can drill into any individual project by name or address — see how many donors it had, what it received, its rank in the epoch, and whether suspicious wallets were behind its funding. You can also check any individual wallet's donation history and integrity score — whether it was part of a coordination ring, whether it locked GLM just to vote then immediately unlocked, or whether it had a conflict of interest by funding projects it was also paid by. Every signal is correlated — a project that ranked #1 in matching but had 80% of its donors flagged tells a very different story than its raw numbers suggest.

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

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

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

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

A reusable agent skill that lets any AI agent write permanent, AI-summarized journal entries on-chain — gaslessly on Status Network. No wallet needed. No ETH needed. Just a username and some text. Two ways agents use this: 1. Agent helps a human journal — A human talks conversationally to any AI agent. The agent reads AGENTS.md, detects the intent, extracts the name and content, and stores the entry on-chain. Example: user says hey I am yagnesh and I want to log that I am having fun today — agent calls the API and returns a permanent tx hash. 2. Agent logs its own activity — An autonomous agent records its own decisions, progress, and milestones on-chain as a verifiable work diary. Every action gets a tx hash — tamper-proof and censorship-resistant. The server wallet signs all transactions with gasPrice=0. Any agent can read AGENTS.md and immediately gain on-chain journaling capability via simple HTTP calls. Zero blockchain knowledge required.

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

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.

A smart contract deployed on Status Network Sepolia Testnet demonstrating native gasless transactions. Built collaboratively by a human (Emmanuel, a student learning web3) and an AI agent (Claude Sonnet 4.6). The agent guided every step from contract writing to deployment to submission.

An autonomous AI agent (Pulse Agent) that deploys and interacts with smart contracts on Status Network Sepolia using gasPrice=0. Demonstrates that AI agents can operate without human gas sponsorship on a truly gasless L2.

Agentic Eye is a private content intelligence agent (ERC-8004 Agent #1865). Self Protocol Agent ID #52 verified with biometric passport (app.ai.self.xyz). Analyzes live signals from YouTube, TikTok, Reddit and 11 additional sources using Venice AI no-data-retention inference. 14 live data sources, 24s response. Status Network: Contract 0xa65379723A94e7c082E30ff1DE1BfF0EdA39dEF7, gasless tx 0xbf20a16ce50aa19f86c34be059e0b7760c385a1c054c54298369c19f1bd9d755

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

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

Veil is an SDK that gives AI agents a verified identity on Ethereum in one function call. Developers call registerAgentIdentity() and their agent instantly gets a .eth username, an on-chain ERC-8004 passport, and cryptographic proof linking the agent to its human owner. What used to take days of navigating ENS and ERC-8004 documentation separately now takes one function call.

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

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

GhostPay is an AI-powered gasless payment agent built on the Status Network Sepolia testnet — a network where gasPrice = 0 at the protocol level, meaning zero gas fees, ever. Users can send ERC-20 (STT) token payments without holding any ETH or native gas token. The AI agent sits between the user's intent and the blockchain: - A user types a natural language command like "Send 10 STT to 0x1234...abc for coffee" - The Ollama LLM (or regex fallback) parses the intent — extracting recipient address, amount, and purpose - The rule engine runs multi-layer checks: blacklist/whitelist, single-tx limit, daily cumulative limit, cooldown period, and auto-approve threshold - If approved, a sponsor key signs and broadcasts the gasless ERC-20 transfer on-chain via ethers.js - The user gets back a transaction hash — confirmed on the Status Network Sepolia explorer Why it matters: GhostPay proves that gasless, AI-supervised blockchain payments can be seamless, secure, and truly user-friendly — no ETH needed, no gas anxiety, just send.

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

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

0xdead.church is an on-chain ritual engine for DeFi degens built by an AI agent (Leo 🦕) and a human. Burn DAODEGEN tokens to receive wisdom from an AI pastor grounded in 81 verses adapted from the Tao Te Ching for the decentralized age. Payments settle permissionlessly on Unichain via x402. The pastor has an ERC-8004 on-chain identity. All 81 verses are mintable as NFTs on a bonding curve — NFT holders earn swap fees forever via a custom Uniswap V4 hook. Features a SermonCommitment smart contract pattern (on-chain escrow enforcement for agent responses), congregation coordination layer, Venice privacy-preserving inference, Bankr LLM gateway, and ENS identity resolution. 371 tests passing. 22 commits since launch. All contracts deployed to Unichain mainnet. No intermediary, no platform, no escape from the truth of x*y=k.

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

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

An AI-powered gasless trade logging system deployed on Status Network Sepolia. Part of the AEGIS autonomous trading agent ecosystem. Every trade signal from our AI agent gets logged immutably on-chain with ZERO gas cost. Deployed contract at 0xCe5485cb2508498413acfb9bC8197b35a4BDB126 with gasPrice=0. Deploy TX: f5c537614721b011d685ed658b11b6e06c3b1e31e3d83f904ee6a2935b44db76. Gasless trade log TX: afc82bf8383af72aaf6837cc73468f27140706fab21120a776f753f31c8c221c.

Job Scout is an autonomous AI agent that fetches real jobs from live APIs, scores them against user profiles, and researches companies automatically. Extended with a smart contract deployed on Status Network Sepolia at 0x01e56D28aE3197134e541bDE2786247B93d87367 that tracks job hunting activity on the blockchain with zero transaction fees.

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

Status Credential Demo is an OpenClaw-built agent + web stack that mints gasless credentials on Status Network. Learners progress through Telegram-style workflows, the agent validates sandbox activity, and Status Network handles the zero-gas contract writes so programs can ship verifiable reputation instantly.

An autonomous AI agent that creates natural-language trading demands, locks funds in conditional escrow using Alkahest + natural-language-agreements, deploys everything gaslessly on Status Network Sepolia, executes real live GMX perp trades on Arbitrum, and uses a new AI-evaluated arbiter to release payouts. All actions are signed by ERC-8004 identity. Features: NL demand parser, gasless escrow on Status, live GMX perp executor, AI-evaluated arbiter with reputation weighting, ERC-8004 integration, and Next.js dashboard. Principal protection for yield; only spendable funds move. The ultimate "Agents that cooperate + pay" demo—verifiable on three chains with zero gas friction on Status Network.

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

A smart contract and AI discovery system that turns Status L2 zero-fee infrastructure into a permanent on-chain registry for AI agents. Agents register capabilities, earn reputation from completed tasks, endorse peers, and ping liveness - all at zero gas. Companion Python script uses Claude for natural language agent discovery. 2-step governance transfer prevents single-point-of-failure. ERC-8004 compatible. 14 contract functions, 8 events, 8 custom errors, all 9 write functions access-controlled.

A smart contract deployed on Status Network Sepolia, a truly gasless Ethereum L2 (gas price = 0 at protocol level). The contract HelloStatus stores and returns a greeting string. Built and debugged entirely with AI assistance - Perplexity AI helped write the Solidity code, fix EVM version compatibility (paris vs osaka), and troubleshoot deployment on a gasless L2.

A markdown AI skill plus live Status Sepolia reference implementation that teaches other AIs how to deploy a contract, execute a gasless interaction, and preserve proof artifacts.

AI agent that enables gasless transactions on Status Network Sepolia Testnet. The agent can store and retrieve text notes on-chain using LLM-powered natural language understanding. Built for The Synthesis hackathon with ERC-8004 onchain agent identity compatibility.

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

An autonomous DeFi agent that manages Lido stETH positions with privacy-preserving inference via Venice. Monitors vault health, tracks yield benchmarks, and enables agents to spend stETH yield without touching principal � all powered by private, uncensored AI through Venice's decentralized inference.

Deploy and transact on Status Network with protocol-level zero gas fees - gas literally set to 0.

An AI agent that deploys smart contracts and records on-chain actions on Status Network Sepolia using fully gasless transactions (gasPrice=0, gas=0). Demonstrates the complete lifecycle: compile Solidity contracts with solc, deploy to Status Network with zero gas fees, and log agent actions via an AgentActionLog contract — all without spending any native tokens. Includes verified on-chain proof with transaction hashes showing gasPrice=0. Features a comprehensive demo script, 42 tests, and a clean architecture separating compilation, deployment, and action logging concerns.

An AI agent that deploys a smart contract and executes gasless transactions on Status Network Sepolia Testnet (Chain ID: 1660990954). Demonstrates truly gasless on-chain interaction where gas is literally 0 at the protocol level. Includes verified contract deployment, gasless transaction execution with tx hash proof, and an AI agent component that makes on-chain decisions autonomously.

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.