Agentic patterns: ReAct, plan and execute, reflection, multi-agent, routing
Beyond the basic loop, agent systems reuse a handful of patterns. Run each one and watch the messages move between planner, workers, critics, routers and people.
Interactive simulation. It needs JavaScript; the text below explains what it shows.
What you are looking at
Each pattern is drawn as its parts and the messages between them; Run plays a typical exchange and the log lists every message. The runs are illustrative scripts, chosen to show where each pattern spends its model calls.
Things to try
- ReAct: count the tool calls before the answer.
- Plan and execute: watch the planner re-plan after a failed step.
- Orchestrator and workers: three workers run in parallel and report back.
- Human in the loop: nothing irreversible happens before approval.
How it works in real systems
Real agent frameworks (LangGraph, the OpenAI Agents SDK, CrewAI, the Claude Agent SDK) implement these patterns as graphs, handoffs or sub-agents. Choosing the pattern is mostly a trade between cost, latency and how much control a person keeps.
This simulation replays a scripted run so that every step is the same each time; the structure is real, the timings and scores are typical values.
Code lab
The same idea in real code, step by step. Copy each block into a notebook or a file and run it in order.
Step 1 · Prompt chaining and routing
A small helper to call a chat model (any OpenAI-compatible endpoint works, including a local server):
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY
def ask(prompt, model="gpt-4o-mini"):
r = client.chat.completions.create(model=model, messages=[{"role": "user", "content": prompt}], temperature=0)
return r.choices[0].message.content
def chain(topic):
outline = ask(f"Write a 3-point outline about {topic}.")
return ask(f"Write a short paragraph for each point:\n{outline}")
def route(msg):
kind = ask(f"Classify as one word, billing, technical or other: {msg}").strip().lower()
return {"billing": lambda m: ask("You are a billing specialist. " + m), "technical": lambda m: ask("You are a support engineer. " + m)}.get(kind, ask)(msg)
Step 2 · Parallelisation and orchestrator–workers
from concurrent.futures import ThreadPoolExecutor
def vote(question, n=3): # sectioning or voting: the same call several times in parallel
with ThreadPoolExecutor() as ex: answers = list(ex.map(lambda _: ask(question), range(n)))
return ask(f"Pick the answer most of these agree on:\n{answers}")
def orchestrate(task):
plan = ask(f"Split this task into at most 4 independent subtasks, one per line:\n{task}").splitlines()
with ThreadPoolExecutor() as ex: parts = list(ex.map(ask, [p for p in plan if p.strip()]))
return ask(f"Combine these results into one answer to '{task}':\n" + "\n---\n".join(parts))
Step 3 · Evaluator–optimiser
def refine(task, rounds=3):
draft = ask(task)
for _ in range(rounds):
verdict = ask(f"Critique this answer to '{task}'. If it is good, reply only PASS.\n\n{draft}")
if verdict.strip().startswith("PASS"): break
draft = ask(f"Improve the answer using this critique.\nTask: {task}\nAnswer: {draft}\nCritique: {verdict}")
return draft
Use the simplest pattern that works; add autonomy only when fixed steps cannot do the job.