Outcome-as-a-Service is what happens to commercial software when the customer is no longer the user.
For a generation, the customer was a person sitting at a screen. Software was sold per seat because the seat was the unit of consumption. One person, one seat, predictable use.
SaaS, PaaS, and IaaS were three different ways to package that arrangement: software as a hosted application, software as a development substrate, software as raw infrastructure. The seat was the unit of every one of them.
In April 2026, Salesforce conceded that the seat is gone.
When Marc Benioff announced Salesforce Headless 360, he did not announce a feature. He announced that the largest SaaS company on Earth has conceded that the interface is no longer where value is delivered. The platform, Agentforce, Slack, the data, the workflows, is now exposed as APIs, MCP, and CLI. "Our API is the UI." If the API is the UI, the customer is whatever can call the API. That is an autonomous agent.
The customer is no longer buying access.
The customer is buying delivery.
That is a different transaction. It needs a different commercial primitive. It needs a different name.
The definition
Outcome-as-a-Service: a commercial architecture where the customer pays for verified delivery of a defined outcome, not for software access (SaaS), platform usage (PaaS), or infrastructure consumption (IaaS). OaaS becomes structurally possible when three primitives exist: (1) autonomous agents capable of executing the outcome, (2) APIs exposing the systems where the outcome is delivered, and (3) settlement infrastructure that can escrow capital, verify delivery, and arbitrate disputes between non-human counterparties.
Why now, and not five years ago
OaaS is not new because someone finally wrote a manifesto for it. It is new because the conditions that make it structurally possible only converged in April 2026.
Three primitives have to exist together. Until then, OaaS is a slide. Once they exist, OaaS is what the architecture becomes.
The first primitive arrived with the production-grade agent frameworks of 2024: LangGraph, CrewAI, OpenAI Agents SDK. An autonomous agent that can execute a defined outcome end-to-end is no longer a research demo. It is a software pattern with multiple mature implementations.
The second primitive arrived on April 17, 2026, when Salesforce went headless. APIs that used to be private SaaS internals are now exposed surfaces that an agent can call directly.
The third primitive is the one nobody is talking about.
When two autonomous agents transact, neither of them is a person, neither has a credit card, neither can dispute through Visa.
The transaction needs four things at once:
- An escrow that locks capital before work begins
- An attestation mechanism that records that delivery happened with cryptographic proof
- A dispute path that resolves when delivery is contested
- A reputation record so good-faith counterparties accumulate trust over time
None of those are optional. Take any one away and the transaction collapses into a bilateral handshake that does not scale.
This is the settlement primitive. It is what the AGIRAILS protocol provides, and it is the third leg without which the other two primitives cannot become OaaS.
The first verifiable instance of all three primitives meeting in production: February 21, 2026. Two AI agents settled $3.69 USDC on Base mainnet through a full escrow lifecycle: request, quote, commitment, delivery, settlement. Gasless. No human in the loop. (BaseScan.)
The amount does not matter. What matters is that the three primitives held.
What the settlement primitive does, and what it does not
The settlement primitive provides the structural pieces that any agent-to-agent transaction needs in order to clear: escrow, on-chain attestation, dispute window, reputation record. These are domain-agnostic. They work the same whether the outcome is a translated document, a code review, a data analysis, or a UAT test pass.
What the settlement primitive does not do, and structurally should not do, is decide whether the work was actually any good. Quality verification is domain-specific. "The translation is accurate" means one thing. "The UAT actually passed" means another. "The code review caught the right issues" means a third. That logic belongs above the settlement layer, built by the teams who own the domain.
This is where the next category of agent-commerce primitives forms. Settlement is necessary but not sufficient. Above it, an emerging layer of open verification primitives is going to determine which agents the market trusts to deliver real outcomes for real money.
What OaaS is not, and what each layer becomes
Not Software-as-a-Service. Software is now the dumb backend that the agent calls.
Not Platform-as-a-Service. Platforms are now interchangeable substrates the agent picks based on what the outcome requires.
Not Infrastructure-as-a-Service. Infrastructure is now metered by the agent at machine speed, not by the human at human speed.
Each of these layers continues to exist. None of them are the unit of commercial transaction anymore. The unit of commercial transaction is the verified outcome.
Why per-seat pricing dies
A pricing model is the financial expression of who the customer is. Per-seat pricing assumed the customer was a human consuming a finite seat. When that assumption holds, per-seat is rational. When the customer is an agent making ten thousand API calls a minute, the assumption no longer holds and the pricing model that depends on it stops working.
Per-call does not work either. The customer does not care about calls; the customer cares about whether the outcome arrived.
Per-month does not work. The work is episodic, not continuous.
Per-feature does not work. There is no feature being used. There is an outcome being produced.
The only pricing model that survives the agent layer is pay-on-verified-delivery. The vendor has to be able to prove the outcome was delivered, cheaply, fast, and verifiably by the buyer without the vendor's cooperation. Which means the proof has to be on-chain, attached to a settlement event, with a mechanism for disputing it if delivery is contested.
SaaS pricing did not need that primitive. OaaS pricing requires it. The traditional payment processors that move trillions of dollars a year for human commerce do not have it either, and structurally cannot retrofit it without becoming a different category.
Where this leaves the consulting layer
Hundreds of billions of dollars a year flow through enterprise SaaS implementation and consulting: people who configure Salesforce, customize Workday, integrate HubSpot. That layer exists because SaaS interfaces are general and business outcomes are specific, and the translation between the two is human work.
OaaS collapses the translation into software. The customer purchases the outcome. The agent figures out which API to call, which workflow to chain, which constraint to honor. Humans who used to configure SaaS move up the stack: defining what outcome a customer is paying for, setting the constraints under which an agent is allowed to operate, arbitrating the disputes that arise when delivery is contested.
The work moves from configuration to judgment. Configuration scaled with headcount. Judgment scales with the settlement infrastructure underneath it, because no human can manually adjudicate ten thousand outcome-deliveries a day.
How to know whether OaaS is real
If OaaS is the real architecture, three things will happen in the next eighteen months.
Other major SaaS companies will follow Salesforce headless. The competitive pressure to expose APIs is structural now. Workday, ServiceNow, HubSpot, Atlassian, every CRM, every HRIS, every ITSM platform will eventually concede.
Per-outcome pricing will appear on at least one major vendor's pricing page, framed as "only pay when the outcome is delivered." Most early versions will be marketing without verification underneath.
The first agent-native company to scale past $100M ARR will run on per-outcome pricing settled through a neutral protocol.
If those three things do not happen, the OaaS framing is wrong and we will say so. We are not in the business of holding a thesis past its expiration date.
Where this connects
The longer essay this page distills: Outcome-as-a-Service: The Architecture Salesforce Just Made Inevitable.
The escrow primitive underneath, defined: What is agent escrow?.
The category of settlement that survives the agent layer: What is non-custodial settlement?.
Why the existing payment rails do not work for this transaction: Why don't traditional payment processors work for AI agents?.
The settlement primitive itself: agirails.io.
The first verifiable OaaS settlement event: BaseScan transaction (February 21, 2026, $3.69 USDC, full lifecycle, gasless, autonomous).
The architecture is inevitable not because we built it. It is inevitable because the conditions that produced SaaS no longer hold.