What is the history of AI agents?

AI agents grew out of seven stages of the software loop: the procedural program, the Windows message loop, the game loop, the Unix and Linux event loop, the Kubernetes control loop, the agent loop and the durable agent loop. Each stage moved control of the loop to a new owner and added one capability, ending with a loop whose execution survives the process running it.

What is agentic orchestration?

Agentic orchestration is the coordination of AI agents, tools and model calls toward a goal, where a language model chooses the next step at runtime instead of following a predefined flowchart. Because the path is not known in advance, agentic orchestration depends on durable execution to recover correctly from failures.

What is agentic AI architecture?

Agentic AI architecture is the structure of a system in which a language model sits inside a control loop: it observes context, chooses an action, calls tools, updates state and repeats until a goal is met. Production agentic architectures separate the model's decisions from control flow, state and failure recovery, which is where durable execution fits.

Is an AI agent just a control loop?

Structurally, yes - an agent is a goal-oriented control loop, and the Kubernetes analogy is the closest one available. Both are driven by a desired outcome and keep acting until reality matches it. The difference is the decision step: a Kubernetes controller follows deterministic reconciliation logic written by a developer, while an agent may let a language model choose the next action, which makes the execution path impossible to know in advance.

Why is checkpointing not durable execution?

Checkpointing preserves state, but it does not provide failure detection, and it does not guarantee correct recovery around external side effects or ambiguous failure boundaries. If a process crashes after a payment API accepted a refund but before the response was recorded, a checkpoint tells you what the state was - not whether the refund happened. Frameworks including LangGraph, Strands, Microsoft Agent Framework, Google ADK and CrewAI give you checkpointing without failure detection.

What are the stages of the software loop?

Seven, in this series: the procedural program (1950s-1970s), the Windows message loop (1980s-1990s), the game loop (1990s), the Unix and Linux event loop (1980s-2000s), the Kubernetes control loop (2010s-2020s), the agent loop (2020s) and the durable agent loop (2020s onward). Each added one capability the stage before it lacked: reactive, then stateful, then asynchronous, then goal-oriented, then probabilistic, then durable. The decades overlap, which is why these are stages rather than eras - the ordering is architectural, not chronological.

What is workflow orchestration, and how is durable execution different?

Workflow orchestration is the coordination of steps in a multi-step process - which runs, in what order, on what condition. Durable execution is a different guarantee: it is about guaranteeing that a logical execution survives infrastructure failure and continues exactly once from where it stopped. Many orchestrators are built on durable execution, but a workflow engine that assumes a known-in-advance path cannot express an agent whose path is chosen at runtime by a model - which is what makes agentic durable execution a distinct requirement.

The Evolution of AI Agents: Seven Stages of the Software Loop

From the 1950s to now: how software loops evolved into AI agents. Each stage added one capability the one before it lacked, and only the last one survives the process running it.

By Mark Fussell, co-founder and CPO of Diagrid.

Published September 3, 2026 · Updated September 30, 2026

AI agents are the latest stage in a 70-year evolution of the software loop. Each stage moved control of the loop somewhere new: to the operating system, the kernel, the controller, and now the language model. The agent loop made the next step probabilistic. The final stage, agentic durable execution, makes the loop survive the process running it.

These are stages, not eras. The decades overlap: Unix event loops were maturing while Windows GUIs shipped, and games stayed stateful throughout. The sequence is architectural, not chronological — each stage adds a capability the one before it lacked.

What each stage added

reactive
stateful
asynchronous
goal-oriented
probabilistic
durable

The history of AI agents in seven stages

(Go to chapters)

STAGE 1 · 1950s–1970s
The procedural program
The developer owns the control flow
A deterministic, readable order of operations
Could not react to anything it did not schedule itself
Read chapter 1
STAGE 2 · 1980s–1990s
The Windows message loop
The operating system owns the control flow
Long-lived, reactive processes
Could not advance without an incoming message
Read chapter 2
STAGE 3 · 1990s
The game loop
The application owns the control flow, continuously
Continuously evolving state, carried forward
Could not survive the process — the world lived in memory
Read chapter 3
STAGE 4 · 1980s–2000s
The Unix & Linux event loop
The kernel owns readiness — select, poll, epoll
Efficient waiting across many sources of work
Could not wait longer than the process lived
Read chapter 4
STAGE 5 · 2010s–2020s
The Kubernetes control loop
The controller owns it, driven by declared intent
Continuous reconciliation toward an outcome
Could not choose a novel next action — the logic is written by a developer
Read chapter 5
STAGE 6 · 2020s
The agent loop
The model owns it, one decision at a time
A dynamic, probabilistic next action
Could not survive the process running it
Read chapter 6
STAGE 7 · 2020s onward
Agentic durable execution
The durable agent loop
A durable runtime owns it, independent of any process
Logical execution that outlives process, container and machine
The question changes: not how do I keep this loop alive, but how does this task continue correctly wherever it runs next
Read chapter 7

Agentic orchestration vs. agentic durable execution

Agentic orchestration is the coordination of AI agents, tools and model calls toward a goal: which agent acts next, which tool it calls, and what happens with the result. Traditional workflow orchestration assumes the path is known in advance and drawn as a flowchart. Agentic orchestration cannot make that assumption, because a model chooses the next step at runtime.

That difference changes what the runtime has to guarantee. When the path emerges as the agent runs, you cannot recover from a crash by rerunning a known sequence. You need to know which steps already ran, which side effects already happened, and where to resume. That is the guarantee agentic durable execution provides, and it is why Stage 7 exists.

In practice, agentic orchestration decides what happens next and agentic durable execution guarantees it happens exactly once, even across process, container and machine failures. Production agents need both. See how Diagrid approaches AI agent orchestration.

Definitions

Software loop: A program structure that keeps running, repeatedly checking for new input or new state and deciding what to do next, instead of executing a fixed sequence once and exiting.
Message loop (message pump): The `while (GetMessage(...))` cycle at the heart of a classic Windows GUI application. It keeps the application alive while the operating system delivers mouse clicks, key presses, resize events, repaint requests, timers and shutdown notifications, and dispatches each into a handler.
Game loop: A continuous cycle - process input, update the world, render - that advances on every iteration whether or not the player acts, and carries a model of the world forward from one iteration to the next.
Event loop: A cycle in which a process waits for the runtime to report which sources of work are ready, handles those, and returns to waiting. Unix provided `select` then `poll`; Linux added `epoll` in the early 2000s.
Control loop (reconciliation loop): A loop that continuously compares desired state with actual state and acts to close the gap. It has no final step: it is outcome-oriented rather than path-oriented.
Agent loop: The cycle at the core of most AI agent frameworks: observe the current context, reason about what to do next, choose an action, execute it, observe the result, update the context, repeat until the goal is judged complete. It is the layer of an AI agent architecture where control actually lives, and it is what people are asking about when they ask how do AI agents work.
Stateful AI agents: Agents whose behaviour depends on context accumulated across iterations rather than on a single prompt. AI agent state management is the operational half of that: deciding where the accumulated context lives, and whether it survives the process holding it.
Durable execution: An execution model in which the logical progress of a task is persisted outside the process running it, so the task can be suspended, recovered and continued - correctly, without repeating completed side effects - after a crash, restart or redeployment. A durable execution engine is the runtime that provides it, and the AI agent execution guarantees it offers - deterministic replay, exactly-once handling of side effects, crash recovery that resumes rather than restarts - are what distinguish it from persistence alone.
Agentic durable execution: Durable execution applied to the dynamic, probabilistic execution model of AI agents, where the path through the work emerges as the agent reasons, acts, waits, retries and changes direction.
Checkpointing: Periodically persisting state so it can be reloaded. Necessary but not sufficient: checkpointing alone does not provide failure detection, and does not guarantee correct recovery around external side effects or ambiguous failure boundaries.