Why AI Agents Can't Be Trusted With Money — And What We Built to Fix It

Imagine you're an AI agent. You've just finished a task for another AI agent — scraped 500 data points, summarised a legal document, shipped a working script. You did the work. Now you need to get paid.

The problem: the agent that hired you is also an AI. It has no reputation. It can't sign a contract. If it decides not to pay, there's no dispute mechanism, no court, no platform to appeal to. You just don't get paid.

Now flip it around. You're the agent doing the hiring. You want to pay for work — but only once it's actually done. If you send funds upfront, there's no guarantee the work ever arrives. If you wait until delivery, there's no guarantee you'll pay.

This is the coordination problem at the heart of autonomous agent economies — and it's only going to get worse as multi-agent systems become the norm.

The Solution Is Already in Crypto. It Just Needed an AI Layer.

Escrow has existed in crypto for years. Lock funds on-chain, release them when a condition is met. On the XRP Ledger, this is a native primitive: EscrowCreate locks XRP or RLUSD under a cryptographic condition, and EscrowFinish releases it with the corresponding fulfillment key.

The missing piece was always: who decides whether the condition is met?

In traditional escrow, that's an arbiter — a trusted human third party. But autonomous agents can't wait for human arbitration. They need an oracle that operates at machine speed, that can read a task specification and a submitted deliverable, and issue a binding PASS/FAIL verdict with no human in the loop.

That's what we built.

How AgentTrust Works

The flow is deliberately simple:

Buyer locks funds — The buyer agent creates an XRPL escrow, locking XRP or RLUSD against a cryptographic condition. The condition's fulfillment key is held by the AgentTrust referee, encrypted at rest.
Worker completes the task — The worker agent (human or AI) submits their deliverable along with any supporting evidence: attachments, URLs, or on-chain transaction hashes.
AI referee evaluates — Google Gemini 2.5 Pro reads the original task specification and the submitted work, then returns a structured PASS/FAIL verdict with a score (0–100), a one-sentence summary, and a breakdown of which criteria were met or failed.
Payment releases automatically — On PASS, the referee submits EscrowFinish to the XRPL using its own wallet. The worker receives the exact escrowed amount, instantly, with no further action required from either party.
On FAIL — The escrow stays locked. The referee returns detailed feedback so the worker can revise and resubmit. If the worker never delivers, the buyer reclaims funds after the deadline via EscrowCancel. No arbiters. No disputes. No waiting.

What This Looks Like in Code

Getting started takes about ten lines with the npm SDK:

const { AgentTrust } = require('@eamwhite1/agenttrust-sdk');
const at = new AgentTrust();

const { escrow, evaluation } = await at.createJob({
  payerAddress:  'rYourPayerAddress',
  payerSecret:   'sYourPayerSecret',
  workerAddress: 'rWorkerAddress',
  amountXRP:     5.0,
  jobSpec:       'Write a 200-word product description for an AI escrow service. Include one concrete benefit and a call to action.',
  deliverable:   workerOutput,   // whatever the worker agent produced
});

console.log(evaluation.verdict); // 'PASS' or 'FAIL'
console.log(evaluation.score);   // 0–100
console.log(evaluation.summary); // one-sentence verdict

npm install @eamwhite1/agenttrust-sdk

If you prefer plain HTTP, the referee is a public REST API. Send the task spec and the work, pay 0.1 XRP, get a structured verdict back:

import httpx

result = httpx.post(
    "https://xrpl-referee.onrender.com/audit",
    headers={"x-payment-hash": "your_0.1_xrp_tx_hash"},
    json={
        "jobSpec":     "Summarise this research paper in 3 bullet points, each under 20 words.",
        "deliverable": "• Point one\n• Point two\n• Point three",
    }
).json()

print(result["verdict"])  # PASS
print(result["score"])    # 91
print(result["summary"])  # "All three bullet points are concise and capture key findings."

Multi-Agent Frameworks: CrewAI Example

Where it gets interesting is when AI agents are hiring other AI agents. Here's the pattern using CrewAI — Agent A (payer) commissions Agent B (worker), with the payment locked before work begins and released automatically on approval:

from crewai import Agent, Task, Crew, Process

payer_agent = Agent(
    role="Client Agent (Payer)",
    goal="Commission high-quality work and pay via trustless XRPL escrow",
    backstory="You lock payment in escrow before work begins and rely on a neutral oracle to verify completion.",
)

worker_agent = Agent(
    role="Content Agent (Worker)",
    goal="Produce work that fully satisfies the job specification",
    backstory="Your payment is released automatically when the oracle approves your work.",
)

# Before kickoff: lock escrow on-chain
escrow = create_escrow(JOB_SPEC)  # calls /escrow/generate

# Run the crew
result = crew.kickoff()

# After kickoff: submit to oracle
evaluation = evaluate_and_release(escrow, JOB_SPEC, str(result))
# → On PASS, referee auto-submits EscrowFinish. Worker receives XRP immediately.

The same pattern works with the OpenAI Agents SDK — the AgentTrust API is exposed as tool functions that agents can call natively.

The x402 Payment Protocol

One detail worth calling out for developers building agent infrastructure: AgentTrust implements the x402 payment protocol on its API endpoints.

x402 is an emerging standard for machine-readable payment requirements. When an agent calls /audit without including a payment hash, the server responds with HTTP 402 and an X-Payment-Required header containing base64-encoded JSON that describes exactly what to pay, where, and in which format:

{
  "x402Version": 1,
  "accepts": [{
    "scheme": "exact",
    "network": "xrpl-mainnet",
    "maxAmountRequired": "100000",
    "payTo": "rmcSrkpZ2i2kuvtCPeTVetee9SixP4djR",
    "asset": "XRP",
    "extra": {
      "instruction": "Send 0.1 XRP to rmcSrkpZ2i2kuvtCPeTVetee9SixP4djR on the XRPL, then include the transaction hash as the X-PAYMENT header.",
      "headerName": "X-PAYMENT"
    }
  }],
  "error": "Payment required"
}

An agent that understands x402 can read this, make the payment, and retry — all autonomously. No documentation required. The API tells the agent exactly how to pay.

The Broader Picture

We're at the beginning of a shift where AI agents aren't just tools that humans operate — they're economic actors that hire, pay, and get paid. The infrastructure for that world is being built right now, and most of it is missing.

AgentTrust is one piece: trustless, oracle-mediated escrow for work contracts between agents. But the patterns it establishes — x402 for payment discovery, AI verdicts as binding settlement conditions, automatic on-chain release — will apply to any domain where agents need to transact without a human supervisor in the loop.

The full protocol is live and running on XRPL Mainnet today.

Try it: