Software is about to start running itself. The question is where.
A new era of the cloud is beginning. We are still early to see it, because it is starting in the part of software no one brags about: the place where work actually runs.
Marc Andreessen once wrote that software is eating the world. That was the thesis of the first cloud era: software would move into every industry, and the cloud would give it a place to live.
The next era is different. It isn’t about the software we write and trust. It is about the software we don’t – and there is about to be an unimaginable amount of it.
Here is what changed. For the entire history of computing, a person sat at the center of every loop. A human wrote the code, ran it, read the logs, and decided what to do next. Now the person is stepping out of the loop. AI agents write code, run it, read the result, fix it, verify it, and try again – thousands of times, in parallel, around the clock.
That changes where advantage comes from. When humans were the constraint, we optimized infrastructure around human speed. When agents become the constraint, the winning layer becomes execution itself: how quickly you can spin environments up and down, how intelligently you cache repeated work, how easily you distribute builds and tests across machines, and how efficiently you run the endless cycle of reasoning, testing, fixing, verification, and evals. The thing that used to be scarce – the human – is no longer the limit. Execution is.
The old world breaks when agents start doing real work. Some of that work is unsafe. Agents explore, create half-broken branches, run evals, reproduce failures, and generate large amounts of code that is mostly wrong before it is right. It is untrusted by default, often runs for hours, and no one is watching it. A laptop is too small. Production is too dangerous.
Some of it is simply volume. One human might try a few approaches. An agent can try a thousand. That means a thousand builds, test runs, environments, logs, and failures. CI was built for humans making commits. Agents turn it into a workload that never stops.
And it is not one workload:
That last agent is the clearest example. To do its job, it has to move through production, dev, CI, evals, and production again. Today those places are split across different tools, trust models, cost models, and policies. That fragmentation was tolerable when humans did the stitching. At agent scale, it becomes fatal.
Underneath all of this is economics. The AI era does not just need more compute. It needs more efficient execution. If every agent action triggers a full build, full test suite, and full environment setup, the economics break before the technology does. The companies that win will not simply run more software. They will run it more efficiently. Efficient operation – efficient execution – will be the difference between those that break away and those that get left behind.
Step back, and the requirements point to a gap in the stack.
We talk about servers, virtual machines, containers, serverless, functions, and Lambda as if they are a menu of choices. But they were mostly built for the same world: trusted code, moving at human speed.
A server assumes the work is trusted and long-running. A function assumes it is trusted and short-lived. A container makes the software portable, but it does not solve the deeper question of where untrusted, autonomous work should run. Each primitive solved an important part of the old problem. None of them was designed for the new one.
Agents create a workload we did not really have before: long-running, stateful, untrusted, unattended, and massively parallel. It does not fit neatly into a function, a server, or a container. It needs:
This is why the old layers are starting to converge. Sandboxing, caching, scheduling, persistence, policy, reproducibility, scaling, and optimization were historically handled by separate products – but in the AI software era they collapse into one problem: execution.
Docker proved how powerful a new primitive can be: it made software portable, and an entire platform layer formed around it, from CI/CD to Kubernetes to the modern cloud-native stack. Execution is now reaching a similar inflection point. As software factories become more autonomous, execution itself becomes infrastructure. Just as observability became its own layer when distributed systems grew too complex to manage manually, execution optimization is becoming a distinct layer in the AI software stack: the Execution Fabric, the Execution Layer, the Execution Control Plane for the next era of software.
Two things flip when agents enter the loop.
Volume. In the old world, execution was gated by human intent: a developer wrote code, opened a branch, triggered CI, reviewed the result, and moved it forward. That model changes when one prompt can create a thousand generated branches. You cannot treat every attempt like a human-authored change waiting for manual review. The bottleneck moves from writing code to executing, validating, comparing, and promoting the right work.
Location. Serverless tried to make location disappear: describe the work, not the machine. That was the right promise, but it was built around short, stateless, trusted work. Agent work is often the opposite – long-running, stateful, iterative, and autonomous. It needs real execution environments with filesystems, caches, toolchains, artifacts, policies, and reproducible state.
None of these challenges appeared overnight. They have existed for years in software engineering, only at a much smaller scale. For more than two decades, Incredibuild has worked with many of the world’s largest engineering organizations on the mechanics of software execution – how to execute work faster, distribute it more efficiently, avoid repeating it, and make better use of compute. AI doesn’t create those problems. It magnifies them by orders of magnitude.
The cloud is not going away. What is missing is the execution layer above it – the layer that makes autonomous software safe, fast, governed, and economically viable.
It starts with a safe place to run. With Islo, each environment is a persistent, hardware-isolated sandbox – its own microVM. State survives, so an agent picks up exactly where it left off. Agents never hold your credentials; access is enforced at the boundary. You decide what each sandbox can reach, where it runs, and what it may do, and the whole environment is described in a file you can version – reproducible by anyone, or anything, on demand.
Then there is the volume, and the first place the flood lands is CI. Agents open pull requests, kick off builds, and run test suites, over and over – and today’s runner model has no slack in it. Triggered by tireless machines, the queue never drains. This is why CI runners are not a footnote in the new era. They are the front line. So we built our own Runners that offload CI load and accelerate pipelines without changing your existing workflows.
Underneath both sits the engine at the heart of Incredibuild. Exponentially more code written means exponentially more pipeline execution, using tools and infrastructure that are already failing to keep up. For years, our engineering team has been attacking exactly this: Incredibuild caches what should never run twice, seamlessly distributes execution tasks across enormous grids of compute, and accelerates code from commit to deploy.
Incredibuild has been building towards this exact moment in the history of software, without even knowing it. What started as a product to unblock engineers waiting for builds – reducing build times by an order of magnitude – is becoming a platform that will unblock agents, swarms of agents, and whole systems of agents and humans, from the time they spend waiting for compute environments, tests, compilations, builds, evals, CI runs, and anything else that stands between generating code and shipping code.
Incredibuild is the execution engine that will accelerate the production lines of your AI software factory.
The first cloud gave software a place to live. The next cloud gives software a place to work.
As software begins to write, test, and operate itself, execution becomes the critical infrastructure layer underneath it all. That is the shift now underway. We believe the companies that control execution will define the next era of cloud computing.
Shimon Hason - CEO, Incredibuild
Incredibuild empowers your teams to be productive and focus on innovating.
