💰When AI Agents Start Spending Money: Lessons from Coinbase, Circle, Kite AI & M12
EntreConnect Event Recap - June 15, 2026
For a while, the easiest way to talk about AI agents was to talk about convenience. They might book a flight. They might find a product. They might finish the annoying task you were avoiding.
But the conversation at EntreConnect's June 15 event moved past convenience quickly. The moment an agent can spend money, call APIs, evaluate tradeoffs, and act on behalf of a user, the question changes. It is no longer just "can the model do the task?" It becomes: who gave it permission, what is it allowed to spend, how does the service know it is trustworthy, and what happens when the transaction becomes the source of truth?
That was the real center of The Agentic Economy: Payments, Commerce & AI-Native Platforms at AWS Loft in San Francisco. The room was full of builders, founders, operators, and investors circling the same shift from different parts of the stack. Some came for payments. Some came for agents. Some came for stablecoins, x402, or AI-native commerce. By the end, the sharper insight was that all of those threads are starting to collapse into one infrastructure question.
If software is going to move from assistant to actor, the internet has to learn how to let machines transact safely.
🤝 Shout out to our partner Kite AI for helping make this event possible!
Kite AI is building payment infrastructure for the agent-native web: a foundational layer where autonomous AI agents can operate with verifiable identity, programmable governance, and native stablecoin settlement. Founded by veterans from Databricks, Uber, and UC Berkeley, Kite AI has raised $33 million from backers including PayPal, General Catalyst, Coinbase Ventures, and 8VC.
Speakers
Kevin Leffew, GTM Lead at Coinbase (NASDAQ: COIN) - co-author of x402, working across stablecoins, wallet infrastructure, and agent-native payment rails
Gagan Mac, VP Product Management at Circle (NYSE: CRCL) - product leader working across stablecoin infrastructure, wallet services, interoperability, and developer products at Circle
Chi Zhang, Co-founder & CEO at Kite AI - leading Kite's work on agentic payment infrastructure; Series A company with $33M raised
Alan Du, Partner at M12 - investor at Microsoft's venture fund, backing early-stage startups across AI, enterprise, and infrastructure
TL;DR
- Agentic payments are not just a checkout problem. They sit at the end of a much longer chain involving discovery, intent, permissions, credentials, identity, and governance.
- Developer and API workflows look like the near-term wedge: agents buying access to tools, data, compute, and services without the old API-key dance.
- Stablecoins are compelling for agent workflows because they are programmable, fast-settling, and easier to constrain with wallet-level guardrails.
- Trust is still the real adoption bottleneck. Identity, reputation, memory, and spend controls have to mature before consumers hand agents real autonomy.
- The infrastructure race is forming around protocols, wallets, orchestration layers, agent identity, and economic reasoning.
Agents Become Economic Actors 💸
The night opened with a deceptively simple question: what are agentic payments?
Gagan Mac gave the cleanest human version of the answer. If software can already do a lot of work for you, the next step is simple to state but difficult to build: software making payments on your behalf to get a job done. Kevin Leffew framed it even more directly: agentic payments are payments an agent initiates and executes.
That sounds narrow until you follow the implications. A normal assistant can answer a question. An agent that can pay can decide which service to use, compare cost and quality, access live data, buy compute, call APIs, generate outputs, and complete a task without asking a human to manually wire together every step. The payment is not just the end of the workflow. It is the moment the agent becomes economically legible.
This is why the conversation kept returning to alignment. Once an agent can make economic decisions, money becomes more than a transfer mechanism. It becomes a signal the agent can reason about: what is worth paying for, what is too expensive, which provider is more efficient, and whether a given action is aligned with the user's intent. Kevin put the point bluntly later in the evening: money may become a utility function for agents.
For founders, that is the first big reframing. The agentic economy is not about making checkout slightly smoother. It is about giving software enough economic agency to complete meaningful work, then building the controls, trust, and infrastructure around that agency so users are willing to let it happen.
Payments Are the Last Mile 🧩
Chi Zhang pushed the room past the word "payments" almost immediately. By the time an agent reaches the payment step, it has already crossed a long chain of decisions: discovery, intent interpretation, context, credentials, tool access, budget, routing, and governance. In that sense, agentic payments are much bigger than payments.
Her consumer example made the point clear. When a human shops on Amazon, a lot of intent is implicit. We know what we mean by "a good gift," "something similar," or "the pair I usually buy." A marketplace interface was built around human context and human judgment. But when an agent shops on behalf of a user, that unspoken context has to become structured enough for software to understand and act on.
That creates problems long before money moves. Product catalogs need to be accessible to agents. User intent has to be translated into machine-readable constraints. The agent needs to know which APIs, credentials, and services it can use. Only after all of that does the payment rail matter. Chi's point was not that payment infrastructure is unimportant. It was that payment is the visible tip of a deeper orchestration problem.
That matters because a lot of market language still jumps straight to the glamorous consumer demo: "Tell your agent to buy sunglasses" or "Have it book your travel." The panel was more sober. Those use cases are exciting because everyone understands them, but they require multiple layers of infrastructure to mature together. Founders who only build the last click may miss where the real bottleneck sits.
The more durable opportunity may be in the systems that let agents move from intent to action safely: discovery, credentials, billing, access control, policy, and settlement. Payments get the headline. The orchestration layer may get the business.
Developer Workflows Come First 🛠️
When Alan Du asked which use cases would take off over the next two to three years, the panel did not land on a single answer. But the most practical near-term consensus was clear: developers and agent builders are likely first.
Kevin argued that there is already product-market fit around agentic payments for developer tooling. Agents need real-time context, external data, model access, web search, APIs, and cloud services. Today, that often means a human goes to a portal, creates an account, adds a credit card, copies an API key, returns to the model, and configures access manually. That flow is absurdly human for a system that is supposed to act autonomously.
His view is that wallet infrastructure can remove a lot of that friction. Instead of depending on API keys and manual configuration, agents could discover services, reason about whether those services are worth paying for, and authorize payment through client-side signatures. That shifts tool use from a brittle setup process into something closer to an open market of callable services.
Chi agreed that developer use cases are likely to arrive before fully autonomous consumer commerce. For Kite AI, the immediate need is around agent-built apps and the infrastructure those apps consume: APIs, model calls, databases, billing, payment flows, and cost controls. If an app's users are driving expensive inference, a builder may need graceful degradation, routing logic, spending limits, or model switching. Those are not abstract problems. They are operating problems for anyone trying to ship agentic software at scale.
Gagan added a useful framework: an agent combines service connectivity, reasoning, and execution. Payments are downstream of what agents can actually do. Today, developer workflows make that visible because the missing pieces are concrete. The agent can write the code, but it cannot always buy the phone number, configure the API, provision the service, and complete the workflow without human intervention. That gap is where the next wave of infrastructure may form.
For founders, the lesson is straightforward. The first big market may not be the fully autonomous personal shopper. It may be the agent that can reliably buy the exact API call, compute resource, model access, or data feed needed to finish the job.
The Open Web Needs New Rails 🌐
Kevin's x402 framing gave the night one of its clearest technical through-lines. If agents become a primary interface to the internet, the open web should not collapse into closed stacks where every assistant can only use its owner's services.
His analogy was simple: it would be strange if Chrome could only visit Google websites, or Internet Explorer could only visit Microsoft websites. As interfaces shift from visual UI to intention-driven agents, he argued, the same open-web principle needs to survive. Agents should be able to discover tools and services across the internet, evaluate them, pay for them, and use them without a human being pulled back into the loop for every setup step.
x402 matters in that context because it treats payment as something native to HTTP. Kevin described it as extending the 402 status code so agents can pay for web resources in a more natural way. The deeper idea is not just one protocol. It is that the web may need a machine-readable payment layer for services, content, data, APIs, and tools.
That is probably how early infrastructure markets usually look: messy, overlapping, and full of competing standards before patterns settle. But the important point is not whether one protocol wins immediately. It is that the web was built for humans clicking through flows, and agents expose how much new plumbing is needed when the user is software.
Stablecoins Fit the Machine Layer 🪙
Stablecoins came up because they sit unusually close to the needs of agent workflows: programmable, fast-settling, digitally native, and easier to constrain than a credit line.
Gagan was careful not to overstate the case. Stablecoins are not perfect for every business model. Subscription revenue, ARR, and enterprise billing often rely on recurring structures where instant settlement is not automatically better. But for programmable workflows, composability, and services that need decisions made quickly without pending transactions, stablecoins become much more interesting.
Kevin pushed the economic argument further. Agents are ruthless efficiency maximizers. They do not have nostalgic attachment to a card network or a preferred payment habit. If a stablecoin rail has instant finality, lower fees, no chargebacks for deterministic digital services, and less merchant friction, an agent may simply route toward the more efficient mechanism.
"Agents are really ruthless efficiency maximizers." - Kevin Leffew
That does not mean chargebacks disappear from the consumer world. If shoes arrive in the wrong size, users still want protection. But for digitally native services that behave more like a vending machine - pay, receive output, complete task - stablecoins may fit better than legacy rails. The point is functional, not ideological. Machines will compare speed, cost, finality, and reliability.
This is also why wallets matter as control surfaces. Kevin argued that giving an agent a credit card means giving it access to your credit score. Giving it a wallet with $10 for a bounded experiment is a very different risk profile. For enterprises, that kind of programmable guardrail may be the difference between interesting demo and deployable workflow.
Autonomy Still Needs Kill Switches 🛑
One of the strongest parts of the discussion came when Alan asked Chi how to balance autonomy and control. The whole point of using agents is to automate work. But if the agent can spend money, call services, and consume resources, complete freedom is not a product strategy. It is a billing risk.
Chi's answer started with cost. Talk to serious AI builders, she argued, and one of the biggest pain points is not simply how to make agents more autonomous. It is how to keep token spend, API usage, and service costs from running out of control without degrading the quality of the app. In the end, a human or company still pays the bill.
"You do have to have some level of kill switch." - Chi Zhang
That is why she described Kite's focus as outbound spending governance: the controls that let builders define how much an agent can spend, when to route to a cheaper model, when to degrade gracefully, and how to manage access to databases, APIs, and other infrastructure. Autonomy is useful only if it can be bounded by policy.
Kevin's wallet framing complemented that. A wallet can hold permissions natively: spend up to $5, approve only a category of calls, run only within a session, or experiment with a limited balance. Gagan flipped the frame again by asking what agents could do when the goal is to make money or save money rather than spend it. If you give an agent $100 and ask it to make $110, the control problem still exists, but the upside becomes easier to imagine.
The founder takeaway is practical. The best agent infrastructure will not ask customers to choose between full autonomy and total manual approval. It will offer degrees of freedom: budgets, policies, approvals, routing logic, reputation, session controls, and kill switches. The winning products will make autonomy feel adjustable.
Consumer Commerce Is Still Early 🛒
The panel did not dismiss consumer agentic commerce. In fact, some of the most relatable examples were consumer ones: an agent buying a monthly gift, canceling unused subscriptions, choosing the best payment method, or letting you talk to your wallet in natural language.
Gagan's prediction was especially vivid. He wants a financial super app where you can talk to your money: buy a stock if it drops 10%, cancel subscriptions you have not used, or help your wallet make better decisions. That kind of interface feels natural because money already has goals attached to it. People want to save, earn, optimize, avoid waste, and act on opportunities without constantly monitoring everything themselves.
"I want to be able to talk to my wallets in natural language." - Gagan Mac
But the panel was careful about timing. Gagan argued that fully trusting an agent to shop on your behalf is still early until reputation, familiarity, and trust mature. Chi compared consumer agentic commerce to autonomous driving levels. The shopping demo is exciting, but before you get to full autonomy, multiple layers have to work: product discoverability, merchant catalogs, intent interpretation, memory, context, payment, and settlement.
That nuance matters. Consumer commerce will probably produce the demos people remember, but developer workflows may produce the first reliable adoption. The flashy version is "my agent bought me sunglasses." The more immediate version is "my agent bought the data, API access, model call, and compute it needed to finish a task."
For investors and founders, that distinction is valuable. The consumer story may be the destination. The infrastructure story is the path.
What Builders Should Watch Next 🔎
By the end of the night, the agentic economy looked less like a single market and more like a stack forming in real time.
At the protocol layer, x402 and other emerging standards are trying to make machine-native payments legible. At the wallet layer, builders are exploring how agents can hold funds, sign authorizations, earn, pay, and operate inside bounded budgets. At the identity layer, the market is still testing how reputation, permissions, and transaction history become part of the trust model.
At the orchestration layer, companies like Kite are trying to manage the messy middle: credentials, API access, billing, model routing, governance, and the policies that let agent builders ship without fearing runaway spend. At the stablecoin and settlement layer, Circle, Coinbase, Base, Kite, and others are competing and collaborating around rails that could support high-throughput, programmable, machine-native transactions.
The most interesting thread may be economic reasoning itself. Kevin argued that agents should reason about money in every decision because money is already one of the coordination mechanisms of the global economy. That idea is still underexplored. If agents can compare marginal cost, output quality, trust, latency, and user alignment, then payment data becomes more than a ledger. It becomes training signal, reputation signal, and decision infrastructure.
"Money should actually be the utility function for agents." - Kevin Leffew
The market will not resolve neatly. Some parts will be open. Some will be proprietary. Some will look like protocols, some like developer platforms, some like wallets, and some like boring governance dashboards that quietly become essential. But the direction is clear enough: if agents are going to act, the next wave of infrastructure has to make action trustworthy, payable, and economically rational.
Final Takeaways
The strongest idea from the evening was not that agents will pay for things. It was that payment forces the rest of the agent stack to become real.
As long as an agent only drafts, summarizes, or suggests, the consequences are limited. The moment it spends money, selects a provider, calls an API, manages a budget, or earns revenue, every hidden assumption becomes visible. Permissions matter. Identity matters. Settlement matters. Reputation matters. Governance matters. The old human-driven web can absorb a lot of friction because people are used to clicking through it. Agents will not be so forgiving.
That is what made the conversation feel early but not abstract. The room was not debating whether agents can eventually transact. It was asking what must exist before that becomes safe enough, cheap enough, and useful enough to become normal. For founders, builders, and investors, that is the useful lens. The opportunity is not just in the agent that acts. It is in the infrastructure that makes action trustworthy.
Thank You
If you enjoyed this recap, subscribe to our newsletter and stay connected:
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article