Do Anthropic's Six Agent Design Patterns Still Hold Up in 2026?

In December 2024, Anthropic published "Building Effective Agents", a short engineering post that did something unusual for the field: it gave a sprawling, fashionable topic a small, precise vocabulary. Five composable workflow patterns — Prompt Chaining, Routing, Parallelization, Evaluator-Optimizer, Orchestrator-Workers — plus one true agent pattern, where the LLM itself decides the control flow in a loop of tool calls and environmental feedback.

That was a year and a half ago. Since then the ecosystem has moved fast: the Model Context Protocol shipped and became a de facto standard, Claude gained Skills and computer use, a dozen agent frameworks launched and several quietly died, and — per Anthropic's own 2026 numbers — more than half of enterprises now have agents running in production. Against that backdrop it's a fair question: is the original taxonomy still how practitioners actually think about this, or has it been quietly superseded?

Having just built a hands-on repo — ai-architecture-pattern — that implements all six patterns against a local Ollama model — including hitting a real bug in the Evaluator-Optimizer script along the way — my answer is: yes, it holds up, and the ways it holds up (and the couple of places it doesn't) are worth spelling out.

Here's the taxonomy the whole post is built on — five composable Workflow patterns, plus one true Agent pattern:

The taxonomy is still the reference point

The clearest sign a framework has stuck isn't that people praise it — it's that other people keep building on top of it instead of replacing it. That's what's happened here. A 2026 arXiv survey on agent design patterns describes Anthropic's December 2024 post as "the most-cited taxonomy in agent-pattern literature," and rather than discarding it, extends it along two new axes (cognitive function and execution topology) — treating the original five-plus-one as the base layer to build on, not a strawman to knock down. Multiple pattern catalogs published in 2026 (AgentPatterns.ai, BuildingEffectiveAgents.com, several enterprise engineering blogs) are still organized directly around Anthropic's original categories. Anthropic's own Academy courses on building agents still teach this framework as the starting point.

Production data backs the "start simple" advice

The most consistently repeated line in the original post is: use the simplest pattern that passes evaluation, and reserve full agentic autonomy for cases where you genuinely can't hardcode the path but can still verify progress. Anthropic's 2026 State of AI Agents report gives that advice an unexpected endorsement, just not the one you'd predict from all the hype about autonomous multi-agent systems. The dominant pattern in production today is single tool-use with human review — an agent calls one or more tools, returns output, a person reviews it. The second most common pattern (17–23% of production deployments) is a multi-step workflow run inside a sandbox with one human handoff at the end. Both are close to the simple end of Anthropic's spectrum, not the sprawling autonomous-agent end. Meanwhile 88% of agent pilots never make it to production, and the leading blockers cited are evaluation gaps, governance friction, and model reliability — precisely the failure modes the original post warned complexity introduces. The market didn't converge on autonomous agents everywhere; it converged on exactly the restraint Anthropic recommended.

What's been layered on top since December 2024

The taxonomy hasn't been replaced so much as filled in. The original post's "augmented LLM" concept — a model extended with retrieval, tools, and memory — was left deliberately abstract about how you'd actually wire up the tools part. MCP answered that: it's now the standard way an agent discovers and calls tools, resources, and prompts across a growing ecosystem of integrations. Agent Skills address a related gap — instead of building a bespoke agent per use case, you package domain expertise as a portable file (a SKILL.md) that any agent can load. Neither of these contradicts the original five-plus-one patterns; they're plumbing that makes the "tools" and "agent" side of the framework easier to build in practice.

Where it shows its age

The critiques that exist are narrower than "this framework is wrong" — they're about scope. A 2026 review of Anthropic's assumptions points out several settings where the framework's guidance under-specifies what to do: high-frequency, low-complexity tasks where deterministic code beats both workflows and agents on cost and latency; tasks with no clear evaluation criterion, where the "evaluate until it passes" loop has nothing to converge against; high-stakes one-shot decisions, where the autonomous-loop pattern doesn't say enough about adversarial verification or external grounding; and retrieval-bottlenecked tasks, where the bottleneck isn't the control flow at all. Separately, a 2026 paper on agent terminology argues the word "agent" itself has been stretched thin across the industry — not a flaw in Anthropic's specific definitions, but a sign of how far vocabulary has drifted since the taxonomy was coined. None of this is an argument to stop using the patterns; it's a reminder that they're a starting vocabulary, not a universal decision procedure.

A small first-hand example

I ran into a live version of this while building the hands-on repo. The Evaluator-Optimizer script's first draft checked for a call-to-action in generated ad copy by searching for the literal words "今すぐ" ("right now") or "ぜひ" ("please do") in the text. Running it against a local model, the loop never converged — the model kept phrasing calls-to-action differently ("体感しよう", "try it for yourself") without ever using those exact words, so a perfectly reasonable draft kept getting rejected by a check that was really testing for a string, not a concept. Swapping the keyword match for an LLM judgment (the same "decide what actually needs an LLM versus what a simple check can handle" tradeoff the original post discusses under Evaluator-Optimizer) fixed it on the next run. It's a small bug, but it's the exact lesson the framework has been teaching since page one, reproduced faithfully on a laptop eighteen months later.

The verdict

Treat the six patterns as durable vocabulary and a set of starting primitives, not as gospel to apply unmodified. The advice that's aged best is the least flashy part of the original post: try the simplest thing first, compose these patterns rather than picking exactly one, and reach for a real agentic loop only when the task genuinely can't be hardcoded but its progress can still be checked. Eighteen months and a full hype cycle later, that's still the right first move.