On December 19, 2024, Anthropic published an engineering blog titled 'Building Effective Agents.' It opens by highlighting confusion around a single term: some use 'agent' to refer to systems capable of autonomous action, while others use it for implementations that follow predefined procedures. The article collectively terms all variants 'agentic systems,' then draws a clear architectural boundary line. More than three months later, in April 2025, OpenAI released a 34-page public guide titled 'A Practical Guide to Building Agents,' addressing the same issue—but from the perspective of product teams. Placing these two documents and two papers side by side reveals they repeatedly answer the same fundamental question: In an automated system, who decides the next step—code or model?
## One Term, Two Architectures
Anthropic’s boundary line is quoted verbatim: 'Workflows are systems where LLMs and tools are orchestrated through predefined code paths. Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.' Translated: workflows are systems in which LLMs and tools are orchestrated via predefined code paths; agents are systems in which LLMs dynamically direct their own processes and tool usage—and retain control over how tasks are accomplished. This binary distinction hinges not on capability strength, but on control-flow ownership: whether the system decides *which step to take next* and *when to stop* is determined by code or by the model. Nor is this a value-laden ranking—the article explicitly treats both as types of agentic systems. One date-related note: metadata indicates the page was published on December 19, 2024, with a revision recorded on October 9, 2026; current examples in the text reference models released after that revision date. This article cites the definitions and pattern descriptions therein, without inferring the original wording at time of publication.
## Five Ways to Encapsulate Judgment in Predefined Boxes
The core of Anthropic’s blog outlines five workflow patterns, each annotated with its appropriate use case. First, *prompt chaining*: decomposing a task into a fixed sequence of steps, where each LLM call processes the output of the prior step; intermediate steps may include programmatic checks—called 'gates' in the original text—to verify the process hasn’t derailed. Model judgment is confined within each box; the order between boxes is hardcoded. Second, *routing*: classifying input first, then dispatching to specialized downstream handlers. This separates concerns; without such classification, optimizations for one input type would degrade performance on others. Classification can be performed by either an LLM or a traditional classifier; dispatching follows code-defined logic. Third, *parallelization*: two variants—*segmentation*, splitting a task into independent, parallelizable subtasks; and *voting*, running the same task multiple times to obtain diverse outputs, with results aggregated programmatically. Fourth, *orchestrator–writer*: a central LLM dynamically decomposes the task, delegates subtasks to worker LLMs, and synthesizes results. Its distinction from parallelization lies precisely in the fact that subtasks are *not predetermined*—the model gains partial decomposition authority, though the overall skeleton remains coded. Fifth, *evaluator–optimizer*: one LLM generates a response, another evaluates and provides feedback, iteratively refining the output. Collectively, all five patterns answer the same question: *At which steps is judgment delegated to the model, and at which must code retain final say?* (This summary is ours.)
## When to Delegate to the Model
So when should you use an agent? Anthropic states: agents suit open-ended problems where the number of required steps is difficult or impossible to predict—and where the execution path cannot be hard-coded. The model may run many rounds, demanding a certain level of trust in its decisions. The trade-offs are stated plainly: autonomy incurs higher cost and risk of compounding errors; thorough sandbox testing and appropriate safeguards are advised. Yet the overarching principle given in the same passage is: *seek the simplest possible solution, adding complexity only when necessary*—and the text adds, bluntly: *this may mean not building an agentic system at all.* A set of trade-off statements follows: workflows deliver predictability and consistency for well-defined tasks; agents excel when scalable flexibility and model-driven decision-making are needed; and for many applications, optimizing a single LLM call—augmented with retrieval and contextual examples—is often sufficient.
## Two Vendors, One Recommendation
OpenAI’s guide enters the definition from a different angle: *an agent is a system that independently completes tasks on your behalf; a workflow is a sequence of steps required to achieve a user’s goal.* Its defining sentence reads: *Applications that integrate an LLM but do not let the LLM control workflow execution—such as simple chatbots, single-turn LLMs, or sentiment classifiers—do not qualify as agents.* In other words, while Anthropic asks *where control flow resides—code or model*, OpenAI asks *whether the LLM manages the execution loop itself*. Both questions point to the same underlying issue. When is building an agent worthwhile? The guide recommends prioritizing workflows previously resistant to automation—especially those where traditional methods consistently fail—and lists three characteristic features: (1) *complex decision-making*, involving nuanced judgments, exceptions, and context-dependent choices—for example, refund approvals in customer service; (2) *unmaintainable rules*, where rulebases grow so large that updates become costly and error-prone—for example, vendor security reviews; and (3) *heavy reliance on unstructured data*, requiring natural-language interpretation, meaning extraction from documents, or conversational interaction—for example, home insurance claims processing. Where none of these three apply, the guide states: *a deterministic solution may suffice.* This aligns directly with the 'simplest solution' principle. Structural recommendations are similarly conservative: agents consist of three components—model, tools, and instructions. Orchestration falls into single-agent and multi-agent systems. A single-agent system runs one model with tools and instructions in a loop until an exit condition is met—common conditions include tool invocation, specific structured output, error, or reaching a maximum round count. The general recommendation is to first maximize the capability of a single agent; adding more agents increases complexity and overhead. If multiple agents are truly needed, the *manager pattern* lets a central agent command specialized agents via tool calls; the *decentralized pattern* allows agents to transfer execution authority among themselves—where the transfer itself is implemented as a tool. The conclusion chapter converges on the same point: *start with a single agent, evolving to multi-agent only when necessary.* Safeguards form a dedicated chapter: layered defenses combine LLM-based classifiers, regex rules, and content moderation APIs, triggering pause-and-review or human escalation based on risk level—human intervention is explicitly called out as a critical safeguard.
## Conversations Carry Control Flow
Between rigid code paths and full model autonomy lies a third form. The AutoGen paper was posted to arXiv on August 16, 2023, with a self-reported length of 43 pages in its comment section. Its proposed multi-agent conversation framework enables customizable, conversational agents—combining LLMs, human input, and tools—and supports programming both in natural language and in code. Here, control flow is carried by *conversation protocols among agents*: the path is neither fully hardcoded nor fully entrusted to a single model, but *emerges from back-and-forth dialogue*. This article uses AutoGen solely for morphological contrast; multi-agent collaboration is covered elsewhere in this series—including a prior piece focused specifically on inter-agent communication protocols.
## Letting Agents Design Agents
A recursive form appears in the ADAS paper. Titled 'Automated Design of Agentic Systems,' it was posted to arXiv on August 15, 2024, and updated to its second version on March 2, 2025. The paper lacks a journal citation field, and this article makes no claim about its formal publication status. Its argument proceeds as follows: foundation models are already used as modules *within* agentic systems—examples include chain-of-thought, self-reflection, and Toolformer; and machine learning history shows that hand-designed solutions are eventually superseded by learned ones. Thus, the new field of ADAS aims to *automatically create powerful agentic system designs*, including inventing novel components and novel composition methods. The algorithm presented is called *Meta Agent Search*: a meta-agent iteratively programs new agents in code, maintains a growing archive of past discoveries, and invents the next agent based on that archive. Because the programming language is Turing-complete, this approach is theoretically capable of learning *any* possible agentic system—including new prompts, tool usages, workflows, and their combinations. Experiments report that, on coding, scientific, and mathematical tasks, the algorithm progressively invents new designs that significantly outperform state-of-the-art hand-designed agents—and retain advantages across domains and across models. The paper itself adds a caveat: *safe development is a prerequisite.* At this point, the fusion of automation and autonomous choice grows recursive: using autonomous methods to design automation.
## Three Judgments
Bringing together the four materials yields the following three judgments—none of which appear verbatim in the source texts.
Judgment One: The boundary between *workflow* and *agent* is *control-flow ownership*, not capability strength (our synthesis). A workflow is not a 'weaker' agent; an agent is not a 'more advanced' workflow. Both address the same question: *who decides the next step?* Designing for task fit—not maximizing autonomous action—is the shared priority, echoed in both vendors’ 'simplest solution' and 'deterministic solution may suffice' principles.
Judgment Two: The common essence of the five patterns is *encapsulating model judgment inside code-defined boxes* (our judgment). Reliability stems from the boxes; flexibility stems from the model *inside* them. 'Agentic-ness' is a continuous spectrum—not a binary switch—where gate density, delegation scope, loop exit conditions, and safeguard layering all represent positions along that spectrum.
Judgment Three: When design authority itself is delegated to agents, human work shifts from writing flows to writing *evaluations and boundaries* (our judgment). Archives grow; meta-agents program; yet *what counts as good*, *when to stop*, and *what must remain off-limits* still require human definition. This aligns with conclusions drawn in earlier pieces of this series: the layer mechanisms cannot resolve ultimately rests on human-written evaluations and constraints.
## What Different Readers Can Take Away
If you’re writing code: First ask—can the number of steps be predetermined? If yes, select the corresponding 'box' among the five patterns and insert programmatic checks between steps. If no, consider agents—and schedule sandbox testing and safeguards on the same ticket. Start with a single agent; exhaust its capabilities before considering multi-agent systems. If you’re making product decisions: Track latency, cost, and error compounding *separately*; increasing autonomy trades these three costs for improved task performance—assess value case-by-case. For scenarios failing to match the three characteristic features, a deterministic solution may suffice. If you’re simply observing this field: Autonomy is a *design choice*, not a progress metric. When hearing 'more agentic,' first ask *where control flow resides*, then ask *how strong the capability is*. In your own system: Is the next step written in code—or held in the model’s hands? Join the discussion in the comments.
Final Boundary Note: This article organizes four primary, publicly available sources—all archived verifiably before writing. Anthropic’s blog and OpenAI’s guide are internal vendor documents, containing references to their own models and products; related statements are paraphrased as 'as stated in the text.' The Anthropic page bears a post-publication revision record; this article uses the metadata publication date as its baseline and quotes the current live text. OpenAI’s guide citations derive from local extraction of the PDF’s text layer; file metadata indicates generation on April 7, 2025. Neither arXiv paper includes a conflict-of-interest disclosure on its abstract page; this article makes no assertions regarding that. Topics including multi-agent collaboration, inter-agent protocols, and tool invocation are covered in dedicated articles elsewhere in this series and are not repeated here.
Source: Anthropic, 'Building Effective Agents' https://www.anthropic.com/research/building-effective-agents