As a leading specialist in enterprise SaaS technology and software architecture, Vijay Raina has spent years at the intersection of infrastructure and autonomous systems. His work has defined how large-scale organizations transition from monolithic software structures to more fluid, decentralized environments. With a background rooted in the design of scalable cloud ecosystems, Raina is uniquely positioned to explain why the current subscription-heavy internet is fundamentally incompatible with the rise of autonomous agents. He argues that we are moving away from a world where humans “inhabit” applications toward one where agents “assemble” complex supply chains of capabilities in real-time. In this interview, we explore the death of the account-bound commerce model and the emergence of a protocol-native internet where every function is a purchasable, metered primitive.
The discussion focuses on the transition from traditional cloud accounts to a request-bound commerce model, emphasizing the role of machine-readable capability manifests and delegated spending mandates. Raina explains why subscriptions served as a “compression algorithm” for human attention and how agents, which operate without checkout fatigue, necessitate a return to microtransactions. We also dive into the technical primitives required for this shift, including the revitalization of the HTTP 402 status code and the implementation of stablecoins as a programmable settlement layer. Finally, the conversation covers the security implications of giving agents financial authority and how business models will pivot from “owning the customer” to “winning the call” in a highly competitive, automated marketplace.
Existing cloud models require durable accounts and manual billing setups for long-term relationships. How would a shift toward “request-bound commerce” change how infrastructure providers like AWS interact with autonomous agents that only need a few seconds of compute?
The traditional cloud model is an oddly large object for the tasks agents actually perform. Right now, if an agent needs twelve seconds of compute, three model calls, and a temporary storage bucket, it is forced into a process designed for a multi-year human relationship involving root emails, billing verification, and formal customer agreements. We are moving toward a request-bound commerce model where the agent does not really need an AWS account, but rather a temporary graph of cloud capabilities that expires the moment the job is done. Instead of a general permission to launch a thousand GPUs, the provider returns scoped capability tokens that can create only the quoted resources for that specific task. This turns the cloud from a formal business relationship into a transaction-scoped utility, where identity, tax rules, and sanctions screening still exist but are handled as metadata within the request itself. It’s a transition where the account remains behind the curtain, and the capability becomes the only public interface for the agent.
You’ve described subscriptions as a “compression algorithm for human attention.” Why is this model, which dominated the last decade of SaaS, suddenly becoming a bottleneck for the agentic internet?
Subscriptions were designed because humans are cognitively limited; we do not want to make a purchasing decision every time we retrieve a database row or run a function. The subscription bundled thousands of tiny decisions into one larger decision—subscribe once and consume many times—which reduced payment-processing costs and gave vendors predictable revenue. However, for an agent evaluating a biotech acquisition or fixing a production bug, no single provider is important enough to justify a monthly subscription if it only needs one paywalled paper or 27 queries to a clinical database. Agents don’t experience “checkout fatigue” and can run an expected utility calculation—quality minus price, latency, and risk—hundreds of times per minute. While subscriptions won because they amortized the mental transaction fee for humans, agents require microtransactions as a better primitive for choosing components in a just-in-time supply chain.
In your “three-dollar cloud” scenario, you envision an agent deploying a private research application with a strict budget and a 24-hour lifespan. What are the biggest technical hurdles to making this a reality across the current web?
The coding part of that scenario is actually the easy part; the hard part is purchasing the ingredients without a pre-existing, manual relationship between the buyer and the provider. For an agent to deploy an app for $0.40 while ensuring all data stays in a specific region, it needs a machine-readable capability manifest and a structured quote that isn’t hidden behind a marketing page. We need to standardize how a service describes its inputs, outputs, and operational limits so an agent can compare providers and check budgets in milliseconds. Today, the commercial relationship is account-sized, meaning price and permission are left outside the API call, but in an agent-ready service, the quote and the mandate must be part of the call itself. We are missing the “price layer” of the internet, where a service returns a signed quote describing exact units, maximum price, and service guarantees that the agent can then authorize with a delegated credential.
Stablecoins are often mentioned as a key to agentic commerce. How do they solve the settlement problem for microtransactions in ways that traditional credit card networks or bank transfers cannot?
Stablecoins turn value into a programmable internet object, allowing for settlement that is both global and practical for incredibly small amounts. Traditional delegated card payments often have high minimums and fees that make a one-cent transaction economically impossible, but stablecoin microtransactions can support payments at that one-cent floor or even lower. They give software access to a unit of value with programmable transfer semantics, meaning money can move across borders without every buyer-provider pair needing a bespoke card relationship. However, it’s important to note that the unit of pricing and the unit of settlement don’t always have to be identical—you can have an agent authorize a fraction-of-a-cent event while a facilitator nets a thousand of those events into a single settlement later. Stablecoins provide the legibility that software needs to hold, constrain, route, and reconcile value at the same speed it routes information packets.
We are seeing a resurgence of the long-neglected HTTP 402 “Payment Required” status code. How does this protocol change the way an agent-to-API interaction actually functions in the real world?
The HTTP 402 code allows the payment challenge to live directly within the resource request itself, creating what we call in-band payment. In this flow, a client requests a resource, the server responds with a 402 and the specific requirements—like a price of 0.004 USDC and an expiration time of 30 seconds—and the agent then retries with a payment credential and a receipt. This removes the need for a separate signup flow or a checkout page, treating a digital service as a paid resource that can be accessed instantly by any authorized agent. This interaction also generates a rich trace that links the intent, the quote, and the execution result, which is far more useful to an agent than a generic credit card statement. It’s a world where an agent can buy 200 authenticated emails or rent a GPU for 90 seconds without ever preloading credits at a new provider, making the transaction itself the boundary of the relationship.
Security experts often worry about “purchasing attacks” where an agent is tricked into spending funds. How do spending mandates differ from traditional wallets, and why is this distinction vital for 2026 infrastructure?
Giving an agent an unconstrained wallet is a massive security risk because every prompt injection could become a potential theft of funds. The correct primitive is a temporary spending mandate, which is a delegated right to spend under very specific constraints, such as a maximum amount per task, approved categories, or data-residency rules. A mandate ensures that even if an agent is instructed by a malicious webpage to buy an expensive “verification service,” it cannot exceed the budget or the vendor list predefined by the human owner. These mandates are cryptographic objects that allow for high-risk transactions to support simulation, escrow, and circuit breakers, ensuring that money only moves when the service is actually delivered. We have to treat spending authority as a permission system rather than just a balance, because in a world of 10,000 calls per hour, manual oversight is impossible and reputation must be machine-readable.
As we move toward this agent-assembled bundle of services, what happens to the traditional SaaS business model that focuses on “owning the customer”?
In the subscription internet, the primary goal for any vendor was to lock a customer into a long-term relationship, but in the agentic internet, the goal is simply to win the individual call. Services will have to compete for machine buyers based on legible metrics like quality, price, latency, and reliability, rather than marketing flair or sales contracts. This will lead to a hybrid market where reserved capacity and on-demand subscriptions still exist for permanent production stacks, but microtransactions handle burst demand and external components. We’ll see the rise of outcome pricing—where a service is only paid when it successfully finds a bug or validates a lead—and agent subcontracting, where one agent pays others for specialized tasks like scientific review. Marketing pages won’t disappear, but the capability manifest and the transaction history will become the dominant factors in how software “hires” other software to complete a task.
What is your forecast for the evolution of agentic infrastructure over the next two years?
By 2028, I expect the “price layer” of the internet to be as standardized as the “identity layer” is today, with the majority of B2B API traffic moving toward a request-bound commerce model. We will see the widespread adoption of protocols that allow agents to negotiate, purchase, and verify services in milliseconds, effectively ending the era where a human must sign off on every four-cent transaction. Large cloud providers will likely offer two distinct surfaces: one for the traditional enterprise account and a new, transaction-scoped interface for autonomous agents. As this happens, the friction of the “account” will fade away, and we will finally see the emergence of a truly fluid digital economy where value is routed as efficiently as data. The most successful software companies won’t be those that capture the most subscribers, but those that can prove their utility to an army of autonomous agents looking for the best price-to-performance ratio for a single, fleeting task.
