2026-08-16
Choosing the right agent loop pattern: a field guide to LoopCraft's 11 patterns (2026-08-16)
ReAct, Plan-Execute, Routing, Evaluator-Optimizer, Multi-Agent — the pattern catalog keeps growing, and picking the wrong one costs you reliability, latency, and tokens. This guide maps each of LoopCraft's 11 patterns to the job it actually does best, and gives a decision path for choosing under uncertainty.
← Back to BlogThe first decision in any agent project is not which model to use — it is which loop pattern to build around. The pattern fixes the shape of the control flow: how the agent plans, acts, observes, and decides whether to iterate. Choose well, and debugging is straightforward and costs stay predictable. Choose poorly, and you spend weeks fighting symptoms that a different shape of loop would never have produced. After reviewing dozens of loops built in LoopCraft, we can map the eleven patterns in our library to the jobs they do best.
ReAct — think, act, observe, repeat — is the pattern for exploratory work. Use it when you cannot know the number of steps in advance: open-ended research, tool-assisted question answering, debugging tasks where every observation changes the next move. Its weakness is exactly its strength: because the model decides every step, runs are unbounded by default. Always pair ReAct with a maximum iteration count and a cost budget, and treat the trace view as your primary debugging surface.
Plan-Execute is the pattern for tasks whose shape is knowable in advance. The planner produces an explicit step list, the executor runs it, and the two are separated so you can review the plan before spending tokens on it. ReWOO pushes this further by batching tool calls so the model is not re-invoked between every step, which cuts latency and cost on well-understood pipelines. LLM Compiler sits in the same family but adds parallel execution of independent steps — the right choice when the plan contains branches that do not depend on each other, such as fetching five data sources at once.
Routing and Prompt Chaining are the patterns for workflows you could already draw on a whiteboard. If you can enumerate the steps, do not pay for the model to rediscover them at runtime: route each item into a specialized sub-loop with a deterministic condition, or chain prompts so the output of one stage becomes the input of the next. Chaining also gives you natural quality gates — validate the intermediate result before it propagates. These two patterns are the cheapest, the fastest, and the easiest to review, and they deserve to be your default.
The parallel family — Parallel Sectioning and Parallel Voting — trades tokens for breadth. Sectioning splits one large input, such as a long document, into independent pieces that are processed simultaneously and merged at the end. Voting runs the same task several times and takes the majority answer, which is worth the extra cost wherever a single wrong call is expensive: classification, moderation, safety checks. Orchestrator-Workers is the dynamic cousin: an orchestrator decomposes the task on the fly and spawns workers as needed, which fits problems whose sub-task list cannot be known before the run starts.
Evaluator-Optimizer is the pattern for work where quality is subjective and iteration pays: writing, code generation, design refinement. A generator produces output, an evaluator scores it against explicit criteria, and the loop repeats until the bar is met or the round cap is hit. Set both caps. An evaluator loop without a round limit is a budget incident waiting to happen, and criteria that live in prose rather than in a checklist produce evaluators that change their mind between rounds.
Multi-Agent is the pattern to reach for last, not first. It earns its overhead only when responsibilities genuinely separate — for example, a researcher that never writes code and a coder that never browses — because every message between agents is a point where context can be lost. If one agent with a good tool set can do the job, one agent is the design.
The decision path we recommend has three questions. First: can you enumerate the steps in advance? If yes, start with Routing or Prompt Chaining. Second: does the agent need to observe the environment between steps? If yes, use ReAct, or Plan-Execute when the overall shape is predictable. Third: does the output need iterative critique to reach quality? If yes, wrap a generator in Evaluator-Optimizer. Reach for parallel patterns and Multi-Agent only when a concrete failing case proves you need them — complexity added before it is needed never comes out of the system, it just accumulates.
In LoopCraft, all eleven patterns are one click away on the canvas: pick the template, rename the nodes to your domain, wire your tools, and export a .loop.md your team can review line by line. The pattern is a starting point, not a cage — every node stays draggable, and the diff-friendly export format means your loop's evolution stays reviewable in version control. Start simple, upgrade with evidence. Full pattern library available at https://getloopcraft.com — sapsap@qq.com.
Reading time: 7 min