The Evolution of Agentic Execution

What each stage added

• reactive→
• stateful→
• asynchronous→
• goal-oriented→
• probabilistic→
• durable

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.

Frequently asked questions

• 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.

  See also: What is the difference between checkpointing and durable execution? · Is checkpointing enough for production AI agents?

• 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.

All seven chapters

• Chapter 1Before the Loop: When Programs Were Mostly LinearA deterministic, readable order of operations
• Chapter 2The Windows Message Loop: How Applications Became ReactiveLong-lived, reactive processes
• Chapter 3The Game Loop: When State Started Carrying ForwardContinuously evolving state, carried forward
• Chapter 4The Linux Event Loop: Making the Loop About Waiting for WorkEfficient waiting across many sources of work
• Chapter 5The Kubernetes Control Loop Changed the QuestionContinuous reconciliation toward an outcome
• Chapter 6The Emergence of the Agent LoopA dynamic, probabilistic next action
• Chapter 7The Loop Escapes the Process: Agentic Durable ExecutionLogical execution that outlives process, container and machine