Software ate labor. Agents ate software.

The Wall Street Journal Headline That Aged Perfectly

On August 20, 2011, Marc Andreessen published “Why Software Is Eating the World” in the Wall Street Journal. His thesis was simple and, as it turned out, correct: every industry would be disrupted by software companies. Borders would fall to Amazon. Blockbuster would fall to Netflix. Taxi dispatchers would fall to Uber.

What Andreessen didn’t predict was that software would eventually eat itself.

Fourteen years later, we’re drowning in the very tools that were supposed to liberate us. The software revolution succeeded so completely that it created a new problem: there’s too much of it. And the solution to too much software isn’t better software. It’s agents that make software invisible.

The SaaS Explosion by the Numbers

Let’s start with the data, because the scale of what happened is hard to grasp without it.

In 2015, there were roughly 5,000 marketing technology products. By 2024, Scott Brinker’s Marketing Technology Landscape counted over 14,000, in marketing alone. Across all categories, Statista estimates there are now over 30,000 SaaS products globally.

Productiv’s 2024 SaaS Management Index found that the average mid-market company (500-2,500 employees) maintains 315 SaaS applications. The average enterprise (2,500+) maintains over 600. Even companies with fewer than 50 people average 87 tools, according to Zylo’s 2024 SaaS Management Report.

The spending is staggering. Gartner projected global SaaS spending would reach $232 billion in 2024, up from $167 billion in 2022. For a mid-market company, that translates to an average of $4.6 million per year on software subscriptions, according to Productiv.

But here’s the number that matters most: Zylo found that 51% of SaaS licenses go unused or underused in any given month. Half. Imagine buying 315 tools and leaving 160 of them running with nobody at the wheel.

This isn’t a procurement failure. It’s a structural one.

Why SaaS Sprawl Is an Architecture Problem

Every SaaS tool makes the same implicit promise: adopt me, and your team will be more efficient. And in isolation, that promise is usually true. Slack genuinely makes messaging easier. Jira genuinely makes task tracking more structured. Datadog genuinely makes monitoring more visible.

The problem is that efficiency gains in isolation become efficiency losses in combination.

Each tool introduces its own data model. Your CRM thinks about the world in terms of contacts, accounts, and deals. Your project management tool thinks in terms of tasks, sprints, and milestones. Your monitoring tool thinks in terms of metrics, alerts, and thresholds. Your communication tool thinks in terms of channels, threads, and reactions.

None of these models are compatible. When a deal closes in your CRM, that information needs to reach your project management tool (to kick off onboarding), your finance tool (to generate an invoice), your communication tool (to notify the team), and your monitoring tool (to set up health checks). That’s four translations, four potential failure points, four places where data can go stale.

The integration industry, Zapier, Make, Workato, Tray.io, exists specifically to bridge these gaps. Zapier alone facilitates over 6 billion tasks per year across 7,000+ app integrations. But integrations are duct tape. They’re brittle, they break silently, and they encode business logic in places nobody thinks to look when something goes wrong.

A 2024 survey by MuleSoft found that 89% of IT leaders say integration challenges are slowing digital transformation. The average enterprise maintains 900+ individual integrations. Each one is a dependency. Each one is technical debt. Each one is a small tax on the organization’s ability to move.

The Human Cost of Tool Fatigue

The financial cost of SaaS sprawl is easy to quantify. The human cost is harder, but arguably more damaging.

RingCentral’s 2024 study on app overload found that employees toggle between an average of 10 applications per hour. Each toggle carries a cognitive switching cost. Research by Gloria Mark at UC Irvine found that it takes an average of 23 minutes and 15 seconds to return to full focus after an interruption. Even micro-interruptions, a Slack notification, a Jira update, a monitoring alert, cost 10-15 minutes of attention residue.

Calculate it out: 10 context switches per hour, each costing even 2 minutes of reduced productivity, means 20 minutes of lost deep work per hour. In an 8-hour workday, that’s nearly 3 hours of cognitive overhead. Not because people are lazy or unfocused, but because the tooling architecture demands constant context-switching.

Harvard Business Review published research in 2023 showing that “digital dexterity fatigue”, the exhaustion from managing too many digital tools, correlates with a 26% decrease in work quality and a 23% increase in employee turnover intention. The tools meant to empower workers are burning them out.

The irony is suffocating: we built software to save time, and now we spend our time managing software.

The Three Eras of Business Software

To understand where agents fit, it helps to see the historical arc.

Era 1: On-Premise (1980s-2000s), Software lived on physical servers. You bought SAP or Oracle, hired a systems integrator for 18 months, and prayed it worked. Expensive, rigid, but at least it was one system. The data model was unified, even if it was painful.

Era 2: SaaS (2000s-2020s), Salesforce proved that software could live in the cloud, be accessed from a browser, and be paid for monthly. The barrier to adoption collapsed. Any team lead with a credit card could buy a tool. This was a revolution in accessibility and a catastrophe for coherence. Instead of one monolithic system, companies ended up with hundreds of point solutions, each excellent in isolation, each a silo in aggregate.

Era 3: Agents (2020s-present), The agent era doesn’t eliminate SaaS tools. It renders them invisible. An agent layer sits above the tools, interacting with them the way a human operations manager would: reading data from one, making a decision, taking action in another, reporting results in a third. The agent doesn’t care whether the underlying tool has an API or a web interface. It cares about the outcome.

The shift from Era 2 to Era 3 mirrors a pattern we’ve seen before. When the web first emerged, companies built individual websites. Then portals like Yahoo tried to aggregate websites into one interface. Then Google made the aggregation layer irrelevant, you didn’t need to know where information lived, you just asked for it. Agents are the Google of SaaS: they abstract the location and format of your tools behind an intent-driven interface.

How Agents Collapse the Stack

Consider a concrete example: a sales follow-up workflow.

In the SaaS era, this involves: checking Pipedrive for stale deals (tool 1), cross-referencing with LinkedIn Sales Navigator for recent prospect activity (tool 2), drafting a follow-up in Gmail (tool 3), logging the activity back in Pipedrive (tool 1 again), setting a reminder in Slack (tool 4), and updating the forecast in a Google Sheet (tool 5). Five tools, six actions, probably 25 minutes of human time per prospect.

In the agent era, an SDR agent does all of this autonomously. It monitors deal staleness in the CRM, enriches prospect data from public sources, drafts personalized follow-ups, queues them for human approval, and updates all relevant systems once approved. The human’s only job is to review the follow-ups and approve or modify them. Total human time: 2 minutes per prospect.

The tools didn’t change. Pipedrive, LinkedIn, Gmail, they’re all still there. What changed is that no human needs to operate them directly. The agent is the operator.

This pattern repeats across every operational domain. QA testing, infrastructure monitoring, meeting summarization, competitor tracking, budget reconciliation, post-sale health scoring, in each case, the agent absorbs the operational work that previously required a human to juggle multiple tools.

The Convergence Thesis

Here’s where it gets interesting for the SaaS industry itself.

If agents can orchestrate any tool, then the competitive moat of a SaaS product shifts dramatically. Today, Slack wins because of network effects, your team is already there. Jira wins because of switching costs, your workflow history is locked in. Salesforce wins because of data gravity, your CRM data is too valuable to migrate.

But agents erode all three moats. Network effects matter less when an agent can post to any communication platform. Switching costs decrease when an agent abstracts the interface. Data gravity weakens when an agent can read from and write to any system.

Bain & Company published an analysis in late 2025 predicting that 40% of current SaaS categories will consolidate or disappear by 2030 as agent layers subsume their functionality. Their logic: if an agent can handle scheduling, do you need Calendly? If an agent can manage tasks, do you need a dedicated project management tool? If an agent can monitor metrics and alert on anomalies, do you need a standalone observability platform?

The answer isn’t always “no.” Complex, specialized tools will survive. Figma isn’t going away because design requires visual creativity. GitHub isn’t going away because code repositories serve a structural purpose. But the long tail of point solutions, the 30,000 tools competing in overlapping niches, will face an existential question: does my tool do something an agent can’t?

The Agent Orchestration Layer

The key architectural insight of the agent era is that the value shifts from individual tools to the orchestration layer.

In the SaaS era, the most valuable company was the one with the best individual product. In the agent era, the most valuable company is the one that orchestrates the best outcomes across products. It’s the difference between selling a great hammer and having a skilled carpenter who knows when and how to use every tool in the shop.

This is why agent platforms, systems that manage multiple agents across multiple tools, are fundamentally different from another SaaS product. They’re not a 316th tool to add to your stack. They’re the layer that makes the other 315 tools work together without requiring humans to be the glue.

Apollo Space’s architecture reflects this directly. Four directors, Growth, Operations, Finance, and Custom, coordinate twelve execution agents across whatever tool stack a company already has. The SDR agent doesn’t replace your CRM; it operates your CRM. The observability agent doesn’t replace Datadog; it watches Datadog and acts on what it sees. The meeting digest agent doesn’t replace your transcription service; it reads the transcript and does something useful with it.

The tools become infrastructure. The agents become the workforce. The orchestration layer becomes the operating system.

What Dies, What Survives

Not everything collapses equally. Here’s a framework for thinking about which SaaS categories face the most pressure from agents.

High risk of agent displacement:

• Simple data routing tools (Zapier, Make), agents handle this natively
• Basic CRM data entry and hygiene, agents maintain data as a byproduct of doing real work
• Notification and alerting tools, agents don’t just alert, they respond
• Scheduling and calendar management, agents negotiate time directly
• Basic reporting and dashboard tools, agents synthesize and deliver insights proactively

Medium risk:

• Project management tools, agents handle task tracking but humans still need visual planning interfaces
• Communication platforms, agents can post anywhere, but humans still need a place to talk to each other
• Document collaboration, agents can draft and summarize, but humans still need to co-create

Low risk:

• Creative tools (design, video, audio), visual and creative work remains human-driven
• Developer infrastructure (Git, CI/CD, cloud), structural tools that agents use but don’t replace
• Specialized vertical SaaS (healthcare records, legal case management), deep domain regulation creates moats agents can’t easily cross

The pattern: tools that primarily move, monitor, or summarize information are most vulnerable. Tools that serve as environments for human creativity or regulatory compliance are least vulnerable.

The Economic Implications

The financial impact of agent convergence is significant enough to reshape how companies budget for technology.

Currently, the average company spends 12-15% of revenue on technology, with SaaS subscriptions comprising an increasing share. Flexera’s 2024 State of Tech Spend report showed SaaS now accounts for 38% of total IT budgets, up from 25% in 2020.

Agent orchestration offers a fundamentally different cost structure. Instead of paying per-seat licenses for 87 tools (for a small company), you pay for an agent layer that operates across all of them. The math changes from multiplication (seats x tools x monthly cost) to consolidation (one orchestration layer + the tools agents need to operate).

Early data from companies adopting agent-first architectures suggests a 30-45% reduction in total SaaS spend within 12 months, primarily from eliminating redundant tools and unused licenses that agents make visible. When an agent operates your tools, it becomes immediately clear which tools actually contribute to outcomes and which ones are just running up a tab.

The Shift Nobody’s Talking About

Here’s the thesis, stated plainly: the SaaS era was about giving humans better tools. The agent era is about removing humans from the tool layer entirely.

This isn’t a dystopian prediction. It’s a liberation. The 58% of time that knowledge workers spend on “work about work”, the context switching, the data entry, the status reporting, the notification triaging, isn’t fulfilling work. Nobody went to business school to copy-paste data between Salesforce and a spreadsheet. Nobody became an engineer to manually run regression tests before every deploy.

Agents absorb this work. Humans ascend to the layer where they actually add value: strategy, creativity, relationships, judgment. The org chart doesn’t shrink. It restructures. The operations coordinator doesn’t lose their job. They stop coordinating operations and start doing the strategic work they were hired for but never had time to do.

Software ate labor by automating physical processes. SaaS ate on-premise by democratizing access. Agents eat SaaS by making the tool layer invisible.

The next operating system for business isn’t another tool. It’s the layer that makes all the tools disappear.

And that’s exactly what we’re building.