Most of the conversation around AI agents gets the direction wrong. People talk about agents replacing software when the more interesting question is what software they depend on to work at all.
The computing stack has always worked the same way. Each layer depends on the one below it. Each new layer makes the one above it possible. And historically, adding a new layer has increased demand for existing layers — not reduced it.
Agents follow that same pattern. But seeing it clearly requires being specific about what each layer actually does.
The Stack
Each layer depends on the one below it. Demand flows down, not away.
Physical substrate. Circuits, chips, storage, networks. The layer everything else is built on.
Makes hardware programmable and reliable. Without it, hardware is inert. It defines what the layer above can do.
The stable, durable layer that agents depend on. APIs, data structures, permissions, control systems, business logic. Software is doing for agents what firmware did for software.
↑ Software is the new firmware
Use goals, context, and software tools to act across systems. They do not replace the layer below — they are only possible because of it.
Software Is the New Firmware
Firmware's job is to make hardware programmable. Nobody gets excited about firmware — it's not the interesting part of the system. But without it, hardware is just circuits. Firmware defines what the layer above it can reach, and it has to be right before anything else works.
Software is moving into that same role relative to agents. An agent can only act through things that already exist — APIs, tools, defined interfaces, data it can query. It can't invent infrastructure mid-task. It either finds a usable surface or it fails. The quality and structure of the software layer sets the ceiling for what any agent on top of it can actually accomplish.
Software is to agents what firmware is to software: the stable substrate everything depends on.
When firmware got better — more capable, more standardized — it didn't reduce demand for software. It raised the floor and expanded what software could do. More firmware capability meant more software was worth writing.
The same thing is happening now. Better-structured software — cleaner APIs, real permission boundaries, observable state — doesn't compete with agents. It makes agents more capable, which makes more agent use cases viable, which creates more demand for the software that enables them.
What Agents Create: Ephemeralware
When agents act, they often generate code. Scripts, adapters, transformations, workflow automation, one-off tools — small pieces of software written for a task and discarded when it is done. This is ephemeralware: software created by agents, for a moment, to accomplish something specific.
Concept
Ephemeralware
Software created by agents to accomplish a task. Not designed for permanence — it may exist for a session, a workflow step, or a single operation, then be discarded, replaced, or regenerated. Distinct from traditional software in that it is an output of agentic work, not a human-authored artifact.
Ephemeralware actually increases demand for foundational software, not the other way around. The temporary code an agent writes still has to run somewhere. It calls APIs, hits databases, triggers workflows, writes logs. The infrastructure underneath has to exist and actually work — otherwise the ephemeral stuff falls apart too.
Consider what ephemeralware depends on:
- APIs that are callable, versioned, and documented
- Permission systems that define what an agent is allowed to do
- Data that is structured, consistent, and queryable
- Audit trails and logging so ephemeral actions can be reviewed
- Control systems that let humans observe, intervene, and stop
Ephemeralware isn't a sign that software is becoming less necessary. It's the opposite — it means software needs to be better than before. More structured, more observable, more predictable. Agents writing and discarding code constantly makes the infrastructure it runs on more critical, not less.
Why Demand for Software Goes Up
Two things push demand in the same direction at once.
1. Efficiency unlocks more demand
When agents can generate and execute software faster, the threshold for building drops. More software gets built — more tools, more automations, more integrations. Each of these creates new surface area that itself requires more infrastructure.
2. Agents require control systems
Every agent that can act autonomously requires software to govern that autonomy — approval flows, rollback mechanisms, permission scopes, observability, escalation paths. This is an entirely new category of software demand that did not exist before agents existed.
The argument in one sentence
Agents are not the end of software.
They are the reason software gets another layer of demand.
The Implication
The businesses that get the most out of agentic AI won't necessarily be the ones that rush to adopt it. They'll be the ones whose software is already structured well enough for an agent to do something useful with — clean APIs, consistent data, systems that actually expose what they do.
Bad software gets worse when agents run on top of it. A human can navigate a messy system through intuition — clicking around, re-reading, making reasonable guesses. An agent can't do that. It either finds a usable interface or it doesn't.
AI doesn't make software less valuable. It makes bad software easier to produce and good software more important.
The interesting work ahead isn't about whether agents replace software. It's figuring out what software looks like when agents are using it as much as humans are.
A note on RNDTND's work
This framing shapes how I approach every project. Building software that's clean enough for agents to use — structured data, callable actions, observable state — isn't a future concern. It's good engineering practice now, and it's what makes businesses ready for the transition that's already underway.
