There is a lot of noise right now about the death of SaaS. The usual argument is that AI makes code cheap, so software loses its value.
This is true. But it misses the structural point.
The problem with SaaS is not price. It is opacity.
The rental trap
For 20 years, we rented software we could not touch. We accepted this trade-off. We gave up control for convenience. If the software did not do exactly what we needed, we filed a feature request and waited six months. Or we built a clumsy workaround with Zapier and duct tape.
This was fine when humans were the primary users of software. A human can adapt. A human can click through a bad UI, work around a missing field, copy-paste between tabs. Humans are flexible. Software did not need to be.
But that era is ending.
Agents need to see the wiring
We are moving from humans using software to AI agents using software.
An AI agent is only as good as its context. To be effective, it needs to understand the database schema, the API logic, the constraints, the business rules encoded in the code. It needs to see the wiring.
Put an agent in front of a closed SaaS product and it is blind. It can click buttons through a browser automation tool. It can call a limited API that exposes 30% of the functionality. But it cannot engineer a solution. It cannot understand why a field validation exists. It cannot modify a workflow that does not match your business logic.
Put the same agent in front of an open codebase and everything changes. It reads the schema. It traces the data flow. It understands the constraints. It can modify, extend, and fix the software because the source is right there.
This is not a philosophical argument about freedom. It is a practical argument about capability. Closed code is a ceiling on what your AI can do.
The rise of elastic software
In the previous era, open source was about community or cost savings. In the AI era, open source is about something different: elasticity.
If the code is open, the AI can read it. If the AI can read it, it can change it. This creates a new category of technology that will define the next decade: elastic software.
Here is what this looks like in practice.
Today, you subscribe to a rigid SaaS tool. It solves 80% of your problem. The other 20% is a feature request that will never ship because it only matters to your team. You work around it. You accept the gap.
With elastic software, you start from a high-quality open-source base and tell your AI: "This billing workflow needs an approval step before invoices go out. Add it." The AI reads the source. It understands the data model. It writes the code. You review it, deploy it, and move on. The tool now solves 100% of your problem because you own the code.
SaaS forced you to change your process to fit the software. Malleable software changes to fit your process.
Why this kills vertical SaaS
Vertical SaaS built a $100B industry on one bet: domain expertise is hard to encode, so customers will pay a premium for pre-built solutions tailored to their industry.
That bet is breaking.
When an AI agent can read an open-source codebase, understand the business logic, and adapt it to a specific vertical workflow in hours instead of months, the value of the pre-built vertical solution collapses. Why rent a tool that solves 80% of your problem for $200 per seat per month when you can build exactly what you need on open infrastructure?
The vertical SaaS vendor's response will be "but we have the domain knowledge." True. But domain knowledge is increasingly available in training data, customer documentation, and industry standards. The moat was never the knowledge. The moat was the code. And the code is the part AI writes best.
The maintenance fear is dead
The old fear of custom software was maintenance. We rented SaaS because we did not want to fix bugs, apply security patches, or handle database migrations ourselves. "Just let someone else deal with it" was a reasonable position when the alternative was hiring three engineers to maintain a custom app.
But the maintenance argument assumed human labor. If an AI agent can monitor the codebase, flag issues, fix bugs, and apply updates on an ongoing basis, the cost of ownership drops to near zero. The risk that kept everyone on rented software evaporates.
This does not mean every company should build everything from scratch. It means the build-versus-buy calculation has permanently shifted. The threshold where "build" beats "buy" just moved from $500k annual spend to almost any project where the SaaS tool does not fit.
What actually matters now
If open source is the architecture that survives, the next question is: what does the infrastructure look like?
An open-source codebase alone is not enough. You still need a database. You still need authentication. You still need permissions, audit logs, deployment, and a way for your AI agents to act on real data under real security constraints. This is the gap we wrote about in Why Every AI-Coded App Is an Island. The code is the easy part. The production infrastructure is what takes weeks.
This is what RootCX provides. One shared PostgreSQL database, SSO, role-based permissions on every resource, immutable audit logs, integrations, and deployment. Build with Claude Code, Cursor, or RootCX Studio. The AI reads and modifies the code because it is open source (FSL-1.1-ALv2, converting to Apache 2.0 after two years). The agents act on real data, under the same RBAC rules as your team, with every action logged.
The black box had a good run. Twenty years of renting software you could not see, could not modify, and could not hand off. That era worked when humans were the only users. It does not work when agents need to understand the system to operate it.
The future belongs to the code you can see. The infrastructure you can own. The tools that bend to your business, not the other way around.
Long live open source.