Agentic Design Patterns: The Four Worth Knowing

"Agentic design patterns" usually gets explained as four building blocks of a custom agent system — reflection, tool use, planning, and multi-agent collaboration. That is accurate, but it makes the patterns sound like something only a developer assembling a pipeline needs. They are not. Each one is also a specific way of structuring a single conversation with a chat tool you already use, no framework required, and three of the four are things you can try in your next chat with no setup at all.

The four patterns, in plain terms

• —Reflection — the model produces a draft, then is asked to review its own output against a specific standard before you accept it, rather than taking the first answer as final.
• —Tool use — the model reaches outside its own training data by calling something external: a search, a calculator, a lookup against a real document. Anthropic’s own tool-use documentation describes this as the model deciding when a task needs an outside fact rather than a generated one.
• —Planning — the model lays out the steps it intends to take before taking any of them, so you can check the plan is sound before a single step runs rather than catching a wrong turn three steps in.
• —Multi-agent — splitting one task across several separate conversations, each given a narrower role, then combining what comes back — one drafts, a second one reviews, a third compares the two.

The common thread is slowing the interaction down on purpose. A single prompt that asks for a finished answer in one pass gives a model no structured chance to catch its own mistake. Each of these patterns inserts a checkpoint — a self-review, an external fact, a visible plan, a second opinion — before the output reaches you. Agentic framework is about whether you need software to wire these together into an automated pipeline; this is about using the same four ideas by hand, inside a normal conversation, which is where most people will actually meet them first.

A worked example: the reflection pattern on a real draft

Weak: ask for a client email, and send the first draft that comes back.

Better: ask for the draft, then in a follow-up message ask the model to check its own draft against a specific standard you name — "does this commit to a date we have not actually confirmed, and is the tone too casual for a client who has an open complaint" — rather than a generic "can you improve this." Naming the exact thing to check is what makes the second pass worth anything; a vague "review this" tends to produce cosmetic polish rather than a real catch.

That specificity point holds for every pattern here, not just reflection — OpenAI’s own prompting guidance makes the same case for any request: a concrete, named check gets a checkable answer, and a broad one gets a plausible-sounding one.

A reflection pass is only as useful as the specific thing you asked it to check. "Review this" catches typos. "Does this promise a date we have not confirmed" catches the mistake that actually matters.

Where each pattern breaks

• —Reflection can turn into the model agreeing with its own first draft rather than genuinely re-examining it — research on sycophancy in language models documents the same folding behaviour when a model is pushed to reconsider an answer, and a self-review that just restates the original with more confidence is worse than no review, because it looks like one happened.
• —Tool use only helps if the tool was actually the right one to call — a model can call a real tool and still misread what it returns, or call a plausible-sounding tool it was never actually given, producing an answer that looks sourced and is not.
• —A visible plan can look sound and still rest on a wrong assumption in step one that nobody checked before steps two through five ran on top of it.
• —Multi-agent review only works if the second pass is independent — asking the same model, in the same conversation, to "check this again" often just produces a second coat of the same confidence rather than an actual second opinion. A widely cited survey of hallucination in large language models covers why fluent agreement is not evidence of correctness, whichever pattern produced it.

Checks before you trust the output

1. 01Name the specific thing a reflection pass should check — a fact, a date, a commitment — rather than asking generally for a better version.
2. 02Confirm a tool actually ran and read real data back, rather than assuming a plausible-looking fact came from a lookup just because the answer mentions one.
3. 03Read a plan before any step of it executes, and check the first assumption specifically — a wrong foundation sinks everything built on it.
4. 04For a genuine second opinion, use a separate conversation or ask the question with no memory of the first draft, rather than asking the same thread to mark its own work.
5. 05Apply the same habit NIST’s AI Risk Management Framework recommends generally: decide in advance what you are actually checking for, rather than trusting that a second pass caught something just because it happened.

What to do Monday

Pick one task you currently send to a chat tool in a single pass, and add one explicit reflection step with a named check before you use the output — that is the lowest-effort version of all four patterns and needs no new tool. Write a prompt that works on the first try covers the same specificity habit that makes every one of these patterns worth the extra step. Once a task genuinely needs several dependent steps run automatically rather than typed by hand each time, agentic workflows covers what that looks like day to day, agentic AI architecture names the pieces a built pipeline actually needs, and AI agent vs LLM is worth reading if the line between "drafts an answer" and "takes several steps on its own" is still not concrete.

Knowing which of these patterns a task actually needs — and which is just an extra step that slows down something already correct — is the same judgement behind the wage premium PwC has measured for workers with demonstrable AI skills: 62%, up from 57% the year before. Coursium teaches that judgement directly, one short lesson at a time. Stay ahead of AI by learning the tools on your phone.