Automating Escrow with USDC and AI - Corey Cooper, Circle

For show of hands,

how many people in this audience know who Circle is, what we do? I'm just trying to gauge. Okay, okay. Do you know anything about our developer tooling? Gotcha, gotcha. So nobody. Okay, so this is good. Allright.

First, you know, I just want to introduce myself. My name is Corey Cooper. I lead DevRel at Circle. This talk is about the intersection of some exploratory work we've been doing internally between AI and programmable money. And, you know, one of the things we noticed a trend in with USDC when Circle launched its digital dollar technology is that it was an order of magnitude better at doing escrow than traditional payment rails.

And so combining USDC with AI gives you a way to do some type of verification of workflows that are happening that need to be met in order for an escrow agreement to be honored. And then you get instant settlement with a stablecoin that can settle faster than T plus two around the world.

So in this presentation, what we'll do is I'll give you a background on Circle, I'll give you an overview of our developer tooling, then we'll jump into our smart contract that powers USDC, the technology that makes it a programmable dollar and gives it features and attributes that you can't do with a digital representation of a dollar in traditional payment rails.

And then we'll end off with giving a live demo of our escrow agent application that we open-sourced recently and allow you all to set up this in your environment. If you want to locally, I can walk you through doing that today, or we can just do a Q&A.

You can ask some questions about, you know, anything about, you know, our dev tooling and where we see this mirrored between agents and USDC going.

So just to give you a quick background about Circle, it's a fintech company that issues stablecoins. We were established in 2013, and some of our backers are the pillars in the financial services industry, like BlackRock and Fidelity. The reason for that is because we've done a really good job of providing trust and transparency that the digital tokenized version of the US dollar or the euro that we deploy on different blockchain networks is backed one-to-one with fiat and short-term treasuries in a bank account.

So it's fully reserved, 100%. We also have led the charge in regulation around this industry and really helped regulators around the world think about this as a groundbreaking technology for payments. And as you see, there are some things that are happening in the US and across the world where laws are being passed to regulate stablecoins, which we're happy about because it's going to give businesses and individuals an opportunity to take advantage of this technology.

And so another note is, you know, since inception, we've been able to be responsible for settling over $26 trillion of transactions on roughly 20 different blockchains and goingright now. But that's a huge accomplishment for the amount of engineering resources, the product resources, marketing resources that the company has poured into to, you know, allowing businesses and individuals to be able to take advantage of this technology and build on top of it as a payment rail.

So here is a chart, or not really a chart, it's an overview slide, a visual of the lay of the land of what we offer as a company. Like I mentioned earlier, you know, we issue USDC and EURC.

We recently acquired a company called HashNote where we now have a tokenized version of a money market fund, which is going to give us the ability to do something with money markets that were never possible for to be able to liquidate out of a money market into USDC 24/7, 365 days a week.

And then we have our liquidity services for payment service providers, financial institutions, where we enable them to be able to mint and redeem USDC to a very secure enterprise-grade vault wallet on-chain for performing different types of use cases that relate to payments, dollar access, as well as capital markets.

And on the farright, we have our developer services. And this portion of what we offer is what will be wrapped into what we will demonstrate today with the sample app that I'll demo, where it comprises of wallets. So a developer can embed wallets in their application programmatically.

We also have Circle contracts. So that's a smart contract platform that enables you to deploy contracts programmatically and read to those contracts as well as write.

And then under that, we have our Circle Paymaster and CCTP. And if anybody knows anything about

transacting on public blockchain networks, there is something called gas fees. And so what we've done is we've enabled end users to be able to pay for gas fees within USDC, so from their USDC balance. So it actually feels like a traditional payment transaction as opposed to having some native token that you always have to have in your wallet to be able to transact.

And then since we're on all these blockchain networks, there is a lot of fragmentation that we were trying to unify. And the way we unify that is with our cross-chain transfer protocol that allows for you to move USDC between different blockchain networks permissionlessly.

And you as a developer can build very seamless multi-chain experiences around this protocol so that you don't have fragmentation where someone is on one chain and they can't transact on another chain. So you can do cross-chain transactions and things like that.

And at the bottom layer are all the blockchains that we natively have USDC issued on. This list is getting longer. So, but, you know, we are in a multi-chain world where we want USDC to be the premier digital dollar.

And so we are building all types of on-chain utility around USDC as well as ERC to make this, you know, support for multiple blockchains more unified. So there will be some other innovations that we're going to release in the next couple of weeks and months that advance the unification of balances across multiple blockchain networks with our stablecoin technology.

So let's dive into USDC and just really talk about the attributes that are really important to a developer. And so one of the things is, you know, it is a dollar that is internet native. And so what that means is the ledger of that dollar is built into internet technology, which is blockchain networks and smart contracts.

And so it enhances the programmability, the transferability to enable money to move in seconds globally. And so it's not constricted to some of the friction points we have in legacy payment rails.

The other thing is, because it's native to the internet, it has no borders. So it works like email or text where, you know, you can send text or email around the world. We want to make money to be that seamless to be able to transact with.

And so because of it being issued on public blockchain networks, it gives it the borderless freedom to be able to transact globally.

And then last, when you have a network that is permissionless and public and open, it makes it very easy for other companies, individuals to plug into this actual network of money and transact with it. And so it's scaling very fast globally because of the openness of anybody being able to build on top of this protocol for sending, receiving, and storing value.

And so how does this work? You know, how it works is how USDC gets issued in the ecosystem is a business gets approved by Circle to set up a business account. And then they connect their bank account to our Circle Mint platform, and they wire their fiat to our reserve bank account.

After that fiat settles as USD in our bank account, then we mint the corresponding amount of USDC and credit their Circle Mint account. And so that is how USDC gets issued in the ecosystem. Now, the reverse process happens when the business wants to get out of USDC.

They can redeem, and there is a one-to-one with every USDC minted to a US dollar. So when they want to get out, they get that one-to-one parity. And so that is the trust and transparency that we provide to our customers.

We also do a little bit of extra things, and you can go on our website, but we have a USDC transparency page where you can go and see our monthly attestations. And we have various auditors that are independent of the company that continue to audit and make sure that we are fully reserved and we, you know, make sure we ensure the trust and transparency around the actual issuance of a digital representation of the dollar on-chain.

So now we're going to jump into the USDC smart contract and really dive into, like, what makes this programmable? How does it work?

So one thing is we have, you know, very strict implementation requirements before we deploy USDC on a different blockchain network. And so here are the things that we want to make sure that we can incorporate in the token contract before deploying it on a blockchain network, just to make sure we have standardization across the board, you know, as we expand to different blockchain ecosystems, but also, too, to make sure that there are safety provisions that we have built into this actual smart contract for businesses and individuals to be able to trust and use our technology as a protocol for money movement globally.

And so here are some of the things I'll jump into and provide a little bit more clarity around the implementation requirements. But the first is allowlist and blocklist. And so this enables us to basically protect, you know, people who use our token contract from bad actors.

And so if we know someone's on a sanctioned list, you know, and they're a malicious actor, we have the ability to actually stop them from transacting and protect other users from transacting with that actual user. And so it's built in for safety for businesses.

And then we have spin on behalf. And so that's a feature where, you know, say if you're a business and you wanted to create a financial workflow where you wanted to enable, you know, somebody to spend a certain amount of money from a wallet balance and give them a cap on that on a daily basis.

There is functionality built into it where you can delegate for a user to be able to spend a certain amount of money from a actual wallet balance using USDC. So, yeah.

Like, is a scenario with that like a corporate, you know, a corporate account or something?

Like corporate business cards. So say if you have some virtual debit cards that you're issuing to your actual employees and the actual debit card is powered by a USDC balance in a wallet, you could design basically a workflow where you could put thresholds on how much they could spend from that corporate card.

Would you realistically be able to run that to like thousands, tens of thousands, hundreds of thousands, or would that not be the proper use case for that?

No, no, you could scale it up. Yeah. Oops, sorry. You could definitely scale that delegation of spending for that wallet address with a virtual debit card to tens of thousands. Yeah, yeah.

Another is mentor configuration. And so, you know, we have the ability to add, you know, other entities to be able to mint from our token contract. This is something that we haven't done, but there could be a future where we could partner with financial institutions and they have a balance that they can mint from the actual token contract.

And then multi-seed transactions. This is for, you know, like if you're building some type of workflow where maybe you require the CEO, CFO, and COO to actually sign off on transactions that are above a certain threshold. You can design these type of transactional experiences to protect from, you know, a wallet being drained based off of like one person having total control of, you know, the transaction ability of that wallet.

Cold storage support. A use case for this is where maybe you know that you're running payroll on a monthly basis using USDC for your employees. You know the date and time that you're going to be sending money out, you know, the amount.

You have the ability to put those transactions in a ready state that are offline. And so when that date and time comes, it's ready. The transaction object has already been approved and signed, and then you can just broadcast that to the actual blockchain network to send that off.

So it allows you to kind of prepare transactions offline.

Is that a proof of funds transaction so that it's ensured that the money is there when the time comes?

It could be designed for that, but it's more of you have a cadence of transactions that you know are going to happen on, you know, a biweekly or a monthly basis, and you want to make sure that that transaction is already ready to go and in a state where it's already been signed and approved for, and then it can just be broadcasted at a later date.

So it doesn't necessarily prevent it from bouncing?

No. No, no. Yeah, yeah.

And then since this is a new concept of money and we're constantly, you know, thinking about ways of how we can enhance the actual protocol of money movement, there are times where we need to pause the contract for upgrading it.

And so this hasn't been done much, but the most recent one was

about two years ago, a year and a half to two years ago. And, you know, it's USDC version 2.2. And the main thing that we did was we made it more gas efficient. And so knowing that we want to make this technology scalable, we want to make sure that gas fees never become an issue.

And so we were able to design different functionality in the token contract to optimize for better gas performance across chains.

And so now I'll jump into the contract functions of USDC. And so these are basically the functions, the core functions that a developer will plug into when commonly transacting with USDC. And you have balance of total supply, allowance, transfer, transfer from, and approve.

And so these are, you know, functions that are built into the actual smart contract that powers USDC that you'll see actually later on when I do the demo that we'll be using to actually perform the actual escrow transaction.

And so one of the most commonly used functions from this actual contract list is transfer from. And so in that argument, you see you put the from address and the to address and then amount, and you pass that, and then that gets broadcasted to the actual blockchain network to be able to actually send that transaction.

And you're telling it to send basically money from this account to that account and then the amount of USDC that you want to send. And so that's the programmability that you get with USDC that is not built into the digital representation of

fiat in a database. And so that's where the magic allows you as the developers in the room to create these very innovative experiences that were not available to us. And so, you know, USDC is, you know, it's kind of funny, but it's designed for agents.

Basically, how we've seen agents kind of proliferate over the last year or so, it seems like it's just the perfect currency for an agent to use to transact. And so some of the reasons why is, you know, one, you get near-instant settlement and built-in verification of transactions.

And so when an agent is transacting, it's not a human. And so one thing, you know, you want to do is you want to allow the agent to be able to transact. And those agents, if they're doing agent-to-agent payments, they want near-instant settlement because these are robots transacting.

Another thing is you don't want robots to have to deal with chargebacks. And so that could be a nightmare because when agents start transacting with each other, money's going to flow very fast. And so a chargeback could be a catastrophic risk to running agent-to-agent payments, you know, on reversible rails.

The other thing is, you know, agents are always on, you know, and so they need a payment rail that's always on 24/7, no banking hours. And so, you know, the great thing about, you know, this public blockchain infrastructure is you have this compute that's always on that enables settlement to happen 24/7 globally with no banking hours.

And all of these transactions are verifiable through private and public key technology. And so the cryptography and the actual openness of these actual ecosystems make it a perfect payment rail for agents to transact because there's no downtime. Oops, let's go back.

And then the last thing is I'll go back to the slide where I was showing the actual contract functions. It's the programmability. You know, agents are going to need to be able to have a lot of programmability because there are going to be transactions where they'll need to be able to, you know, perform some sort of logic that they need to pass before they can actually make that transaction.

And so that logic can actually be built into composable smart contracts that we'll show in this demo of how, like, this is great for escrow because, you know, you have the ability to perform value transfer with all this conditional logic that you can actually program in, and the agent can actually interact with that logic to be able to perform those transactions.

So very powerful technology here. And so now I'll jump into the sample app. And so first I'll run through kind of the architecture, what we used and how it works, and then we'll jump into a demo of it, and then everybody can have time to actually set it up in their own environment, and I can walk around and help you out if you have any issues.

So

the core building blocks from a dev tooling standpoint of what we used to build this actual escrow flow is we used Circle wallets. And so that enabled us to actually provision wallets for the agent and the two parties involved in the actual escrow process.

And then also, too, we used Circle contracts. So we were able to actually, we wrote a solidity contract, and then we deployed that using the Circle contracts API. So it was a repeatable process of us deploying contracts for each actual group of parties that are transacting.

And so that API allowed for us to take, you know, this template of an escrow contract and solidity and repeatedly deploy it and use it for different parties involved transacting amongst each other. And then lastly, USDC. Being able to embed the USDC stablecoin in the actual smart contract gave us the ability to design basically a smart contract that is running off of dollars and interoperable with the actual fiat world as well because kind of the likely process of some of this will be there's an on-ramping experience from fiat to USDC, and then there's an off-ramping experience where the beneficiary wants to go back to actual fiat.

And using the actual smart contract in USDC gives both parties the trust that they have a tokenized version of the dollar that they know they can get in and out of anytime, one to one. So here's kind of how the onboarding flow works.

As you can see from this design, you have a client, which is the business and the freelancer, and they both come to a platform and create an account. And so as they create an account in the background, there's an API call to the Circle APIs that provisions a wallet for each of those actual parties.

And then the next thing is the actual business will take basically a PDF version of an agreement that they have with that actual freelancer that they probably negotiated outside of the platform for this use case. And then they would upload that agreement.

And what would happen is once they upload that agreement to the platform, it would pass it to the OpenAI's API and run it through a multimodal model to actually parse out information about the actual agreement. And so that information would be related to, you know, the amount that these two parties have agreed upon as far as the work is concerned, and then the summary of tasks that need to be delivered in order for the actual escrow to be completed and payout to happen.

And so after that happens, basically there's a listing on the platform that the AI agent generates and lists. And there's a human in the loop in this process where, you know, the actual business approves that, hey, this is the amount I'd agreed upon.

This is the list of, you know, things that need to be done in order to honor the agreement and receive payout. And this is a good summary of what the agreement is about. So I want to publish that listing to the platform.

And then after that happens, then the actual business would need to

create a smart contract. And so since we've already got a template running in the background, they're not designing that smart contract themselves. What it is doing is it's taking the information that the agent has parsed out from the actual contractual agreement and initializing certain constructor variables for the actual smart contract to be in a ready state to be deployed on-chain to govern the rules of the actual agreement.

And so those things are just simple thingsright now. It's just use USDC as the stablecoin of choice for the currency that flows through. Also, too, the agent will be given a wallet that can only be used to actually release funds from the contract.

And then who is the, you know, depositor wallet and who is the beneficiary wallet? And so those rules will be enforced within the smart contract before it's deployed on-chain. And so after, so to deploy it on-chain, we're using the Circle APIs for this.

And so after that is deployed on-chain, there's a notification that comes on the screen telling the actual business that the contract has been deployed successfully. And in the background, the developer can use the developer console that we have at Circle to track all this activity and to design webhook notifications as well around this activity.

And so that's one of the powers of our dev console. We allow for you to do a lot with on-chain data because we're indexing all this information and putting it in a nice format to allow you to design different programmable flows around that information that's happening on-chain.

And so once the actual contract has been deployed on-chain, the next thing is you're going to have to, the business will have to actually on-ramp into USDC, or if they have pure USDC, then they can fund that actual contract from some USDC they already have in an external wallet.

And so

you will deposit, you'll call the actual deposit function on the smart contract. And what that would do is that would basically initiate an approval for a certain amount of USDC to be sweeped from your actual wallet address and transferred into the smart contract so that the smart contract can go into a ready state of letting the beneficiary know funds have been deposited in the smart contract.

Now it's ready for you to do the work you need to do to honor the contract. And so that's one, you know, magical moment where you have now in this escrow experience a smart contract that's actually holding the money in code, and there is some sort of transparency that you know the money actually is there because you're dealing with these public networks that have the ability to verify, you know, that information by just looking it up on the block export to be able to see that, okay, funds are actually in this smart contract.

So I know this person's serious about paying me. So

after that, then the actual

freelancer will, and for this actual experience, we're using image.

The task at hand was to design basically some marketing material in the format of an image that had certain things within that image that promoted the brand of the actual business. And so freelancer uploads that image to the platform.

It passes it off to OpenAI, and the agent goes to work, and it looks and verifies, okay, does this image have all the things in it that, you know, were required of it in the actual task agreement? If it does, then it'll go through a simple scoring system.

And if that system scores it as, you know, confidence level high, that means, okay, yes, release funds from the actual smart contract. And then the agent can use its wallet to actually call a release funds function within the smart contract that will ultimately release funds to the beneficiary's wallet.

And so this is where, like, the automation, the verification happens, where in most escrow situations, there's a lot of convoluted backend office work where manual review is being done. And agents now are getting to the point where they're very good at reading, seeing, hearing, doing a lot of things.

And so what we think is there could be a future where agents could be a major checkpoint in a lot of escrow transactions, and coupled with USDC becoming a great way to settle escrow transactions instantly. When you combine all this together, you can build some very cool stuff together.

Yeah. So I did a lot of talking. Let me show the demo because I know people want to see that. So let me get out of here and open up my

app. Okay.

Allright. Let's see.

Allright. Can everyone see this okay? Okay. Allright. Thanks. Allright. So here's the escrow agent app. I'm already logged in, and I have some transactions that I've already set up because I wanted to show you what things look like in each state.

And then I'll kind of walk through certain transactions and get to the actual cool part of actually letting the agent actually release funds. But here's a transaction I've staged, andright now it's in the initiated status. And so this status is someone has already uploaded a contract in PDF form to the platform.

It's parsed out the information with the agent using the 401(b) model and then that human-in-the-loop process of approving that, hey, this is what, you know, the agreement should look like, listed on the platform so that the beneficiary can receive that listing.

And so this is the state of what it looks like after you get past that. So it's showing you the summary of the agreement. Obviously, it has the amount here of $10, and then here are some of the deliverables: high-quality image, you know, featuring Sparkle Fizzle.

So that's the brand, a fictitious company we created. And so this is what it'll look like before a smart contract is deployed to govern the rules of an actual agreement.

Now, in this state, say I clicked deploy smart contract on-chain, it has now built out the logic and the rules that will govern this agreement. The next thing is, you know, depositing funds in the smart contract so the actual beneficiary knows that, you know, this person's serious, the money is there, it's time for me to go to work and do the thing so I can receive the money.

This is what state it'll look like. And then if you hit this button, you can deposit funds, and it will withdraw the $10 amount from your account balance, and it'll deposit it in the actual smart contract and provide a notification of when that money has settled in the actual smart contract.

And then once it's, you know, in the smart contract, the state will move to locked. And so that means the smart contract will lock itself. And now the next thing that can happen in that smart contract is basically the agent actually reviewing the work and interacting with it to either release the funds or, you know, revert the actual funds back to the actual

depositor if, you know, a period of time elapses where, you know, that person was never able to kind of meet the agreement. So what I'll do now is let me run through a test transaction. Okay. So let's see.

Allright.

So here's a PDF document. I'm going to upload it. Let's see.

Allright. So in the background, the agent was running, parsing out the information in the PDF document. Again, it's parsed out the amount and the task. And so if I hit continue, what it's going to do is it's going to generate that listing on the platform.

So we've got our webhook working and it's passing updates. Make sure.

And let me do a refresh so that listing will show.

Yeah. Okay. Yep. So that's the listing. And so now

what we want to do is we want to create a smart contract because it has all the information that it needs to actually create this agreement now on-chain. So we hit create smart contract. What it's doing now is calling the Circle APIs to actually deploy that contract on-chain.

So it may take a little time, but

it should work in a few minutes. Let's see.

I have a question maybe in the meantime. Are you doing like Ethereum or which one are you on?

Actually, great question. The network I'm using is base SEPOLIA. Yeah. Yeah.

Oh,right. Yeah.

No, no, no. I mean, it's a great partner, but we support, you know, a lot of different chains. Yeah. Let me see. It's taking a little time.

I got a follow-up question. Can you do an escrow cross-chain, or does it have to be within a single chain?

Yeah. You actually can perform cross-chain escrow experiences. You can use our cross-chain transfer protocol to do that. So I'll give you an example of how maybe that would look is it's more of maybe a cross-chain deposit. So maybe someone comes to the platform and the contracts are on base, but their USDC is on Solana.

And so they want to deposit from Solana USDC to base. They can send it over the cross-chain transfer protocol of CCTP,right? And then it will deposit into that base contract. And then if the beneficiary says, "Hey, you know, like, I'm not on base.

I'm on, you know, another chain, Ethereum. I want it on Ethereum," then you can do a cross-chain, you know, payout from that contract.

Oh, so it's not actually part of the contract, but it's on the platform.

Right. Right. So usually what we've seen is developers who are building cross-chain experiences where they're dealing with smart contracts escrow, a lot of them pick like one chain where the actual contracts will live, and then they build interoperability between like deposit and payout flows.

Yeah. Yeah.

Let's see.

Let me go here to the oops. Wrong one. Let's log in here.

Let's see something.

Okay. I got to logs.

Okay. So yeah, it's working. It's pending. It's just taking some time. A little latency here to actually deploy the contract. So these are different contracts I deployed, testing it. So it's on base SEPOLIA.

Let's see.

Actually, what I'm going to do, let me show this cool video so you all can see like end-to-end really quickly because there is, you know, some sort of latency around the internet in here. So

I'll play this videoright quick so you guys can see an end-to-end flow of like how it works.

And so another thing too is, you know, you don't have to worry about gas with using our tooling because you can design these experiences, and then we have built-in gas abstraction with our wallet as a service infra. And so it enables you to really abstract away kind of dealing with, you know, holding native tokens for gas.

And so we also make it very easy for, you know, as we're abstracting the gas away, obviously there is a cost there, but we make it easy for you to actually pay for your gas fees from fiat directly from a debit card that you would or a credit card that you put on file.

But we really have designed this for, you know, enterprises that, you know, probably aren't Web3 native to be able to integrate our technology, take advantage of the near-instant settlement that comes with public blockchain networks, and manage wallets and transactions at a scalable level to be able to, you know, expand their actual footprint of payments around the world.

So the last thing I have is, let's see.

Just a question. Yeah.

Yeah.

I used to be really into Ethereum. I'm a little rusty, to be honest. I remember deploying the contracts before the biggest gas pauses.

Yeah.

Do you reuse existing contracts like with an additional client later?

Yeah. You can actually deploy like a contract factory, and then that'll allow you to kind of create iterations of that within the contract factory to be more efficient on the gas. Yeah. Yeah. Yeah.

So in the mechanics of what you're doing, is that first step basically taking an unstructured document and you creating basically structured data to then feed to the Circle API in terms of. And I guess how does that piece work?

Is it as simple as like feeding the contract to OpenAPI and just doing a little bit of prompting to kind of get the structured data you want as far as the JSON format?

Yeah. Yeah. I'll jump into thisright quick for you. So, okay.

So yeah, that first part is, you know, we've created a prompt to make sure it outputs it in JSON. So it parses things out, outputs it in kind of a JSON format that looks like this. And then that's how we're able to kind of feed it through to be able to create basically that listing that adheres to a consistent format of showing the actual transaction amount and task.

I'm not super familiar with escrow contracts. Are they fairly standardized, or do they come in different forms? And I guess how

robust has it been able to be in terms of handling different formats?

Yeah. So here's the actual solidity code I'll show you for the actual escrow contract here. And this is a very simple one. It's only like a couple hundred lines and a few functions. They can get very robust, but if you're

for most escrow, you know, experiences, this could cover a lot, you know, for most escrow experiences. And there are a lot of templates out there since escrow has been a big thing in the actual crypto ecosystem that you can use.

One is one that our research team worked on. It's called the refund protocol. I'll pull it upright now, but it's an escrow template that kind of gives you all the robustness you would probably need to handle any type of escrow scenario that has been prevalent in the ecosystem.

Let me pull it upright now. And you could actually use that as a template and, you know, add to it if you want or just use it straight out of the box.

So let me show you this one.

Yeah. Here it isright here. So if you go to Circle Research, this is an article about it, and it kind of explains, you know, the functionality built into it. But also too, we have a repo. It is

where is this repo?

Refund protocol. So yeah, this oneright here. You could use this as a template.

Yeah.

Can you just wait for the microphone so everybody can hear you? Hold on one second.

Thank you.

Okay. So my question here is towards the challenges of minimizing human intervention. I find LLMs and agents

sometimes unreliably non-deterministic,right? So there is always this pattern of the LLM or the agent builds like a plan, and someone reviews to approve.

Given the nature of your business,right, I understand that like

I guess the question here is like what are for Circle AI the biggest challenges when you talk about minimizing human interaction using agents?

Yeah. Great question. So the question here is, you know, what is the challenges with minimizing interactions with payments as it relates to Circle? So I think that

our focus as our company is kind of like creating more of a frictionless exchange of value using public blockchain networks for settlement,right? But we started to see a huge trend over a year ago where a lot of developers were building agentic workflows using USDC as the payment rail of choice to transact between agents and agents.

And so what we think is obviously

the one thing about, you know, AI is it's not deterministic, and payments are deterministic. You want them to be deterministic, but there is a lot of conditional logic that is happening before payments are being released in the world.

And so what I think isright now the best, safest way to design these experiences is with human-in-the-loop built into it and really kind of focus on it

being just a peer review, basically, for a person in an actual payment operation job to be able to have just something else out there that is doing work 24/7 and saying, "Hey, here are a list of payments that are ready to go.

And this is what we've analyzed and why we believe it's ready to go. But at the end of the day, like you're the final approver." And so that's what we think, you know, in the near future, combining these technologies together, it can be a great combination.

But autonomously and just, you know, full automation of controlling sending and receiving payments, I'm not sure we're thereright now. But I will say that, you know, the way this AI industry is moving, there could be a world, you know, five to ten years from now where people actually trust these agents to autonomously handle payments and procurement and things like that.

So hopefully that answers your question. Yeah. But we're in the first inning of this. And to be completely transparent, you know, there's people in this room who have a lot of experience building with agents. This is designed to inspire you all to like test out the combination of this technology and give us feedback too.

We're learning alongside.

Oh.

Oh.

I missed the first part, but what's the closest real-life examples you have of this autonomous work evaluation and settlement? Do you have any kind of real-life examples you can share?

Yeah. So we haven't released anything that's like in production doing this, but there are companies that are doing thisright now in production. And that is, you know, you have CrossMet is one company. And then another company is ThirdWeb with Nebula, their model.

So those companies are kind of, you know, on the bleeding edge of offering these experiences to developers, but also kind of, you know, putting things out themselves. So I'd encourage you to check out those two companies. They're both CrossMet's headquartered in New York, I think, and ThirdWeb isright down the street here in the Bay.

Yeah. Yeah.

Hi. I have a question regarding like around the escrow transactions. So I wanted to know how feasible is it to implement zero-knowledge proof in this blockchain-based escrow transactions?

Yeah.

That is something that is pretty feasible with the advancements that we've seen with proving TLS notary communications. Those are a little bit lighter weight to prove, and you can generate a proof faster and pass that to a smart contract to be able to perform escrow.

So there is a company called ZKP2P that actually is experimenting with this, and it's a live experiment that is working really well. So there are different ways you could design these and integrate ZK proofs into them that we've seen, and ZKP2P is one of them that has done it pretty well.

Yeah. Great question.

Yeah. Thank you. I have sorry. I have another question as well. So could you go to the slide where the implementation thing is there for the cold storage support?

Okay. Let's see.

Yeah.

So here I have a doubt like.

So yes, in this like transactions should not always be instantaneous. So you should be like creating ahead of time and broadcast next month,right? So I'm not sure. Like I have a doubt like is there a possibility if like there might be a double spending kind of attack if we like hold the transaction and it is not instantaneous?

So the question is, could actually generating an offline transaction that's approved create a double spending exploit? Is that the question?

Yes.

I don't think it could necessarily do that. You know, from my experience of people actually kind of generating transactions offline to actually broadcast later, I haven't seen that issue become a problem with double spending.

Oh, and like could you like a little bit explain to me the scenario of like how transactions should not always be instantaneous like around this?

Yeah. So this use case of maybe if you are a company and you're running payroll on-chain and you know that there is a transaction that you're going to make in the future for a certain amount to do payroll and it's on a consistent cadence, you could actually generate that transaction, sign and approve it offline, and then broadcast it on the day of the actual transaction that needs to be sent out.

Oh, got it. Thank you.

Yeah. Okay.

Yeah.

Hey, how's it going?

Good. How are you doing?

I must have missed the first part where you mentioned multi-sig, but my question was just revolving around like some of the different use cases of multi-sig, combining that with, you know, humans, agents. You know, for example, in this contract evaluation, you could have like three different agents try to evaluate the same contract and criteria inside of multi-sig.

But what other use cases of multi-sig and AI do you see?

Great question. You know, I think that, you know, there could be a world where you like you have multiple agents that may act as, you know, in kind of like a financial operations unit at a company, small company, and you may have, you know, a CFO agent, a controller agent, accountant agent, and those agents are cross-checking each other's work and things like that.

But then ultimately, they need to do some sort of multi-signature process to be able to sign off on maybe transactions that are over like $25,000. So that could be like a world that we see with agents and USDC.

Great. Thank you.

Yeah. Okay.

So where are you using that AI for reading the document and generating the like what the contract should be? So there is a human in the loop. So in order for the human to approve or reject it, he needs to go through that document himself as well,right?

So how exactly is that agent saving any effort because the human has to still go and read the document,right?

Yeah. Yeah. So like, you know,right now, like this is just a simple prototype,right? We could have gone the extra mile and started out with someone, you know, using NLP to like just create like a simple prompt to say, "Hey, I want a contract between, you know, me and this other person that does these things."

And then the agent goes out and writes it. And then the agent could actually, you know, parse out the information it wrote and then send a notification to the two parties that this is an agreement for $100 and these are the things that need to be met.

So that's a world where we could have done that, but like we were just trying to put together a simple prototype to just showcase the combination of technology. But this is not, you know, something we feel like is you should, you know, deploy in production and useright now, but it's inspiration, you know, of combining these different technologies.

Okay. Got it. Thanks.

Yeah. Yeah.

So I guess, yeah, we don't have any other questions. We can close it out. Thanks, everyone.