Why Your AI Agent Needs a Wallet: USDC and Nanopayments — Harshal Bhangale, Circle
Description
Harshal Bhangale gave two identical agents the same job: plan a trip to the World Cup final, covering flights, hotels, resale ticket prices and what people said about getting to the stadium, then email him the summary and call him about it. One had a funded wallet. The other did not. The agent without one drafted the email into his inbox and could not send it, then admitted on screen that it had no way to place a call. The agent with one paid for the data it needed, sent the mail, and rang him on stage, where it also answered a follow up question about reaching the stadium from his hotel. Circle issues USDC, and Bhangale's answer for why a stablecoin company belongs at this conference is that paying is where agents stall. The economics are the whole argument. Agents consume in fractional amounts at high frequency, and a card fee near 3% cannot sit on top of a one cent call, which is exactly the size sellers are moving toward now that they can meter a slice of their data instead of selling a human a subscription. He cites roughly 24 million dollars transacted against paid API endpoints over x402 in thirty days, almost all settled in USDC. Blockchains alone do not fix it either. Gas exists to stop spam, but gas on a microtransaction swamps the transaction, and shared block space makes latency unpredictable. Circle's answer is to keep settlement off the chain: funds are deposited into a smart contract, the agent signs authorizations cryptographically, and the seller relays them for confirmation in a few hundred milliseconds. The wallet enforces the spending cap, not a human. Speaker info: - https://www.linkedin.com/in/harshaldbhangale Timestamps: 0:00 - Why a stablecoin company is at an AI conference 1:05 - Where agents actually stall 1:58 - From prompts to workflows to agents that pay 2:53 - x402 in one paragraph 4:48 - Why card fees break on a one cent transaction 5:41 - Demo: two agents, one with a wallet 9:34 - Guardrails in the wallet instead of human approval
Summary
Generated by gpt-5.6-terraAt-a-Glance
- Verdict: Watch fully
- Core thesis: Autonomous agents need wallet-native, policy-constrained micropayments to purchase APIs, data, communications, and compute without human signup, card, or API-key workflows.
- Why it matters: Payment is emerging as a practical bottleneck in agent autonomy: an agent can reason and orchestrate tools, but cannot reliably access paid resources or complete paid actions unless it can transact programmatically at very small amounts.
- Best use: Use this as a concrete architecture and product-pattern briefing for adding delegated spending, merchant monetization, and payment guardrails to an agent control plane.
Executive Summary
Circle argues that the next stage of the agent economy is not primarily better models or orchestration, but agents that can independently pay for the specific data, APIs, inference, and action services they need. Human-oriented commerce flows—account creation, credit-card entry, API-key management, and recurring subscriptions—interrupt an agent’s workflow and do not fit high-frequency, fractional-value purchases.
The central implementation pattern is an agent wallet funded with USDC and bounded by explicit spending policy. Rather than asking a human to approve every one-cent or ten-cent transaction, the wallet can enforce limits such as a maximum amount per transaction, session, or day while allowing the agent to purchase resources autonomously.
In the demo, a wallet-enabled Claude Code agent completed a World Cup trip-research task by purchasing premium data and action APIs, sending an email, and placing a phone call. The comparison agent without a wallet could research publicly available information but stopped at execution boundaries: it created a Gmail draft rather than sending the email and could not make the call.
Circle’s technical pitch is that ordinary on-chain settlement is also poorly suited to agent micropayments because gas costs, shared-chain throughput, and variable latency can overwhelm sub-cent purchases. Its NanoPayments layer uses prefunded smart-contract balances plus signed off-chain payment authorizations, allowing a merchant to verify funds and release a resource within a few hundred milliseconds rather than requiring every payment to settle individually on-chain.
Key Takeaways
- Claim: Payments, rather than model intelligence alone, are a key constraint on end-to-end agent autonomy. | Evidence: The speaker describes agents that can scrape hundreds of pages or orchestrate sub-agents but stall at a paid endpoint, where a human typically must create an account, enter card details, or manage an API key. | Implication: Agent-system design should treat access procurement as a first-class capability alongside tools, identity, memory, and orchestration; otherwise workflows will fail precisely when they need proprietary data or external execution.
- Claim: Credit-card and subscription payment models are economically mismatched to agents that buy narrowly scoped resources at high frequency. | Evidence: The talk contrasts a card fee of roughly 3% with an agent making repeated one-cent purchases, while describing merchants charging, for example, ten cents for a requested subset of data. | Implication: For agent-facing APIs, consider per-call or per-result monetization rather than forcing customers into human signup and subscription funnels. | Caveat: The argument applies most strongly to granular, usage-based purchases; many recurring or high-ticket agent services may still be adequately served by conventional billing.
- Claim: A wallet should function as a delegated-spending control plane, not merely as a balance an agent can access. | Evidence: In the demo, the agent was configured with a 15-cent maximum for a paid call, and the speaker recommends wallet-enforced caps per session or per day so humans do not need to approve each microtransaction. | Implication: If Ken gives agents spending authority, policy should be programmable and enforced below the agent prompt layer, with narrow budgets and service-level permissions rather than broad access to a general-purpose payment instrument. | Caveat: Spending caps alone are not a complete authorization system; the presentation does not address merchant allowlists, category restrictions, anomaly detection, revocation, audit trails, or consequences of compromised agent credentials.
- Claim: A wallet-enabled agent can cross the boundary from research to paid execution by purchasing specialized action and information services on demand. | Evidence: For a FIFA World Cup final trip task, the wallet-equipped Claude Code agent paid for Polymarket data through Blockrun, retrieved premium research, sent an email through a provider, and placed a phone call; the non-wallet version produced a Gmail draft and stated it could not call. | Implication: The immediate opportunity is not a generic ‘AI wallet,’ but a purchasable-tool ecosystem where agents can discover, authorize, and invoke narrowly scoped services without pre-provisioning every vendor relationship. | Caveat: This is a vendor-controlled live demonstration, not a benchmark; the transcript does not disclose total cost, reliability, provider coverage, security controls, or whether comparable non-crypto integrations could perform the same actions.
- Claim: Direct on-chain payments are not sufficient for the smallest agent transactions because transaction overhead and network conditions can dominate the value exchanged. | Evidence: The speaker says even efficient blockchains impose gas fees, that gas is important for anti-spam protection, and that shared block space can create throughput limits, unpredictable latency, and degraded performance under load. | Implication: Any agent-payment architecture using blockchain rails needs an off-chain or batched authorization/settlement mechanism if it is intended for frequent sub-cent transactions.
- Claim: Circle’s NanoPayments architecture seeks to make micropayments fast by separating immediate authorization from final settlement. | Evidence: A user funds a wallet with USDC and deposits funds into a smart contract; the agent signs an off-chain cryptographic authorization specifying recipient and amount; the merchant relays it to Circle and reportedly receives confirmation of funds within a few hundred milliseconds before releasing the resource. Circle claims support down to one microcent, seller gas-free operation, and instant cross-chain capability. | Implication: Evaluate this as a payment-network dependency and authorization layer, not simply as a wallet SDK; its operational and compliance properties will matter as much as its developer experience. | Caveat: These are Circle product claims. The transcript does not establish custody model, dispute handling, settlement finality, privacy properties, supported chains, geographic availability, fee structure, or dependency and counterparty risk.
- Claim: Circle sees 2026 as the point at which agents begin paying for services at meaningful scale, and cites early X402 transaction activity as evidence. | Evidence: The speaker reports approximately $24 million of transactions with paid API endpoints over X402 in the prior 30 days, with 99% settled in USDC, while acknowledging the volume remains small in the broader payments landscape. | Implication: Track X402 and USDC agent-payment adoption as an early ecosystem signal, but do not treat the cited volume alone as proof of durable product-market fit. | Caveat: The statistic is presented without methodology, source breakdown, or distinction between organic production demand and ecosystem or promotional activity.
Detailed Brief
X402 request-payment flow
- Claims: X402 is presented as a protocol pattern for turning a denied API request into a machine-payable request rather than a human checkout flow.; The merchant returns a HTTP 402 response containing payment instructions; the agent signs a wallet authorization, pays or authorizes payment, and retries the original request.
- Evidence: The speaker characterizes the flow as: server returns a 402 header with payment details, agent signs from its crypto wallet, then retries the request after payment.; The named resources agents may purchase include data, compute, inference, and other API-accessed services.
- Caveats: The transcript does not cover service discovery, quote expiration, partial delivery, refund handling, authentication binding, or protections against a malicious endpoint repeatedly requesting payment.
- Implications: HTTP-level payment negotiation could reduce the integration burden of pre-registering an agent with every data or action vendor, provided trust, receipts, and policy enforcement are standardized.
Circle stack and merchant-side proposition
- Claims: Circle positions its offering as a full stack comprising Agent Wallets, merchant SDKs, USDC, Gateway interoperability infrastructure, and NanoPayments.; The merchant-side value proposition is to put an endpoint or resource behind a paywall with only a few lines of SDK code and sell granular access to agents.
- Evidence: The stack is explicitly summarized as wallets for holding and autonomously spending funds, SDKs for wrapping merchant endpoints, and USDC/NanoPayments for sub-second settlement behavior.; Circle directs developers to agents.circle.com to provision an agent wallet.
- Caveats: The presentation is a Circle product talk and offers no comparison with competing payment protocols, hosted billing systems, virtual-card approaches, or direct vendor OAuth/API integrations.
- Implications: The strategic question is whether a sufficiently broad merchant network emerges; the utility of agent wallets rises sharply with interoperable endpoint coverage rather than wallet capability in isolation.
Notable Concepts & Terms
- USDC: Circle’s regulated stablecoin and the settlement asset underlying its proposed agent-payment stack.
- X402: A payment pattern built around an HTTP 402 response, intended to let an agent receive payment instructions, authorize payment, and retry access to a paid resource.
- Circle Agent Wallet: A wallet intended to give an agent autonomous but policy-bounded control over funds for paid tools and services.
- NanoPayments: Circle’s infrastructure layer for sub-cent agent transactions that aims to avoid per-transaction on-chain gas and latency costs.
- Gateway: Circle’s interoperability product, described as the layer on which NanoPayments is built.
- Off-chain authorization: A cryptographic signature from the agent authorizing a specified payment; it enables merchants to verify available funds without waiting for every individual transaction to settle on-chain.
- Delegated spending guardrails: Wallet-enforced limits such as maximum spend per transaction, session, or day that permit autonomous purchases without continuous human approval.
- Blockrun: A provider used in the demo to access Polymarket data through a paid API call.
Operator Notes / Why Ken Should Care
- Define an agent-payment policy model before enabling any wallet: per-transaction cap, session and daily budget, merchant allowlist, approved service categories, emergency revocation, and immutable spending logs.
- Run a constrained proof of concept on a workflow that currently fails at proprietary-data or action-service access; compare wallet-based pay-per-call access against prepaid vendor accounts, OAuth integrations, and virtual-card approaches.
- Ask Circle for production diligence on custody, key management, authorization replay protection, settlement finality, merchant disputes/refunds, compliance/KYC obligations, supported jurisdictions, fees, SLA, and incident-response controls.
- Monitor X402 merchant coverage and independently validate the reported transaction-volume growth before making an ecosystem-level platform commitment.
- Avoid giving a general research agent unrestricted funds; expose payment as a narrowly scoped tool governed by an external policy engine rather than relying on prompt instructions.
Source/Metadata
- Title: Why Your AI Agent Needs a Wallet: USDC and Nanopayments — Harshal Bhangale, Circle
- Transcript words: 4335
- Duration seconds: 1252
- Timestamp note: No usable timestamps or chapters were present in the supplied transcript; the latter portion substantially repeats the earlier presentation.
Transcript
Good morning, everyone. So 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? 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 holds in practice 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 manage API keys. That's where the limitation is, and that's the gap that I want to talk about today. I'm Harshal, and I'm an engineer on the Agent Tech product team at Circle. Let's take a step back and see how we got here. We believe that the Agent Tech economy is already here. In 2023, we interacted with agents via 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. The signals are promising. Just in the last 30 days, agents have transacted with paid API endpoints, and the volume is about $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 going to get larger. So what is X402? Essentially, X402 is a way where agents can pay for the resources that they want. The server essentially returns a 402 header with the details of how they want the payment to proceed. Then the agent just signs an authorization from the crypto wallet, pays for the resource, and retries the request again. 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 agents get stuck? The answer is simple. For the last 30 years, we've built the internet around one customer, and that was humans. We built payment schemes, monetization strategies, all catered towards how humans interacted. You had your sign-up 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 come in and grab that piece of data, resource, compute, inference, whatever, and they have the ability to consume knowledge at a scale that humans just cannot. I'm sure you have seen sessions where it's able to scrape through hundreds of web pages and then it stalls because it can't reach a particular endpoint and it skips over it. You could think, oh yeah, just give it a credit card or something like that. While that is possible, these agents, because they consume so much data as they go, they pay in fractional amounts. Tiny amounts, but at a very high frequency. Credit cards and their fees are just not sustainable for this kind of economic model. You cannot pay 3% each time an agent tries to make a one-cent transaction. 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 access their data. And they just want a subset of the data. So you could monetize that as a seller by just offering that by wrapping that in a paywall and saying, hey, I take one, pay me 10 cents and grab this data. That's why these are tiny microtransactions, but highly frequent, because agents are just making these API calls constantly. So what do these agents need? Agents need payments to work like the internet. They have to be real-time, low-cost, programmable, and always on. That's why we've built the Circle Agent Stack, the full-stack platform for the agent economy. Let me show you what I mean with a live demo. So I'll explain what I'm trying to do. If I can get the terminal, okay. Let me see. What we have over here are two sessions. One is your regular Claude code, and on the right-hand side is a Claude code that comes equipped with Circle Agent Wallet. It has a wallet which is funded and has the ability to pay for premium content. Now let me actually just quickly add a task to this and run it. So I'll explain what I'm trying to do over here. The task I'm giving Claude, and it's the same task on both terminals, is: plan my trip for the FIFA World Cup Final. Give me a summary of flights, hotels, logistics. Also, what are the odds of my favorite team Argentina being in the final? Who is it going to play? What are 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? Grab all of that, send me an email, and if possible, make a phone call and confirm that all of this has been researched and brief me on the summary. So we'll see what's happening on both terminals here. As you can see, the left, the vanilla Claude code has spun up a bunch of sub-agents and it's going about doing its research. Similarly, on the right-hand side, it's actually going through the wallets and making, paying for all of these premium content. We'll see what the results are. As you can see, it's trying to make a phone call to find an API call to Stable and Rich, and it's paying from its wallet. It's set up a guardrail of, 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. These agents are just making these one-cent, five-cent, ten-cent transactions. You want to enforce those guardrails, which is, hey, this is the max amount you can spend per session, or this is the max cap you can do per day. So the agent is still spending within the guardrails that you set, but it is autonomous enough to make these individual API calls. Let me just look at what the vanilla one is looking up and doing some research for hotels. Lights are coming in. Also, in the prompt, try to tell the agent to wrap this whole thing up within six to eight minutes in the interest of time. So let's see if we're able to get an email and a phone call done in the same time. Let me also walk you through what the agent's doing, if I can grab it. As you can see, over here, the agent was able to 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. All right, so let's go back to the main sub-agent here. 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 just adding a draft into my Gmail account that is logged in, but it just cannot send it to someone. Whereas the other agent on the right-hand side will just be able to use a provider, pay it, and send an email. Let's see. This one's the other agent is also about to send an email and place the call. Okay, so the left agent, the vanilla Claude code's finished, and as you can see, it's sort of made a confession that yeah, it cannot have the ability to make a phone call. So it's just providing me the highlights over here in the terminal itself. And whereas on the right-hand side, the email's been sent. Now let me try to actually show you the email that we got. Grab this somehow. Okay. Let me make the phone call. Okay. Okay. Let me look at the email. Yep, there we go. So I got this email. This is the old one. Let's see. Yep. This is the one that we just received like two minutes ago, and yeah, it has all the details that it was able to find, including getting to the stadium, open stadium and maps. It was able to find all of these, and then what to expect by looking at Reddit, tickets, et cetera. I'll wait for the call, but in the interest of time, it takes sometimes a few minutes for the call to come in. Let me move on. So how does this work in the background? Let's get back to the slides. Yeah, so as you can see, the agent on the right-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 also some bottlenecks. Even the most efficient blockchains have a gas fee, and these small transactions just don't scale because the gas fee will be a significant fraction of the actual transaction. But it is important to have gas fees because they prevent the network from spam and abuse. Blockchains also have some throughput limitations because there are other use cases that run on blockchains and block space is shared infrastructure. So the problem for agents is unpredictable latency and degraded performance under load. What we did for that is essentially we built a new infrastructure layer on top of our interop product called Gateway, called NanoPayments. It's built for subsent transaction sizes for as low as one microcent. It supports gas-free for the seller, and it's instantly cross-chain. The way it works is you essentially just fund your wallet and then, while I explain this, let's listen to the actual call that came in. 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. 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 order a seat. Thank you. I'll read the rest of it in my email. Thank you. You're welcome. Have a good one. All right. So that was just a quick demo of how you can have AI agents. If they're equipped with a wallet, they can do a lot of things, as opposed to an agent that does not have a wallet. I have a couple more minutes, so I'll just walk you through how this technology works underneath. 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. From there, you can deposit the funds into a smart contract. The next thing the agent has to do is sign these off-chain authorizations, which are essentially cryptographic signatures saying, I am paying this address this particular amount of money. Then the server just has to relay this to Circle, and within a few hundred milliseconds, the server knows, the merchant knows that the user has the funds and is able to release the actual resource that the agent requested. With this, you avoid the issue of latencies and stuff that are associated with actually settling every single transaction on-chain, and the agents are able to 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 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. 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 make these phone calls and things like that. Yeah. Thank you. 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've 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 sign-up 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 come in and grab that piece of data, resource, compute, inference, whatever. And just, you know, and they have the ability to even consume knowledge at a scale that humans just cannot. I'm sure you have seen sessions where it's able to just scrape through hundreds of web pages. And then it just stalls because it can't 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, I 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 agent 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 do. If I can get the terminal, okay. Okay. Let's see. Mm-hmm. Pull it. Yeah, 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. Okay. Thank you. So, what we have over here are two sessions. One is your regular cloud code. And on the right-hand side is a cloud code that comes equipped with Circle Agent Wallet. So, it has a wallet which is funded and 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, 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 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 FYI's? And stuff like that. Grab all of that. Send me an email. And if possible, make a phone call and 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 the right-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 find, sorry, an API call to stable and rich. 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 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 the vanilla one is looking up and doing some research for hotels. Yeah. Lights are coming in. Also, like, in the prompt, like, try to, like, tell the agent to wrap this whole thing up within six to eight 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. All right, so let's go back to the main sub, 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 the right-hand side will just be able to use a provider, pay it and send an email. Now, let's see, like this one's the other agent is also like, is about to like send an email and please the call. So let's see. Okay. So as the, I think the left agent, the vanilla cloud 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 use the code. 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 the right-hand side, the email's been sent. Now, let me try to actually show you the email that we got, I wish. Grab this somehow. Okay. I'm gonna make, make the phone call. Okay. Okay. Grab my, in 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. Yep. This is the one that we just received like two 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, et cetera. 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, as you can see, like the agent on the right-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 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 spaces 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 subsent transaction sizes for as low as one 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, 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. 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 order a seat. Thank you. I'll read the rest of it in my email. Thank you. You're welcome. Have a good one. All right. So that was just a quick demo of how you can have AI agents. If they're equipped with a wallet, they can do a lot of things, 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 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 relay this to Circle. And within a few hundred milliseconds, the server knows, the merchant knows that 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 latencies and stuff that are associated with actually settling every single transaction on-chain. And the agents are able to 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 just wrap their endpoints and resources and monetize it with a few lines of code using our SDKs. Then, USDC and Nano Payments 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 make these phone calls and things like that. So, yeah. Thank you. Thank you.