Software for Humans Will Die. Agent Infrastructure Will Survive.

I think a large part of software built for humans will die.

Not every company. Not every screen. But the idea that a person should learn ten dashboards, move data between them and click through the same workflow every day is already starting to look old.

The software that survives will be software an AI agent can use, or software that disappears behind a completed outcome.

Payment rails will survive. Databases will survive. Messaging, identity, permissions and delivery infrastructure will survive. Services will survive. What changes is who operates them.

The next user is not always a human. Sometimes it is an agent working for a human.

A new software category is appearing

If agents become the operators, a new category of service has to appear around them.

API documentation can no longer be written only for a developer who reads it once and writes an integration. It also needs to be easy for an agent to discover, understand and use safely.

Workflows need their own registry or store. A good workflow should not be trapped inside one person's chat history. It should be packaged, described, permissioned and reusable.

And many services that are still locked behind dashboards will need an API. Not because APIs are new, but because an agent cannot reliably operate a human interface at scale.

I call this the API-fication of workflows.

The context-window problem

There is one obvious answer to all of this: let the AI agent remember every workflow.

But that creates a different problem.

As agents store more workflows, their context gets bigger. More context creates more possible paths, more stale information and more chances to miss the one instruction that matters. The issue is not only memory size. It is entropy.

A company would never put every process, customer record, permission and exception into one giant document and ask a new employee to figure it out each morning. Yet that is close to how people imagine an all-knowing agent should work.

Anthropic's own context-window guidance says that more context is not automatically better. Accuracy and recall can decline as tokens accumulate, which it calls context rot. For long-running agentic work, it recommends compaction rather than simply keeping everything forever.

The research points the same way. The Lost in the Middle study found that models often perform worse when the relevant information sits in the middle of a long context. Bigger context helps, but it does not automatically give us clean state, correct permissions, deterministic execution or proof that a workflow ran.

Four paths from here

I see four possible paths. These are my interpretation of where the market is going, not claims about the companies' official strategies.

1. Agents get built-in software blocks

In this path, the agent comes with its own task manager, workflow creator, database, communication tools and other basic blocks.

My shorthand is that Instinct is playing this path: give the agent native building blocks so it can hold state and execute work without asking the user to jump between products.

This reduces fragmentation. It can also make the agent more reliable because the blocks are designed around agent use from day one.

2. Agents compose API-first software

The second path is an ecosystem. Agents discover external services, read their agent-friendly documentation and compose them into a workflow.

My shorthand is that Muse is moving in this direction. Meta's official Muse Code documentation already describes reusable skills, external tools through MCP, hooks and automation, plus multi-agent workflows. I have not found evidence of a formal Muse workflow marketplace, so I treat the store as a market direction, not a claim about a current product.

This path could create thousands of narrow services. One may enrich a lead. Another may verify a document. Another may turn a workflow into an API. The agent assembles them.

3. Models absorb more of the workflow

The third path is that context becomes much larger, models get better at reasoning across it, and separate software matters less.

My shorthand is Claude for this bet: keep improving the model's ability to understand and manage long context until it can hold more of the workflow.

But even Anthropic treats context management and compaction as necessary. The realistic version of this future is not infinite memory with no structure. It is stronger reasoning over carefully managed context, backed by external state when the work needs it.

4. Services bring their own software and agent

The fourth path is different because the customer never assembles the system.

A provider brings the software, agent, workflow, quality checks and exception handling. The customer buys the result.

A company does not Download claims software; it buys a processed claim. It does not buy contract tools; it delivers a redlined contract. It does not buy recruiting automation; it delivers qualified candidates.

Bessemer calls these AI-native services: software used to help people do the work, but agents can now deliver the work itself. Sequoia describes services as the new software, arguing that the budget for work is much larger than the budget for tools. And a16z's pricing analysis says outcome pricing works when the result is observable and attributable: a resolved support conversation, a qualified lead, a booked meeting or a processed claim.

This fourth model may create the biggest companies because it sells into the work budget, not the software budget. But it also carries the most responsibility. The provider owns failures, edge cases and quality, not only the interface.

The likely answer is all four

I do not think one path wins everything.

Agent-native blocks will handle universal jobs: tasks, memory, messages, files, approvals and schedules. API-first services will provide specialist capabilities. Models will handle more reasoning and orchestration. Outcome companies will take ownership of entire jobs.

The interface may disappear. The infrastructure will not.

The companies that win this shift may not look like today's SaaS companies. They may sell an API, a workflow, a permission layer or a completed service. Their documentation may be read more often by agents than by humans.

So I would tighten the original provocation this way:

Human-operated SaaS will shrink. Agent-operated infrastructure, systems of record and outcome services will grow.

Software is not going away. It is changing operators.

References to Instinct, Muse and Claude describe Tej Pandya's interpretation of four market paths, not the companies' stated strategies.