TL;DR — Start Here

The shortest path to understanding how agents are actually built:

1. Read Anthropic — Building Effective Agents (the workflows-vs-agents distinction + 5 core patterns) and Lilian Weng — LLM Powered Autonomous Agents.
2. Understand the loop: ReAct (reason+act) is the canonical single-agent loop; Reflexion adds self-correction; CodeAct makes the action space executable code.
3. Pick a framework: LangGraph (graph/state) or OpenAI Agents SDK (minimal) or smolagents (code-as-action). For coding: OpenHands or Aider.
4. Learn the standard: MCP (Model Context Protocol) — how agents connect to tools/data.
5. Benchmark it: SWE-bench Verified (coding), GAIA (general assistant), τ-bench (tool+user), Terminal-Bench (terminal).

💡 The most important design lesson (Anthropic): start with the simplest thing that works. Use predictable workflows for well-defined tasks; reserve autonomous agents for when you genuinely need model-driven flexibility. Frameworks add abstraction that can obscure your prompts — consider going without one first.

Concepts & Architecture

Harness vs framework vs scaffolding vs agent vs workflow

The terminology is genuinely contested. The distinctions practitioners actually draw:

One-liner: Agent = the autonomous decision-maker · Harness = the runtime wrapping it · Scaffolding = the static setup that assembles the harness · Framework = the library you build harnesses with · Workflow = orchestration where code, not the model, holds control.

mindmap
  root((Agent Harness))
    Loop patterns
      ReAct
      Plan-and-Execute
      ReWOO
      Reflexion
      Tree of Thoughts
    Topologies
      Single agent
      Supervisor / workers
      Group chat / debate
      Handoffs / swarm
      Network / graph
    Components
      Tool calling
      Context management
      Memory
      Planning
      Sandboxing
      Human-in-loop
      Observability
    Philosophies
      Simple first
      Context engineering
      Code-as-action
      MCP standard

The agent loop & reasoning patterns

The core control loop is perceive → reason → act → observe, repeated until a stop condition. Patterns differ in how reasoning, acting, and observation interleave.

flowchart LR
    G[Goal] --> R[Reason / Plan]
    R --> A[Act: call tool]
    A --> E[(Environment / tools)]
    E --> O[Observe result]
    O -->|not done| R
    O -->|reflect| RF[Self-reflection]
    RF --> R
    O -->|done| F[Final answer]

• ReAct (Reason + Act) — interleaves reasoning traces with actions; reasoning helps track plans and handle exceptions. The canonical single-agent loop.
• Plan-and-Solve — split into a planning stage (decompose into sub-tasks) then an execution stage. Cuts missing-step errors.
• ReWOO — Planner/Worker/Solver; plans the full chain up front so it isn't re-prompted on each observation (~5× fewer tokens than ReAct).
• Reflexion — verbal self-reflection stored in episodic memory; "linguistic" reinforcement without weight updates.
• Tree of Thoughts — explore a tree of reasoning paths with self-evaluation, lookahead, backtracking (Game-of-24: 4% → 74%).
• Evaluator-Optimizer — one LLM generates, another evaluates/feeds back in a loop until quality criteria are met.

Orchestration topologies

flowchart TB
    subgraph single[Single agent]
      S1((Agent))
    end
    subgraph sup[Supervisor / workers]
      O((Orchestrator)) --> W1((Worker)) & W2((Worker)) & W3((Worker))
    end
    subgraph swarm[Handoffs / swarm]
      H1((Agent A)) <-->|handoff| H2((Agent B))
      H2 <-->|handoff| H3((Agent C))
    end

• Single agent — one LLM in a tool loop until it produces a final answer (the ReAct loop).
• Supervisor / orchestrator-workers — a central LLM decomposes the task, delegates to workers, synthesizes results. Subtasks determined by input, not predefined.
• Hierarchical — supervisors of supervisors; a multi-level tree.
• Sequential pipeline (prompt chaining) — ordered steps, each processing the previous output, with optional gates.
• Group chat / debate — agents take turns in a shared context; a selector or round-robin picks the speaker (AutoGen).
• Handoffs / swarm — agents delegate via a tool call while sharing message context; decentralized routing, no central orchestrator.
• Blackboard — agents read/write a shared state store until a solution emerges.
• Network / graph — execution as nodes + (conditional) edges over shared state, with cycles for loops/retries/reflection (LangGraph's model).

Core harness components

Design philosophies

• Simple first (Anthropic) — find the simplest solution; add complexity only when demonstrably needed; consider skipping frameworks.
• **Context engineering