Contextual Agentic

Start With One Agent: Choosing the Simplest Pattern That Works

Multi-agent designs are not a maturity level. Each rung from a single call to orchestrator-workers adds cost and failure points, so climb only when the work branches.

·5 min read

Written as at 17 August 2026.

agentic-aimulti-agent-systemsagent-patternssolution-design

A team proposes four agents to answer “What is our refund policy?”: a planner, a retriever, a writer and a checker. The design will work. It will also cost several times more than it needs to, take longer to answer, and give the team four places to debug instead of one.

One model call with retrieval over the policy document answers that question. The extra agents add coordination, not capability.

At Poly, the studio I am building, the work is different. Building Lesson 3.2 on prompt caching means a script, three diagrams and a five-question quiz. Research, diagrams and quiz can run at the same time, the script needs the research, and quality review needs everything. That work branches, and a multi-agent pattern earns its cost there. The skill is telling the two situations apart.

Complexity has to be earned by the shape of the work

Anthropic’s guidance in “Building effective agents” (2024) is blunt: find the simplest solution that works and add complexity only when it improves the outcome. It separates workflows, where code fixes the path through model calls, from agents, where the model directs its own steps and tool use.

The reason is arithmetic. Every extra call adds tokens, latency and a new way to fail. A chain can carry an early mistake through every later step. A router can misroute quietly. A fan-out can hit a rate limit all at once. None of that is a reason to avoid patterns. It is a reason to pay for one only when the work demands it.

Five rungs, each adding one kind of freedom

Animated diagram of a five-step ladder of patterns: single call, prompt chain, routing, parallel, and orchestrator-workers. A dashed line after the first step marks the move from one model call to a system of calls. A token labelled Poly requests starts on the single-call step, where the script, diagrams and quiz come out inconsistent. It steps up to a prompt chain, which is consistent but slow and serial, then up to orchestrator-workers, where research, diagrams and quiz run in parallel and the evaluator passes the lesson within its budget. Then a typo fix starts six agents, and the token steps down to routing, which sends simple edits to one call and full lessons to the orchestrator.
Figure 1. The pattern ladder. Climb when the shape of the work demands it; step down when the evidence says a simpler rung will do. Figures are illustrative. Animated; shown as a still image if your device is set to reduce motion.

Read the ladder from the bottom. Each rung adds one freedom and one characteristic failure.

  1. Single call, with retrieval and tools. One loop of think, call a tool, observe. Use it for one question against one source of truth, like the refund policy. It fails when a long task bloats the window.
  2. Prompt chain. Fixed steps with a check between them: outline, draft, then a runtime check on the script. Use it when the steps are known in advance. An early error flows into every later step unless the checks catch it.
  3. Routing. A classifier sends each request down a specialist path. A claims team might send glass-only motor claims to a small model and injury claims to a larger model plus a person. Misroutes go unnoticed unless someone samples the router’s decisions.
  4. Parallel. Independent sections run at once, or several attempts vote. Supplier onboarding can check business registration, the sanctions list and the insurance certificate in parallel. You pay roughly N times the tokens for lower latency, and merging the results is where it breaks.
  5. Orchestrator-workers. A model plans the subtasks at run time, delegates them and merges the results. Use it when you cannot know the subtasks until you see the input, as with Poly’s lesson build. It fails through over-delegation and runaway spend.

An evaluator loop, where one model drafts and another judges against a rubric, can sit on any rung above the first. It needs a measurable rubric and a hard cap on revisions, which is what I call Loop Engineering: treating an agent’s iteration as a control loop with progress signals, budgets and stop conditions enforced outside the model (my construct; see Loop Engineering).

Scale effort to the query, not to the architecture

Anthropic’s account of its multi-agent research system shows both sides of the trade. A lead agent on Claude Opus 4 with Claude Sonnet 4 subagents outperformed a single Opus 4 agent by 90.2 per cent on its internal research evaluation. The same post reports that agents use about four times the tokens of a chat interaction, and multi-agent systems about fifteen times. Token usage alone explained 80 per cent of the performance variance in their analysis.

The gain came on broad research that splits into independent threads. The token bill arrives on every query, including the ones that did not need it. So Anthropic wrote scaling rules into its prompts: simple fact-finding gets one agent with 3–10 tool calls, direct comparisons get 2–4 subagents with 10–15 calls each, and complex research gets more than ten subagents. The post also notes that work where every agent needs the same context, or with many dependencies between agents, suits the approach less well.

Poly’s orchestrator carries the same kind of rule. A typo fix gets one agent, a comparison two to four, and a full lesson up to six. Without it, an illustrative typo fix in Lesson 2.1 started six agents and cost $0.90, two of them editing the same file.

Ask five questions before you climb a rung

Work down this table and stop at the first “yes”. You can try the same questions interactively in the pattern finder.

Question If yes Evidence to collect first
Can one call with the right context and tools do it? Single call Pass rate on a small golden set
Are the steps known and fixed in advance? Prompt chain Which step fails, and whether a check catches it
Do request types differ enough to need different handling? Routing Share of each type, cost per type, misroute rate
Do independent subtasks exist, known in advance? Parallel Latency saved against tokens added
Do the subtasks only become clear from the input? Orchestrator-workers Quality gain over the rung below, at the cost per successful task

The last column matters most. Keep the simpler design running in your evaluation suite as a baseline, so every climb is a measured improvement and not a hunch.

Step down when the evidence says so

A ladder works in both directions. Step down when turns per task keep rising, when workers duplicate each other, when the evaluator never sends anything back, or when cost per successful task exceeds the simpler baseline without a quality gain to show for it.

Stepping down is often partial. Poly did not abandon orchestrator-workers. It put a router in front, so simple edits take one call and full lessons go to the orchestrator.

Whatever rung you choose, the controls stay the same. Budgets, stop conditions and tool permissions belong in the Deterministic Shell, which is my term for the code around the model that owns identity, authority, state and commitment, while the Probabilistic Core reasons and proposes inside it (see Why Enterprise AI Needs a Deterministic Shell).

The ladder does not tell you what quality bar the work needs, or who owns a wrong answer. It will not make a vague task well defined, and no pattern rescues an evaluation set that does not reflect real requests. It tells you how much machinery a well-understood task deserves.

Who does what

Executives: ask for cost per successful task by request type, not total model spend. A single average hides the simple requests paying for machinery built for hard ones.

Architects: record the rung chosen for each request type, with the evidence that justified it, and review it when models or volumes change.

Engineers: keep a single-call baseline in the evaluation suite, put the effort-scaling rule in code where a router or orchestrator can enforce it, and alert on turns per task.

This article is part of The Agentic AI Architect, a series from the author of The Contextual Agentic Enterprise. Each piece matches a module of his course in development, Agentic AI Architect Pro.

References

  1. The Contextual Agentic Enterprise.
  2. Anthropic (December 2024) "Building effective agents". https://www.anthropic.com/engineering/building-effective-agents
  3. Anthropic (13 June 2025) "How we built our multi-agent research system". https://www.anthropic.com/engineering/multi-agent-research-system

← All articles

Related