At Stripe Sessions 2026 in May, the company shipped 288 new products and features to a room of roughly 9,000 builders. The through line was blunt: agents are about to become customers, and most of the existing plumbing was built for humans. Stripe's CEO called AI the biggest platform shift for the economy since the internet and said that before long, agents will account for most transactions online.
That is a big claim. But you do not have to believe the full version to notice the money moving. US startups raised about $395 billion across roughly 3,850 equity rounds in the first half of 2026, a 130% jump in capital over the same stretch of 2025. A growing slice of that is going to companies whose entire customer is a piece of software acting on someone's behalf.
I have been building with agents long enough to be skeptical of the hype cycles. This one feels different, mostly because the infrastructure layer is getting specific. When startups start selling phone numbers, wallets, and audit logs designed for non-human users, the production problems are real enough to have names. Here is how I'd map the stack.
1. Payments: letting an agent hold a card
This is the layer with the most gravity right now. Traditional processors assume a human clicks "buy" once. An agent can fire hundreds of sub-cent actions per conversation, which breaks seat-based and per-transaction pricing.
Stripe's answer is the Agentic Commerce Suite, plus two protocols: the Agentic Commerce Protocol (ACP), an open standard, and the Machine Payments Protocol (MPP), co-authored with Tempo for autonomous agent-to-business transactions. The clever primitive is Shared Payment Tokens, which let an agent pass a buyer's credentials to a merchant without the agent ever holding the raw card.
Mastercard shipped Agent Pay for Machines in the same window, aimed squarely at high-frequency, low-value payments running continuously in the background. Google has its own Agent Payments Protocol (AP2), and Visa is issuing tokenized credentials for the same job.
The pattern across all of them: the human authorizes a budget once, and the agent spends inside scoped limits it cannot exceed.
That budget-plus-scope idea is the part worth internalizing, because it shows up everywhere else in the stack too.
2. Identity: an agent is not a user
If an agent is going to spend money, it needs to not log in with your credentials. Startups are building identity and access management for non-human entities: each agent gets its own identity, scoped permissions, approval flows, and an audit trail.
Newcore came out of stealth building exactly this, giving agents their own credentials instead of borrowing a human's session. Agentic Fabriq is doing similar work on the enterprise side, controlling what an agent can touch across tools and data.
Here is the shape of the control I want at this layer, sketched in TypeScript:
type AgentGrant = {
agentId: string;
scopes: string[]; // e.g. ["catalog:read", "checkout:write"]
budgetCents: number; // hard ceiling per session
spentCents: number;
};
function authorizePurchase(grant: AgentGrant, amountCents: number) {
if (!grant.scopes.includes("checkout:write")) {
throw new Error(`agent ${grant.agentId} lacks checkout:write`);
}
if (grant.spentCents + amountCents > grant.budgetCents) {
throw new Error("purchase exceeds session budget");
}
return { ok: true, remaining: grant.budgetCents - grant.spentCents - amountCents };
}
Nothing exotic. The point is that this check belongs to the platform, not the model. You never want the thing generating the plan to also be the thing enforcing the spending limit.
3. Memory and context: necessary, not yet a business
Every serious agent needs persistent memory: what it did last time, who the user is, what it is allowed to assume. Technically it is central. Financially it is the awkward layer.
Investors keep giving agent-memory startups a small share of capital, which reads as "we know this is required, we are not sure it is a standalone company." I think that is roughly right. Memory tends to get absorbed by the frameworks and the model providers, so if you are building here, the durable version is probably the one wired to identity and audit, not a generic vector store.
4. Compute and sandboxes: where the real money went
The single biggest US round of June 2026 was not a flashy app. It was infrastructure: Baseten, TensorWave, Hydra Host, and RunPod collectively raised over $2 billion to own the compute and serving layer.
Agents also need somewhere safe to run the code they write. Sandboxes-as-a-service is a quietly booming category for exactly that reason. When an agent executes an action, you want it inside a disposable box with its own scoped identity, not on your production host.
The protocols at a glance
| Protocol | Backer | What it does |
|---|---|---|
| ACP | Stripe | Open standard for agent checkout |
| MPP | Stripe + Tempo | Autonomous agent-to-business payments |
| AP2 | Delegated agent payment authorization | |
| Agent Pay for Machines | Mastercard | High-frequency machine transactions |
| UCP | Google + Shopify | Agents connect to any merchant catalog |
Stripe walked through the machine-payments piece in detail at Sessions, and it is the clearest ten minutes I have found on why this is a protocol problem and not a feature:
Why the demand is not hypothetical
An IBM study this year found 45% of consumers already use AI for part of the buying journey, and agent-driven traffic across the open web has grown more than 1,300% in nine months. Y Combinator's 2026 batches are running around 60% AI, up from 40% in 2024, and the spring cohort was the most agent-heavy YC has ever assembled. When the accelerator's pattern-matching tilts this hard toward one thesis, it is usually reacting to real signups, not vibes.
Where I'd place my bets
If I were starting something here, I would avoid the memory-only play and avoid competing with Stripe on rails. The interesting gaps are at the seams: identity that spans multiple payment protocols, spend controls a finance team actually trusts, and observability for agents that already went rogue once. The winners of the last platform shift sold pickaxes. This time the miners are software, and they still need somewhere to keep their money, prove who they are, and run without setting the house on fire. Build that, and it will not matter which model wins.