An agent architecture pattern is the fixed control structure around an LLM that decides in what order it thinks, calls tools, checks its results, and stops. You already know the basic loop: the model picks a tool call, the harness runs it, the result goes back into the messages, and the loop repeats. The pattern is what you build on top of that loop, and it is usually the first technical question in an agent round: "How would you structure this agent's reasoning loop, and why that pattern over the others?"

• ReAct lets the model pick one action at a time after seeing each result.
• Plan-and-execute writes the whole plan first, runs it, and replans only when a trigger fires.
• A reflection loop adds a check that sends work back for revision. Each trades flexibility against steps, latency, and cost.

Our example is an electronics retailer's support agent, about 40k conversations a day, with two task shapes: an open investigation ("my order says delivered but I never got it"), where each step depends on the last result, and a known return-and-refund workflow that moves money.

The choice follows the shape. Use ReAct when the path cannot be written in advance, plan-and-execute when the task is long and known and you want a reviewable plan, and reflection only when an external signal such as a validator or a test run can catch a wrong answer. When the steps are fixed, skip the agent and hard-code the chain of calls. When one lookup answers the question, use single-shot retrieval instead of a search loop. When there is no external signal, spend the extra call on a better first attempt.

A mid-level answer names ReAct and plan-and-execute and says when each fits. A senior answer prices them per step, names the replanning triggers and the stop rules, and knows what reasoning models change. This tutorial covers loop control for a single agent. Tools, context, multiple agents, and failure recovery each have their own section in this course.