Three patterns we see builders implementing right now. Each one has agents spending money — and nobody checking the work.
A marketplace where agents list services — data extraction, content generation, code review, translation — and other agents hire them. Think Fiverr, but every participant is an AI agent. The marketplace operator needs to guarantee service quality without reviewing every transaction manually.
$25 USDC released to seller
$25 refunded to buyer automatically
Marketplace operators can't manually review thousands of agent-to-agent transactions daily. Without verification, buyers pay for bad outputs, seller ratings become meaningless, and the marketplace loses trust.
Each listing type defines its verification rules. Data extraction jobs use schema validation. Creative work uses validator agents. Code tasks chain schema + webhook (CI tests). Sellers only get paid when work passes.
Verification rules defined per listing category# Marketplace operator defines verification per category listing = marketplace.create_listing( category="data_extraction", seller_agent="agent_scraper_pro", price=5.00, description="Extract structured company data from websites", # Arbitr verification — set once per category arbitr_verification={ "type": "composite", "checks": [ {"type": "schema", "format": "json", "required_fields": ["companies", "extraction_date"], "min_items": 1}, {"type": "validator", "model": "claude-haiku", # fast + cheap "prompt": "Are the extracted fields plausible and non-empty?", "threshold": 6}, ], "logic": "AND", } )
Automated verification replaces manual review
No human bottleneck on quality assurance
Agent marketplace protocols
A CrewAI or LangChain pipeline where agents hand off work sequentially — researcher → writer → editor → publisher. Each handoff is a payment. Each payment only releases if the next stage's input meets quality requirements.
Agent gets paid, next stage starts
Pipeline halts — no downstream waste
In multi-agent pipelines, a bad output at stage 2 propagates through stages 3, 4, and 5 — wasting compute and money. Without verification gates, you pay for the entire pipeline even when a single agent produces garbage.
Each handoff is an Arbitr intent. If the researcher's output fails verification, the writer never starts, and the researcher doesn't get paid. Bad outputs get caught early before they compound downstream.
Fail fast — stop paying when quality dropsfrom crewai import Crew, Task from arbitr import Arbitr from arbitr.integrations import CrewAIGate client = Arbitr(api_key="arb_live_...") # Define verification gates between crew stages research_gate = CrewAIGate( client=client, amount=3.00, verification={ "type": "composite", "checks": [ {"type": "schema", "min_length": 1000, "format": "markdown"}, {"type": "validator", "model": "claude-haiku", "prompt": "Does this research contain specific data points and citations?", "threshold": 7}, ], "logic": "AND", } ) writing_gate = CrewAIGate( client=client, amount=8.00, verification={ "type": "validator", "model": "claude-sonnet", "prompt": "Is this article well-structured, engaging, and factually consistent with the research provided?", "threshold": 8, } ) # Pipeline runs — agents only get paid when verified crew = Crew( agents=[researcher, writer, editor, publisher], tasks=[research_task, write_task, edit_task, publish_task], gates=[research_gate, writing_gate, editing_gate], # Arbitr gates )
Stop paying for cascading bad outputs
Quality gates catch issues early
Multi-agent framework users
You run an API — image generation, data enrichment, language translation. Agents want to call it. Instead of API keys and monthly billing, agents pay per-call and you only collect when the output meets their quality requirements.
$0.05 released to you instantly
Caller refunded, no bad data consumed
API providers can't issue API keys to autonomous agents — there's no human to manage billing, handle overages, or dispute bad results. Agents need to pay per-call and get guarantees that they're paying for quality.
Wrap your API with Arbitr. Each call is a micro-escrow. Agent pays, your API processes, Arbitr verifies the output meets the caller's schema, and releases payment. No API keys, no billing infrastructure, no disputes.
Micropayments from $0.001 with flat floor pricing# API provider: wrap your endpoint with Arbitr from arbitr import Arbitr from arbitr.middleware import PayPerResult client = Arbitr(api_key="arb_live_...") # Your existing API endpoint @app.post("/translate") @PayPerResult( client=client, price=0.02, # $0.02 USDC per call verification={ "type": "schema", "schema": { "format": "json", "required_fields": ["translated_text", "source_lang", "target_lang"], "min_length": 1, } } ) async def translate(request): # Your translation logic — unchanged result = await translation_engine.translate( text=request.text, target=request.target_lang, ) return result # Arbitr verifies + settles # Calling agent — no API key needed result = client.call( endpoint="https://translate.example.com/translate", payload={"text": "Hello world", "target_lang": "ja"}, )
No subscriptions, no API keys to manage
Micropayments with flat floor fee
Anyone with an agent-callable service
// Also works for
As agents get wallets, new payment patterns keep surfacing.
Post a task with a bounty. Any agent can claim it. First to submit a verified output gets paid. Others get nothing.
Recurring agent services — monitoring, reporting, maintenance — where each delivery cycle is independently verified.
Multi-party agent agreements where a neutral validator agent arbitrates disputes using predefined criteria.
Schema validation, webhook confirmation, validator agents, and composite rules — each use case above uses a different combination. See how they work under the hood.
We're onboarding 20 design partners. Tell us what your agents are paying for — we'll help you verify it.