“No man ever steps in the same river twice, for it’s not the same river and he’s not the same man.” — Heraclitus
I have been thinking a lot recently about permanence. In our industry, we have spent the better part of fifty years worshipping the static. We build “architectures” as if they were cathedrals—imposing, rigid, and designed to withstand the ages. We draft blueprints, we define schemas, and we treat our code artifacts like sacred texts that must be preserved, versioned, and migrated.
But if you have been paying attention to the signals coming out of the agentic AI space—and if you are reading this, I suspect you have—you know that the era of the cathedral is ending. We are entering the era of the river. We are moving from solid state software to Liquid Software.
The Illusion of the Blueprint
In traditional systems, architecture is a negotiation that happens before construction. We gather in conference rooms, draw boxes and arrows on whiteboards, and decide that this service will talk to that database. It is a blueprint approach, borrowing heavily from civil engineering.
But what happens when the architect is not a human, but an agent? And what happens when the “construction” doesn’t take months, but milliseconds?
I recently imagined a concept I call Just In Time (JIT) Architecture, and it strikes me as the inevitable convergence point of the trends we are seeing in serverless computing and infrastructure-as-code. The core idea is disarmingly simple yet profound: stop building applications. Start building capabilities.
In this new world, an application is not a compiled binary sitting on a server. It is a “seed” prompt combined with a permissions boundary. It is a ghostly potentiality that only crystallizes into reality when a user expresses an intent.
The Agentic Negotiation
Imagine a user who needs to track local news sentiment. In the old world, we would buy a SaaS product or build a scraper. In the liquid world, the user simply states the intent. An orchestrator agent parses this request and performs a real-time ephemeral composition.
It looks at the available tools—a web scraper here, a sentiment analysis model there, a Slack connector over yonder—and it stitches them together. It negotiates the architecture in real-time. It spins up the necessary serverless functions, pipes the data through a temporary Redis instance, delivers the insight, and then—poof. It dissolves.
The architecture exists only as long as the intent exists. It is software that negotiates its own reality.
The Shadow Side: Governance as Physics
Of course, my regular readers know I cannot discuss a technological leap without looking at its shadow. The danger of liquid software is not that it won’t work, but that it will work too well, too fast, and with too much autonomy.
If we allow agents to generate architecture dynamically, we introduce massive “blast radius” risks. If an agent decides that the most efficient way to solve your problem is to spin up a $10,000/hour compute cluster, your bank account will be drained before you finish your coffee.
This is where the concept of the Governance Mesh becomes critical. We cannot rely on polite suggestions to our AI agents. We need policy-as-code that acts like physics. These constraints such as:
Max cost = $5
Data residency = EU-only
must be immutable laws that the AI cannot override, no matter how clever it thinks it is.
We also need to rethink identity. We cannot have hardcoded API keys lying around in a world where apps are born and die in minutes. We need ephemeral credential vending, a dynamic trust model where access is leased, not owned.
The Persistence Paradox
There is one stubborn rock in this river of liquid software: State. Code is cheap and disposable; state is heavy and precious. If our liquid architect decides to swap a document store for a relational database on a Tuesday, what happens to the data we stored on Monday?
This is the “Persistence Paradox.” To solve it, we need a Universal Abstract Storage layer, where the logical view of the data is completely decoupled from the physical storage. It requires a level of semantic contract negotiation that we rarely see today, where a “Data Ingestion Agent” and a “Database Agent” can agree on a schema on the fly without a human writing a migration script.
From Products to Factories
Buckminster Fuller often spoke of “ephemeralization”—doing more and more with less and less until eventually, you can do everything with nothing. JIT Architecture is the software equivalent of that.
We are shifting from building Software as a Product to delivering Software as a Capability. Our job as engineers is no longer to assemble the supply chain; it is to build the factory—the highly constrained, semantic environment where AI can assemble the supply chain for us.
It is a terrifying and exhilarating shift. The river is rising. We can either try to build higher walls, or we can learn to swim.
