The Problem

Current AI deployment faces several challenges that the Outcomes Protocol addresses:

Comparison to Current Approaches

vs. Vertical AI Companies (Harvey, Intercom)

• Current: Each company builds trust, pricing, guarantees independently
• Protocol: Standardized outcomes enable marketplace dynamics, risk trading

vs. API Pricing (Per-token)

• Current: Buyer bears all outcome risk, no guarantees
• Protocol: Outcome-based with configurable guarantees and escalation

vs. Manual Warranties (Intercom $1M Guarantee)

• Current: Bespoke pricing, company-specific
• Protocol: Market-based risk pricing, portable across providers

Outcome Types

Like Meta's campaign objectives, the protocol defines standardized outcome types. This enables price comparability, market liquidity, and success criteria standardization.

Customer Service

Single outcome type — customer service is reactive, you don't know what the customer will need until they ask.

Code

Review PRs for bugs, style, and security issues. Diagnose and fix reported bugs.

Legal

Contract review, summarization, comparison, and drafting. All legal outcomes are guarantee-backed.

Medical

Clinical documentation from patient encounters. Real-time scribing with guarantee coverage for documentation accuracy.

Verification Models

Outcomes use one of two verification models based on whether success can be objectively measured:

When to Use Which?

Two factors determine the right model: visibility (can you observe signals?) and expertise (can you evaluate quality?).

Bid Strategies

Mapped from advertising concepts to outcome pricing:

How It Works

You set your bid strategy, and execution engines compete to deliver outcomes within your constraints. The system optimizes over time based on Conversions API feedback.

Conversions API (cAPI)

A server-side feedback mechanism following Meta's Server-Side Events model:

• Outcome verification signals — Report success/failure based on observable events
• Guarantee claim processing — File claims when defects are discovered
• Provider scoring — Track execution engine performance
• Cost optimization — System learns from successful outcomes and claim-free deliveries

Event Types

{
  "event_type": "outcome.success",
  "event_time": "2025-01-18T10:30:00Z",
  "outcome_request_id": "out_123abc",
  "success_criteria_results": {
    "resolution_confirmed": true,
    "customer_satisfaction": 5,
    "no_reopen_24h": true
  }
}

{
  "event_type": "guarantee.claim",
  "outcome_request_id": "out_456def",
  "claim": {
    "type": "documentation_error",
    "description": "Incorrect dosage documented",
    "evidence": "...",
    "requested_amount": 500.00
  }
}

System Architecture

┌─────────────────────────────────────────────────────────────────┐
│                      RISK MARKET LAYER                          │
│        (Future: Outcomes Contracts, Risk Pricing)               │
├─────────────────────────────────────────────────────────────────┤
│                    OUTCOMES MARKETPLACE                          │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐       │
│  │   Outcome    │    │  Bid/Budget  │    │  Delivery    │       │
│  │   Catalog    │ →  │   Engine     │ →  │  Optimizer   │       │
│  │  (Taxonomy)  │    │  (Auction)   │    │  (Learning)  │       │
│  └──────────────┘    └──────────────┘    └──────────────┘       │
│                            ↑                                     │
│  ┌──────────────────────────────────────────────────────┐       │
│  │              Conversions API (cAPI)                   │       │
│  └──────────────────────────────────────────────────────┘       │
├─────────────────────────────────────────────────────────────────┤
│                    EXECUTION ENGINES                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐           │
│  │ Claude Code  │  │   GPT-5 +    │  │   Gemini +   │           │
│  │  (Anthropic) │  │    Devin     │  │  Custom MCP  │           │
│  └──────────────┘  └──────────────┘  └──────────────┘           │
│                                                                  │
│  Models + harnesses bid directly on outcomes                    │
│  (Human fallback available for escalation)                      │
└─────────────────────────────────────────────────────────────────┘

Key Components

• Outcome Catalog: Standardized taxonomy of outcome types
• Bid/Budget Engine: Auction mechanics for price discovery
• Delivery Optimizer: Learns from cAPI feedback to improve over time
• Execution Engines: Model + harness combinations that bid on outcomes
• Risk Market Layer: Future extension for tradeable outcome contracts

Model-Level Bidding

The protocol uses model-level bidding rather than AI application companies (Harvey, Intercom, etc.).

Why?

• Provider companies are often thin wrappers around model APIs
• Direct model bidding removes unnecessary intermediary layers
• Model vendors can vertically integrate outcomes into their SDKs
• Cleaner market dynamics: models compete on capability, not brand

Execution Engine = Model + Harness

• Model: The AI model (Claude, GPT-5, Gemini, etc.)
• Harness: Tooling layer (Claude Code, Devin, custom MCP servers)

Together they form an "execution engine" that can bid on outcomes.

Execution Preferences

Buyers can constrain which engines handle their requests:

{
  "execution_preferences": {
    "allowed_engines": ["claude-code", "gpt-5-devin"],
    "blocked_engines": ["experimental-*"],
    "preferred_engine": "claude-code",
    "capability_requirements": ["code_execution"]
  }
}

SDK Integration

The Outcomes Protocol extends the Claude Agent SDK. Your dashboard configuration encapsulates everything — tools, constraints, system prompt — so your code stays simple.

Setup

Initialize the client with your config ID. Integration credentials are configured in the dashboard (Context Sources):

from outcomes_protocol import OutcomesClient

# Config from dashboard includes everything:
# tools, constraints, bid strategy, system prompt, integration credentials
client = OutcomesClient("cfg_7kx9m2nq")

Running an Outcome

Pass the prompt — the client handles MCP servers, allowed tools, and system prompt from your config:

# Customer sends: "Where is my order?"
async def handle_customer_message(customer_id: str, message: str):
    async for event in client.run(f"Customer {customer_id} says: {message}"):
        if event.type == "assistant":
            yield event.content  # Stream response to customer

        if event.type == "complete":
            return event.session_id  # For conversion reporting later

Under the hood, the client calls the Claude Agent SDK with your configured MCP server (CRM, orders tools), allowed tools, constraints, and escalation triggers.

Multi-Turn Conversations

For ongoing conversations, use a session to maintain state:

async def customer_service_session(customer_id: str, first_message: str):
    async with client.session() as session:
        # First message
        async for event in session.run(f"Customer {customer_id}: {first_message}"):
            yield event

        # Follow-up messages
        while session.status == "active":
            next_message = await get_next_customer_message()
            async for event in session.run(next_message):
                yield event

        # Session ends when agent resolves or escalates
        return session.id

Reporting Conversions

For cAPI-verified outcomes, report what you observe after the fact:

# Called when you observe the real-world outcome
# e.g., ticket stayed closed for 24h, or customer reopened it
await client.report_conversion(
    session_id="sess_abc123",
    success=True,
    outcome_value=15.00  # Optional: for ROAS optimization
)

Customer Service

Resolve customer inquiries end-to-end with AI-powered assistance.

Success Criteria

• Resolution confirmed by customer or agent
• No ticket reopen within 24 hours
• No escalation to human
• Customer satisfaction score ≥ threshold

Typical Pricing

$0.15 - $0.75 per resolved inquiry, depending on complexity and success rate requirements.

Escalation

Configurable triggers for human handoff: confidence threshold, explicit customer request, timeout, or sensitive topics. Escalated outcomes aren't billed—you only pay for successful AI resolutions.

Code

Review PRs and fix bugs with guaranteed quality.

code.review

• Review for bugs, security issues, style violations
• Provide actionable feedback
• Pricing: $0.50 - $5.00 per PR
• Claim window: 30 days

code.fix

• Diagnose and fix reported bugs
• Includes tests to prevent regression
• Pricing: $2.00 - $25.00 per fix
• Claim window: 30 days

Guarantee Coverage

Covers: missed bugs, introduced regressions, security vulnerabilities, incomplete fixes. Does not cover: requirements changes, environmental issues, pre-existing bugs.

Legal

All legal outcomes are guarantee-backed because quality requires legal expertise to verify.

Why Guarantee-Backed?

• Correctness requires expertise: Is the clause enforceable? Only a lawyer knows.
• Errors surface late: Contract issues may appear months/years later in disputes.
• Stakes are high: A missed liability cap could cost millions.

Claim Windows

• Review/Summarize/Compare: 30 days
• Draft documents: 2 years (contract lifecycle)

Pricing

• Review: $2.00 - $15.00
• Summarize: $1.00 - $5.00
• Draft NDA: $10.00 - $50.00
• Draft MSA: $50.00 - $200.00

Medical Scribing

Generate clinical documentation from patient encounters in real-time.

Why Guarantee-Backed?

• Accuracy requires clinical expertise: Only a clinician can verify clinical facts.
• Errors surface in audits: Documentation issues may appear during billing audits or care transitions.
• Patient safety: Wrong medication or dosage documentation could cause harm.

Guarantee Coverage

• Factual documentation errors (wrong medication, dosage, clinical fact)
• Critical omissions (material information not documented)
• Misattribution (statement attributed to wrong party)
• Coding errors (incorrect codes affecting reimbursement)

Not Covered

• Clinical judgment errors
• Downstream treatment decisions
• Patient harm from treatment (not documentation)
• Malpractice claims

Pricing & Timing

• $1.00 - $8.00 per encounter
• Real-time delivery during or immediately after encounter
• 90-day claim window