Here’s a dirty secret every fast-moving team knows: we hate the tools we pay for.
Not because they’re bad. Because they’re rigid. Every SaaS product comes with an opinion about how you should work. Salesforce tells you a deal has seven stages. Jira tells you a ticket moves through a specific lifecycle. HubSpot tells you a lead must be “qualified” before it becomes an “opportunity.”
These aren’t just data models. They’re imposed processes.
If you’ve ever worked on a genuinely fast team — the kind that ships weekly, pivots on a phone call, and treats bureaucracy like kryptonite — you know the feeling. The tool that was supposed to help you becomes the thing that slows you down. You spend more time feeding the system than doing the work.
We accepted this tradeoff because the alternative was chaos. Without Salesforce, deals slip through cracks. Without Jira, engineers lose track of what’s shipping. Without a system, collaboration breaks down. Someone has to play program manager — chasing updates, maintaining the board, reconciling spreadsheets, making sure everyone sees the same reality.
SaaS was the program manager we hired because we couldn’t afford a real one. Rigid, by-the-book, doesn’t understand context — but at least it kept the lights on.
The Bundle Nobody Noticed
Let’s be precise about what we’ve been buying for 25 years.
In 1999, Marc Benioff staged a fake protest outside a Siebel Systems conference. Actors carried “No Software” signs. The message: you shouldn’t need servers, IT teams, and $1M just to track your customers. He was right. Salesforce made CRM accessible. Then everybody copied the model.
But Salesforce wasn’t just a database in the cloud. Every operational SaaS product — the tools that define how a company runs — is actually five things bundled together:
System of Record | The data model — what exists, how it relates | Accounts, Contacts, Opportunities
Operating Procedures | The encoded workflow — what happens when | Lead → Opportunity → Negotiation → Close
Views | How humans see the data | Pipeline boards, dashboards, reports
Collaboration | How teams share and coordinate | Assignments, permissions, @mentions
Integrations | How this tool connects to others | AppExchange, APIs, Zapier connectors
The pattern holds across every CRM, project management, HR, and support tool:
Linear = Issues + Triage→Done workflow + Board/List views + Team assignments + GitHub/Slack integrations
Asana = Tasks/Projects + Status workflow + Timeline/Board views + Team coordination + 200+ integrations
The reason your company uses 250+ SaaS tools (yes, that’s the average — and growing) is that each tool froze a different slice of reality into a different data model with different procedures. None of them agree on what a “customer” or “project” or “task” actually is. And the fifth primitive — integrations — exists solely because of this fragmentation. An entire industry (Zapier, Workato, Tray.io) exists to duct-tape these frozen data silos together.
The global SaaS market hit roughly $200 billion in 2023 (Gartner). A meaningful chunk of that is paying for the same data to exist in slightly different shapes across different tools — and then paying again to connect them.
The Process Tax
Every SaaS tool you adopt is a process you’re committing to. Not choosing to follow — committing to. The tool’s data model IS the process. If Salesforce says a deal has stages, you have stages. If Jira says work has story points, you’re estimating in story points.
This was the bargain: structured coordination in exchange for workflow rigidity.
For most companies, most of the time, it was worth it. The alternative — spreadsheets, email chains, “can you send me the latest version?” — was worse.
But fast teams always knew the cost:
Process theater — updating the CRM not because it helps the deal, but because the manager needs a forecast
Tool-shaped work — restructuring how you actually work to fit what the tool allows
Integration tax — a customer emails you (Gmail), you log it (Salesforce), create a ticket (Jira), post an update (Slack), track the deliverable (Asana). Five tools. One workflow. Fifteen minutes of context-switching.
Lowest common denominator — the tool encodes a generic version of your process, not YOUR process
The best teams always wanted adaptive processes — structures that emerge from the work rather than being imposed on it. The sanity of a system without the straitjacket of a product.
They wanted what was impossible before AI.
AI Doesn’t Just Fix SaaS. It Removes the Rigidity.
The popular narrative is “AI copilots make SaaS better.” Salesforce adds Einstein. Notion adds AI. Every SaaS product gets a chatbot that can summarize things and draft emails.
This misses the point entirely.
The copilot approach bolts AI onto rigid software. You still have seven deal stages. You still estimate in story points. You still spend 15 minutes context-switching across five tools. The AI just helps you do these rigid things slightly faster.
The real shift is deeper: AI removes the rigidity entirely. The system stops imposing processes and starts adapting to how you and your team actually operate.
Operating Procedures | Rigid SaaS: Hardcoded — the product decides your workflow | Agent-Native: Adaptive — agents learn your team’s actual process
Views | Rigid SaaS: Fixed dashboards designed by a product team | Agent-Native: Generated on demand — “show me what matters today”
Collaboration | Rigid SaaS: Complex UI everyone must learn | Agent-Native: Agent-mediated — “what does the team need to know?”
Integrations | Rigid SaaS: Hardcoded API connectors (Zapier, AppExchange) | Agent-Native: Dynamic — agents connect to any system through protocols like MCP
System of Record | Rigid SaaS: The database inside the SaaS product | Agent-Native: ???
Four of the five primitives become soft — dynamic, generated, adaptive. An AI agent can learn any sales process, not just Salesforce’s. An AI can generate any view of your data. An AI can coordinate a team without everyone staring at the same Kanban board. An AI can connect to any system without pre-built integrations.
But the fifth primitive — the system of record — remains hard. Data has to live somewhere. It needs structure, persistence, relationships, permissions. You can’t hand-wave this with a language model.
In the agentic era, the only durable layer of SaaS is the data layer. Everything else adapts.
Every operational SaaS product is a UI on top of a database with some business logic. AI can generate the UI and the business logic. What it can’t generate is your data. But if data is the durable moat, shouldn’t incumbents who already have the data win? Not necessarily — because their data is siloed. Salesforce has your sales data. Jira has your engineering data. HubSpot has your marketing data. No incumbent has the cross-system graph. That’s the opening.
Different Types of SaaS, Different Futures
“SaaS” is actually several different types of software sold under the same label. AI hits each differently:
Infrastructure SaaS — identity (Okta), payments (Stripe), communications (Twilio), monitoring (Datadog). These are APIs that other software calls. In the agent era, infrastructure SaaS transforms: agents become the primary users alongside humans. Okta shifts from authenticating employees to also authenticating agents. Stripe processes agent-triggered payments. The plumbing stays — the users change.
Productivity SaaS — individual work tools. Todo apps, personal notes, personal writing assistants. Model labs are absorbing this category directly — ChatGPT and Claude handle personal productivity natively. This is where the labs have gone first, and it makes sense: single-player, no coordination complexity.
Operational SaaS — the tools that define how a company runs. Sales operations (Salesforce), engineering operations (Linear, Jira), customer operations (Zendesk), people operations (Workday), marketing operations (HubSpot). This is where the five-primitive bundle lives. This is where teams coordinate around shared reality. And this is what agents unbundle. Salesforce alone is a $40B+ business. The operational layer represents the bulk of the SaaS market.
Some products span categories — Slack has infrastructure qualities (messaging API), productivity qualities (personal DMs), and operational qualities (team coordination). The taxonomy doesn’t need to be exhaustive. It needs to be useful for understanding where the next platform gets built.
What about model labs moving into operations? Model labs will expand wherever there’s a big enough market and it fits their strategy. They haven’t yet built agent storage, coordination layers, or data infrastructure for agents. Will they? Maybe. What we can observe is what’s structurally missing today: nobody — including the model labs — has built an adaptive, cross-system operational layer with a flexible system of record designed for agent workloads. The gap is real, even if we can’t predict how long it lasts.
Microsoft and Google are a special case — they already own both AI engines and operational suites. They’ll use AI to deepen their ecosystem lock-in. The opportunity is the rest of the market — companies that use a mix of tools and need cross-system intelligence none of those vendors will provide.
The Missing Piece: A System of Record for Agents
So if we were building operational SaaS for agents from scratch, what does the data layer look like?
Not a traditional database. Not a data lake. Something fundamentally different — because agent-operated systems create a new workload pattern that doesn’t map to any existing storage category.
Flexible schema — agents discover new entity types and relationships as they operate. The schema isn’t designed upfront — it emerges. This is fundamentally different from both rigid relational schemas AND schemaless document dumps. You need structure that can evolve without migrations.
Mutable state + immutable events — current truth AND the full history of what happened. Agents need both: “what is the deal status now?” and “what changed last week?”
Relationships — “this customer mentioned this bug in that email, which relates to this feature request.” Business reality is a graph, not a table.
Semantic + structured queries — agents ask questions in meaning (“find all customers who complained this month”) that require both text understanding AND structured filtering. No single query engine handles both natively today.
Agent-scale concurrency — this is the workload that doesn’t exist yet. Not a single user editing a record, but a swarm of agents hitting the same entities concurrently. When Agent A updates a deal stage and Agent B reads it 100ms later to decide whether to send a follow-up email, you need strong consistency. Eventual consistency means agents make decisions on stale data. The throughput and latency requirements of agent swarms are genuinely novel — not OLTP, not OLAP, not document store, not graph database. Something new.
Provenance — who created this? Human or agent? Based on what source? When? This matters enormously when agents are autonomous actors making decisions that affect real business outcomes.
Three storage types, one unified API. Entities for current state. Events for history. Objects for files. A semantic index across all of them that enables meaning-based queries.
This isn’t a database. It’s a knowledge substrate — the foundation that agents understand, operate on, and keep coherent. And building it is a genuine systems engineering challenge, not an application-layer problem.
The Formula
Agent-native Operational SaaS = System of Record + Agents + Shared Understanding
The system of record is the flexible data layer — entities, events, objects, semantically indexed.
The agents are the adaptive operating layer — not hardcoded procedures, but intelligent actors that learn how your company actually works.
The shared understanding is what makes it operational — maintained by agents, visible to humans on demand, queryable in any form.
You don’t need Salesforce. You need a customer record, a sales agent, and a way to ask “how’s the pipeline?”
You don’t need Linear. You need an issue record, a triage agent, and a way to ask “what’s blocking the release?”
You don’t need 250 SaaS tools. You need one flexible system of record, agents configured for your operations, and the ability to see your reality in whatever shape you need — without waiting for a product team to build the dashboard.
Day One (What This Future Looks Like)
Here’s how agent-native operational SaaS should work, from first principles.
A company signs up. Two questions:
Is this for you or for your team?
What do you want to operate?
“I want to run my sales pipeline and make sure nothing falls through the cracks.”
The system provisions:
An entity model: Companies, Contacts, Deals, Activities
A sales agent: monitors email, qualifies leads, updates deal stages, alerts on stale opportunities
A default view: pipeline board with AI-generated daily brief
Nobody configures stages. Nobody sets up automations. The agent learns what “Negotiation” means for THIS company by watching how deals actually progress.
A week later: “I also want to track our product roadmap.” The system extends — new entities, new agents, and the graph lights up: “Acme asked for this feature twice across support and sales.”
The team grows. The system adds role-based visibility, handoff procedures, a daily team brief generated fresh each morning.
For a 5-person startup, you’re running in minutes. For a larger team, the agent accelerates implementation — but complex business rules still need human input. Adaptive where flexibility helps. Structured where compliance requires it.
Every action has a provenance trail — what data it was based on, what decision was made, why. When an agent gets it wrong, you see exactly why and the correction compounds across every agent in the system.
The Transition (Nobody Rips and Replaces Overnight)
Here’s the practical problem with this vision: your company has data in Salesforce right now. Tickets in Jira. Conversations in Slack. Years of institutional knowledge encoded in these systems.
Nobody is going to delete Salesforce on Monday morning.
Software has been through many major transitions — digitization, the internet, client-server, mobile, on-prem to cloud — and none of them happened overnight. Digitization took two decades. The cloud transition took a full decade, and companies like Nutanix proved there’s a multi-billion-dollar market just in building the bridge. Each transition followed the same pattern: gradual migration, not a sudden switch.
But there’s another pattern worth noticing: the transitions are compressing. Each one happens faster than the last. Mobile went from the iPhone launch to dominant platform in about seven years. Cloud adoption that took enterprises a decade in the 2010s now takes months. The agent transition will likely be faster than any of them — because the AI itself accelerates adoption.
The operational SaaS transition needs the same kind of bridge:
Phase 1: Connect. Agents plug into your existing tools — Salesforce, Jira, Google Workspace, Slack, your databases. They learn your data. They build a knowledge graph across all of them. Everything keeps working as-is.
Phase 2: Augment. Agents add value on top. They spot patterns across systems that no single tool could see — “this customer complained in support, their renewal is in 60 days, and they haven’t had a QBR in 3 months.” Your team keeps using familiar tools, but with an intelligence layer they never had.
Phase 3: Absorb. The agent layer becomes the primary interface. “What’s happening with Acme?” replaces opening Salesforce. The underlying tools fade to data sources — still connected, but no longer the interface anyone touches daily.
Phase 4: Replace. Some subscriptions get cancelled because nobody logs in anymore. Not mandated — just natural. Many companies will live in Phase 2-3 for years, and that’s fine. The value accrues in the augmentation layer.
The Prediction
Every era of business software was defined by who it was built for:
Ledgers and filing cabinets → built for clerks
Mainframes → built for accountants
Client-server → built for departments
SaaS → built for humans collaborating through browsers
What comes next → built for agents operating on behalf of teams
When the primary user shifts from human to agent, the entire product architecture changes. Views get generated, not designed. Processes get learned, not hardcoded. Data models become flexible, not frozen. Integrations become dynamic protocols, not hardcoded connectors.
The SaaS market was built on a simple bargain: coordination in exchange for process rigidity.
AI breaks that bargain. Coordination without rigidity is now possible.
The next great operational platform won’t be built for humans to click through. It will be built for agents to operate — with humans asking questions, setting direction, and stepping in when judgment matters.
It’s not the end of software. It’s the end of software that forces everyone into the same workflow.
Anoop Jawahar is the founder of SynOS, building agent-native operational software. Connect on LinkedIn
