What is the Software Teardown Series?
Everyone's building a platform. Ask what that means and you'll get a pitch deck, a diagram with six boxes and an arrow labeled "AI," and a vague gesture toward developer experience. The word has been stretched so far it's almost stopped meaning anything.
At DOSS, we're building operations software for the Real World. Warehouses doing inventory counts, accounting teams closing books, supply chain operators moving goods, consumer brands trying to understand their margins. Our customers aren't debating abstractions. They're trying to answer simple, critical questions: what do we have, what happened, and what do we do next?
We started the Software Teardown series to understand how software actually meets the physical world. Last time we unpacked Systems of Record . Before that, Agents for the Real World . This time we brought together Karan Mahendru from Madrona, Ghazi Masood from Replit, Brian Raymond from Unstructured, Kapil Chhabra from WisdomAI, and DOSS's own Wiley Jones to pull the word "platform" apart and see what's load-bearing.
The question of whether agents are coming for enterprise software has already been answered. They're here. The question worth asking now is different:
What does the platform underneath the agent have to look like for agents to be useful inside businesses that have to be right about inventory, dollars, and decisions?
Every thread the panel pulled on came back to a different facet of that question.
Everything Becomes a Software Development Lifecycle (SDLC)
Anything that can be modeled as code is legible to machines. Anything legible to machines can be moved through what looks and feels like a software development lifecycle. Anything that can be moved through an SDLC can be automated agentically.
Here’s a look at what that loop looks like:
- Gather context from unstructured sources
- Distill it into a specification
- Translate that into a design
- Build, test, and deploy
- Capture logs and feed them back in
The moment any business process leaves that loop, the moment context is trapped in someone's head or a Slack thread or a PDF, the agent breaks. The question for any company building in this era is which of the customer's processes can be modeled as code, and how to keep them on rail end to end.
This is what it means to turn knowledge work into tokens: tight loops that close on themselves.
The loops aren't always agentic at the surface. Replit is one of the best examples in the world of using AI to generate fundamentally deterministic systems. Most of what gets built on Replit has no AI in it at all. It's a machine powered by AI that produces machines that aren't.
The platform is the loop the agent runs inside. The first job of any platform in this era is making that loop reachable.
Once the loop exists, the next question is who's buying it and what they need from it.
The Experimentation Economy vs. the Production Economy
In the world of platforms and AI, there’s both an experimentation economy and a production economy, and they're very different businesses. The experimentation economy runs on demos, vibe coding, and screenshots of impressive completions. The production economy runs on observability, auditability, and defensibility. It requires the ability to defend the decision an agent made when someone in a compliance hat asks.
That second list is the least sexy stuff in enterprise software, but it’s also where the money is. There's an extraordinary amount of capital being invested right now on back-end APIs, observability stacks, and auditability layers. Much less on chat UIs.
The distinction sharpens when you look at what agents actually do with data. Humans use data to make decisions. Agents use data to take actions. When the next thing that happens after a query is a write, when an invoice gets paid, an order gets shipped, or a stock level changes, the system has to be reliable and consistent. The onus is on the platform to make a fundamentally probabilistic stack behave deterministically enough to be trusted with the action.
That raises the obvious follow-up. How deterministic does "deterministic enough" have to be to avoid errors?
The Bar for Correctness
You're either SOX compliant or you're not. You either reconcile to the penny or you don't. There's no probabilistic version of "the books closed."
Using this framework of exactness, the role of agents in regulated and operational work clarifies. Agents help author deterministic systems faster, and operate continuously on the ones already in place. You can't close the gap between probabilistic and deterministic on a single run, but what you can do is shrink the iteration cycle.
The end state is an iteration loop short enough that imperfection no longer matters.
That reframe is also why so much value still accrues to systems of record. They remain the source of truth. Agents operate on top, continuously validating against them rather than replacing them.
But correctness goes beyond being a technical property. It's also a governance problem.
The sharpest question of the evening came from an audience member on the subject of ERPs: if an agent ships the wrong product to a customer at Amazon scale, who's on the hook?
There are categories of work, anything touching regulation, liability, or irreversibility, where humans stay in the loop putting the final stamp on the decision. Authorization into a critical system is the clearest example. You can have very smart AI systems making the authorization process better, faster, more contextual. A non-deterministic system performing the authorization itself is a different proposition entirely. Probabilistic systems won't fully replace deterministic ones in the places where being wrong is uninsurable.
Underneath the liability question is a permissions problem, which has turned into a recurring theme in these panels. The agent is a different legal and operational entity from the human, but the temptation to treat it like a faster employee in the permission model is where most of the upcoming pain is going to live. You can't assume that the access and privileges a human has are going to be the access and privileges their agent has, because the agent will do things with those privileges the human wouldn't. They don’t have the voice in the back of their head that says “maybe I shouldn’t do that.” The cause is speed, breadth, and a lack of context the human silently carries.
We touched on the same theme in our Agents for the Real World teardown when we wrote about identity, scope, and the audit trail an agent leaves behind. The platform question is that question asked one level down. The platform has to give the agent its own identity, its own scoped credentials, its own permission envelope, and its own log. Inheriting a human's seat is the easy way to ship. It's also the easy way to lose a customer when the agent does something the human never would have done.
The production economy will pay a premium for platforms that get this right. The experimentation economy won't notice it's missing.
Where Defensibility Lives
As the stack blurs, with database, workflow, and app collapsing into agent-shaped products, where does business defensibility end up living?
A few strategies are playing out at once.
Data gravity. The Databricks and Snowflake play. Vacuum every byte into one ecosystem and layer agentic services on top. Value accrues to whoever owns the gravity.
Composability. The middleware bet. Make it dead simple to stitch together pipelines so customers don't have to commit to a single platform.
Verticalization. The app-layer bet. Specialize around a domain like legal, healthcare, or ops, and own the workflows that live there.
Headless. The Salesforce thrash. The recognition, late in the game, that the UI was never the moat, and that the canonical data model and the governance around it might be.
At the infrastructure layer, defensibility comes from deep pipelines that run, deliver business value, and aren't reasonably reproducible by someone vibe-coding their way through a weekend.
At the application layer, the picture is sharper. When the bubble burns down to its load-bearing pieces, what's left is governance, intelligence, and a data platform. The application layer in the agentic era expresses how an organization holds its own agency. What a forecast means at this company, how deals and ops work, and how the canonical data model encodes control. The UI is the surface where humans assert structure over the business. That gets more important when agents arrive, because agents need a place to look up what we mean by this here.
There's a related shift that isn’t often discussed. A lot of what used to be back-end infrastructure is migrating to the front end. For example, Auth0 was originally sold to back-end engineers building apps. Now, Clerk sells authentication to front-end React and Next.js developers. For every one back-end engineer there are roughly a thousand front-end developers. As app development moves from the back to the front, thanks to Replit and the rest of the AI app-gen wave, the infrastructure follows. The front end is eating things that used to live below it. The defensible surface is moving too.
Build where correctness has a consequence you can't reverse easily. Where human comprehension of correctness is itself the bottleneck.
Waymo is a great example here. We can objectively prove the cars are better drivers than humans, and we still hold them to an unreasonable standard. Anywhere the same dynamic applies in software, you have a moat. The model will never be allowed to consume it on its own, purely on the basis of human trust.
Pricing the Probabilistic
How do you charge for this stuff? It's something founders rarely talk about in public, and the panel spent real time on it.
Seat-based pricing is throttling adoption inside enterprises. A casual or part-time user doesn't justify a full seat, so accounts stall. The alternative is a usage-based consumption model: annual contracts, pools of credits, no per-user cap. Initial deal sizes are smaller, but the bet is that once the product is in, growth is natural.
On the infrastructure side, self-serve flows work on per-page or per-unit pricing because it's intuitive. Larger deployments often run on project-based pricing: license by use case, no COGS exposure when compute and API keys belong to the customer. The aspirational endpoint is data successfully delivered to agents, priced by the unit of delivery.
Outcome-based pricing, the model where you charge per closed case, doesn't generalize cleanly. It works when the atomic unit of value is countable. Most platform companies don't have one. A more durable framing of this would be:
- Tie pricing to consumption of the agent's work, not the seat it sits in
- Be patient with land contracts. Trust the expansion curve
- Resist the temptation to make outcome-based pricing the headline before the unit economics are real
The pricing model that survives the agentic era will look more like a meter than a license.
What This Means
The founders who've been building platforms the longest are the ones most willing to throw out their early assumptions. The platform you'd build today isn't the platform you built three years ago. The assumptions change that fast.
The next generation of platforms won't look like the last. They'll be:
- SDLC-native → modeling business processes as code so the agent loop reaches into more of the customer's operations
- Production-grade → investing in observability, auditability, and deterministic execution, the unsexy infrastructure the production economy actually buys
- Correctness-first → holding agents to the bar the business demands, with their own identity, scope, and audit trail
- Consumption-priced → charging for the agent's output, not the seat
Patrick Collison captured the feeling when asked what this moment is like:
We're reminded of the phenomenon of falling into a large black hole. If you ever experience that particular misfortune, you won't feel anything special at the moment you cross that event horizon because the path is locally smooth. But the space of possible futures changes irrevocably upon crossing the threshold.
That's what this era feels like. Locally smooth. Everything getting better, better, better. A year from now we'll look back and find ourselves in an entirely different world.
Our customers didn't come to DOSS for AI. They came because they didn't know where they stood on inventory, margins, and revenue. They needed a foundation. The platform is the foundation. The agents run on top.
That's the Real World. And that's what we're building for.
