The Omni Agent Thesis
A first-principles theory of how the software industry shakes out
The claim
The software industry is going to collapse into a small number of omni agents, and every business will run on exactly one of them. Not the apps plus an agent. The agent, with the apps as emergent behavior underneath it.
This is not a claim about vibe coding. People are not going to rebuild their CRM over a weekend, and the vendors who say "you'll never replace us, we've encoded ten thousand edge cases" are right that nobody will replicate the code. They are wrong about what they were selling. The code was never the product. The product was a job getting done, and the job is about to get done by something that doesn't need the code.
I'll make the argument from first principles: what software actually is, why an agent can re-achieve its value without reproducing it, why there will be one agent per business rather than many, what survives the collapse, where it starts, and why the platforms that look best positioned to win it structurally can't. I build one of these agents, so I have an interest. I also think the argument stands on its own, and I'd rather you check it than trust me.
What software actually is
Strip any business application down and you find two things: crystallized judgment and crystallized routine. Someone decided what a "lead" is, which fields matter, what happens when a deal stalls, how a refund flows, what counts as an exception. Then they froze those decisions into code so a machine could repeat them cheaply, forever, without the person who decided.
That freezing is expensive. It takes product managers to extract the judgment, engineers to encode it, years of customers to surface the edge cases, and a sales force to convince each buyer that this particular frozen snapshot of someone else's judgment fits their business well enough. SaaS gross margins of 75 to 85 percent are not the cost of running the software. They are the price of scarcity: the scarcity of having already done the thinking, and the scarcity of the distribution needed to find everyone who needs it.
The industry is also recursive to a degree no other is. B2B software sells to B2B software, which sells to B2B software, which eventually reaches a business that serves a consumer or a government. Every layer carries its own margin, its own sales team, its own investors, its own pricing weirdness. The end customer pays for all of it, stacked.
There is a third thing hiding in the code, and it is the one that matters most. Code is a tax. You pay it when you force judgment into a structured language that cannot hold judgment well. Every if statement is a decision made in advance about a situation the author could only imagine. The thousands of edge cases a vendor brags about are thousands of places where the frozen judgment broke and had to be patched. Code is the right tool for collapsing the cost of a routine. It is the wrong tool for exercising judgment, and most business software is mostly judgment.
The artifact was always incidental
An agent with a frontier model behind it can re-derive judgment on demand. It does not need someone to have decided in advance what a stalled deal looks like; it can look at the deal. It does not need a field for every attribute; it can read the email. It does not need the ten thousand edge cases encoded, because an edge case is just a situation, and situations are what language models are for.
This is the move that separates the thesis from vibe coding. The vibe-coding story keeps the artifact and changes who builds it. This story says the artifact was never the point. A competitive-research tool that runs every Monday against your rivals does not need to exist as software. An agent can simply do the research every Monday. Nobody who could get the result would ask for the app.
Code doesn't disappear. It gets demoted to what it was always good at: collapsing the cost of a routine once the routine is known. An agent that notices it has done the same thing fifty times writes the code, runs it, and goes back to exercising judgment on the things that vary. Call it what it is: caching. Judgment is derived once, run deterministically after that, and re-derived when the world moves. When the code throws an error, the error is itself a situation, so the agent handles it: patches the code, re-runs, moves on. Software that weaves in and out of traditional code and model inference, seamlessly and on its own initiative, is just what software becomes. I ship code written this way every day and rarely read it. The business runs.
The objection every incumbent reaches for is the edge-case objection: "you can't replace our product, we've encoded years of exceptions." Take it seriously and it inverts. Those years of exceptions are the record of how badly code holds judgment. An agent meets each exception as it arrives and decides, the way the product manager would have if she'd been in the room. And when the agent serves many businesses, it does something the vendor only ever did in slow motion: an exception met for one customer becomes a learned behavior available to the next. A product manager always did this. She saw one customer's edge case, abstracted it into a feature, and shipped it to everyone else a few quarters later. The agent runs the same abstraction, stripped of the first customer's specifics, in days. The omni agent gets the one thing that made SaaS defensible against custom development, amortizing edge cases across a customer base, except the amortization happens through learned behavior instead of shipped code. That is multi-tenancy reinvented one layer up, and it is the whole economic argument.
The honest limit: where a value proposition is really a data loop, a network effect, or standing (a license, a registration, a relationship with a regulator or a counterparty, and a balance sheet on the hook when something goes wrong), that is a property of the business, not the software, and it does not collapse the way software does. I'll come back to what survives. It is less than you'd think, and thinner.
Context has gravity
If agents can do the jobs, why one agent per business rather than a dozen specialized ones? Because context has gravity, and gravity concentrates.
Every task a business does is easier with the company's context than without it. Who the customer is, what was promised last quarter, which supplier is unreliable, what the founder meant by "the usual." An agent that already holds that context does the next task better and cheaper than one that doesn't. So the next task goes to the agent with the context. Which gives it more context. The loop closes fast, and it closes on one agent, because two agents means fragmented context, which is the exact disease the agent exists to cure. And much of what the agent holds was never in any system to begin with. What "the usual" means, which supplier's dates to ignore, why that account gets slack, who not to email on a Friday: nobody made a field for it, so it was said out loud, on a call or in a hallway, and then it lived in someone's head. Now it is said to the agent, and the agent is the only place it exists.
This is the axiom the rest of the thesis hangs on, and it has a consequence that is easy to miss. The agent that holds the whole company's shared context, plus each person's private context, is the system of record. Not a CRM with an agent bolted on; the record itself, broader than any CRM ever was, because it holds everything the business knows rather than the subset someone once decided to make a field for.
Once you see that, the thesis stops being "the agent replaces the software" and becomes something cleaner: the agent replaces the database and the interface, and the features are emergent. A CRM-shaped view of the context exists when someone wants one. So does a project-tracker-shaped view, a ledger-shaped view, a hiring-pipeline-shaped view. None of them are products. They're lenses on one record, generated when asked for and discarded when not. This doesn't abolish structured, transactional state. The agent provisions its own store: one row, one truth, permissions in the schema, stable identifiers to point at and argue over. What it abolishes is the vendor of that store, because the schema is now derived from the business instead of frozen by a product manager a decade ago. People who want a board to point at still get one. It's a lens, kept for as long as it's useful.
Multiplayer follows from this rather than being a feature. A business is a group of people with overlapping but not identical context, so the agent has to hold private memory per person and shared memory per group, and it has to meet each person where they already are: Slack, Teams, email, a text message. An agent that lives in one channel is a captive of that channel. The one with gravity lives in all of them.
What survives, what dies, and where the money goes
The stack today is deep: a consumer or government at the bottom, a business serving them, and above that business a tower of SaaS vendors serving SaaS vendors, each with its own margin, sales team, and cap table. The stack after the collapse has three layers.
The tower in the middle, every vendor serving another vendor, is what disappears; what remains is the relationship, the agent, and the plumbing underneath it.
The application layer dies. Anything whose value is crystallized judgment plus routine, which is most of what gets called "business software," has its value re-achieved by the agent and its revenue line collapses toward the cost of the compute that does the job. Project management, light CRM, reporting and dashboards, competitive intelligence, scheduling, internal tools, workflow glue, the thousand point solutions that exist because someone needed a lens on their data and the only way to get one was to buy an app.
The infrastructure layer thins. Payments, payroll, tax, regulated filings, EDI: these survive, because they are standing, not software. A payroll company's value was never that it knew the tax code. The agent knows the tax code, and will interpret it better than the first guess a product manager encoded, because it can cross-reference everything ever written about it and every outcome of every filing it has seen. The value is being a registered agent in fifty states, holding funds under a license, filing under its own number, and eating the penalty when a filing is wrong. The knowledge half of that business collapses into the agent. The standing half survives as a thin API under it, priced like a wire fee plus insurance, with no application and no relationship to the end customer. The customer never sees it. The agent calls it.
The relationship is the only durable position. Whoever is the business's one agent owns the context, which means it owns every task, which means it owns the customer. The lock-in is not the data; a business can take its data any time. It is that the agent is woven into how the business runs, and that six months of telling it how things actually work would have to be told all over again to anything that replaced it. Everything else is either emergent behavior or plumbing.
Now the money. Seat-based pricing dies on its own, before anything else, because agents don't have seats. An agent is priced on what it does, and it can tell you what that was worth, which per-seat software never could. (The invoice can still say a flat number each month. That's packaging, and it's how small businesses like to buy.) Omni agent gross margins are compute-heavy, so they sit well below the 80 percent SaaS enjoyed, and the agent vendor is inside the collapse, not above it. What keeps its position is not margin but the one asset the collapse can't commoditize: the business's own knowledge, elicited over months and compounding. The honest prediction is therefore not that software revenue moves from old vendors to new ones. It is that the category's total revenue shrinks and concentrates: a smaller pie, most of it eaten by the agent vendors, with the remainder returned to end customers who stop paying for twenty vendors' rent, headcount, and investor returns at once. The customer saves enormously. The agent vendor does well. The tower in the middle goes away.
That is what "collapse to compute" means. Not free. Priced like the thing it is.
Where it starts
It starts at the bottom, in the businesses software never fit.
Small businesses are, by count, essentially the entire consumer-facing economy: in the US they are 99.9 percent of firms, roughly 33 million of them, and the bakery, the dental practice, the landscaper and the three-person agency are where consumer transactions actually happen. By weight they are something like 44 percent of GDP and 46 percent of private employment. By software spend they are far smaller than either number, and a skeptic will use that fact to wave the whole segment away.
The skeptic has it backwards. Small businesses spend little on software because software was never built for them. It was built for teams with an admin, priced per seat, and overserving on features; a five-person company buying a CRM gets two thousand capabilities it will never touch and a monthly bill it resents. So most of them run on a phone, a spreadsheet, and whoever's inbox they signed up with first. That is not a small market. That is an unserved one.
The omni agent is the first thing that fits. The friction in small-business software was never learning the tool; it was changing how you work to fit it. A teammate adapts to you: describe the pain and it asks you the rest. No seats to count, so pay-per-usage is natural. No admin, so it has to set itself up. No IT department, so it has to write its own integrations. No procurement, so it meets the owner in the text thread she already lives in. The expected shape is not that agents capture existing small-business software spend, which is modest. It is that they create spend that didn't exist, from businesses that were never customers of anyone. The early evidence is that businesses which would not pay forty dollars a month for software that stores things will pay hundreds a month for an agent that does things.
This is the classic shape of low-end disruption. The entrant arrives where the incumbent product was overserving, is dismissed as a toy for the market that didn't matter, and climbs. The incumbents will say "fine for a bakery, not for us," which is precisely what the pattern predicts they will say right before it stops being true. Context depth and reliability compound; every business the agent serves teaches it something the next one needs. The enterprise is not where this begins. It is where it ends.
The same logic is why I expect the winners to be horizontal. A vertical agent for dental practices has to rebuild the whole substrate, memory, multiplayer, channels, integrations, the loop that turns judgment into code, in order to add its bit on top. A horizontal agent adds the dental bit as a learned skill once it has enough dental practices. The meta-learning loop is written once and compounds everywhere; a vertical's bit compounds in one place.
I don't think the thesis needs a date, but it does have a clock, and the clock is reliability, not cost. Cost per unit of intelligence is falling roughly tenfold a year, and the rational play at the frontier is to subsidize until trailing models cover the need, which is already happening. The date is when reliability crosses the bar at which an owner lets the agent email a customer unsupervised. That is measurable, and it only moves one way. Whether the low end flips in three years or ten, this is the most important arc in the history of the software industry, and the incumbents' problem is the same either way: the thing eating them does not look like them, so they will not see it as competition until it is too late to become it.
One more extension, because it follows and it's large. Consumers get agents too, one each. A consumer's agent will talk to a business's agent to book, buy, ask, and complain. When that is how the transaction happens, the consumer-facing surface collapses as well: the website, the app, the support desk. The chain I described earlier, B2B serving B2B serving B2C, compresses to three things. A consumer agent, a business omni agent, and plumbing.
Why the platforms can't be it
The obvious objection to "one agent per business" is that the winner is already decided: Microsoft and Google sit on the inbox and the calendar, Intuit sits on the books, Shopify and Square sit on the payments. They hold most of the context that supposedly has gravity. Why wouldn't the default omni agent be theirs?
Because a platform's agent exists to serve the platform, and an omni agent exists to serve the business. Those are different jobs, and the conflict between them is structural rather than a matter of execution.
- Captive by design. Copilot's job is to make Microsoft 365 stickier. Gemini's is to make Workspace stickier. Intuit Assist's is to keep you in QuickBooks. Each is rationally built to deepen its own suite, so every integration outside the suite is second-class and every recommendation has a thumb on the scale. The omni agent's defining property is indifference to where the data lives. A platform can't build that without making its own apps optional, and no product organization ships that on purpose.
- Neutrality is the actual requirement, and no incumbent can have it. A typical small business runs on Gmail and QuickBooks and Shopify and Square. None of those four can be the agent over the other three; each is the others' competitor or an uneasy partner at best. The one agent per business has to be Switzerland. The same logic that keeps the platforms from merging keeps any one of them from being the neutral layer across all of them.
- Per-seat revenue means they will price the agent as an add-on to seats, not a replacement for them. Microsoft sells Copilot per seat on top of per seat. That isn't a tactical choice; it's the only choice that doesn't cannibalize the core. But the thesis says agents end seat pricing. An incumbent cannot lead the transition to the pricing model that kills its revenue line. This is the innovator's dilemma in its purest form, and it doesn't require the incumbents to be slow or dumb. It requires them to be rational.
- Model lock-in. Google will run on Gemini. Microsoft's relationship with OpenAI is complicated and getting more so, but it will not route your work to whichever lab is best at it this week. The omni agent routes per task to whatever is best and cheapest, and the gap compounds every time the frontier moves.
- Self-written integrations threaten the marketplace. Platforms monetize ecosystems: app stores, partner programs, revenue share. An agent that writes its own integration on the fly routes around all of it. Shipping that means dismantling an existing business to serve a future one.
- Wrong surface. Small businesses live in iMessage, WhatsApp, a phone, and an inbox. Microsoft's agent lives in Teams; Google's lives in Workspace. Neither can be in a text thread, and neither builds for a business with no admin, no IT and no procurement. Their motion is enterprise-first and trickle-down. Multi-channel, pay-per-usage, zero-setup is a different product, not a feature flag.
The strongest counterargument is bundling, and it deserves a straight answer. Teams beat Slack not by being better but by being free with something people already paid for. Won't Copilot do the same, good enough and already there? Bundling wins when the category is a feature of a bigger thing. If the omni agent is the operating system and the apps are the features, then bundling an app-level agent doesn't capture the OS layer; it makes the apps a little better. The thesis stands or falls on whether the omni agent is the OS, which is why context-has-gravity had to come first. Once that holds, the bundling objection answers itself: a captive agent, by definition, cannot be the one with all the context.
To be fair to the other side: the platforms can and do build connectors to systems outside their suites, and they are shipping agent protocols. The honest read is that they can build connectors but cannot build neutrality, and connectors inside a captive pricing and model structure don't change the gravity. The thing a platform agent most wants is to pull context toward its own apps. The thing an omni agent most wants is not to care.
The sharper objection isn't the platforms at all. It's the labs. OpenAI, Anthropic, and Google-as-a-lab have no CRM to protect, sell usage rather than seats, sit in every channel already, and learn in weights. They might be the omni agents. I'll concede that outright, because it changes nothing above: the industry collapses into agents whether the surviving ones are theirs or mine. What it changes is the incumbent's question, which stops being "build or buy" and becomes "the agent over your product will belong to a lab, or to something you own."
So here is what I expect the incumbents to do: price the agent per seat, keep it captive, win some share through bundling in companies already deep in one suite, and eventually conclude that the rational move is to buy a neutral agent rather than build one. That last step is where this ends for most of them.
What this means
If you buy software: stop evaluating features and start evaluating which agent will hold your context, because that choice is the only one you'll still be living with in five years. Every month a business runs on an agent is a month of context that agent owns.
If you build software: the question is no longer "what app should exist" but "what does the agent need to be able to do," and most answers to that are skills, not products. Don't mistake a skills marketplace for an ecosystem. Appy began as one, a place where anyone could define and sell a skill; it was too early, and I now think it was also the wrong layer. A skill that is pure judgment gets absorbed into the agent the way Amazon Basics absorbed every commodity on the marketplace. The skills that survive are the ones that were never software, a license or a counterparty, and those are plumbing. The application layer is not a place to build a company anymore. The plumbing is a fine place, if you can accept utility margins. The relationship is the only place to build something large.
If you are an incumbent: your agent is captive, your pricing is per seat, and your customers are not asking you for the thing that replaces you, which is exactly what makes it dangerous. The window to become the omni agent for your customers, rather than a feature inside someone else's, is open and closing. You will most likely close it by buying one.
This is the thesis I'm building Appy.ai on: one omni agent per business, multiplayer by default, present in every channel a business already uses, writing the code and the integrations it needs as it goes, and priced on what it does rather than who's logged in. If a lab ends up being that agent, the thesis still holds; the window for anyone else is the gap between a general agent and a business-shaped one, and it is open now. I may have the details wrong. I don't think I have the shape wrong. The software industry is about to collapse into the agents, and the only question left is which ones.
Appendix: the objections, briefly
Why not the labs? Maybe. It doesn't change the shape; it changes who the incumbents should fear. The one thing a single lab can't do is route each task to whichever model is best this week, and the frontier is a dead heat, so no lab holds a model edge an agent can't borrow.
A business can't run on a model's judgment. It needs consistency and an audit trail. It runs on judgment the agent has cached as code: derived once, run deterministically, re-derived when the world moves. Three things the agent owns that a vendor never did: deciding when a case matches, making a rule explicit before it stands, and noticing when it has gone stale.
The edge cases are the law, not judgment. The law is text and outcomes, which is what models read. The agent interprets it better than a product manager's first guess and keeps interpreting as it changes. What the agent can't be is licensed, registered, and on the hook. That is plumbing, and it survives thinner, because the knowledge half of its margin is gone.
Learning across customers leaks their data. It's what every SaaS product manager has always done: see one customer's edge case, abstract it, ship it to the rest. The agent runs the same abstraction, minus the specifics, in days instead of quarters.
Collapse to compute applies to the agent vendor too. Yes. What exempts it isn't margin but an asset: the part of the business that was never in any system and was told only to the agent. Data is portable. That isn't, except by telling it again.
Small businesses don't buy software. They didn't buy software that made them adapt. They are paying hundreds a month for a teammate that adapts to them. Cost is collapsing; the clock is reliability.
Every platform shift fragmented software. Why would this one consolidate it? Earlier shifts made building cheaper and left buying per-product, so every new thing became a vendor. This one consolidates buying: the business adopts one agent and everything else is internal to it. Agent-written code is state, not a market.
Humans want interfaces. They get them. A board, a pipeline, a ledger view, generated when wanted. The interface stops being a product and becomes a lens over a store the agent owns.
Play it as the CEO of…
Each company below is a branching simulation of the same five years, built on that company's real facts. Every ending lands in one of the three layers above.