Coding agents have revolutionized how software is created. The new default assumption in technology is that when software becomes easier to create, we will get many more applications. You can already see the effect in app stores and on GitHub.
Agentic coding makes it much cheaper to produce internal tools, prototypes, dashboards, and simple websites. Many things that were previously too small, too specific, or too temporary to justify engineering time can now be built by non-technical users. And that’s great.
Do we really need all that software?
But I suspect the framing “easier coding = more apps” misses a much more interesting change.
The real question will not be: how much more traditional software can we create now? It will be: how much traditional software do we still need?
18 months ago I wrote about the future of the software industry. One possible future outcome I explored was the “obsolescence of traditional software”. What was largely speculation back then has now come into increasingly sharp focus.
General-purpose agent platforms like OpenAI’s Codex and Anthrophic’s Claude Cowork are being adopted very rapidly. People aren’t using agent harnesses just for coding, but increasingly for any kind of knowledge work. And the agents they create aren’t traditional software, they are something amorphous, more flexible and more malleable.
There is an older precedent for this. It is the spreadsheet.
Spreadsheets are probably the most successful form of user-created software in history. Most people do not think of them that way, because a spreadsheet does not look like an application. It has no polished interface, no fixed workflow, no engineering process behind it. But in practice, spreadsheets implement an enormous amount of business logic, including many mission-critical workflows. They track sales pipelines, manage inventory, run budgets, plan events, manage hiring processes, report KPIs.
The tech industry tends to forget it, but normal people actually don’t enjoy using and paying for software products. They just want to get work done. Often a structured app is the best way to do that, but quite frequently the flexibility of a spreadsheet is the right (and much cheaper) solution.
Spreadsheets gave users a few powerful primitives: cells, formulas, tables, lookups, charts and integrations. With those building blocks, people could solve a problem without having to turn it into a formal application.
The four capability pillars of AI agents
AI agents may be the same kind of thing, but for a much broader and deeper class of work. And that means that they will frequently be a better solution for a given problem than formal software.
A contemporary AI agent is not just a chat interface. Over the past few months, the architecture of a general-purpose AI agent has crystallized around the underlying foundation models with four important pillars on top:
1. Tool and computer access: The agent can use software the way a person does. It can open files, search, browse, call APIs, edit documents, query databases, send messages, and operate across many systems. In principle, anything that can be done on a computer can become part of the agent’s capabilities.
2. Persistent memory. The agent can remember facts, instructions, decisions and past outputs. In companies, it may also have access to shared context: document stores, CRM records, chat history, meeting notes, code repositories, and so on. This means the agent does not have to start from scratch every time. It can build on what is already there, and it leaves its own work traces.
3. Skills. The agent can use pre-defined procedures that package more than just a prompt. A useful skill may include workflow steps, data connections, acceptance criteria, formatting rules, and escalation rules. This is important because most valuable work is not a single instruction. It is a procedure with judgment points. Skills make agents less like free-form improvisers and more like operators who have been trained on a specific task.
4. Autonomy. The agent can act without being manually steered through every step. It can run on a schedule, react to an incoming event, monitor a condition, or carry a task through until it needs help from a human. The user is delegating work to a system that uses apps on their behalf.
None of these ingredients are entirely new. Traditional software had integrations, settings, automation. It had plugins, macros and scheduled jobs. RPA tools could operate user interfaces. Enterprise applications have always embedded deep business logic.
But the combination is new in depth and generality. Tool access gives the agent rich capabilities in the digital realm. Memory gives it continuity. Skills give it repeatability. Autonomy gives it independence. Together, these create something that is a clear departure from traditional software categories. It is at the same time more flexible and more powerful than conventional software.
A new playing field for computation
Many tasks are are still best solved in traditional apps. CRMs, payroll software, accounting, core banking or medical record management benefit from the characteristics of conventional applications. They need high structure, strong permissions, repeatable interfaces, and clear audit trails.
But a huge amount of work sits outside that zone: Anything that deals with unstructured text, information sources that are spread over several systems and have to be pulled together, the combination of internal and external information, and most importantly workflows that are somewhat unpredictable and need just-in-time judgement and adaptation. These tasks have some structure, but they are too varied and fluid to fit into a normal application.
Historically, these tasks lived in the manually maintained gaps between applications. People copied information from one system into another. They maintained spreadsheets, created templates and used checklists. They relied on memory and asked colleagues. They improvised.
Agents are so revolutionary because they can operate in this complex, foggy space.
They do not require the entire workflow to be formalized upfront. They can work with partial structure and high-level goals, navigate ambiguity and can ask for clarification when needed. Agents can use a spreadsheet, a CRM, an email inbox, a web browser, and a document repository in the same task. They can produce an output, check it, revise it, and remember what changed for next time.
Solving problems instead of producing code
This also suggests a different way to think about the future of software. The naive view is that AI coding expands the long tail of custom applications. Every company can make more internal tools. Every team creates its own micro-apps. Every user vibe-codes their own solution. Some of that will happen. But today’s cool agent-coded application is tomorrow’s maintenance nightmare, especially for rapidly moving requirements.
That’s why I believe that agentic workflows will absorb many things that would otherwise have become applications.
For example, instead of building a fixed analytics dashboard, you may ask an agent to investigate metrics and produce the right view for the current business question. Next month the question might be different, and the agent can just run an adapted process, building on its experience from last time.
Instead of turning every workflow into a SaaS product, you may let agents operate across existing systems with enough memory, permissions, and procedural skills to get the job done.
The boundary will not be whether something is “important”. Spreadsheets already showed that important work often happens in informal software. The boundary will be risk, reliability and regulations.
When a process needs strict consistency, formal governance, high scalability, or a clean and highly predictable customer-facing experience, traditional applications still win. There is no reason to replace a well-designed transactional system with an agent wandering through a UI. That would be a worse architecture.
But when a process is variable, judgment-heavy, context-dependent, or changes faster than an application can be designed, agentic software will be the better fit.
Doing stuff that previously wasn’t possible or too expensive
This could make agents the equivalent of spreadsheets for the AI era, just many times more powerful. A computer turns from something that you use into something that does work for you and in the process helps you do your work better and more efficiently.
This includes many things that are useful, but previously would have been much too complicated or expensive to solve. Heavy users of agents are already experiencing the benefits.
An example from my own work as a VC: I have an agent that reads my calendar, figures out which new startups I’m scheduled to talk to, then pulls together every piece of information about these startups that it can get, and then writes a detailed preparation report with a market overview, competitive differentiation drill-down, and SWOT analysis. As a result, I’m much better prepared when I talk to a startup team for the first time, and the following steps in the process are expedited. It would be prohibitively expensive to do these things with human labor. But the agent both saves time and improves quality, at negligible cost.
I did not have to write any code to set this up, but it wasn’t an immediate success. I needed a few weeks of iterations to get everything right. It was a bit like training a junior employee while at the same time improving the underlying process, and now the agent executes flawlessly, consistently and fully autonomously.
This is a deep shift. Coding agents let us create more formalized software. But agentic patterns may reduce the need to create so much traditional software in the first place. They allow us to solve computation problems in a dynamic, lightweight, yet very powerful way.
What this means for the software industry
The obvious conclusion would be that this is bad news for software companies. I think that is too simple.
Traditional software will not disappear, but it will have to focus. In many areas it may become even more valuable. Systems of record, transactional infrastructure, compliance-heavy workflows, and core enterprise processes still need structure, security and auditability. These are not good places for improvisation and rapid iteration. If anything, agents make the need for trustworthy underlying systems more obvious.
But the role of many software products will change. A large part of SaaS was built around owning the user interface in tight combination with the underlying data model for a particular set of workflows. In an agentic world, that pattern is far less relevant. The agent may become the primary interface, while the SaaS product becomes a reliable data source or business logic repository behind the scenes. Software is increasingly moving from screens to capabilities, from apps to skills, from fixed workflows to adaptive procedures.
That is the biggest implication for software founders and investors: the best opportunities will not necessarily look like “software companies” in the familiar sense. They could look like agents, services, infrastructure, or strange full-stack hybrids.
And there might be a new class of problem solver that thrives in this environment. The industry currently talks a lot about “AI-first builders”: People who use AI to build software products in the traditional sense. There are hackathons with demo days were these products are being shown off. And that’s great. There is a lot of room for a new class of applications that look and feel like products.
But it seems like we’re starting to see a new kind of entrepreneur and startup, one that doesn’t think primarily in productization terms, but focuses on solving customer problems at scale with the help of agents. The currently so popular “forward-deployed engineer” might be a first blueprint for this. “Service as software” is another popular buzzword. But I think these are just first prototypes that show a glimpse of the future.
It’s perfectly normal in technology waves that the dominant pattern of the future emerges slowly and iteratively. As I have written before, the now so familiar SaaS playbook needed well over a decade to be defined.
AI in many ways is a much more profound shift, so we shouldn’t expect to have clarity so early in the process. But it seems like agents are now at a stage where we can at least see them as a clear milestone pattern that points to the future.
