Andrew Ng’s Agentic Patterns: Production Trade-offs

A content pipeline can produce a polished article and still fail at the job. The source may be stale, a claim may not be supported, or the publishing step may run before the output is ready. Building autonomous content systems has made me wary of calling a workflow “agentic” as if that tells us whether it is dependable.
Andrew Ng’s four agentic design patterns, Reflection, Tool Use, Planning, and Multi-Agent Collaboration, are a useful way to examine that problem. I use them as design choices, not a maturity ladder. What matters is whether each pattern improves the work enough to justify the uncertainty it introduces.
Reflection needs evidence outside the model
Reflection is useful when a model can revise an output against a meaningful check. It is much less convincing when the model simply reads its own answer and decides it looks better. For production LLM applications, I want the critique tied to evidence the system can inspect, not just a second opinion generated from the same context.
Ng describes Reflection as having an LLM critique and improve its output. He also suggests external feedback, including unit tests or web search. That distinction matters. A failed test gives a coding agent a specific defect to address. A retrieved source can show a writing agent that a claim lacks support. “Improve this draft” gives it far less to work with.
The risk is not merely that unaided reflection wastes a model call. Research on LLM self-correction in reasoning tasks found that correction without external feedback can fail to improve an answer and can sometimes make it worse. I would not generalize that result to every writing or coding task, but it is a strong reason to stop treating self-critique as validation.
In an autonomous content system such as BizFlowAI ContentStudio, which researches, writes, optimizes, and publishes across sites, I would separate checks by what they can establish:
- Mechanical checks can catch missing fields, broken structure, and output that fails a required schema.
- Source checks can ask whether a specific claim is supported by material the system retrieved.
- Editorial checks can flag ambiguity, repetition, or a mismatch with the intended reader.
- Outcome checks come later, when real search performance informs what the system targets next.
Those checks are not interchangeable. A clean schema does not make a factual claim true. A model’s favorable editorial review does not prove that a page helped its reader. The self-learning content loop I have built, measure, learn, target, generate, publish, makes that last distinction especially important: performance feedback informs future work, but it cannot retroactively verify every sentence in an article.
My implementation preference is to make a revision request narrow. Return the failed check, the relevant source material, and the portion of the output that needs work. Ask for a correction, then run the check again. If the system still cannot establish support for a claim, remove or hold that claim rather than letting a fluent revision pass as evidence.
Tool use is an interface design problem
Tool Use lets an LLM request a function to gather information, manipulate data, or take an action. In production, the difficult part is rarely getting the model to request a function. It is deciding what that function is allowed to do, what it returns, and how the rest of the system handles an uncertain result.
That is the pattern Ng outlines in his Tool Use discussion. He also notes that, when there are too many tools to describe in context, a developer can select a relevant subset for the current step. I think that is good interface design as well as context management. An agent preparing a draft does not need publishing authority merely because publishing exists somewhere in the application.
For a content workflow, I would keep retrieval, analysis, and publication as distinct capabilities. A retrieval tool should return material the agent can cite or inspect, along with enough provenance to distinguish a source from the model’s interpretation of it. An analysis tool should return the data it was asked for and indicate when it has no result. A publishing tool should accept a validated artifact, not an open-ended instruction to “publish whatever seems ready.”
The return path matters as much as the call. If a tool times out, an empty result should not look like “no relevant information exists.” If a write request is retried, the application needs a way to recognize that it may already have succeeded. These are ordinary integration concerns, but agentic workflows encounter them while a model is deciding what to do next. Ambiguous tool responses become ambiguous decisions.
I also keep a sharp distinction between information and authority. Retrieved text is data, even if it contains instructions addressed to the assistant. A tool’s description defines the operation; a web page or document returned by that tool does not get to redefine the agent’s role. For LLM application development, this boundary is more useful than a vague instruction to “ignore prompt injection.” The application should decide which inputs can authorize an action.
Tool Use holds up well when tools are narrow and their results are legible. It holds up less well when one broad tool combines searching, editing, and irreversible action behind a friendly name. In that design, it becomes difficult to tell whether a failure came from the model’s decision or the tool’s hidden behavior.
Planning belongs where the route genuinely varies
Planning lets an LLM choose steps for a larger task. It is not necessary just because a workflow has several steps. If the sequence is known, I would encode it in the application and reserve the model’s judgment for decisions the application cannot determine reliably in advance.
Ng makes that distinction: a fixed sequence does not necessarily need Planning, and he describes Planning as less predictable than Reflection and Tool Use in his experience. Anthropic similarly distinguishes workflows, whose paths are predefined in code, from agents that dynamically direct their process and tool use.
Take a content operation. Research, draft, validate, and publish can be a coded sequence. The system does not gain much from asking a model to rediscover that order for every item. But research might reveal that the proposed topic overlaps an existing page, lacks adequate sources, or calls for a different format. Those are useful places for a model to recommend a route, provided the recommendation is visible and the application defines what routes are permitted.
I would represent a plan as an inspectable artifact: the objective, proposed steps, needed tools, dependencies, and a condition under which the work should stop or return for review. Then I would separate proposing a plan from executing it. That gives the application a chance to reject a step that requires unavailable evidence or an action outside the task’s scope.
The biggest planning failure I watch for is confident continuation. A plan starts reasonably, an early assumption turns out to be false, and the agent keeps completing the remaining steps as though nothing changed. A useful execution trace should make that divergence visible. At each transition, the system needs to know what was expected, what actually happened, and whether the next step is still justified.
This is where the boundary between orchestration and autonomy earns its keep. I want deterministic code to own scheduling, persistence, and the conditions for completion. I want the model to handle bounded decisions about content, evidence, and next actions. Calling the entire pipeline an agent does not remove the need to say which side owns each decision.
Multi-agent collaboration needs distinct work, not roles
Multi-Agent Collaboration can help when a task can be divided into parts with different inputs or skills. It is not automatically better because several agents discuss the same material. I would add another agent only when I can describe the separate work it will perform and how its output will be checked.
Ng’s pattern assigns parts of a complex task to agents in different roles. He also says he finds this pattern and Planning harder to predict than Reflection and Tool Use. That matches the trade-off I consider when designing multi-agent pipelines: specialization can improve coverage, but every handoff creates another place for context to be lost or assumptions to drift.
Multi-agent design may be valuable when the work can be divided meaningfully. For an account of a research-system implementation, readers can check Anthropic’s engineering write-up. Its observations should be evaluated in the context of that system, not treated as a forecast for a content pipeline or an enterprise AI automation project. The added model calls and handoffs also need to be weighed against any improvement on the workload at hand.
For ContentStudio, the useful question is not “How many agents can I involve?” It is “Which work can proceed independently, and what must the next stage know?” Research on separate aspects of a topic may be divisible. Deciding whether the assembled draft is supported requires a shared view of the sources and claims. If each role receives only a polished summary from the previous role, unsupported details can acquire the appearance of established facts as they move through the pipeline.
I would give each handoff a concrete artifact: source findings with provenance, a draft with claims that can be traced back to those findings, and a validation result that names unresolved issues. I would also retain the ability to inspect the work behind an agent’s summary. A role label such as “researcher” or “reviewer” is not a quality control.
Multi-agent collaboration is worth considering when independent work reduces a real bottleneck or when a separate review perspective catches defects the producing step cannot. If the agents mostly repeat one another, the extra complexity has no clear job.
What I’d do before adding another pattern
I would start with the smallest workflow that can complete the task and show me where it failed. Then I would add Reflection, Tool Use, Planning, or Multi-Agent Collaboration only to address a specific limitation observed in that workflow. This is less exciting than designing a full agent team upfront, but it makes the eventual system easier to reason about.
My practical order is:
- Define a successful output and a failed output. Include cases where the system should stop because evidence is missing.
- Keep known steps in code. Do not ask a model to plan a route the application already knows.
- Add narrow tools where the model needs information or a bounded action. Make failures and empty results distinguishable.
- Add feedback-backed revision. Test whether a revision resolves the identified defect, rather than asking whether the model likes its revised answer.
- Inspect traces before adding roles. Find the step producing materially poor results, then decide whether another agent would actually improve it.
Ng recommends inspecting workflow traces during error analysis. That is the habit I would protect as an application grows. Without traces, a team can mistake an elegant architecture for a working one. With them, it can see whether the problem is retrieval, a tool response, a planning decision, or an unsupported final claim.
My view of Ng’s patterns is that Reflection and Tool Use are the easiest to justify when feedback and tool boundaries are clear. Planning and Multi-Agent Collaboration can be valuable, but they need a stronger reason to exist because they add more decisions and handoffs to inspect.
If you are working through those trade-offs in an AI system, you can reach me at lamingsrb@gmail.com. I’m most interested in the point where a promising workflow has to become something a team can operate and trust.
Frequently asked questions
What are Andrew Ng’s four agentic design patterns?
Andrew Ng’s four patterns are Reflection, Tool Use, Planning, and Multi-Agent Collaboration. I treat them as design choices rather than a maturity ladder. In production, I ask whether each pattern improves the work enough to justify the uncertainty it adds.
Can an LLM reliably validate its own answer through reflection?
I would not treat an LLM’s favorable review of its own answer as validation. Reflection is more useful when a revision responds to external evidence, such as a failed test or a retrieved source that does not support a claim. Without that feedback, self-correction can fail to improve an answer and may make it worse.
How should an AI content pipeline check an article before publishing?
I separate mechanical, source, editorial, and outcome checks because they establish different things. A valid schema does not prove a claim is true, and a favorable editorial review does not prove the article helped readers. When a claim fails a source check, I request a narrow correction and rerun the check; if support still cannot be established, I remove or hold the claim.
How do you design tools for a production LLM agent?
I give an agent narrow capabilities for retrieval, analysis, and publication rather than one tool that does everything. Retrieval should provide inspectable material and provenance, while publication should accept a validated artifact. I also make timeouts, empty results, and retried writes distinguishable so an uncertain tool result does not become an uninformed decision.
How do you prevent retrieved content from giving an AI agent instructions?
I treat retrieved text as data, even when it contains instructions addressed to the assistant. The application defines which inputs can authorize an action; a web page or document cannot redefine the agent’s role. That boundary is more concrete than relying only on an instruction to ignore prompt injection.
Building something hard with AI or automation? I am open to talk.
Get in touch