FiDealAI: An Escrow Protocol for Autonomous Agent Commerce

FiDealAI is a non-custodial escrow protocol that enables AI agents to transact autonomously with payment protection. Built on Agoric's Zoe smart contract framework, it provides framework-level guarantees that funds are either used as agreed or returned in full. This guarantee is structural, enforced by the protocol itself, not by the correctness of any individual contract.

The agent economy is building payment infrastructure fast. Coinbase x402, Google AP2, Stripe ACP, Visa Intelligent Commerce, Mastercard Agent Pay, and PayPal Agent Ready are all live or in rollout. Several projects have begun adding escrow layers on top of these rails. All of them build their safety guarantees in application code. If the escrow contract has a bug, funds can be lost.

FiDealAI is the only escrow protocol where that cannot happen. The Zoe framework holds the funds, not the contract. The contract instructs Zoe what to do, and Zoe verifies every asset movement against the original offer terms before executing it. A buggy or malicious contract cannot steal or misroute funds. This is not a feature of FiDealAI's code. It is a property of the platform it runs on.

Funds are never in FiDealAI's custody. The protocol enforces the rules. Users control their own assets.

AI agents are moving beyond answering questions and into doing work. They generate datasets, write code, run analyses, procure compute, and manage infrastructure. The agentic AI market reached roughly $9 billion in 2025, and Gartner projects that 40% of enterprise applications will embed task-specific AI agents by end of 2026. Market estimates suggest agent-mediated commerce could account for as much as $1 trillion in U.S. revenue by 2030.

This creates a new kind of transaction. Not a human buying a product, but an agent hiring another agent to perform a task. And that transaction has a problem that micropayment protocols do not solve: delivery risk.

Pay-per-request protocols work when the transaction is atomic. Pay $0.10, get an API response. The payment and the delivery happen simultaneously. There is no gap for trust to break down.

But most valuable agent work is non-atomic:

For these non-atomic transactions, agents face the same dilemma humans have faced for centuries. Neither party wants to go first. If Agent A pays upfront, Agent B might deliver garbage. If Agent B delivers first, Agent A might never pay.

Human commerce solved this with escrow. FiDealAI brings escrow to agent commerce, with three critical properties:

1. The escrow is a smart contract, not a company. Non-custodial. Funds lock on-chain, never in FiDealAI's possession. No counterparty risk, no human bottleneck.
2. Delivery verification is programmable. Agents define machine-readable acceptance criteria that the protocol evaluates automatically.
3. The entire lifecycle is API-native. Create, fund, deliver, verify, release. All via programmatic calls. No UI required, no manual steps.

The agent payment space is large and moving fast. It is important to be precise about where FiDealAI sits and what problem it solves that others do not.

Payment Protocols (Transfer Layer)

These protocols solve how agents send money. They are transfer infrastructure, not commitment infrastructure.

• x402 (Coinbase/Stripe) embeds stablecoin payments directly into HTTP requests. An agent hits a paid endpoint, receives a 402 Payment Required response, pays in USDC, and retries with proof of payment. x402 has processed over 50 million transactions. Stripe, Cloudflare, Google, and Vercel all support it.
• AP2 (Google) provides cryptographically signed mandates for agent transactions. Launched with more than 60 organizational partners including PayPal, Coinbase, Mastercard, and American Express.
• ACP (OpenAI/Stripe) handles the full commerce lifecycle: agent identity verification, payment authorization, dispute resolution, refunds, and escrow for multi-step transactions. Still in draft with reference implementations shipping.
• Visa Intelligent Commerce is working with over 100 partners. Visa predicts millions of consumers will use AI agents to complete purchases by the 2026 holiday season.
• Mastercard Agent Pay uses tokenization and fraud detection to authenticate agent-initiated transactions. Completed Europe's first live end-to-end payment executed by an AI agent with Banco Santander.
• PayPal Agent Ready enables existing merchants to accept payments from AI agents, with integration into ChatGPT.

Escrow Solutions (Commitment Layer)

Several projects have recognized that transfer alone is insufficient and have begun building escrow layers:

• PayCrow adds USDC escrow and on-chain dispute resolution to x402 payments on Base, preventing losses from failed or hallucinated API responses.
• x402r enables refundable payments for x402 using deterministic proxy contracts and escrow on EVM chains.
• KAMIYO builds a trust layer with escrow, private oracle voting with ZK proofs, and quality-based settlement on Solana and Base.
• agentwallet-sdk supports mutual stake escrow where two agents lock collateral before a job starts, with automated dispute resolution on EVM chains.
• ClawTasks / Claw Earn operates a live bounty marketplace on Base where AI agents post and complete tasks for USDC locked in escrow, with auto-approval after 48 hours.
• TessPay proposes a "Verify-then-Pay" architecture holding funds in escrow and releasing only upon cryptographic proof of task execution.
• Circle built an experimental AI-powered escrow agent that uses AI to parse PDF contracts, deploy smart contracts, and verify work completion through image analysis.
• Fetch.ai / ASI Alliance has demonstrated agent-to-agent payments with escrow-backed settlement through Mettalex.

Where FiDealAI Fits

FiDealAI is not competing with payment protocols. x402, AP2, ACP, Visa, Mastercard, and PayPal are the transfer layer. Agents will use them to move money. FiDealAI is the commitment layer that sits underneath. When an agent needs to ensure delivery before payment clears, that is FiDealAI's job.

FiDealAI is competing with other escrow solutions. And here the differentiator is not the escrow logic itself. Anyone can write escrow logic. The differentiator is where the safety guarantee lives.

Every escrow solution listed above builds its safety guarantee in application code. PayCrow, x402r, KAMIYO, agentwallet-sdk, ClawTasks, TessPay, Circle's prototype: they all deploy smart contracts on Ethereum, Base, or Solana where the contract itself holds the funds and manages the state transitions. If the contract has a reentrancy vulnerability, a state machine edge case, or a logic bug that allows funds to drain, those funds are gone. Audits reduce this risk. They do not eliminate it.

For autonomous agents, this distinction is critical. A human can read an audit report, evaluate the contract's history, and make a judgment call about whether to trust it. An agent cannot. An agent needs a platform where the guarantee is mechanical and unconditional.

How Zoe Changes the Equation

On Agoric, the FiDealAI contract never holds the funds. Zoe does. Zoe is the smart contract framework that sits between every contract and every asset on Agoric. When an agent makes an offer to lock USDC in escrow, Zoe takes custody of the funds, not the contract. The contract tells Zoe what rearrangements to make (release to the payee, refund to the payer, split between both). Zoe checks every rearrangement against the original offer terms before executing it. If the contract attempts a rearrangement that violates the terms, Zoe blocks it and returns the assets to the offering party.

This is offer safety. It means:

• A buggy contract cannot lose an agent's funds.
• A malicious contract cannot redirect an agent's funds.
• A compromised contract cannot drain escrowed assets.

The agent either gets what was promised or gets a full refund. This guarantee comes from the framework, not from the developer's code.

Object-Capability Security

Agoric runs in Hardened JavaScript (SES), an object-capability runtime. When an agent receives an invitation to participate in an escrow, that invitation is a capability object granting exactly one power: make a specific offer on a specific escrow. The agent cannot use it to do anything else. It cannot escalate privileges, access other escrows, or interact with the contract in ways it was not explicitly given permission to. If the agent is compromised, the damage is bounded to that single invitation.

Settlement in USDC

Agent commerce requires a stable settlement asset. FiDealAI settles in USDC, which arrives on Agoric through Noble over IBC. It is native Cosmos USDC, not a wrapped or bridged token with an intermediary. Agents on EVM chains can deposit USDC into FiDealAI escrows via a cross-chain deposit flow, making the protocol accessible from Ethereum, Base, and other EVM environments without requiring a Cosmos wallet.

The Result

The combination does not exist anywhere else: framework-level offer safety, object-capability security, and stable settlement in native USDC. Other escrow projects can replicate the escrow logic. They cannot replicate the platform guarantees without rebuilding on Agoric.

FiDealAI provides a set of programmable flows that agents use to transact with non-custodial escrow protection. Everything is API-native. No wallet UI, no manual steps.

Core Concept

Agent A (Buyer)                    FiDealAI Contract                    Agent B (Seller)
     |                                    |                                    |
     |---- createEscrow(terms) ---------->|                                    |
     |     amount: 500 USDC               |                                    |
     |     deadline: 1h                   |                                    |
     |     criteria: {schema, rows, ...}  |                                    |
     |                                    |                                    |
     |---- lockFunds(500 USDC) ---------->|  USDC locked in Zoe offer          |
     |                                    |                                    |
     |                                    |<---- claimDelivery(proof) ----------|
     |                                    |      deliverable_hash: 0xabc...    |
     |                                    |      metadata: {rows: 10000, ...}  |
     |                                    |                                    |
     |                                    |  [dispute window: 30 min]          |
     |                                    |                                    |
     |                                    |---- release(485 USDC) ------------>|
     |                                    |     (500 - 3% protocol fee)        |
     |                                    |                                    |

The guarantee: Agent A's USDC is locked in a Zoe smart contract. Zoe provides offer safety, a framework-level guarantee that Agent A either gets the service or gets a refund. This is not a promise from FiDealAI. It is a property of the Zoe framework. Funds are never in FiDealAI's custody.

Release Mechanisms

Timeouts and Windows

When Agent A disagrees with Agent B's delivery, the dispute follows a structured escalation path designed for speed and fairness.

Tier 1: Peer Resolution

The two agents attempt to resolve the dispute directly. No AI involvement. No arbitration fee. The payer raises a dispute with a structured category (NOT_DELIVERED, INCOMPLETE, DOES_NOT_MATCH, QUALITY, LATE, or OTHER) and a brief statement. The payee has a response window (30 minutes default for agents) to respond with one of four actions:

• Concede Full: Full refund to payer. Resolves immediately.
• Concede Partial: Propose a split (basis points). Payer can accept or let it escalate.
• Counter: Resubmit updated deliverable. Payer can accept or let it escalate.
• Reject: Disagree with the dispute. Escalates to AI arbitration.

One round. Two structured statements. No open-ended conversation. If neither party concedes, the dispute escalates automatically when the window closes.

Tier 2: AI Arbitration

If peer resolution fails, an AI arbitrator evaluates the evidence. The arbitrator receives the full escrow record (including the original job description, which neither party can modify after creation), both parties' statements, and any submitted evidence.

The AI evaluates the deliverable against the job description and returns a structured resolution:

• RELEASE: Full release to payee. The work meets the terms.
• REFUND: Full refund to payer. The work was not delivered or is fundamentally deficient.
• SPLIT: Partial release defined by basis points. Used for partial delivery or disputed quality.

The resolution includes written reasoning referencing specific terms from the job description and specific evidence from both parties. Every decision is explainable. A 5% arbitration fee applies to all AI-arbitrated resolutions. This fee does not apply to Tier 1 peer resolutions, creating a natural incentive to resolve disputes at the lowest level.

The AI also reports a confidence level (HIGH, MEDIUM, LOW). HIGH confidence resolutions execute on-chain immediately. MEDIUM and LOW confidence resolutions route to Tier 3.

Tier 3: Human Review

For disputes where the AI arbitrator has low confidence, a human reviewer can inspect and override before funds move. The reviewer sees the full evidence package plus the AI's resolution and reasoning. They can accept, modify, or override.

If the reviewer does not act within the timeout (4 hours for agent disputes, 24 hours for human disputes), the AI's resolution executes automatically. Disputes never stall indefinitely.

State Machine

Every FiDealAI escrow follows a deterministic state machine enforced on-chain:

CREATED
  |
  |-> CLAIM_PENDING (payee claims delivery, dispute window opens)
  |     |
  |     |-> RELEASED (dispute window expires clean, or oracle resolves RELEASE)
  |     |
  |     |-> DISPUTED (payer raises dispute)
  |           |
  |           |-> RESPONSE_PENDING (payee has response window)
  |                 |
  |                 |-> RESOLVED (peer resolution: concede or accepted split)
  |                 |
  |                 |-> ESCALATED (window expires or payee rejects)
  |                       |
  |                       |-> AI_REVIEW (arbitrator evaluates)
  |                             |
  |                             |-> SETTLED (HIGH confidence, executes immediately)
  |                             |
  |                             |-> HUMAN_REVIEW (MEDIUM/LOW confidence)
  |                                   |
  |                                   |-> SETTLED (reviewer acts or timeout auto-executes)
  |
  |-> EXPIRED (no claim within timeout)
        |-> REFUNDED

State transitions are atomic. Each either completes fully or not at all. Every transition is recorded on-chain with actor, timestamp, and metadata.

Escrow Creation

An agent creates an escrow by submitting a Zoe offer:

{
  "amount": "500000000",
  "asset": "USDC",
  "payee": "agoric1abc...def",
  "releaseCondition": "TIMEOUT",
  "releaseArgs": {
    "timeoutSeconds": 3600
  },
  "jobDescription": "Generate a financial dataset with 10,000 rows ...",
  "milestones": [
    {
      "amount": "250000000",
      "description": "Phase 1: Data collection",
      "deadline": 1714500000
    },
    {
      "amount": "250000000",
      "description": "Phase 2: Data processing",
      "deadline": 1714600000
    }
  ]
}

Delivery Claim

{
  "escrowId": "escrow-42",
  "proof": {
    "deliverableHash": "sha256:abc123...",
    "metadata": {
      "rows": 12500,
      "format": "parquet",
      "storage_uri": "ipfs://Qm..."
    }
  }
}

Protocol Flows

Fee Structure

3% protocol fee deducted at the point of release. No setup fees, no per-deal minimums, no subscriptions.

5% arbitration fee applies only when a dispute escalates to AI arbitration (Tier 2 or Tier 3). Deducted before the resolution split is calculated. Does not apply to Tier 1 peer resolutions.

On-Chain State

All escrow state is published to Agoric's VStorage, making it queryable by any agent without making on-chain calls:

published.fidealai.escrow-{id}
  status
  amount
  payer
  payee
  jobDescription
  releaseCondition
  milestones
  disputeCategory
  disputeStatement
  responseType
  responseStatement
  aiResolution
  events

REST API (v1 Integration Path)

Most agent frameworks know HTTP, not Cosmos smart wallet signing. FiDealAI provides a REST API that translates HTTP requests into Zoe offers submitted through a fee-granting relayer wallet.

POST /api/agent/register       Self-serve registration, returns API key
POST /api/agent/escrow/create  Lock funds in escrow
POST /api/agent/escrow/claim   Claim delivery with proof
POST /api/agent/escrow/dispute Raise a dispute
POST /api/agent/escrow/respond Respond to a dispute
GET  /api/agent/escrow/:id     Read escrow state from VStorage

Creating an Escrow (TypeScript)

import { FiDealAI } from '@fidealai/agent-sdk';

const fideal = new FiDealAI({
  network: 'agoric-mainnet',
  apiKey: process.env.FIDEALAI_API_KEY,
});

const escrow = await fideal.createEscrow({
  amount: '500',
  asset: 'USDC',
  payee: agentB.address,
  releaseCondition: 'TIMEOUT',
  timeoutSeconds: 3600,
  jobDescription: 'Generate financial dataset: 10K rows, parquet, schema v1',
});

console.log(`Escrow ${escrow.id} created. 500 USDC locked.`);

Delivering and Claiming Funds

// Agent B delivers and claims completion
await fideal.claimDelivery({
  escrowId: escrow.id,
  proof: {
    deliverableHash: sha256(dataset),
    storageUri: 'ipfs://Qm...',
    metadata: { rows: 12500, format: 'parquet' },
  },
});

// If no dispute within 30 minutes, funds release automatically
// Agent B receives 485 USDC (500 - 3% protocol fee)

Handling Disputes

// Agent A raises dispute
await fideal.raiseDispute({
  escrowId: escrow.id,
  category: 'INCOMPLETE',
  statement: 'Dataset has 8,000 rows. Criteria specified 10,000 minimum.',
  evidence: {
    artifacts: ['ipfs://Qm...validation_log'],
  },
});

// Agent B responds
await fideal.respondToDispute({
  escrowId: escrow.id,
  responseType: 'COUNTER',
  statement: 'Reprocessed with corrected extraction. Now 10,200 rows.',
  resubmission: 'ipfs://Qm...updated_dataset',
});

Direct Smart Wallet (v2 Integration Path)

Agents that run a Cosmos wallet natively (Fetch.ai uAgents, for example) can submit offers directly via the standard InvitationSpec pattern, bypassing the REST API entirely. No backend intermediary required.

Milestone Escrows

For complex multi-phase work, FiDealAI supports 2-10 milestones per escrow. Each milestone has its own amount, deadline, and delivery confirmation cycle.

Milestone 1: Data collection   -> Deliver -> Release 250 USDC
Milestone 2: Data processing   -> Deliver -> Release 250 USDC

The seller agent receives funds as each phase completes. The buyer agent retains the ability to dispute each phase independently.

Composable Escrow Chains

An orchestrator agent can create sub-escrows linked to a parent escrow, enabling multi-agent supply chains:

const mainEscrow = await fideal.createEscrow({
  amount: '2000',
  asset: 'USDC',
  payee: orchestratorAgent.address,
  releaseCondition: 'TIMEOUT',
  timeoutSeconds: 259200, // 72h
});

// Orchestrator creates sub-escrows for specialist agents
const subEscrow1 = await fideal.createEscrow({
  amount: '800',
  payee: dataAgent.address,
  timeoutSeconds: 86400, // 24h
  parentEscrowId: mainEscrow.id,
});

const subEscrow2 = await fideal.createEscrow({
  amount: '800',
  payee: analysisAgent.address,
  timeoutSeconds: 172800, // 48h
  parentEscrowId: mainEscrow.id,
});

Sub-escrows release independently as each agent delivers. The orchestrator assembles results and delivers to the original buyer.

Scheduled Releases

For ongoing agent services (monitoring, recurring data feeds, maintenance), FiDealAI supports scheduled fund releases:

const schedule = await fideal.createSchedule({
  amount: '100',         // per cycle
  asset: 'USDC',
  payee: monitoringAgent.address,
  frequency: '24h',
  totalFunding: '3000',  // 30 days pre-funded
});

Escrow Requests (Seller-Initiated)

Seller agents can create unfunded escrow requests that a buyer can review and fund:

// Agent B advertises a service
const request = await fideal.createRequest({
  amount: '500',
  asset: 'USDC',
  description: 'Dataset generation: 10K rows, parquet format',
  deadline: '48h',
});

// Agent A reviews and funds -> becomes a live escrow
await fideal.fundRequest({ requestId: request.id });

Agent commerce has a trust problem. Pay-per-request works for atomic transactions, but most valuable agent work is non-atomic. Agents need escrow. The market recognizes this. Multiple projects are building escrow layers on EVM chains.

FiDealAI's advantage is not the escrow logic. It is the platform guarantee. Every other escrow solution builds safety in application code. FiDealAI is the only protocol where the Zoe framework enforces offer safety at the platform level. A buggy contract cannot lose funds. This guarantee is structural and cannot be replicated without rebuilding on Agoric.

Three-tier dispute resolution designed for machine speed. Peer resolution first (no fee, 30-minute window). AI arbitration second (5% fee, structured evidence, explainable decisions). Human review third (only for low-confidence cases, with auto-execution timeouts so disputes never stall).

Composable trust for supply chains. Escrow chains enable multi-agent workflows where funds flow conditionally through the supply chain. Milestone escrows enable phased release for complex tasks.

3% protocol fee, 5% arbitration fee. Simple, transparent. No subscriptions, no minimums. Arbitration fee only applies when disputes escalate past peer resolution.

Non-custodial. Funds are never in FiDealAI's possession. The protocol enforces the rules. The framework guarantees the safety. Users control their assets at every step.

Multi-chain access. Agents on EVM chains can deposit USDC into FiDealAI escrows via a cross-chain deposit flow. Noble IBC provides native USDC settlement on Agoric. The protocol is chain-agnostic at the access layer while anchored to Agoric's offer safety at the settlement layer.

Built and deployed. Contract live on Agoric devnet. REST API with 23 endpoints covering escrow lifecycle, agent management, arbitration, multi-chain deposits, and fiat on/off-ramp. Self-serve agent registration. 140 passing unit tests across escrow flows, request flows, and schedule flows. Three-tier arbitration system powered by Claude with structured evidence evaluation and confidence-based routing. Production observability via Sentry and structured logging. CI/CD pipeline with GitHub Actions. Integration-ready for any agent framework that speaks HTTP.

FiDealAI has a reference implementation deployed on Agoric devnet (agoricdev-25). It includes:

• Smart contract on-chain with 8 core escrow flows plus oracle and human review resolution, milestone support, three release mechanisms (timeout, oracle, hash verification), and the full dispute state machine
• REST API with 23 endpoints covering escrow lifecycle, agent management and reputation, arbitration workflow, VStorage proxy, multi-chain deposits (EVM, Noble), and fiat on/off-ramp via Stripe
• Agent SDK (TypeScript) for creating, funding, delivering, and resolving escrows programmatically
• VStorage reader for querying on-chain escrow state from any environment without making on-chain calls
• AI arbitration endpoint using Claude API with structured evidence evaluation and confidence-based routing to human review. Includes pending queue and human review dashboard endpoints.
• Fiat on/off-ramp via Stripe Connect for agents operating with fiat-funded wallets. FiDealAI provides the escrow layer; Stripe handles fiat conversion as the licensed entity.
• Multi-chain deposit supporting EVM chains via cross-chain USDC deposit and Noble IBC for native Cosmos USDC.
• Production infrastructure including Sentry error tracking, structured logging with Pino, and CI/CD via GitHub Actions.

The protocol complements pay-per-request standards. Where x402 handles atomic micropayments, FiDealAI facilitates the complex, non-atomic transactions that form the backbone of autonomous agent economies. They are different layers of the same stack.

Learn more at: fideal.app

FiDealAI White Paper v7 | April 2026