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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
| Service | Responsibility |
|---|---|
| Circle Wallets | Embed and provision wallets programmatically |
| Circle Contracts | Deploy contracts and read or write their state |
| Circle Paymaster | Pay gas from a USDC balance |
| Cross-Chain Transfer Protocol, or CCTP | Move 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
- A business receives Circle’s approval and opens a Circle Mint account.
- It connects its bank account and wires fiat into Circle’s reserve bank account.
- After the USD settles, Circle mints the corresponding USDC and credits the business’s Circle Mint account.
- 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
| Function | Purpose |
|---|---|
balanceOf | Read an address’s token balance |
totalSupply | Read the token’s total supply |
allowance | Read an owner’s authorization for a spender |
transfer | Send tokens from the caller |
transferFrom | Move tokens using spending authorization |
approve | Set 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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:
| Stage | What has happened | Next action |
|---|---|---|
Initiated | PDF parsed and listing approved | Deploy the contract |
| Deployed, awaiting funds | Contract exists onchain | Deposit the agreed USDC |
Locked | Funds have settled in escrow | Review 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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
An educational escrow design with restricted arbitration powers, refunds, lockup periods and early withdrawals.
Historical announcement of USDC and EURC contract changes addressing gas costs, account abstraction and security.
Explains how users can prove the provenance of website data while selectively revealing its contents.
Further reading
Cooper describes his exploration of escrow services combining AI agents, smart contracts and USDC.
Full transcript
Loading transcript…