How to Build Effective AI Agents: Key Principles, Patterns, and When to Use Them

Motivation for a cloud memory component

Agents that need to retain information across sessions, users, or instances cannot rely on short‑term local context alone. A persistent memory service such as memOS provides the long‑term, cross‑session storage required for such agents.

Workflow vs. Agent

LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.

Workflow : LLM and tools are orchestrated through predefined code paths; the control flow is scripted in advance.

Agent : The LLM decides its own control flow, selects tools, and determines steps at runtime.

Limitations of current workflow platforms

Tools such as Dify, RagFlow, and Coze enable rapid prototyping but produce long, node‑heavy workflows that are as inflexible as hand‑written code. They are better suited for proof‑of‑concept rather than production‑grade agents.

When an agent‑specific memory component is required

Local context solves short‑term, single‑turn memory. When an agent must remember information across days, users, or instances, an external memory component (e.g., memOS) becomes essential.

Anthropic’s three criteria for deploying an agent

Task cannot be expressed by a fixed flow – the execution path is dynamic and cannot be enumerated beforehand.

Frequent, flexible tool invocation – the system must decide on‑the‑fly which tools to call.

Highly feedback‑driven environment – errors (e.g., code execution failures) must be observed, corrected, and retried until success.

Many current business scenarios satisfy only the first two criteria and therefore do not yet need fully autonomous agents.

Six construction patterns (from simple to complex)

Prompt Chaining : Sequential prompts where each step consumes the previous output. Example: generate outline → verify quality → expand into full text.

Routing : Classify input first, then direct it to a specialized pipeline. Example: simple queries routed to Haiku, complex queries routed to Sonnet.

Parallelization : Run independent sub‑tasks concurrently and optionally aggregate results via voting. Example: multiple reviewers independently scan code for vulnerabilities and flag issues.

Orchestrator‑Workers : A central LLM dynamically decomposes a task and delegates subtasks to worker LLMs when subtasks cannot be predicted ahead. Use cases include programming products that modify many files per iteration and search tasks that gather information from multiple sources.

Evaluator‑Optimizer : One LLM generates output, a second LLM evaluates and provides feedback, forming an iterative improvement loop. Example applications are literary translation (where subtle nuances are refined) and complex multi‑round search tasks (where the evaluator decides whether further searches are needed).

Fully Autonomous Agent : Multi‑turn, self‑directed execution that continuously adapts to environmental feedback. This pattern incurs the highest cost and risk but offers the greatest capability.

Core engineering principles

Keep it simple – always verify whether the simplest solution satisfies the problem.

Transparency – explicitly expose planning steps to aid debugging and comprehension.

Clear tool interfaces – document tool contracts with the same rigor as code comments for junior developers.

Anthropic’s SWE‑bench experiments showed that converting relative file paths to absolute paths eliminated an entire class of agent errors, underscoring the importance of precise tool design.

Practical warning

Start simple and let demand drive complexity, not the other way around.