Why Your AI Agent Needs a Wallet: USDC and Nanopayments — Harshal Bhangale, Circle

Good morning, everyone. So, um, I've had the pleasure of meeting a lot of folks at the booth over the last couple of days, and the interactions have been great. But one question kept coming up, which was: Circle is a stablecoin company, so why is a stablecoin company at an AI engineering conference?

And, well, the answer to that is fairly simple, because Circle issues USDC, which is the world's largest regulated stablecoin. And we've built, over the years, expertise in making payments simpler and cheaper. And it turns out that's one of the bottlenecks for your AI agents.

So when you often think about making AI agents smarter, we think about better models, more tool calls, complex orchestration. But where your agent actually, in practice, actually halts is when it hits a paywall, or when it has to pay for something.

Then you have to step in: either create an account, sign up, or, you know, manage API keys. So that's where the limitation is, and that's the gap that I want to talk about today. So, yeah, I'm Harshal, and I'm an engineer on the Agentic Product team at Circle.

So let's sort of take a step back and see how we got here. We believe that the agentic economy is already here. So how are, you know, in 2023 we interacted with agents via, like, prompts, your ChatGPT, and stuff like that.

We got a little bit better in 2024, we built workflows. 2025 was all about MCPs, skills, and orchestration. And we believe this year, 2026, is when agents actually start paying for services that they want. And the signals are promising.

Just in the last 30 days, agents have transacted with paid API endpoints, and the volume is about, like, $24 million over x402. And 99% of it has been settled in USDC. While this number may look small in terms of volume in the broader landscape, it's only about to get larger.

So what is x402? Essentially, x402 is a way where agents can pay for the resources that they want, because the server essentially returns a 402 header, and with the details of how they want the payment to proceed. And then the agent just signs an authorization from their crypto wallet, and then pays for the resource and retries the request again.

So that's x402 in a nutshell, and we'll see that in action in a live demo. But then the question is: why do traditional payment rails not work, and why do the agents get stuck? So the answer is simple, because for the last 30 years, we built the internet around one customer, and that was humans,right?

So we built payment schemes, monetization strategies, all catered towards how humans interacted. So you had your signup flows, add your credit card, put in your information, and manage your API keys. But agents just don't function that way. Agents want to, like, come in and grab that piece of data, resource, compute, inference, whatever, and just, you know, and they have the ability to even, like, consume knowledge at a scale that humans just cannot.

I'm sure, like, you have seen sessions where it's able to, like, just scrape through hundreds of web pages, and then it just, like, stalls because it can't, like, reach a particular endpoint, and it skips over it. So

then you could think, oh, yeah, just give it a credit card, or something like that. So while that is possible, these agents, because they consume so much data as they go, it's, they pay in fractional amounts, so tiny amounts, but at a very high frequency.

And credit cards and their fees are just, like, not sustainable for this kind of, like, economic model. You cannot pay, like, 3% each time an agent tries to make a one-cent transaction. And the reason these transaction amounts are so small is because on the sell side, or on the merchant side, they've realized that these paywalls were actually catered for humans, and now there's an entirely different customer base which is trying to, like, access their data, and they just want, like, a subset of the data.

So you could monetize that as a seller by just offering that, by wrapping that in a, you know, in a paywall, and saying, hey, take one, pay me 10 cents, and grab this data. And that's why these are tiny microtransactions, but highly frequent.

So because the agents are just, like, making these API calls constantly.

So what do these agents need? The agents need payments to work like the internet. So they have to be real-time, low-cost, programmable, and always on.

And that's why we've built the Circle Agent stack. So it's the full stack platform for the agentic economy. And what we mean by that, let's look at it with a live demo. Yeah, wish me luck.

So, okay. So I'll just explain what I'm trying to, if I can get the

terminal. Okay. Okay.

Let's, um, pull it

here. I don't know.

Excuse me, can I? Yeah, I tried, but it's just not, I don't know where the placement of the desktop is.

Can you escape out of this?

Yeah.

Hold on.

Ah. Okay.

Thank you. So, so what we have over here are two sessions. One is your regular Claude code, and on the other, on theright-hand side is a Claude code that comes equipped with Circle Agent wallets. So it has a wallet which is funded and has the ability to, like, make, has the ability to pay for premium content.

And now let me actually just

quickly add a task to this. Yep. And run it. So I'll explain what I'm trying to do over here, which is, yeah, so, so the task I'm giving Claude on, and it's the same task on both the terminals, is plan my trip for the FIFA World Cup final.

So just, you know, give me a summary of flights, hotels, logistics. Also, like, what are the odds of, like, my favorite team, Argentina, being in the final? Who is it going to play? And stuff like that. And also, what's the ticket prices in the secondary market?

How is the experience of other people who've actually been to the stadiums, and are there any FYIs and stuff like that? Grab all of that, send me an email, and if possible, make me, make a phone call and tell, confirm that all of this has been researched and, you know, sort of brief me on the summary.

So we'll see, like, what's happening on both the terminals here. And, sorry, it's a bit hard to navigate. So as you can see, the left, the vanilla Claude code has spun up, like, a bunch of sub-agents, and it's going about doing its research.

Similarly, on theright-hand side, it's actually, like, going through the wallets and making, like, paying for all of these premium content, and we'll see, like, what the results of it are.

So, as you can see, it's trying to make a phone call to, sorry, an API call to StableNinRich, and it's paying from its wallet. It's set up a guardrail of, like, hey, max amount is 15 cents. The beauty of having an agent with a wallet is you sort of build these guardrails into the wallet, and you don't have to, as a human, approve every single transaction.

Because that would just not scale, because these agents are just making these 1 cent, 5 cents, 10 cents transactions. You want to, like, enforce those guardrails, which is, hey, this is the max amount you can send, spend per session, or this is the max cap you can do per day, and stuff like that.

So the agent is still spending within the guardrails that you set, but it is autonomous enough to, like, make these individual API calls.

So let me just look at what,

okay, the vanilla one is looking up and doing some research for hotels.

Yeah,

flights are coming in. Also, like, in the prompt, like, try to, like, tell the agent to wrap this whole thing up within 6 to 8 minutes in the interest of time. So let's see if we're able to, like, get an email and a phone call done in the same time.

So,

let me also walk you through what the agent's doing, if I can grab.

Yep. As you can see, over here, the agent was able to, like, make an API call to the Polymarket data via a provider called BlockRun, and it provided a query and, again, set the max amount guardrails, and is now passing all the results.

Allright. So let's go back to the

main sub-agent, main agent here.

Yep. And this is where I think you'll see on the left-hand side that the agent gets stuck, because the agent just does not have the ability, it cannot send out an email natively. So what it's doing is it's using my, it's just, like, adding a draft into my Gmail account that is logged in, but it just cannot send it to someone.

Whereas the other agent on theright-hand side will just be able to use a provider, pay it, and send an email.

Now let's see, like, this one, the other agent is also, like, is about to, like, send an email and place the call. So let's see.

Okay.

So as the, I think the left agent, the vanilla Claude code's finished, and as you can see, it's sort of, like, made a confession that, yeah, it cannot have, it does not have the ability to make a phone call.

So it's just, like, providing me the highlights over here in the terminal itself. And now, whereas on theright-hand side, the email's been sent. Now let me try to

actually show you the email that we got, I wish. So let

me grab this somehow. Okay.

Okay, I'm going to make, make the phone call. Okay.

I'm just going to drag my

thing here, and then let's look at the email. So,

yep, there we go. So I got this email. Oh, this is the old one. Let's see the new one.

Yep. This is the one that we just received, like, 2 minutes ago, and, yeah, it has all the details that it was able to, like, find, including, like, getting to the stadium, open stadium and maps. It was able to, like, you know, find all of these.

And then

what to expect by looking at, like, Reddit, tickets, etc. So I'll wait for the call, but in the interest of time, it takes sometimes a few minutes for the call to come in, but let's see. And I'll move on.

So how does this work? In the background is, yeah, let's get back to the slides.

Yeah, so, so as you can see, like, the agent on theright-hand side with the wallet was able to just make a bunch of these API calls and pay for it. While blockchains make all of these things theoretically possible, there are, there are also some bottlenecks, because even the most efficient blockchains have a gas fee, and these small transactions just don't scale, because the gas fee will, again, be a significant sort of fraction of the actual transaction.

But it is important to have gas fees, because they prevent the network from spam and abuse. And blockchains also have some throughput limitations, because there are other use cases that run on blockchains and block space as shared infrastructure.

So the problem for agents is unpredictable latency and degraded performance under load. So what we did for that is, essentially, we built a new infrastructure layer on top of our interop product called Gateway. So it's called Nanopayments. It's built for sub-cent transaction sizes for as low as 1 microcent.

It supports, it is gas-free for the seller, and it's instantly cross-chain. And the way it works is you essentially, you just fund your wallet and then deposit. Oh, sorry. While I explain this, let's listen to the actual call that came in.

And.

Hi, Harshal. Here is your World Cup final trip for you for July 19 at MetLife Stadium. Fly SFO to either EWR or JFK nonstop. SFO is showing live arrival delays today, so build buffer.

Awesome.

The airports are all clear.

Can you tell me how do I get to the stadium from my hotel?

On match day, take NJ Transit to Secaucus Junction, then the Meadowlands Rail Spur direct to the stadium. Budget about an hour to 40 seats.

Great. Thank you. I'll read the rest of it in my email. Thank you.

You're welcome.

Allright. So that was just a quick demo of, like, how you can have, like, AI agents. If they're equipped with a wallet, they can do a lot of things with the, as opposed to an agent that does not have a wallet.

So I have a couple of more minutes, so I'll just walk you through how this technology works underneath. So if you have a wallet and you funded it with USDC, it's very easy, because Circle works with a bunch of providers to on-ramp your actual US dollars into USDC.

And from there, you can deposit the funds into a smart contract. The next thing it does is the agent just has to, like, sign these off-chain authorizations, which are essentially cryptographic signatures saying, I am paying this address this particular amount of money.

And then the server just has to, like, relay this to Circle, and within a few hundred milliseconds, the server knows, the merchant knows that, you know, the user has the funds and is able to release the actual resource that the agent requested.

And with this, you avoid the issue of, like, you know, latencies and stuff that are associated with actually settling every single transaction on-chain. And the agents are able to, like, pay for things at the speed at which they operate.

So in conclusion, the way the stack would work is you have Circle agent wallets, which give you the ability to equip your agents with wallets. The agents can now hold their money, spend that money autonomously, but within the guardrails that you set.

The wallets enforce those guardrails, and then on the sell side, the merchants are able to, like, just wrap their endpoints and resources and monetize it with a few lines of code using our SDKs. Then USDC and nanopayments is the layer underneath it, which sort of helps settle these transactions at the speed at which agents operate, which is sub-second.

So, and this is how it scales. And you can give it a try yourself by going to agents.circle.com. It's just a couple of clicks, and you will have your agent equipped with a wallet and ready to, like, you know, make these phone calls and things like that.

So, yeah, thank you.