Software Is Compressing: Every SaaS Is Now an Agent
Every SaaS product decomposes into four things: a data model, business rules, integrations, and a UI. Agents have the first three. They don't need the fourth.
The UI was always a concession. You built dashboards because humans needed to click buttons. An agent reads the data, applies the rules, calls the integrations, and does the work. No dashboard required.
This is not a metaphor. It is a literal decomposition that applies to every category of business software. And once you see it, you cannot unsee it.
What software actually is
CRM (Salesforce): Database of contacts + pipeline rules + email/calendar integrations + dashboards. Agent equivalent: workspace files + qualification skills + API scripts + summary reports.
Accounting (QuickBooks): Ledger + categorization rules + bank feeds + reconciliation screens. Agent equivalent: transactions.csv + accounting skills + bank API scripts + generated reports.
Marketing (Jasper + Semrush): Content calendar + SEO rules + social integrations + editor UI. Agent equivalent: keywords.csv + content skills + publishing scripts + generated content.
The pattern is identical every time. Data + rules + integrations = the product. Remove the human, remove the UI.
The four compression techniques
Software compression is not just "replace the app with an agent." There are specific techniques that make agents dramatically more efficient than the software they replace.
Trace compression
When an agent performs a task — researching a lead, reviewing a contract, reconciling transactions — it generates a trace: every step it took, every tool it called, every decision it made. Raw traces are verbose. A single lead research task might produce 3,000 tokens of trace data.
Trace compression strips the noise. Research on agent trace optimization (notably the AgentDiet paper) shows that 39–60% of agent traces are redundant — repeated tool calls, verbose intermediate reasoning, exploration paths that led nowhere. Compress the trace to its essential steps and you get a replayable recipe at a fraction of the token cost.
This matters because compressed traces become the building blocks of automation. A task that cost 3,000 tokens the first time costs 800 tokens every subsequent time. The agent is not re-reasoning from scratch — it is replaying a proven path.
Runbook compilation
Trace compression is step one. Runbook compilation is step two.
A runbook is a compressed trace that has been generalized. Instead of "research Acme Corp," it becomes "research any company matching these criteria." The specific values become parameters. The fixed steps become a deterministic sequence.
The insight here comes from Lobster, an open-source agent framework that demonstrated you only need four primitives for deterministic replay: read, write, call, and branch. A manager agent records the trace during the first execution. The system compresses it into a runbook. From that point forward, a cheaper model — or even a simple executor — replays the runbook without the expensive reasoning that created it.
This is how agents get cheaper over time while SaaS stays the same price. The first execution is expensive. Every subsequent execution is a replay. SaaS charges you the same per-seat fee whether you use a feature once or a thousand times.
Token optimization
Every agent interaction consumes tokens. Context windows are finite. The difference between a well-optimized agent and a naive one is the difference between $0.02 per task and $0.50 per task.
Token optimization techniques that matter in practice:
- Context pruning — Before each agent turn, strip conversation history to only the information relevant to the current step. A contract reviewer does not need the full conversation about lead qualification from three tasks ago.
- Skill caching — Agent skills (the prompts and instructions that define behavior) can be cached and reused across sessions. You load the skill once, not every time the agent runs.
- Structured output — Instead of asking the agent to write a paragraph explaining its analysis, ask for structured JSON. Structured output is shorter, parseable, and eliminates the "let me explain my reasoning" preamble that consumes tokens without adding value.
- Progressive detail — Start with a fast, shallow pass. Only invoke the expensive, deep analysis when the shallow pass finds something worth investigating. A contract reviewer scans all 40 pages quickly, then does deep analysis only on the 5 flagged clauses.
Memory persistence
Stateless agents re-learn everything from scratch on every invocation. Stateful agents — agents with persistent memory — accumulate knowledge over time.
Research on agent memory systems (published by multiple teams working on long-running agent architectures) shows that persistent memory improves task completion rates by 44 percentage points compared to stateless agents on complex, multi-step tasks.
In practice, this means an agent that has reviewed 100 contracts for your company knows your preferred terms, your common counterparties, and your historical redline patterns. It does not start from zero every Monday morning. A sales agent that has run 500 outreach campaigns knows which subject lines perform, which industries respond to which value propositions, and which sending times work for which time zones.
Memory persistence is what turns an agent from a tool into a team member. The tool does the same thing every time. The team member learns.
Three compressions in action
Sales stack: Apollo ($79/seat/mo) + Outreach ($100/seat/mo) + Gong ($100+/seat/mo) = $16,740/yr for 5 SDRs. Agent team: $3,600/yr. 78% reduction.
Finance stack: QuickBooks ($200/mo) + bookkeeper salary ($48K/yr) = $50,400/yr. Agent team: $3,600/yr. 93% reduction.
HR stack: Lever ($6K/yr) + BambooHR ($20K/yr) + recruiter ($73K/yr) = $99,000/yr. Agent team: $3,600/yr. 96% reduction.
Why now
Three capabilities converged: LLMs that reason (read a contract, understand anomalies, evaluate resumes — comprehension, not keywords). Tool use that acts (call APIs, run scripts, send emails, update databases). Persistent memory (workspace files, session history, accumulated skills — research shows 44 percentage point improvement over stateless agents).
But the real catalyst is cost curves. In 2024, running an agent for a single complex task cost $1–$5 in API fees. In 2026, the same task costs $0.02–$0.10. That is a 50x cost reduction in two years. When agent execution costs less than a SaaS subscription, the economics flip permanently.
The compression is not uniform
Not all software compresses equally. The most compressible software has these characteristics:
- Rule-based workflows — If the software's core value is applying rules to data (categorize this transaction, score this lead, flag this clause), an agent replaces it directly.
- Low interaction density — Software where the user looks at a dashboard once a day compresses easily. Software where the user interacts with the UI hundreds of times per hour (design tools, IDEs, games) does not.
- Standard integrations — If the SaaS connects to common APIs (email, calendar, CRM, databases), the agent can call those same APIs. If the SaaS has proprietary connectors that only work within its ecosystem, compression is harder.
- Reporting as output — If the end product is a report, summary, or recommendation, the agent produces it directly. If the end product is a collaborative artifact (a shared document, a design file, a codebase), the agent assists but does not replace the collaboration layer.
Software that resists compression: real-time collaboration tools (Figma, Google Docs), creative tools with tight feedback loops (Photoshop, music production), and platforms where the network effect IS the product (social networks, marketplaces).
Software that compresses completely: CRM data entry, bookkeeping, lead research, contract review, compliance monitoring, report generation, scheduling, and any "check the dashboard, make a decision, take an action" workflow.
What this means
Buyers: Stop paying per-seat for dashboards. If the SaaS is "data + rules + UI," an agent replaces it.
Builders: Stop building settings pages. Ship a workspace, not a web app. Your users do not want to configure a tool — they want the outcome the tool was supposed to produce.
Incumbents: Your moat is data and integrations, not UI. If your advantage is a pretty dashboard, you are about to get compressed. If your advantage is a proprietary dataset or a network of integrations that took years to build, you have time — but not as much as you think.
A 6-vertical agent deployment: $21,600/yr. Same coverage in SaaS + headcount: $300,000–$500,000/yr. This is not a prediction. This is math.