{"id":555,"date":"2026-07-29T03:00:00","date_gmt":"2026-07-28T23:00:00","guid":{"rendered":"https:\/\/neomeric.com\/blog\/?p=555"},"modified":"2026-07-29T03:00:00","modified_gmt":"2026-07-28T23:00:00","slug":"ai-agent-design-patterns","status":"publish","type":"post","link":"https:\/\/neomeric.com\/blog\/ai-agent-design-patterns\/","title":{"rendered":"AI Agent Design Patterns: 7 to Know in 2026"},"content":{"rendered":"

An AI agent design pattern is a reusable way of arranging language-model calls, tools and control flow to get reliable behaviour out of an unreliable component. There are seven worth knowing in 2026, and the most important skill is not implementing them — it is knowing which one your problem actually needs, because the default instinct (build a fully autonomous multi-agent system) is usually the most expensive and least reliable answer available.<\/p>\n

Gartner predicted in June 2025 that over 40% of agentic AI projects will be cancelled by the end of 2027<\/a>, citing escalating costs, unclear business value and inadequate risk controls. Pattern selection decides a lot of that cost.<\/p>\n

What are the seven patterns, and when does each apply?<\/h2>\n

Five of these are documented in Anthropic’s Building Effective Agents<\/a>, which remains the clearest practical taxonomy available. Two more — tool-use loops and human-in-the-loop gating — are what production systems add on top.<\/p>\n

1. Prompt chaining<\/h3>\n

Decompose a task into a fixed sequence of steps, where each model call processes the output of the previous one. Use it when the task has a genuinely predictable shape: extract, then classify, then summarise. It trades a little latency for a lot of accuracy, because each step gets a smaller, clearer job.<\/p>\n

Use when:<\/em> the steps are known in advance. Avoid when:<\/em> the path depends on what you find partway through.<\/p>\n

2. Routing<\/h3>\n

A classifier — often a small, cheap model — directs each input to a specialised handler. This is the highest return-on-effort pattern in the entire list and the most under-used. Routing lets you send 80% of traffic to a cheap model and reserve the expensive one for the hard cases, and it lets you write focused prompts instead of one bloated prompt that tries to cover every situation.<\/p>\n

Use when:<\/em> your inputs fall into distinguishable categories. Avoid when:<\/em> the categories overlap so much that misrouting is common.<\/p>\n

3. Parallelisation<\/h3>\n

Run multiple calls simultaneously, in one of two shapes. Sectioning<\/em> splits a task into independent parts and merges the results. Voting<\/em> runs the same task several times and aggregates — useful when you need confidence rather than speed, for example running three independent safety checks and failing closed if any one objects.<\/p>\n

Use when:<\/em> subtasks are independent, or you need consensus. Avoid when:<\/em> the parts genuinely depend on each other.<\/p>\n

\n

Free: The Australian AI MVP Cost Guide 2026<\/h4>\n

Honest cost benchmarks, the hidden costs vendors don’t quote, and a 10-line scoping worksheet.<\/p>\n

Get the free guide<\/a><\/div>\n

The heavier patterns: orchestration, evaluation and tools<\/h2>\n

4. Orchestrator–workers<\/h3>\n

A central model breaks a task down dynamically, delegates the pieces to worker models, and synthesises the results. Unlike parallelisation, the subtasks are not known in advance — the orchestrator decides them at runtime.<\/p>\n

This is powerful and expensive. Anthropic’s own multi-agent research system uses this shape; the published account of it reports that the multi-agent configuration consumed roughly 15 times the tokens of a standard chat interaction, while outperforming a strong single-agent setup by more than 90% on their internal research evaluations<\/a>. That is a real gain for a real cost — and it only makes sense when the task value justifies it.<\/p>\n

Use when:<\/em> subtasks are unpredictable and the task is high-value. Avoid when:<\/em> a fixed chain would do the same job for a tenth of the spend.<\/p>\n

5. Evaluator–optimiser<\/h3>\n

One model call generates; a second critiques against explicit criteria; the first revises. The loop runs until the evaluator passes it or you hit a cap.<\/p>\n

It works only when you can articulate what “good” means in words — otherwise the evaluator simply hallucinates approval. Always cap the iterations.<\/p>\n

6. The tool-use loop (the actual “agent”)<\/h3>\n

The model is given tools and runs open-endedly: think, call a tool, observe the result, decide again, until done. This is what most people mean by “an AI agent”, and it is the pattern with the widest gap between demo and production. It needs a hard step limit, a token budget, idempotent tools, and a defined behaviour for every failure mode. Getting this right is mostly an engineering problem, not a prompting one — we cover the production requirements in our AI app production-readiness checklist<\/a>, and the deployment side in our guide to deploying agentic AI in the enterprise<\/a>.<\/p>\n

7. Human-in-the-loop gating<\/h3>\n

Not glamorous, and the single most valuable pattern for anything touching money, customers, health data or legal obligations. The agent proposes; a human approves; the action executes. Design the approval as a first-class step with its own audit trail, not an afterthought bolted on when compliance objects.<\/p>\n

How do you choose the right pattern?<\/h2>\n

Work down this list and stop at the first “yes”.<\/p>\n

    \n
  1. Can a single well-written prompt do it?<\/strong> Then do that. Most production “agents” are one good prompt with retrieval attached.<\/li>\n
  2. Are the steps known in advance?<\/strong> Prompt chaining.<\/li>\n
  3. Do different inputs need different handling?<\/strong> Routing — and route to the cheapest model that clears your quality bar. Our guide on choosing an AI model for your app<\/a> covers how to set that bar.<\/li>\n
  4. Are the subtasks independent?<\/strong> Parallelisation.<\/li>\n
  5. Is quality judgeable against written criteria?<\/strong> Add an evaluator–optimiser loop.<\/li>\n
  6. Are the subtasks genuinely unpredictable and the task high-value?<\/strong> Only now consider orchestrator–workers.<\/li>\n
  7. Does the action have consequences?<\/strong> Wrap it in human-in-the-loop gating regardless of everything above.<\/li>\n<\/ol>\n

    The patterns compose: a router can feed a chain, an orchestrator can wrap evaluator loops. Working implementations of the core five are documented in the Spring AI effective-agents reference<\/a>.<\/p>\n

    What makes agent costs run away?<\/h2>\n

    Cost in agentic systems is not linear in the number of agents. As one 2026 engineering analysis puts it, orchestration overhead, repeated context transfer, verification layers, retry loops and coordination overhead compound across every handoff<\/a>. Three agents do not cost three times one agent.<\/p>\n

    Four controls, in order of impact: cap iterations and tokens per run; route aggressively so expensive models only see hard inputs; pass summaries between agents rather than full context; and log token spend per run from day one.<\/p>\n

    Neomeric, a Melbourne-based AI product and consulting company — and the team behind NeoMind, Australia’s onshore AI teammates platform<\/strong> — ships these patterns weekly for Australian founders and operators. The pattern that survives contact with production is almost always simpler than the one that was designed in the workshop.<\/p>\n

    Frequently asked questions<\/h2>\n

    What is the difference between an AI workflow and an AI agent?<\/h3>\n

    A workflow follows a path you defined in advance — prompt chaining, routing and parallelisation are workflows. An agent decides its own path at runtime using tools, which is the tool-use loop pattern. Workflows are more predictable and cheaper; agents are more flexible and harder to control.<\/p>\n

    Should I build a multi-agent system?<\/h3>\n

    Usually not first. The published account of Anthropic’s multi-agent research system reports roughly 15 times the token consumption of a standard chat interaction, for a gain of more than 90% over a strong single-agent setup on their internal research evaluations. That trade is worth it for high-value, heavily parallel research tasks. For most business workflows a router plus a chain does the job at a fraction of the cost.<\/p>\n

    Why do so many agentic AI projects get cancelled?<\/h3>\n

    Gartner’s June 2025 forecast that over 40% will be cancelled by end-2027 attributes it to escalating costs, unclear business value and inadequate risk controls. In practice these usually show up together: an over-complex pattern was chosen, costs compounded across handoffs, and nobody could point to the business metric it moved.<\/p>\n

    How do I stop an agent looping forever?<\/h3>\n

    Cap iterations and total tokens per run at the framework level, not in the prompt. Add a wall-clock timeout. Make every tool idempotent so a retry is safe. And define explicitly what the agent does when it hits the cap — escalate to a human is usually the right answer.<\/p>\n

    Do these patterns depend on which model I use?<\/h3>\n

    The patterns are model-agnostic; the economics are not. Routing in particular exists to exploit price and capability differences between models, so the pattern choice and the model choice should be made together rather than in sequence.<\/p>\n