What the Expediter Actually Runs

Opening Scene

An expediter running a kitchen’s pass isn’t magic — it’s a specific, learnable set of responsibilities: understanding exactly what the dining room actually ordered, breaking that into what each station needs to produce, tracking what’s been completed and what’s still outstanding, and checking each finished plate before it leaves the kitchen. Strip away the kitchen setting, and those same responsibilities describe exactly what a working AI agent architecture actually consists of.

In Plain English

A working agentic system consists of several core components: a goal (the actual objective, not just a single instruction), a planner that breaks the goal into concrete steps, tools the agent can invoke to take real actions, a memory of what’s happened so far (covered in more depth in Article 13), and a control loop that keeps checking whether the goal has genuinely been reached, taking further steps if it hasn’t. Understanding these as distinct, separately buildable components — rather than one opaque black box — is essential to building or debugging any real agentic system.

The Old Way

Before agentic architecture was well understood as a set of distinct components, early attempts often blurred these pieces together:

Early experiments with model autonomy sometimes combined planning, action, and evaluation into one undifferentiated prompt, making it hard to debug or improve any single piece.
There wasn’t yet a widely shared vocabulary or architectural pattern for describing what a genuinely working agentic system actually needed.
Building reliable multi-step autonomy required significant custom engineering, without established, reusable architectural patterns to draw on.

Recognizing these as distinct, separately addressable components represents genuine, accumulated practical experience from the field’s early experimentation.

What’s Changing (and Why AI Is the Reason)

Established architectural patterns — like the ReAct pattern covered in Article 15 — have emerged specifically to structure these components into a genuinely reliable, debuggable system.
Dedicated agent frameworks and libraries have matured to provide reusable implementations of planning, tool use, and memory, reducing how much custom engineering a new agentic application actually requires.
This series follows this component breakdown directly: tool use in Article 6, memory in Article 13, planning patterns in Article 15, giving each its own dedicated, focused treatment.

The Metaphor, Fully Extended

The Kitchen	Agentic Architecture Concept
Understanding exactly what the dining room actually ordered	Understanding the actual goal, not just a single instruction
Breaking that order into what each station needs to produce	A planner breaking the goal into concrete steps
The station’s actual equipment and ingredients	The tools an agent can invoke to take real action
Tracking what’s been completed and what’s still outstanding	An agent’s memory of progress so far
Checking each finished plate before it leaves the kitchen	A control loop verifying whether the goal has genuinely been reached

For Beginners: What to Actually Do

Practice identifying each of these five components — goal, planner, tools, memory, control loop — in any agentic system you encounter or build.
Learn to debug an agentic failure by first identifying which specific component is actually responsible, rather than treating the whole system as one opaque block.
Get comfortable with the idea that these components can often be built and tested somewhat independently before being assembled into a full system.

For Practitioners and Leaders: The Deeper Layer

Use this component breakdown as a standard architectural vocabulary across your team, making agentic system design and debugging considerably more systematic.
Evaluate agent frameworks specifically for how well they support each of these five components, rather than judging them as an undifferentiated whole.
Recognize that a genuinely reliable agentic system requires real, deliberate attention to each component, not just a capable underlying language model.

Quick Recap

A working agentic system consists of a goal, a planner, tools, memory, and a control loop.
Understanding these as distinct, separately addressable components is essential to building or debugging real agentic systems.
Established architectural patterns and dedicated frameworks now provide reusable implementations of these components.
This series covers each component in dedicated depth throughout the articles ahead.

Where This Fits in the Series

Article 2 covered the core components behind any working agent. Article 3 looks at how automated systems accomplished multi-step tasks before agentic architectures existed.