Anthropic’s Agent Development: The Counter‑Intuitive “Less Is More” Principle

Anthropic recently published a blog post on agents, concluding that the future of AI development lies in the principle “Less is More.”

Definition of Agent

Although many assume an agent is a product of large language models (LLMs), its modern definition dates back to the 1950s and was formally introduced by Marvin Minsky in 1972. An AI agent should perceive the world, reason, and act.

Anthropic splits agents into two categories:

Workflows : Pre‑defined code paths that orchestrate LLMs and tools in a clear, controllable sequence.

Agents : Systems where the LLM dynamically guides its own process and tool usage, acting as an autonomous decision‑maker.

The key distinction is whether the LLM can dynamically control its own workflow and tool usage.

Framework Myth: Returning to the Essence of LLM APIs

When building LLM applications, follow the “keep it simple” rule: use the simplest solution that works and only introduce complexity when required, as more complex agent systems incur higher latency and cost.

Use a workflow when the task is well‑defined and can be broken into fixed steps; use an autonomous agent when the task demands flexibility and self‑decision.

Agent Frameworks

LangGraph (an extension of LangChain) – a modular “Lego‑like” toolkit for building complex agents.

Amazon Bedrock AI Agent framework – a professional toolbox for constructing agents.

Rivet – a drag‑and‑drop GUI LLM workflow builder.

Vellum – an advanced tool for building and testing complex workflows.

These frameworks simplify LLM calls and tool definitions but add abstraction layers that can obscure prompts and responses, making debugging harder.

“Many patterns can be implemented in a few lines of code. If you use a framework, ensure you understand the underlying code; mistaken assumptions about the fundamentals are a common source of customer errors.”

Less Is More – Core Development Path

Start with an enhanced LLM (with retrieval, tool use, memory). Then adopt workflow patterns such as Prompt Chaining, Routing, Parallelization, Orchestrator‑Worker, and Evaluator‑Optimizer. Finally, progress to autonomous agents that can plan and execute complex tasks.

Prompt Chaining

Break a task into sequential steps, each LLM call handling the previous output, allowing programmatic checks at each stage.

Routing

Classify inputs and direct them to specialized downstream tasks, e.g., routing simple queries to a smaller model and complex ones to a larger model.

Parallelization

Run independent sub‑tasks simultaneously or use multiple votes to improve reliability, useful for safety checks or performance evaluation.

Coordinator‑Worker Model

A central LLM decomposes tasks and assigns sub‑tasks to worker models, then aggregates results—ideal for dynamic, unpredictable workflows such as code modification.

Evaluator‑Optimizer Model

One LLM generates responses while another evaluates and provides feedback in a loop, effective for tasks with clear evaluation criteria like literary translation or multi‑round search.

Autonomous Agents: The Future

When LLMs master complex input understanding, planning, tool use, and error recovery, agents can handle open‑ended problems without predefined steps, pausing for human intervention when needed and enforcing stop conditions to avoid infinite loops.

Agent clusters excel at large‑scale, flexible tasks in controlled environments, but require trust in their decision‑making.

Anthropic’s Three Core Principles for Building Agents

Keep designs simple; avoid unnecessary complexity.

Prioritize transparency; clearly show planning steps.

Design the Agent‑Computer Interface (ACI) carefully with thorough tool documentation and testing.

The overarching message is that success in LLM‑based systems comes from building the simplest solution that meets the need, iterating with evaluation, and only adding multi‑step agent systems when simpler approaches fall short.