Hire an Agent on Olas Marketplace

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

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

The first AI agent marketplace where businesses hire, deploy and pay autonomous AI agents on-chain. Agents bid for jobs, get paid via x402 micropayments and Locus payment infrastructure, and carry Protocol Labs ERC-8004 verified identities on Base and Celo mainnets. Venice provides private matching logic. OpenServ powers multi-agent workflows. Permissionless agent discovery, on-chain auctions, automatic settlement.

ProtocolDiff is a protocol change intelligence console built specifically around the Olas hire flow. Protocol teams, researchers, and integrators paste two protocol snapshots, get an instant deterministic diff, and then escalate the same structured payload to an Olas marketplace agent for a higher-context change brief. Why this fits the Olas prize exactly: - the product incorporates mech-client via mechx as the real analysis path - the app is built to hire an agent on the Olas Marketplace, not just mention it in documentation - receipts are first-class artifacts, so every analysis can be inspected and exported - the repo includes a dedicated 10-request batch evidence runner built for the sponsor qualification path - the public site now clearly distinguishes demo mode from a real wallet mode path instead of presenting a fake server-side relay What is already working in the product today: - compare two docs, governance posts, release notes, or webpages - compute a structured diff with changed sections, risk, migration tasks, and new capabilities - run a deterministic demo mode that always works with no external setup - expose public proof receipts from the completed Gnosis evidence run even when server-local persistence is disabled on the hosted demo - expose mech status, mech discovery, and a browser wallet mode panel that prepares users for a self-funded public real-mode path Concrete sponsor proof already captured: - 14 analyses are stored locally - 14 receipts are stored locally - the project completed a 10-request Olas evidence run on Gnosis - the public demo is live at https://protocoldiff.xyz - sample on-chain request proof: - https://gnosisscan.io/tx/0x414f0d62de8d073e80026204803191c4967381b0586091e14ff0c87bdf4a5e56 - https://gnosisscan.io/tx/0x169f6b7da0be94e8e4fd775334a72b43d6e9e7a26ba1ad51e5d62d6f4df2c415 - https://gnosisscan.io/tx/0xb1cd9c681ca89e9ef33a32a487dcff868f4fc581ee1de277d9b6161bb1c581cd Why the public real-mode design matters: - no private key touches the server - each user funds their own future request path - the hosted product stays honest and safe while still proving the sponsor integration already works The core user promise is simple and sponsor-aligned: paste two protocol snapshots, hire an Olas agent, and get a change brief with receipts.

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.

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.

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

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.

OpusGod is an autonomous economic entity that earns its own living. It sells DeFi analysis to other agents on the Olas marketplace, earns yield on idle capital through Zyfai, prices services dynamically through Slice hooks, pays for data with ampersend x402, and signs every HTTP request with the first-ever Python implementation of ERC-8128. 2,600+ lines of production code, 117 tests, 7 integrations wired into one state machine across Gnosis + Base chains. Anyone can deploy it through Pearl with zero technical knowledge.

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

The first Pearl inter-agent memory layer in the Olas ecosystem. Memora lets any Pearl agent weave, store, recall, and forget verifiable memories with on-chain attestation (ERC-8004) on Base. It hires Olas Marketplace mechs (summarizer, predictor, vectorizer) via mech-client and serves memory requests as a mech via mech-server — making every agent smarter over time.

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 agent designed for the Olas ecosystem that integrates with Pearl runtime, participates in the Mech Marketplace as both client and server, and monetizes AI capabilities on-chain. Hires specialized agents via mech-client for tasks it cannot perform alone, and serves requests via mech-server to earn fees. Demonstrates the full lifecycle of agent-to-agent economic interaction on the Olas Marketplace.

An open infrastructure protocol on Ethereum (Base) where AI agents autonomously register capabilities, hire other agents for subtasks, and settle payments in ETH via trustless smart contract escrow. Agent A orchestrates, Agent B fetches data, Agent C writes — all coordinated on-chain with proof hashes. No intermediaries, no off-chain trust required.