AI Engineer World's Fair 2025

Automating Escrow with USDC and AI

Loading slides…

Read the talk

Automating Escrow with USDC and AI

Follow an escrow workflow from agreement extraction to funded smart contract and image review, then examine where human approval still belongs.

From a talk by Corey Cooper

Before you start: Basic familiarity with APIs, blockchain wallets and smart contracts will help; the article explains the USDC operations used by the escrow workflow.

What must happen before money moves?

An escrow agreement connects two different problems: deciding whether someone has fulfilled an obligation, and releasing the money once they have. AI can help inspect the evidence; a smart contract can enforce the permitted movement of funds. Combining those capabilities is the starting point for Corey Cooper, who introduces himself as Circle’s DevRel lead.

Circle title slide naming Corey Cooper, DevRel, beside his portrait and the presentation title.Open full source frame
Automating Escrow with USDC and AI — Corey Cooper, Circle.

Cooper describes USDC as an order of magnitude better for escrow than traditional payment rails, but supplies no benchmark for that comparison. His concrete premise is that AI can verify a workflow’s conditions before a programmable dollar settles the resulting payment. He describes that settlement as instant and faster than T+2 globally. The walkthrough moves from Circle’s infrastructure to the USDC contract interface, then to a recently open-sourced escrow application offered for local experimentation.

0:370:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:37 · section reference included

The issuer, liquidity services and developer tools

Circle supplies the dollar infrastructure beneath the application. Cooper describes a fintech company founded in 2013, with BlackRock and Fidelity among its backers, issuing tokenized dollars and euros backed one-to-one by reserves. He characterizes those reserves as fiat and short-term treasuries, and presents stablecoin regulation as a way to make the technology more usable for businesses and individuals.

Cooper reports more than $26 trillion in cumulative onchain transaction volume and roughly 20 supported blockchains at the time of the talk. Those figures describe the broader payment network, not escrow-specific volume or application throughput. The product map extends beyond USDC and EURC: following Circle’s Hashnote acquisition, Cooper describes a tokenized money market fund and the prospect of round-the-clock conversion into USDC. Institutional liquidity services handle minting and redemption into enterprise vault wallets for payments, dollar access and capital markets.

The developer-facing services divide the integration work into distinct responsibilities:

ServiceResponsibility
Circle WalletsEmbed and provision wallets programmatically
Circle ContractsDeploy contracts and read or write their state
Circle PaymasterPay gas from a USDC balance
Cross-Chain Transfer Protocol, or CCTPMove USDC between blockchain networks

Paymaster addresses the need to hold a chain’s native token merely to transact. CCTP addresses a different problem: a user’s USDC may live on a network other than the one an application uses. Cooper describes permissionless transfers between supported networks and previews further balance-unification work without specifying its implementation. These are the services as presented in the recording; the walkthrough does not substitute later products or APIs.

Product overview grouping USDC, EURC and USYC alongside Mint, Vault, Wallets, Contracts, Paymaster and CCTP, above supported blockchain logos.Open full source frame
Circle’s stablecoins, tokenized funds, liquidity services and developer services.
2:292:48
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:29 · section reference included

How bank dollars become programmable dollars

USDC’s ledger lives on blockchain networks, with smart contracts exposing operations that applications can call. Cooper describes global transfers in seconds and uses email and text messaging as the analogy: public networks let developers build sending, receiving and storage experiences across borders. Open participation in that network is distinct from the approval process for a business minting directly with Circle.

The issuance flow connects those public networks to bank-held reserves:

  1. A business receives Circle’s approval and opens a Circle Mint account.
  2. It connects its bank account and wires fiat into Circle’s reserve bank account.
  3. After the USD settles, Circle mints the corresponding USDC and credits the business’s Circle Mint account.
  4. To exit, the business redeems USDC through the reverse process at one dollar per USDC.

Cooper points to Circle’s transparency page and monthly attestations as ways to inspect reserve backing, alongside independent oversight. The distinction matters for the escrow application: an onchain transfer and the bank-funded issuance or redemption process are separate operations.

8:068:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:06 · section reference included

Spending authority, shared approval and offline preparation

Before deploying USDC on another blockchain, Circle looks for standardized behavior and protective controls. Cooper begins with allow lists and block lists: sanctioned or malicious addresses can be prevented from transacting, including with other users. Public access to the network therefore coexists with issuer controls over the token.

Delegated spending lets one party spend an authorized amount from another wallet’s balance. Cooper’s example is a corporate USDC wallet backing employee virtual debit cards, with a workflow imposing spending thresholds or daily caps. The token’s spending authorization supplies a building block; the business workflow determines the policy around it. Cooper says this delegation could scale to tens of thousands of cards or users, without presenting a load test.

Other controls address who may create money and who may authorize its movement:

  • Minter configuration: the token contract can authorize additional minting entities. Cooper suggests financial institutions with assigned minting balances as a future possibility, while saying Circle had not implemented that arrangement.
  • Multisignature approval: a payment workflow can require several parties—such as a CEO, CFO and COO—to approve transactions above a threshold. This reduces the risk of one person having sufficient authority to drain a wallet.

Offline preparation separates signing from broadcasting. For scheduled payroll, a company can prepare a transaction with a known amount, obtain approval and signatures offline, and broadcast it on the payment date. The audience presses on whether that also proves the money will be available. Cooper’s answer is no: preparing a signed transaction does not itself reserve funds or prevent the later payment from failing. Proof-of-funds behavior would require additional design.

11:3211:44
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:32 · section reference included

The contract interface an application calls

Cooper next discusses pausing and upgrading the contract, using USDC v2.2 as the example of improving gas efficiency. The historical release was announced in November 2023 and rolled out across supported EVM deployments; its changes should not be read as an identical upgrade to every blockchain implementation.

The core functions form a small interface for inspecting balances and authorizing or moving tokens:

FunctionPurpose
balanceOfRead an address’s token balance
totalSupplyRead the token’s total supply
allowanceRead an owner’s authorization for a spender
transferSend tokens from the caller
transferFromMove tokens using spending authorization
approveSet a spender’s allowance

In Solidity, that interface can be expressed directly:

solidity

pragma solidity ^0.8.20;

interface IUSDCToken {
    function balanceOf(address account) external view returns (uint256);
    function totalSupply() external view returns (uint256);
    function allowance(address owner, address spender)
        external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount)
        external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}

Cooper focuses on transferFrom: its arguments identify the source address, destination address and amount. An application submits a transaction invoking that operation, and the blockchain processes the resulting token movement. The source address is an argument, not a substitute for spending authorization. This is the programmable interface the later escrow flow builds around.

16:5217:13
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:52 · section reference included

From agent payments to an escrow application

Agents introduce a reason to care about settlement and verification together. Cooper argues that near-instant payment confirmation suits software transacting with other software, while chargebacks on reversible rails become difficult to manage as automated money movement accelerates. Public blockchain infrastructure also supports transactions outside banking hours, with signatures and publicly inspectable transactions providing cryptographic verification.

Conditional payment logic belongs in a contract the agent can interact with. An agent may need to establish that some prerequisite has been satisfied before requesting a transfer. Composable smart contracts supply the rules governing that transfer; the agent supplies an interaction with those rules. Escrow makes the separation concrete because evidence of completed work must precede release of the funds.

Purple slide with a USDC symbol and three bullets covering near-instant payments, reliable onchain compute and programmable money flows triggered by smart contract logic.Open full source frame
USDC for AI agents: payments, onchain compute and programmable money flows.

The sample application combines three building blocks. Circle Wallets provisions wallets for the agent and the two escrow parties. A Solidity escrow template is deployed repeatedly through Circle Contracts for different agreements. USDC supplies the currency moving through those contracts, with fiat on-ramping before funding and a possible fiat off-ramp for the beneficiary afterward. The application reuses a contract design; it does not ask the model to invent a new financial program for every agreement.

19:2419:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

19:24 · section reference included

Turning an agreement into a deployed escrow

The business and freelancer first create accounts on the platform. Behind each signup, an API call provisions a wallet. The business then uploads a PDF agreement negotiated outside the application. An OpenAI multimodal model extracts the payment amount and the tasks the freelancer must complete.

Extraction produces a proposed listing, not an immediately binding payment instruction. The business reviews the amount, task list and agreement summary before publishing. Once approved, those values feed a prewritten contract template. Its configuration identifies USDC as the currency, the depositor wallet, the beneficiary wallet and an agent wallet whose described authority is limited to releasing funds. The model supplies agreement data; the template supplies the executable rules.

Deployment is another explicit operation. The platform calls Circle’s APIs and reports success after the contract is deployed. Developers can inspect the activity in Circle’s console and use webhooks to build notifications or other workflows around indexed onchain events. This creates a boundary between requesting an action and observing its completion—a distinction that becomes visible during the live demonstration.

24:2324:38
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

24:23 · section reference included

Funding the contract and evaluating the work

After deployment, the business obtains USDC through an on-ramp or funds the flow from an existing external wallet. Cooper describes the deposit flow as approving a specified amount for transfer from the depositor’s wallet into the escrow contract. Once those funds arrive, the beneficiary receives a notification that work can begin. A block explorer lets the freelancer inspect the contract’s funded state instead of relying solely on the business’s promise to pay.

The deliverable in this application is a marketing image containing requirements associated with the business’s brand. The freelancer uploads the image; the platform sends it to OpenAI for evaluation against the agreement. A simple scoring system decides whether confidence is high enough to release payment. On a qualifying result, the agent uses its wallet to call the contract’s release-funds function, which pays the beneficiary. The talk does not specify the threshold or measure evaluation accuracy.

Agent Settlement flowchart linking Freelancer, Image, Platform, Open AI, Decision, Circle API and Contract, with Yes and No branches and a release-funds arrow.Open full source frame
Agent settlement connects image review to a decision and contract fund release.

That review step is the proposed automation of escrow back-office work: inspect evidence, compare it with requirements, and determine whether payment conditions appear satisfied. Cooper sees agents as a possible checkpoint in these workflows as their ability to process text, images and other evidence improves. The contract can enforce who receives funds, but the reliability of the evidence judgment remains a separate concern.

28:1228:34
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

28:12 · section reference included

The Sparkle Fizzle demo and a pending deployment

Cooper opens the application with transactions already staged at different points in the lifecycle. An Initiated agreement has passed PDF extraction using GPT-4o mini and human approval. The example offers $10 for a high-quality image featuring Sparkle Fizzle, a fictitious brand. At this point, the platform has a reviewed agreement, but the smart contract has not yet been deployed.

The staged screens distinguish agreement creation from actual funding:

StageWhat has happenedNext action
InitiatedPDF parsed and listing approvedDeploy the contract
Deployed, awaiting fundsContract exists onchainDeposit the agreed USDC
LockedFunds have settled in escrowReview the submitted work

For the Sparkle Fizzle agreement, the deposit action transfers the $10 amount from the account balance into the contract and reports settlement. Cooper describes release following agent review, or a return to the depositor if time elapses without the agreement being met. He does not specify the refund timeout or its detailed execution rules.

The live attempt begins with a fresh PDF upload. The agent extracts an amount and task, and selecting Continue creates the listing. Webhook updates arrive, although Cooper refreshes the page to make the listing appear. He then selects Create Smart Contract, initiating an asynchronous Circle API deployment request.

While deployment is pending, an audience question establishes that the demo runs on Base Sepolia, a test network. A second question asks whether escrow can work across chains. Cooper’s proposed arrangement keeps the escrow contract on one chain and implements interoperability around it: USDC on Solana could move through CCTP to fund a Base contract, and a beneficiary could request payout on Ethereum. The platform coordinates those deposit and payout flows; this cross-chain extension is not demonstrated in the sample.

Back in the console, Cooper finds the deployment still pending alongside earlier test contracts. He attributes the delay to latency and the room’s internet connection, then switches to a prerecorded end-to-end video. The live sequence establishes that a deployment was requested and remained pending; it does not establish a completed live payout.

32:1532:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

32:15 · section reference included

Gas costs, JSON extraction and reusable templates

Gas abstraction removes native-token management from the user experience, but it does not remove the cost. Cooper describes wallet infrastructure that lets enterprises pay gas expenses in fiat using a debit or credit card on file. The intended audience includes businesses that want programmable settlement without operating like a Web3-native company. Asked about the expense of repeated contract deployments, he suggests a contract factory for creating instances more efficiently; he does not show a factory as the sample’s implemented architecture.

The next question isolates the application’s data transformation: how does an unstructured agreement become input suitable for the platform? Cooper explains that the prompt asks OpenAI to return JSON. Consistent fields for the transaction amount and task let the application generate listings in a predictable format. That structured representation is the bridge between document interpretation and the later contract-configuration workflow.

Asked whether agreements are standardized and how robust extraction is across document formats, Cooper turns to the Solidity template. He shows a simple escrow contract with a few functions, then points to Circle Research’s Refund Protocol and its repository as a more capable starting point that developers can use or extend. That answers the question of reusable contract logic, but leaves document-format robustness unmeasured. The Refund Protocol’s own publication also identifies its code as educational and unaudited, without security guarantees; template availability is not evidence of production readiness.

41:1541:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

41:15 · section reference included

Who should make the final payment decision?

An audience member challenges the central automation step: LLMs can be unreliable and nondeterministic, so how far should a payment system minimize human intervention? Cooper distinguishes Circle’s focus on frictionless settlement from the uncertainty introduced by an agent’s judgment. AI is nondeterministic; payment execution is something businesses want to be deterministic.

His recommendation is human approval supported by agent review. An agent can work continuously, assemble a list of payments it considers ready, and explain the evidence behind each recommendation. A payment-operations professional remains the final approver. This is a more conservative operating model than automatically paying whenever an image evaluator returns high confidence. Cooper regards full autonomous control of sending and receiving payments as premature, offers a speculative five-to-ten-year horizon for greater trust, and invites developers to experiment and provide feedback.

Asked for real-world autonomous work-evaluation and settlement examples, Cooper says Circle has not released a production system doing this. He names Crossmint and thirdweb’s Nebula as offerings to investigate, describing them as active in production experiences. He does not provide a specific evaluated-work escrow case or its results.

A question about zero-knowledge proofs introduces another way to strengthen evidence. Cooper points to TLSNotary communications as relatively lightweight to prove and suggests passing a proof into an escrow workflow. He cites zkP2P as a working experiment, without giving implementation details or proof-generation measurements. TLSNotary’s provenance and selective disclosure of TLS data address whether evidence came from a particular source; deciding whether that evidence satisfies a freelancer’s agreement is still a separate question.

46:4746:55
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

46:47 · section reference included

Delayed broadcasts and multiple-agent approval

The audience returns to offline signing with a security question: could holding an approved transaction before broadcasting it create a double-spending attack? Cooper says he has not encountered that problem in practice, but does not supply a protocol-level security explanation. He returns to the payroll use case: generate, sign and approve a known payment in advance, then broadcast it on the scheduled day. The operational benefit is preparation; the earlier distinction between a signed instruction and reserved funds still applies.

Another question proposes three agents evaluating the same contract and criteria within a multisignature arrangement. Cooper extends the idea into a hypothetical finance team: CFO, controller and accountant agents cross-check one another’s work, then participate in shared authorization for larger payments. He uses transactions above $25,000 as an illustrative threshold. This is a possible future workflow, not an implemented or validated feature of the escrow prototype.

Google Slides editor displaying The USDC Smart Contract slide with three implementation requirement columns: Multisig transactions, Cold storage support and Pausing / upgrading.Open full source frame
USDC smart contract requirements include multisig transactions, cold storage support and pausing or upgrading.
52:4153:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

52:41 · section reference included

Does extraction save work if a human still reads the agreement?

The final question tests the practical value of the human-in-the-loop design. If an approver must read the original agreement to check the extraction, where does the agent save effort? Cooper does not offer a measured reduction in review time. He instead describes the application as a simple prototype and suggests a different starting point: a user could request an agreement in natural language, have the agent draft it, and then have the agent extract its terms and notify both parties.

In that hypothetical flow, the notification describes a $100 agreement and the conditions to be met—a separate example from the $10 Sparkle Fizzle demonstration. It illustrates how agreement creation might become part of the same workflow, but it does not resolve how much verification a human still needs to perform. Cooper closes with an explicit boundary: the sample showcases a combination of technologies and should not be deployed in production as it stands. Programmable settlement is available; trustworthy automation of the judgment that authorizes it remains the engineering problem.

56:2656:45
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

56:26 · section reference included

Resources

From the talk

Transcript download
Full transcript

Loading transcript…