Son of a SaaS! AI Killed SaaS, Here Is What’s Next

Software has changed forever—again. While the internet, virtualization, cloud, and containers were seismic shifts, they will soon seem like minor tremors compared to the coming inflection of Generative AI and its impact to the software industry.

We are witnessing a massive boom, but it isn’t just a tech upgrade; it is the death of the seat-based, ticket-driven SaaS model as we know it. If the “Service-as-a-Software” or ”Vertical SaaS” variations on SaaS seem incremental – you are not alone. The coming change is bigger. To understand why the shift is far more profound, we must look at the fusion of software architecture and business models into a new breed of systems: the Outcome-Driven Agentic Software (ODAS).

Software Development: The Renaissance of the Domain Architect

For decades, those of us creating software have known that the code itself was never the moat. The real value of software lies in knowing what code to write, how to package it, and — most importantly — understanding how it will be used.

When I joined Motorola as a software engineer in the mid-90s, I wasn’t handed a keyboard and a Jira ticket. I was sent to mandatory domain training in wireless radio frequency (RF) technologies. This was the prerequisite for writing mission-critical software for cellular infrastructure. Sure, mastering C++ was important but the focus was on applying software engineering skills to solve high-stakes human problems within a domain.

However, over the last twenty years, software development somehow was dumbed down into a lucrative “translation” job: developers simply turned requirements produced by a product manager into code and demanded increasingly detailed requirements in tickets. This ticket-driven sprint model created long development cycles and a “SaaS sprawl” of bloated, mediocre systems built by developers who did not understand the end-user’s world.

Now that AI can write code faster and often better than humans, deep domain expertise, along with speed and distribution, are the true moats. 

If you possess the architectural vision and domain depth, a team of agents can handle the syntax. The “Architect” has now returned to the center of the software systems story. (sidebar: “Nirmata” translates to “architect” or “creator” in Indo-Aryan languages).

Software Architectures: Towards Objects with an Attitude

Every major shift in software has been driven by a change in how we handle data and logic. Databases moved us from monoliths to client-server models; the internet moved servers to the cloud, giving birth to Service-Oriented Architecture (SOA) and its variants including microservices which were initially dubbed the “fine-grained SOA pattern” by Adrian Cockroft, who was then leading Netflix’s cloud migration.

Today, the Large Language Model (LLM) is the new entity in the software stack. At their core, LLMs are pattern-matching engines that predict the “most likely next word.” They excel at unstructured data and synthesis but are notoriously inefficient at the predictable workflows that make up the bulk of enterprise software. To bridge this gap, we are seeing the rise of standards, tools and techniques like the Model Context Protocol (MCP), RAG, and Vector DBs. But the real breakthrough is the return of the Agent.

In the 1995 classic “Distributed Objects Survival Guide“, authors Robert Orfali, Dan Harkey, and Jeri Edwards described intelligent agents as “objects with an attitude” connected via an “object bus” (remember CORBA?).  Today, LLMs have finally given software components the “attitude” (agency) they need to make autonomous decisions. 

The next generation of enterprise software won’t be a collection of static tools; it will be a system of cooperating agents focused entirely on delivering value to their users.

Software Businesses: From Dashboards to Outcomes

With the fundamental changes in software development and software architectures, the very business of software is also facing a reckoning. 

In 1984, Tony Ulwick watched the IBM PCjr flop because it was built on “ideas first” rather than “needs first.” This eventually led to his work on Outcome-Driven Innovation (ODI), which applied Six Sigma rigor to the innovation process — a methodology he later shared with Clayton Christensen, who popularized it as the ‘Jobs-to-be-Done’ (JTBD) framework.

Christensen famously noted that customers “hire” a product to do a job—like the “milkshake dilemma”, where his team analyzed what really drove the sales of milkshakes (it’s not what you think it is – watch the video). In the SaaS era, we sold the milkshake machine (the software) and billed the store operator (the enterprise) per employee that used the machine. In the AI era, enterprises will pay for the outcome (satisfied craving) they deliver to their users, internal or external.

The bar for enterprise software has been raised: Users want outcomes, not another dashboard.

Introducing ODAS: The Future of Enterprise Tech

The successor to SaaS is the Outcome-Driven Agentic Software System (ODAS). It is defined by three pillars:

• Outcome-Driven: Success is measured by the job done, not the features provided or seats filled.
• Agentic: Software components possess their own identity and autonomously perform actions across multiple systems on behalf of the user to drive an outcome.
• Software Systems: Instead of isolated silos, AI agents and assistants work together within a unified context and with secure access to other software components. 

An ODAS system is a collection of agents, where each agent is responsible for delivering an outcome. Agents can be stateful i.e. have a stable identity, persistent storage, and can be stopped and re-started by users. An “assistant” or a “co-pilot” acts as the primary user interface. An agent may have a generative UI, like a chart or table, that becomes part of a composable canvas. An ODAS system typically contains a few traditional services for configuration, user management, etc. but the bulk of the system is focused on the lifecycle, observability, and governance of agents.

ODAS will initially build on existing layers, and integrate with existing enterprise ERPs, CRMs, and other systems of record. Over time, as is usually the case, the layers will collapse and optimize for agentic workflows.

ODAS is unique because it is both an architecture and a business model. By aligning how we build software with how we deliver value, we have a chance at eliminating the “system rot” and over-engineering of the previous decade. With ODAS, pricing is typically per outcome or per agent.

Conclusion

Our industry is not just experiencing a change—it is at a massive inflection point, arguably the most significant since the advent of the internet itself. The shift from the Software-as-a-Service (SaaS) model is accelerating, driven by the exponential capabilities of artificial intelligence. AI doesn’t merely enhance software; it fundamentally rewrites the rules of creation, operation, and consumption.

We are entering a period where the volume of new software created in the next few years will dwarf the collective output of the last several decades combined. This explosion of code, coupled with the complexity of autonomous systems, makes traditional SaaS governance models obsolete. The scale and speed of this new environment demand a paradigm shift towards intelligent, self-governing software systems.

At Nirmata, we recognized this inevitable transition. We are not merely passive observers of the SaaS era’s end; we are active architects of the future. We are building an ODAS for autonomous infrastructure governance that powers the largest new world financials, utilities, retail, and other industries.

ODAS is more than a technological upgrade; it’s a cultural and economic revolution. The era of the monolithic, human-managed SaaS application is giving way to a decentralized, self-optimizing ecosystem of autonomous services driving business value. This is a moment of unprecedented opportunity.

It’s a truly great time to build. Join us to architect the future.