Skip to content
ReviewRamble

The weekly brief

AI, reviewed, in your inbox.

  • New reviews of tools, models, MCP servers and repos, with the verdict up front
  • Re-checked prices and ratings when something changes
  • New analysis pieces as they are published

Models, agents, MCP servers and the tools actually worth your time.

One email a week. Unsubscribe with the link in any brief. How we use your email

Analysis Agent Frameworks & Automation

One agent or a team? How to choose an AI agent architecture, and when more agents make it worse

By ReviewRamble editors ·

Most AI products that call themselves agents would work better, and cost less, as a short piece of ordinary code that calls a model two or three times. The ways of building with language models run from a fixed recipe to a team of models that message one another, and each step up buys flexibility with money, speed and predictability. Here is what each pattern does, when it earns its place, and the evidence that adding agents often makes the answer worse.

Our position is simple. Start with the plainest design that does the job. Move to a single agent when you cannot write the steps down. Move to several agents only when you can name the failure that one agent keeps making, and can show that splitting the work fixes it.

The first question: who chooses the next step?

Every design here answers one question differently: does your code decide what happens next, or does the model? Anthropic's engineering guide, Building effective agents, draws the line cleanly. A workflow is a system in which models and tools are "orchestrated through predefined code paths". An agent is one in which the model directs "its own processes and tool usage". Our glossary entry on workflow versus agent covers the distinction in more detail.

Think of a dentist's reminder service and a travel agent. The reminder service runs the same three steps every evening: look up tomorrow's appointments, write a polite text, send it. Nobody wants that software to improvise. The travel agent's job changes with every call: the flight is full, so check the train, which moves the hotel booking by a day. A workflow is the reminder service. An agent is the travel agent, and you pay for its judgement in tokens, time and the occasional wrong turn.

Anthropic's guide goes further than most vendors would. The simplest approach, it says, "might mean not building agentic systems at all", and for many applications one well-prepared model call, with retrieval and a few examples in the prompt, is enough.

Five workflows that cover most products

Prompt chaining: one small job per call

A chain breaks a task into steps, and each model call works on the output of the one before. A salesperson's call recording becomes a summary, the summary becomes a list of promised follow-ups, and the list becomes a draft email. Between steps, plain code can act as a gate: if the summary names no date for the next meeting, the chain stops and flags it rather than sending an email that invents one.

The trade, in Anthropic's words, is latency for accuracy. Each call has an easier job, so it makes fewer mistakes, and the whole thing takes longer. When a single prompt keeps dropping one of six instructions, a chain is usually the fix.

Routing: a receptionist before the specialists

A router reads the request, decides what kind it is and sends it down the matching path. A support inbox sorts refunds, password resets and complaints into separate prompts, each tuned for its own job, so improving the refund answer cannot quietly break the password one. The same trick sends easy questions to a small, cheap model and hard ones to a large one, which our entry on LLM routing explains.

Everything rests on the sorting. A router that files a chargeback as a password question sends a frustrated customer the wrong instructions with complete confidence, so measure the classifier on its own before trusting what sits behind it.

Parallelisation: sectioning and voting

Some work splits into pieces that do not depend on one another, and those can run at the same time, with code stitching the results together. Anthropic names two versions.

Sectioning gives each call a different part of the job. A tenant's lease goes to three calls at once: one reads the rent and deposit terms, one the repair obligations, one the break clause. Each reads with full attention for one thing, and a final step in code assembles the report. A common pairing has one call screen a request for abuse while another drafts the answer.

Voting gives several calls the same job and compares their answers. Three separate reviews of a code change for security holes, with a rule that any single flag sends it to a person, catch more than one review does. The threshold is yours to set: one vote in three for a security warning, two in three before you hide a customer's post.

Evaluator-optimiser: a writer and an editor

One call writes; a second checks the result against stated criteria and sends it back with notes; the loop repeats until the checker is satisfied. A restaurant translating its menu into Japanese is a fair example: the evaluator checks that every dish keeps its allergen warning, that prices are unchanged and that no dish name has been rendered literally into nonsense.

Anthropic gives two signs that the pattern fits: a person's feedback would clearly improve the draft, and a model can give that kind of feedback itself. Where neither holds, the editor either waves everything through or nitpicks for ever. Put a hard limit on the rounds, and see our entry on LLM-as-a-judge for the ways a judging model goes wrong.

Orchestrator-workers: the hinge

Anthropic files this one under workflows, but it is the point where the model starts writing the plan. A lead model reads the task, decides which pieces it needs, hands each to a worker call and combines what comes back. Unlike sectioning, the pieces are not fixed in advance: a request to rename a product across a website might mean changing three files or thirty, and only reading the code tells you which. It returns below, because it is also the usual shape of a multi-agent system.

The single agent loop

When you cannot write the steps down, you give the model tools and a goal and let it work in a loop. Anthropic describes agents as "typically just LLMs using tools based on environmental feedback in a loop". The pattern most of them follow comes from ReAct: Synergizing Reasoning and Acting in Language Models, a 2022 paper by Shunyu Yao and colleagues at Princeton and Google, published at ICLR 2023. The model alternates between a short line of reasoning and an action: think, call a tool, read what came back, think again.

Picture a lost parcel. The agent reads the tracking page and sees the parcel stuck at a depot, looks up the depot's notices, finds a suspension of deliveries, checks whether the order can be sent again, and drafts a refund request when it cannot. Nobody could have scripted that path in advance, because each step depends on what the last one found. In the paper, interleaving reasoning with actions beat imitation and reinforcement learning methods by 34 and 10 points of absolute success rate on two interactive tasks, ALFWorld and WebShop, with only one or two worked examples in the prompt.

The loop is where most of the engineering goes. Our entries on the agent loop, ReAct and the agent harness, the software around the model that runs the tools and enforces the rules, describe the parts. Two matter most. One is a stopping condition, such as a maximum number of steps, so a confused agent does not spend all night. The other is the tools themselves: Anthropic's third principle is to document and test them with the same care as the prompt, because a vague tool description is a vague instruction.

Plan-and-execute: write the list first

A ReAct agent decides one step at a time, which is flexible and sometimes aimless: it can repeat a search, wander down a side road or lose sight of the goal by step twenty. Plan-and-execute separates the thinking from the doing. A planner writes the whole list up front, an executor works through it item by item, and after each item, or when something fails, the planner may revise what is left.

It is how a sensible person moves house: write the list (book the van, cancel the broadband, redirect the post), tick things off, and rewrite the list when the van company is fully booked. The written plan gives you something to show a user, or a person to approve, before anything happens, and the executor can often be a smaller, cheaper model. The cost is a plan that goes stale. If the planner never looks again, the executor dutifully completes steps that stopped making sense three items ago.

Orchestrator and workers, as a team of agents

A multi-agent system gives several agents their own instructions, tools and context, and some form of orchestration decides who works when. The common shape is a lead agent that starts subagents, each with a clean context window, and merges their short reports.

Anthropic's own research feature is the strongest public case for it. In its June 2025 write-up, a lead Claude Opus 4 directing Claude Sonnet 4 subagents beat a single Opus 4 agent by 90.2% on Anthropic's internal research evaluation. The same write-up gives the bill: agents use about four times the tokens of a chat, and multi-agent systems about 15 times. In Anthropic's analysis of the BrowseComp benchmark, token use alone explained 80% of the variance in performance. Much of the gain, in other words, is the extra reading that the extra agents pay for. Anthropic also says these systems fit poorly where agents must share the same context or depend on one another, and that most coding tasks have fewer truly parallel parts than research does.

Research suits the pattern because it is breadth: ten companies to look into, each independent of the others, each producing more pages than one context window can hold.

Handoffs: passing the call to a specialist

Everyone knows the phone call that goes wrong at the transfer. You explain the problem to the first person, get put through to billing, and start again from your account number. A handoff is the same move between agents, and done well it carries the conversation along.

In the OpenAI Agents SDK (4.4), a handoff appears to the model as a tool: a handoff to a refund agent becomes a tool called transfer_to_refund_agent, and calling it passes control. By default the new agent "gets to see the entire previous conversation history", according to the handoffs documentation. An input_filter can trim what crosses over, and an on_handoff callback can check the reason the model gives and stop the transfer. The alternative is an agent used as a tool, where the first agent keeps control, asks the specialist a narrow question and gets an answer back, like a shop assistant phoning the stockroom rather than handing you the receiver.

Handoffs suit a front desk that passes conversations to specialists who each own their tools: the refund agent can issue refunds and the order-tracking agent cannot. That separation of permissions is a real reason to split. The risk is the other side of carrying history: everything the customer said, and every tool result, travels with the call unless you filter it out.

Human approval checkpoints

An agent can stop and ask a person before it continues, and Anthropic counts that as part of the agent pattern: agents "pause for human feedback at checkpoints or when encountering blockers". Our human-in-the-loop entry describes the mechanics, and LangGraph (4.6) is built for agents that must stop, keep their state through a restart and wait for someone to approve.

Put the checkpoint where an action cannot be undone: before money moves, before an email reaches a customer, before a change merges. A finance team's agent can gather invoices and draft the payment run on its own; a person approves the run. An approval on every step trains people to click yes without reading, which we looked at in who presses yes when an AI agent asks. A few well-placed checkpoints get read; dozens a day do not.

When more agents make results worse

The most careful test of the multi-agent bet so far comes from Google Research, Google DeepMind and MIT. In Towards a Science of Scaling Agent Systems by Yubin Kim, Xin Liu and colleagues, first posted in December 2025 and summarised on the Google Research blog in January 2026, the authors compared a single agent with four multi-agent designs: independent agents whose answers are merged at the end, a central orchestrator, peers that debate, and a hybrid of the last two. They held tools, prompts and token budgets equal and ran models from OpenAI, Google and Anthropic. The current version of the paper covers 260 configurations across six benchmarks.

The results split by the shape of the task.

  • Parallel work gained. On Finance Agent, a financial analysis benchmark whose questions break into separate strands (news, filings, operations), a central orchestrator scored 80.8% better than a single agent, 0.631 against 0.349.
  • Sequential work lost, every time. On PlanCraft, a crafting puzzle set in Minecraft in which each step depends on the last, every multi-agent design did worse than one agent: by 39.1% for the hybrid and up to 70.0% for independent agents. The single agent scored 0.568; the independent agents 0.170.
  • Errors spread without a checker. Independent agents amplified errors 17.2 times compared with a single agent, because nothing caught one agent's mistake before it reached the final answer. A central orchestrator held that to 4.4 times by checking work before combining it.
  • A strong single agent leaves little to gain. Once one agent already succeeded more than about 45% of the time, adding agents tended to make results worse.
  • Tool-heavy jobs pay a tax. With the token budget fixed, splitting it among agents left each with too little to handle many tools. The paper's example is a business workflow with 16 tools.

The paper's own example is the clearest picture. Asked to craft a diorite wall, the single agent looked up the recipe, moved the stone to the grid and crafted it: three turns. A centrally coordinated team split the same job into a recipe researcher, an inventory checker and a crafter, two of them redundant, and spent its budget on messages about the work rather than on the work. Four cooks around one omelette.

The lesson is not that teams of agents fail. They help where work splits into independent pieces and something checks the pieces, and they hurt where the work is a chain of dependent steps. Using measurable features of the task, the paper's model picked the best design for 87% of configurations it had not seen, which is a better guide than any framework's demo.

A decision order

  1. Try one model call with good retrieval and examples. Measure it on 30 to 50 real cases, as in our guide to testing AI apps and agents, before building anything else.
  2. If it drops steps, chain them. If inputs differ in kind, route them. If parts are independent, run them in parallel; if one reader misses things, let several vote. If quality has a standard you can check, add an evaluator with a limit on rounds.
  3. If the steps cannot be written down, run one agent loop with a step limit, carefully described tools and logs that someone reads.
  4. If that agent wanders, make it write a plan first and revise the plan as it goes.
  5. Add agents only for a failure you can name: the material overflows one context window, the work splits into independent searches, or different steps need different permissions. Put an orchestrator that checks results in charge, never a pile of independent agents.
  6. Wherever an action cannot be undone, stop for a person.

What the frameworks assume

A framework steers you towards the pattern it was built around. LangGraph (4.6) makes you draw the graph explicitly, which suits workflows and long-running agents with approval steps, at the cost of more code. The OpenAI Agents SDK (4.4) is small and built around handoffs and guardrails, and sends traces to OpenAI unless you switch that off. CrewAI (4.1) gets a team of role-playing agents running quickly; our review found that production teams end up writing its fixed Flows rather than free-form crews. Pydantic AI (4.5) brings typed outputs to a single agent, and the Claude Agent SDK (4.2) hands you Claude Code's loop and tools ready-made. AutoGen (2.6), Microsoft's influential multi-agent framework, is archived. Our agent framework entry covers what they have in common.

Anthropic's guide suggests starting with the model APIs directly, since "many patterns can be implemented in a few lines of code", and warns that frameworks can hide the prompts you need to see when debugging and make extra complexity tempting. A chain or a router is a few lines in any language. A framework earns its place with what it does well, such as durable state or tracing, not with a pattern you could write in an afternoon.

The catch: the evidence is thinner than the confidence around it. The Google study fixed token budgets, so a team that simply spends more may see different results, and its benchmarks are not your product. Anthropic's 90.2% comes from its own internal evaluation, and its patterns guide dates from December 2024, with a note that the tooling has changed since. Treat all of it as a reason to measure your own task, not as a ruling.

Our take: build an agent system the way a small business hires. Nobody opens a bakery by appointing a head of operations, a head of logistics and a head of customer experience; they hire one good baker and write down the recipes. A second person comes on when the first is demonstrably swamped by work that can be done side by side, and someone checks the trays before they go out. The extra agent should be the answer to a problem you have already seen.

Sources

The ReviewRamble brief

AI, reviewed. Once a week, in your inbox.

The verdicts that matter across AI, robotics and tech, with what to use and what to skip. No hype, no digest of everything.

Models, agents, MCP servers and the tools actually worth your time.

One email a week. Unsubscribe with the link in any brief. How we use your email