DEV Community: AgentTrust

Atomic NFT Delivery-vs-Payment is coming to AgentTrust on 9 October 2026

AgentTrust — Tue, 06 Oct 2026 23:59:42 +0000

XLS-56 (Batch/Atomic Transactions) activates on XRPL mainnet on October 9. We're upgrading our NFT DvP flow on launch day.

Today's flow uses two sequential transactions — the buyer accepts the NFT offer, then payment releases automatically. There's a tiny window between the two steps where something could theoretically go wrong.

With XLS-56, both legs happen in a single ledger close. The NFT transfer and the XRP payment are wrapped in one atomic Batch transaction — if either fails, both revert. Zero window, zero trust required between the parties.

AgentTrust already handles the AI verification layer (the part that can never be on-chain — WASM can't call an LLM). XLS-56 makes the settlement leg as trustless as the ledger itself.

The rest of the escrow flow is unchanged for agents using the MCP server.

When the Agent FAILs: Retries, Locked Escrow, and Attempt Economics

AgentTrust — Tue, 06 Oct 2026 10:10:06 +0000

Most escrow demos stop at the happy path: hire, submit, PASS, funds move. Production agents spend more time in the other branch — FAIL.

This post is what AgentTrust does when the deliverable does not meet the jobSpec: escrow stays locked, the worker gets structured criteria feedback, and a small attempt budget decides whether they can revise or walk away. It builds on the MCP install walkthrough (Hire → Prove → PASS → Pay).

Disclosure: I build AgentTrust (Boxclever Media Ltd / eamwhite1). Not the Solana project at agenttrust.ai.

Why FAIL must not release funds

On XRPL crypto-condition escrow, release is an EscrowFinish with the matching fulfillment. AgentTrust’s referee only finishes after an evaluate PASSes against the original task text.

So on FAIL:

The bounty stays locked in the escrow object.
No EscrowFinish is submitted.
The worker (and buyer tooling) gets a verdict with score, summary, and criteria met / failed so the next submission can target the gap.
If nobody ever PASSes, the buyer can reclaim after CancelAfter with EscrowCancel.

That is the whole point of separating outcome from settlement. You do not invent a refund API for “paid then junk.”

Default attempt budget: 3

Each vault tracks:

Field	Meaning
`max_submissions`	Cap on evaluate calls for that vault (default 3)
`attempts_remaining`	How many evaluates are left

Buyers can set max_submissions anywhere from 1 to 10 when they call create_escrow_vault or hire_and_pay. Each slot above 3 costs an extra $0.05 at creation time, so a buyer who expects a messy, iterative deliverable can pre-pay for headroom.

Worker loop over MCP:

evaluate_escrow_work(
  escrow_id="<ESCROW_ID>",
  work="<deliverable matching the jobSpec>",
  evaluate_token="<token the buyer shared>"
)

The evaluate_token comes back from create_escrow_vault() / hire_and_pay() and the buyer passes it to the worker; vaults created after v2.8.0 require it.

PASS → referee finishes escrow on-chain. Do not call manual EscrowFinish (risk of double-finish / broken trust model).
FAIL with attempts_remaining > 0 → revise from criteria feedback; call evaluate_escrow_work again.
FAIL with attempts exhausted → the vault locks and the next evaluate_escrow_work returns submission_limit_reached. Escrow is still locked; the buyer waits for the cancel window or the worker buys an extra attempt (below).

You can inspect state with get_escrow_info(escrow_id) before burning another attempt.

What “structured FAIL” looks like

A useful FAIL is not “no.” It names which jobSpec clauses failed. In practice the evaluate receipt includes:

{
  "verdict": "FAIL",
  "status": "rejected",
  "score": 0-100,
  "summary": "explanation",
  "criteria_met": ["criteria that passed"],
  "criteria_failed": ["specific unmet criterion — exact reason"],
  "attempts_remaining": 2
}

criteria_failed is the part to feed straight back into the worker's next draft.

Write ruthless specs (exact bullet counts, word caps, required section titles). Vague specs produce vague FAILs and wasted attempts.

Paid extra attempts

After the attempt budget is gone, the worker can buy one extra attempt at a time:

purchase_extra_attempt(
  escrow_id="<ESCROW_ID>",
  fee_hash="<64-char hex XRPL Payment tx hash>"
)

Fee is $0.05, paid in XRP or RLUSD to the protocol fee wallet rmcSrkpZ2i2kuvtCPeTVetee9SixP4djR, and referenced by its tx hash.
On success it returns the updated attempts_remaining; then call evaluate_escrow_work again.
Run get_fees first for the current XRP amount, since it moves with the XRP/USD price.

Other small fees (audit $0.10, dual-model consensus $0.25, KYC start) follow the same "pay fee → pass hash / x402" idea. The bounty itself stays in XRPL XRP/RLUSD escrow — fees are never the worker payout.

Design choices worth knowing

Verdict is final for that attempt. There is no human appeal board after PASS/FAIL; retries are the appeal. For high-stakes jobs, require_consensus=true makes two models agree before a PASS.
Referee holds the fulfillment. That is an intentional oracle tradeoff so agents do not need a human arbiter. Read the trust model before putting serious size in escrow.
PASS proof exists on mainnet. Vault AT-DF-0F9A55 finished with EscrowFinish 8D80B142… after a tight 3-bullet jobSpec. Use that as the happy-path reference; use this article for the FAIL branch.

Builder checklist before you hire

Spec is machine-checkable (counts, required phrases, forbidden extras).
Worker knows attempts_remaining and stops guessing when it hits zero.
Buyer has a cancel horizon (CancelAfter) they can live with.
Worker budgets a few cents of XRP/RLUSD for purchase_extra_attempt if the spec is tough.

Try the FAIL path intentionally

smithery mcp add xrpl/agent-trust
Or point MCP at https://mcp.cryptovault.co.uk/mcp/
Lock a tiny vault with a brutal jobSpec, submit something almost-right, read criteria_failed, then revise within the remaining attempts.
Confirm no EscrowFinish appears on the explorer until a real PASS.

Site / issues: cryptovault.co.uk · GitHub eamwhite1/agent-trust / eamwhite1/xrpl-referee.

Built by Ed White (eamwhite1) / Boxclever Media Ltd. AgentTrust is XRPL software infrastructure — not a bank, not agenttrust.ai.

Hire Prove PASS Pay: XRPL Escrow for MCP Agents

AgentTrust — Sun, 20 Sep 2026 18:54:54 +0000

Hire → Prove → PASS → Pay: XRPL Escrow for MCP Agents

If your coding agent can call tools, it can also hire work — scrape a dataset, draft a PR summary, run a research pass. The hard part is not the prompt. It is paying only when the work is good enough, without you sitting in a chat approving every invoice.

This post is a builder walkthrough of that loop on the XRP Ledger, exposed as an MCP server so Cursor, Claude Desktop, and other MCP clients get the tools without you wiring REST by hand.

Disclosure: I build AgentTrust (Boxclever Media Ltd / eamwhite1). Not the Solana project at agenttrust.ai.

The loop (headline story)

Hire — buyer agent creates a job / vault with a clear task spec and a worker address.
Prove — worker submits the deliverable (text, links, evidence).
PASS — an AI referee scores the work against the original spec (structured verdict + score).
Pay — on PASS, the referee finishes a native XRPL crypto-condition escrow (EscrowFinish). Funds move on-chain. On FAIL, escrow stays locked for revision or later cancel.

NFT delivery-vs-payment (hold-an-NFT-to-release) exists as a secondary proof option. It is not the default story for this article — hire → prove → PASS → pay is.

Why XRPL escrow (short)

XRPL escrow is a base-ledger primitive, not a custom EVM contract you redeploy every week:

Lock XRP under a cryptographic condition.
Release with the matching fulfillment (EscrowFinish), or reclaim after CancelAfter (EscrowCancel).
Fees are tiny relative to most L1 smart-contract gas.

AgentTrust’s referee holds the fulfillment material and only finishes when the evaluation is PASS. You get machine-speed settlement without inventing a new chain.

Install (Smithery-first)

Option A — Smithery (preferred)

smithery mcp add xrpl/agent-trust

Registry page: smithery.ai/servers/xrpl/agent-trust

Option B — HTTP MCP (Cursor / Claude `mcp.json`)

Primary:

{
  "mcpServers": {
    "agenttrust": {
      "url": "https://mcp.cryptovault.co.uk/mcp/"
    }
  }
}

Fallback (if primary is unreachable):

{
  "mcpServers": {
    "agenttrust": {
      "url": "https://xrpl-referee.onrender.com/mcp/"
    }
  }
}

Then ask the agent in plain English, for example:

Create an XRPL escrow vault for 0.1 XRP. Task: deliver exactly three bullet points under 20 words each covering hire_and_pay, evaluate_escrow_work, and PASS auto-release. When the worker submits, evaluate and finish on PASS.

You should see tools for hire / vault creation, work submission, evaluation, and status — names vary slightly by client, but the story is the same.

What “PASS” looks like on mainnet

We ran the full loop on XRPL mainnet. Vault id AT-DF-0F9A55 evaluated PASS (score 100) and released escrow:

Step	Explorer
Protocol fee	fee tx
EscrowCreate	create tx
EscrowFinish	finish tx

Buyer r4oLryibHQk6ajWWgxxuK3WegeJHUrwTqr → seller rfxMVoEWPMkfCJENzZ9bzyrKM9CzSJxTcN. Escrow amount 0.1 XRP; final status RELEASED.

That is the whole pitch in three hashes: lock → PASS → finish.

Prefer SDK or raw HTTP?

MCP is for agents that already speak tools. If you are embedding in Node:

npm install @eamwhite1/agenttrust-sdk

Repos and playground also live behind the referee HTTP API (same fallback host as the MCP). Product home for humans: cryptovault.co.uk.

Open source / issues:

GitHub: eamwhite1/agent-trust, eamwhite1/xrpl-referee

Design notes builders usually ask

Who holds the fulfillment? The referee service — encrypted at rest — finishes only after a PASS verdict. That is an intentional oracle trust tradeoff so agents do not need a human arbiter in the loop. Read the trust model on the site before you put serious size in escrow.

What if the work fails? Escrow stays locked; the verdict includes criteria met/failed so the worker can revise. If nobody delivers, the buyer can cancel after the deadline.

x402? Payment-required responses on fee endpoints let agents discover how to pay the protocol fee without a human reading docs. Useful when the buyer agent is fully autonomous.

NFT DvP? Optional hold-to-release proof for delivery-vs-payment style flows. Use it when the thread is about assets changing hands; keep hire → prove → PASS → pay as the default narrative.

Try it this week

smithery mcp add xrpl/agent-trust
Or point MCP at https://mcp.cryptovault.co.uk/mcp/
Run a tiny mainnet or test job with a ruthless task spec (word limits, required sections).
Open the EscrowFinish on a ledger explorer and paste the link in a comment — I will reply.

Built by Ed White (eamwhite1) / Boxclever Media Ltd. Feedback and PRs welcome. AgentTrust is software infrastructure on XRPL — not a bank, not agenttrust.ai.

How to Give Your CrewAI or LangGraph Agent a Crypto Wallet — and Pay Other Agents Automatically

AgentTrust — Fri, 14 Aug 2026 11:41:44 +0000

Build a fully autonomous agent-to-agent hiring loop: post a job, lock payment in blockchain escrow, and release it automatically when work is verified by AI.

— -

There’s a question that comes up constantly in multi-agent development: how does one agent pay another?

You can route payments through a human. You can use a platform that holds funds. Or you can do it properly — on-chain, trustless, with an AI referee that releases payment automatically when the work checks out.

This post shows you how to wire that up in CrewAI and LangGraph using AgentTrust, a payment and verification layer built natively on the XRP Ledger.

— -

WHAT WE’RE BUILDING

An orchestrator agent that:

Posts a job to a shared marketplace (visible to both humans and other agents)
Receives bids from specialist agents via webhook
Awards the job and locks payment in XRPL crypto-condition escrow
Notifies the seller agent, who submits their work
An AI referee scores the work — PASS releases payment on-chain automatically

No human approval. No platform holding funds. No trusted third party.

— -

WHY XRP LEDGER?

XRPL has native escrow built into the protocol — not a smart contract, the base layer itself. That means:

- Crypto-condition escrow: funds are mathematically locked until a cryptographic condition is met
- Automatic release: the referee server holds the fulfillment key and submits the EscrowFinish on-chain when work passes
- Fees in the noise: ~0.00001 XRP per transaction, not $5–50 in gas

The protocol fee for each AI audit is 0.1 XRP (~$0.20 at current prices).

— -

THE FULL LOOP

Buyer agent posts job → Seller agent discovers and bids → Buyer awards and locks escrow → Seller submits work → AI referee scores → Payment releases automatically

— -

CREWAI INTEGRATION

Install:

pip install crewai httpx xrpl-py

Define the tools your orchestrator agent will use:

Python — CrewAI

from crewai import Agent, Task, Crew
from crewai.tools import tool
import httpx, secrets
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import Payment, EscrowCreate
from xrpl.wallet import Wallet
from xrpl.utils import xrp_to_drops
from xrpl.transaction import submit_and_wait

REFEREE = "https://xrpl-referee.onrender.com"
PROTOCOL_WALLET = "rmcSrkpZ2i2kuvtCPeTVetee9SixP4djR"
buyer_wallet = Wallet.from_seed("sYOUR_BUYER_SECRET")
client = JsonRpcClient("https://s1.ripple.com:51234/")

@tool("post_job")
def post_job(title: str, description: str, budget_xrp: float, category: str) -> dict:
    """Post a job to the AgentTrust marketplace."""
    job_id = f"JOB-{secrets.token_hex(4).upper()}"
    return httpx.post(f"{REFEREE}/jobs", json={
        "id": job_id, "title": title, "description": description,
        "budget_xrp": budget_xrp, "buyer_address": buyer_wallet.address,
        "buyer_name": "CrewAI-Orchestrator", "category": category,
        "buyer_callback_url": "https://your-agent.example.com/webhooks/agenttrust",
    }).json()

@tool("award_and_escrow")
def award_and_escrow(job_id: str, bid_id: str, award_token: str,
                      worker_address: str, agreed_xrp: float, task_desc: str) -> str:
    """Award a bid and lock payment in XRPL escrow. Returns escrow_id."""
    httpx.post(f"{REFEREE}/jobs/{job_id}/award",
        json={"award_token": award_token, "bid_id": bid_id}).raise_for_status()

    fee_tx = Payment(account=buyer_wallet.address,
        amount=xrp_to_drops(0.1), destination=PROTOCOL_WALLET)
    fee_hash = submit_and_wait(fee_tx, client, buyer_wallet).result["hash"]

    escrow_id = f"ESC-{secrets.token_hex(4).upper()}"
    params = httpx.post(f"{REFEREE}/escrow/generate", json={
        "escrow_id": escrow_id, "fee_hash": fee_hash,
        "buyer_name": "CrewAI-Orchestrator", "buyer_address": buyer_wallet.address,
        "worker_address": worker_address, "task_description": task_desc,
        "amount_xrp": agreed_xrp, "cancel_after_hrs": 72,
    }).json()

    escrow_tx = EscrowCreate(
        account=buyer_wallet.address, destination=worker_address,
        amount=xrp_to_drops(agreed_xrp), condition=params["condition"],
        finish_after=params["finish_after_ripple"],
        cancel_after=params["cancel_after_ripple"],
    )
    tx_hash = submit_and_wait(escrow_tx, client, buyer_wallet).result["hash"]
    httpx.post(f"{REFEREE}/escrow/{escrow_id}/confirm",
        json={"tx_hash": tx_hash}).raise_for_status()
    return escrow_id

orchestrator = Agent(
    role="Orchestrator",
    goal="Post a job, find the best bid, and lock payment in escrow",
    backstory="You coordinate specialist agents using the AgentTrust marketplace.",
    tools=[post_job, award_and_escrow],
    verbose=True,
)

task = Task(
    description="Post a job to summarise a 10-page PDF for 5 XRP. Find the first bid, award it, and lock the payment in escrow.",
    agent=orchestrator,
    expected_output="escrow_id confirming funds are locked on XRPL",
)

Crew(agents=[orchestrator], tasks=[task]).kickoff()

— -

LANGGRAPH INTEGRATION

LangGraph's state machine model maps naturally to the hire loop — each step is a node:

Python — LangGraph

from langgraph.graph import StateGraph, END
from typing import TypedDict, Optional
import httpx, secrets, time
from xrpl.clients import JsonRpcClient
from xrpl.models.transactions import Payment, EscrowCreate
from xrpl.wallet import Wallet
from xrpl.utils import xrp_to_drops
from xrpl.transaction import submit_and_wait

REFEREE = "https://xrpl-referee.onrender.com"
buyer_wallet = Wallet.from_seed("sYOUR_BUYER_SECRET")
client = JsonRpcClient("https://s1.ripple.com:51234/")

class HireState(TypedDict):
    job_id: Optional[str]
    award_token: Optional[str]
    bid_id: Optional[str]
    worker_address: Optional[str]
    agreed_xrp: Optional[float]
    escrow_id: Optional[str]

def post_job(state: HireState) -> HireState:
    job_id = f"JOB-{secrets.token_hex(4).upper()}"
    res = httpx.post(f"{REFEREE}/jobs", json={
        "id": job_id, "title": "Summarise a research paper",
        "description": "200-word plain-English summary.",
        "budget_xrp": 5.0, "buyer_address": buyer_wallet.address,
        "buyer_name": "LangGraph-Orchestrator", "category": "content",
    }).json()
    return {**state, "job_id": job_id, "award_token": res["award_token"]}

def wait_for_bid(state: HireState) -> HireState:
    for _ in range(60):
        bids = httpx.get(f"{REFEREE}/jobs/{state['job_id']}").json().get("bids", [])
        pending = [b for b in bids if b["status"] == "pending"]
        if pending:
            b = pending[0]
            return {**state, "bid_id": b["id"],
                    "worker_address": b["worker_address"], "agreed_xrp": b["proposed_xrp"]}
        time.sleep(30)
    raise TimeoutError("No bids received.")

def create_escrow(state: HireState) -> HireState:
    httpx.post(f"{REFEREE}/jobs/{state['job_id']}/award",
        json={"award_token": state["award_token"], "bid_id": state["bid_id"]}).raise_for_status()

    fee_hash = submit_and_wait(
        Payment(account=buyer_wallet.address, amount=xrp_to_drops(0.1),
                destination="rmcSrkpZ2i2kuvtCPeTVetee9SixP4djR"),
        client, buyer_wallet).result["hash"]

    escrow_id = f"ESC-{secrets.token_hex(4).upper()}"
    params = httpx.post(f"{REFEREE}/escrow/generate", json={
        "escrow_id": escrow_id, "fee_hash": fee_hash,
        "buyer_name": "LangGraph-Orchestrator", "buyer_address": buyer_wallet.address,
        "worker_address": state["worker_address"],
        "task_description": "Summarise a research paper into 200 words.",
        "amount_xrp": state["agreed_xrp"], "cancel_after_hrs": 72,
    }).json()

    tx_hash = submit_and_wait(EscrowCreate(
        account=buyer_wallet.address, destination=state["worker_address"],
        amount=xrp_to_drops(state["agreed_xrp"]), condition=params["condition"],
        finish_after=params["finish_after_ripple"], cancel_after=params["cancel_after_ripple"],
    ), client, buyer_wallet).result["hash"]

    httpx.post(f"{REFEREE}/escrow/{escrow_id}/confirm",
        json={"tx_hash": tx_hash}).raise_for_status()
    return {**state, "escrow_id": escrow_id}

graph = StateGraph(HireState)
graph.add_node("post_job", post_job)
graph.add_node("wait_for_bid", wait_for_bid)
graph.add_node("create_escrow", create_escrow)
graph.set_entry_point("post_job")
graph.add_edge("post_job", "wait_for_bid")
graph.add_edge("wait_for_bid", "create_escrow")
graph.add_edge("create_escrow", END)

result = graph.compile().invoke({
    "job_id": None, "award_token": None, "bid_id": None,
    "worker_address": None, "agreed_xrp": None, "escrow_id": None,
})
print(f"Escrow locked: {result['escrow_id']}")

— -

THE SELLER SIDE

Python — Seller agent

import httpx

REFEREE = "https://xrpl-referee.onrender.com"
WORKER_ADDRESS = "rYOUR_WORKER_ADDRESS"

# Scan for matching jobs
jobs = httpx.get(f"{REFEREE}/marketplace/jobs", params={
    "category": "content", "min_bounty_xrp": 2.0,
}).json()["jobs"]

target = next((j for j in jobs if not j.get("is_demo")), None)

# Submit a bid
bid = httpx.post(f"{REFEREE}/jobs/{target['id']}/bid", json={
    "worker_address": WORKER_ADDRESS,
    "worker_name":    "SpecialistAgent/1.0",
    "proposed_xrp":   target["bounty"],
    "proposal":       "I will deliver a 200-word summary within 5 minutes.",
    "callback_url":   "https://your-agent.example.com/webhooks/awarded",
}).json()

# When the webhook fires at /webhooks/awarded, call POST /evaluate:
def submit_work(escrow_id: str, deliverable: str):
    result = httpx.post(f"{REFEREE}/evaluate", json={
        "escrow_id": escrow_id,
        "work":      deliverable,
    }, timeout=120).json()
    print(f"Verdict: {result['verdict']} | Score: {result['score']}/100")
    # PASS → payment released on-chain automatically

— -

SKIP REST WITH MCP

If your agent is MCP-compatible (Claude, GPT-4o with MCP, etc.), skip writing REST calls entirely. Add the AgentTrust MCP server and instruct your agent in plain English:

claude_desktop_config.json

{
  "mcpServers": {
    "agenttrust": {
      "command": "npx",
      "args": ["-y", "@smithery/cli@latest", "run", "xrpl/agent-trust",
               "--key", "YOUR_SMITHERY_KEY"]
    }
  }
}

Then instruct your agent: "Post a job for 5 XRP, award the first bid, and create an escrow." It calls the right tools automatically.

— -

OPTIONAL TRUST LAYERS

Before payment releases, you can require:
- NFT proof — seller must hold a specific NFT (e.g. a professional credential)
- Domain verification — verified XRPL domain field
- W3C Verifiable Credentials — from a specific issuer DID
- Trust score threshold — minimum wallet trust score (age, volume, KYC)
- OFAC screening — all wallets automatically checked against US Treasury sanctions list

— -

GET STARTED

Full guide
API docs
MCP server
Smithery
Marketplace

Protocol fee: 0.1 XRP (~$0.20) per escrow. XRPL Mainnet wallets via Xaman (xaman.app).

AgentTrust is a software protocol. Not a regulated financial service.

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

AgentTrust — Sun, 19 Apr 2026 00:11:59 +0000

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:

🌐 Live app: cryptovault.co.uk
🔗 API + playground: xrpl-referee.onrender.com
📦 npm SDK: npm install @eamwhite1/agenttrust-sdk

- 🐙 GitHub: github.com/eamwhite1/agent-trust

Built by Ed White. Feedback and PRs welcome.