6 agent patterns for AI engineers: (explained with usage) 1) prompt chaining → split the task into fixed steps, each one checking the last. → use when the task decomposes cleanly and accuracy matters more than latency. 2) routing → classify the input first, then send it to the... model or tool built for it. → use when inputs fall into distinct classes that need different handling. 3) parallelization → run several calls at once and merge them, either by splitting the work or voting on the same question. → use when subtasks are independent, or when one answer deserves several opinions. 4) orchestrator-workers → a lead model decides what the subtasks are at runtime, then delegates them. → use when you cannot list the steps in advance. 5) evaluator-optimizer → one model writes, another grades, the loop repeats until it passes. → use when you have clear criteria and iteration measurably helps. 6) autonomous agent → no fixed path. it plans, acts, reads feedback from the environment, and decides when it is done. → use when the steps are unknowable and you can afford the cost and the blast radius. the first five are workflows: you wrote the path. only the last one writes its own. most production systems people call agents are pattern 1, 2, or 5 with good error handling. this taxonomy is from Anthropic's own writeup on building effective agents. full breakdown in the article below.show more

That last line is exactly what I've been building around: the agent writes the path, but the runtime runs it In looperators, a Master Agent proposes the workflow. Once approved, the handoffs, retries, joins, and stop conditions run deterministically across long-lived Agent sessions

This breakdown of the 6 main agent patterns is exactly what you need to understand real agentic workflows.

What is the orchestrator that often use those agents ????

Understanding these patterns matters more than memorizing frameworks.

yep, the routing one especially. keep coming back to that pattern

saving this. the last line is the most honest part.

The evaluator optimizer pattern is especially interesting beacause it mirrors how humans improve their work create , review, refine. Good AI Systems will likely come form combining these patterns thoughtfully rather than forcing full autonomy everywhere.

Insightful breakdown of agent patterns for AI engineers. The autonomous agent offers a dynamic approach.

ty for explained with usage

动画真好看

The pattern nobody teaches is knowing when to collapse back to a single call. Most production failures I see aren't from picking the wrong pattern, they're from keeping a 3-step chain alive long after the task got simple enough that one well-scoped prompt would do.

This is a great mental model — loops over prompts really does feel like where agent design is heading. Saving this one.

These patterns really highlight different approaches for efficiency and accuracy in AI tasks. Useful breakdown.

I used to think "more autonomous" automatically meant "better." Now I'd rather have a predictable workflow that's easy to debug.

honestly prompt chaining breaks down the second your decomposition is wrong. routing fails earlier and louder, which is why i'd run it first on anything ambiguous

Rightly showed but no one is doing the parallel one now, the cost is too much.

building workflow patterns first before jumping to fully autonomous agents saves so much debugging time

The pattern list is useful because it makes agents feel less magical. In production, I’d add one more layer across all six: explicit stop conditions, observability, and human handoff when confidence drops.

bro what tools you used to make those animations diagram ?

Do this simply with any ai

this is such a cool tool for builders

"Half agree — for everyday stuff, yes. But for automation workflows the benchmarks tell a different story. Right tool for the right task."

i thought more apps were real agents

prompt chaining is still the most underrated pattern here. everyone jumps straight to multi agent when half the time a fixed sequence with checks would just work

Useful taxonomy. One orthogonal dimension is who owns navigation. In a push-guided runtime, the agent doesn’t reconstruct its position and choose from every possible path; verified state + rules derive and push the next legal action—dynamic like an agent, governed like a workflow.

Honest bit: most 'agents' in production are really patterns 1, 2, or 5 with solid error handling. The tell is how much of the path you can name up front. If you can list the steps, use a workflow, it's cheaper and testable. Save 6 for when the steps are truly unknowable.

routing + prompt chaining still cover most real agent work — people jump to multi-agent swarms and then wonder why nothing is reliable

autonomy should be a local property, not the whole architecture. let agents choose the path only where uncertainty exists and keep everything else deterministic

routing is the one that quietly rots. classifier drifts, a new input type shows up, and it keeps confidently sending it down the wrong branch. give it an unknown bucket that escalates instead of guessing. a silent misroute costs more than a loud failure.

routing feels like the unsung hero here. most people underestimate how much cleaner your system gets when you just triage upfront instead of hoping one prompt does everything

Production AI is often about orchestration, not autonomy.

Insightful breakdown of agent patterns for AI engineers. The autonomous agent offers a dynamic approach.

This is a really important point. The gap between what AI labs promise and what they actually deliver keeps getting wider. What's your take on where the accountability should fall?