The market keeps saying “SaaS is dead.” That’s probably true, but it’s also incomplete. What’s actually dying is the idea that value lives inside a vendor-controlled black box. The next era is about utilities: unlimited coding capacity and unlimited analytical capability. And if those two utilities are real, then the vendor model has to change.
Unlearning 25 years as a Vendor
I’ve spent my entire career in customer-facing enterprise roles. I’ve watched the industry move through all the waves: Client / Server, Y2K, data center modernization, cloud migrations, and finally SaaS as the default delivery model.
SaaS worked because it packaged complexity into something the enterprise could buy and operate with predictable effort. But AI changes the unit economics of software creation.
When an engineer can pair with a coding agent and effectively get “on-demand software,” the value of many SaaS surfaces compresses fast. The enterprise no longer needs a vendor to build every workflow. They need help to operate the workflows safely, at scale, and with trust.
Unlimited coding + unlimited analytics is not enough
These new utilities don’t automatically produce outcomes. They produce potential —and potential can be dangerous. If customers try to wire everything up themselves, they inherit unlimited risk: security, reliability, cost blowups, hallucinated analysis, hidden failure modes, and brittle automation. Velocity loses its value the moment it compromises production integrity.
So the vendor of the future has a job: To provide connective tissue between those utilities and a set of domain workflows tailored by the customer (i.e. what I call the system of context).
The vendor of the future builds a customer-owned control plane
Every enterprise has a unique history, constraints, and meaning. Every domain has unique challenges. And with some challenges, especially at scale, AI is not the best solution. So the vendor of the future does three things:
- Connects the utilities into a working control plane —the connective tissue between models, tools, data and enterprise systems is the System of Context that turns AI capabilities into trusted outcomes.
- Codifies best practices — proven templates, reliability patterns, and the non-promptable hard parts teams shouldn’t have to rediscover.
- Handles the domain specific challenges — focus on the tasks where AI is not the best solution.
Why we built AURA
We built AURA because we believe this control plane is going to exist in every serious enterprise. The only question is who owns it. The market is currently pushing teams toward black boxes, i.e. closed systems that ask the customer to hand over the most valuable asset they have: operational context and the workflows built on top of it.
We think that’s the wrong contract.
AURA is an open source framework that lets teams assemble an agentic stack that aligns with their priorities and constraints, without being trapped inside one vendor’s worldview.
Why open source is the only strategy that matches the thesis
If the system of context should be customer-owned, then the core control plane cannot be closed. Open source does a few things that matter here:
- Trust and inspectability. If an agent is going to take action in prod, teams need to see how it works and why it decided what it decided.
- No lock-in on the control plane. Teams can extend, swap components, and build their own workflows without negotiating permission.
- A real ecosystem. Composable configs and templates can be shared and improved across teams, not trapped behind one vendor’s UI.
Agent frameworks will be everywhere. The opportunity is operationalizing them in a specific domain by building and maintaining a trustworthy system of context: the workflows, reliability patterns, and supporting infrastructure that make agent decisions inspectable, safe, and scalable in production.
Life after SaaS
SaaS as we know it is changing. What comes next is better: enterprises get leverage to build workflows faster than ever, tuned to their reality, without waiting on vendor roadmaps. In that world, the vendor that wins does three things:
- Gives customers a control plane they can own and extend — that’s why we’re contributing AURA as open source.
- Provides domain templates and guardrails — proven workflows and reliability patterns that make production AI real.
- Solves the hard “data + operations” layer — because this is where most AI workflows collapse.
That’s why we built AURA. That’s why it needs to be open source. And that’s what being a vendor means now. Sign up for early access here.