Chapter 4: Orchestration — Agent Execution Flow#

You give an Agent a task: “Help me research competing products and write an analysis report.”

What does it do first? Search for information? Or first outline the structure? After getting the search results, does it write the report directly, or first organize them into a table? After writing the report, does it give it to you directly, or first review it itself?

These decisions are what orchestration manages. Orchestration is the Agent’s skeleton — it determines the order and logic of how it works.

4.1 Starting with the Simplest Loop#

Think → Act → Observe#

The simplest Agent execution loop has only three steps:

Think: Analyze the current situation, decide what to do next. Act: Call a tool, execute an operation. Observe: Check the result, judge whether the goal is reached.

This is the ReAct loop discussed in Chapter 2. In each round of the loop, the Agent re-evaluates the situation and then decides the next step.

For example, you ask the Agent “help me check Tesla’s latest earnings revenue.”

First round: Think → I need to search for Tesla’s earnings report. Act → Call the search tool. Observe → Found the earnings PDF link.

Second round: Think → I need to read this PDF. Act → Call the file reading tool. Observe → Got the earnings content.

Third round: Think → I need to extract revenue data from the earnings report. Act → Analyze the text, find the revenue numbers. Observe → Task complete, output the result.

Three rounds, three steps, done.

A Key Design: Step Limit#

When does the loop end? Under normal circumstances, the Agent stops itself after judging the task is complete. But there’s a dangerous scenario: the Agent falls into an infinite loop — repeatedly searching, repeatedly analyzing, repeatedly modifying, never delivering results.

You must set a step limit for the Agent. Empirical data shows that within 10 steps is the safe zone. Beyond 10 steps, error probability and cost both increase sharply.

How to implement: In LangGraph, set the step limit via the recursion_limit parameter:

Limitations of Single Agent#

The single Agent pattern suits simple tasks. But complex tasks have three problems:

Information overload. One Agent has to search, analyze, and write — the context window gets filled up quickly. It’s like one person doing three things at once, not doing any of them well.

Error accumulation. Assuming each step has a 95% success rate, the overall success rate after 10 steps is only 60%. The more steps, the worse the cumulative error.

Single capability. It’s hard for one Agent to be good at searching, analyzing, writing, and coding all at once. It’s like it’s hard for one person to be a good programmer, good designer, and good product manager all at once.

So, complex tasks require more advanced orchestration patterns.

4.2 Workflow vs Autonomous Agent: First Figure Out Which You Need#

Anthropic made an important distinction in “Building Effective Agents”: Workflow and Agent are two different things. Many teams mix them up, and end up building unnecessarily complex systems.

Workflow#

A Workflow uses pre-defined code paths to orchestrate model calls.

The developer designs the process in advance: first call the model to do A, then call the model to do B based on the result, then pass B’s result to C. The entire process is fixed and predictable.

It’s like an assembly line: what each step does and how it does it are all pre-designed.

Advantages: Controllable, predictable, easy to debug. You know what will happen at each step.

Disadvantages: Not flexible. If it encounters a situation the designer didn’t anticipate, the Workflow won’t automatically adjust.

Agent (Autonomous Agent)#

An Agent is about letting the model dynamically guide its own process.

The model itself decides what to do next, which tools to use, and when to stop. You give it a goal, and it uses its own judgment to complete it.

Advantages: Flexible. Can handle situations the designer didn’t anticipate.

Disadvantages: Unpredictable. You don’t know which path it will take, or whether it will make mistakes.

How to Choose#

Anthropic’s advice: first use the simplest method.

If a pure model can complete the task, don’t add Harness. If adding one tool can handle it, don’t add ten. If a fixed Workflow can meet the requirements, don’t make it an Agent.

Only when simple solutions truly can’t meet the requirements should you gradually increase complexity.

This isn’t laziness, it’s engineering wisdom. The simpler the system, the more reliable, the easier to maintain, the easier to debug.

4.3 Directed Graph: Turning Flow into Executable Code#

Why Do We Need Directed Graphs#

You designed an Agent flow: search → analyze → write → review. This flow is clear in your mind, but how do you turn it into executable code?

LangGraph’s answer is: use a directed graph.

Nodes are operations (search, analyze, write), edges are transition conditions (search complete → enter analyze, analyze complete → enter write).

This modeling approach has several benefits:

Visualizable. You can draw the Agent’s complete execution flow, clear at a glance.

Debuggable. When problems occur, you know at which node the error occurred, which edge’s condition judgment was wrong.

Composable. Complex Agents can be composed from multiple simple subgraphs.

Supports loops. Directed graphs naturally support loops — the Agent can repeatedly execute a certain node until the condition is met.

Conditional Branching#

Agents aren’t linear. They need to make branching decisions based on intermediate results.

For example: Found useful information → enter analysis. Found irrelevant information → change keywords and re-search. Search failed → ask user for supplementary information.

LangGraph uses conditional edges to implement this kind of branching logic. One node can have multiple outgoing edges, each corresponding to one condition. After the Agent finishes executing the node, it selects which edge to follow based on the result.

Parallel Execution#

Some operations can be performed simultaneously.

For example: the Agent needs to search for information from three different sources. These three searches can be executed in parallel, no need for serial waiting.

LangGraph supports parallel execution — multiple nodes within the same super-step can run simultaneously. This can significantly shorten the Agent’s execution time.

4.4 Human in the Loop: Which Links Need Human Intervention#

Why Do We Need Humans#

Agents aren’t omnipotent. In the following scenarios, human intervention is needed:

High-risk operations. Deleting files, sending emails, modifying databases — once these operations are done wrong, they’re irreversible. Having a person confirm before execution is a necessary safety measure.

Ambiguous decisions. The Agent encountered two possible interpretations, unsure which one the user wants. For example, the user says “help me process that file,” the Agent is unsure which file.

Quality check. After the Agent finishes writing a report, have a person review it before publishing.

Intervention Modes#

Approval mode. The Agent pauses at key nodes, continues only after human approval. Suitable for high-risk operations.

Correction mode. After the Agent finishes executing, it displays the results; the human can modify or redo. Suitable for content creation.

Guidance mode. The Agent proactively asks when uncertain; the human provides direction. Suitable for exploratory tasks.

4.5 Multi-Agent Collaboration: When Do You Need Multiple Agents#

Why Do We Need Multi-Agents#

When a single Agent handles complex tasks, it encounters three problems:

The context window gets stuffed. One Agent has to search, analyze, write, and review — all information is crammed into one context, and it exceeds the limit quickly.

Role confusion. One Agent simultaneously plays the roles of search expert, analyst, writer, and reviewer, and isn’t professional enough at each role.

Error amplification. Errors made by one Agent affect all subsequent steps, with no cross-checking.

Multi-Agent collaboration solves these problems: split the task among multiple specialized Agents, each doing its own job, coordinating with each other.

Common Collaboration Patterns#

Pattern 1: Supervisor-Worker

One Supervisor Agent is responsible for breaking down tasks and assigning work; multiple Worker Agents are responsible for executing specific tasks.

This is the most common pattern, suitable for scenarios where tasks can be clearly divided.

Pattern 2: Pipeline

Agents process in sequence. The first Agent finishes processing, passes the result to the second. Like a factory’s assembly line.

Suitable for scenarios where tasks have a clear sequential order.

Pattern 3: Verifier-Critic

One Agent is responsible for generation; the other Agent is responsible for checking. Generator writes code; Verifier runs tests. Writer writes articles; Critic checks facts and logic.

This pattern can pull up output quality.

The Cost of Multi-Agents#

Multi-Agents aren’t free. They have several costs:

Increased Token consumption. Each Agent needs its own context. The Token consumption of multi-Agent systems is typically 10-15x that of a single Agent.

Coordination overhead. Information needs to be passed between Agents, states synchronized, conflicts resolved.

Error amplification. Research has found that independent Agent systems can amplify errors by a factor of 17.

How to optimize: Use small models for inner loops. In multi-Agent systems, many Agents only need to do simple operations (search, organize, format conversion). These Agents can use small models with 8B parameters, such as DeepSeek V4-Flash ($0.14/million tokens), which is fast and cheap. Only core decision-making Agents need large models.

Chapter Summary#

Orchestration is the Agent’s execution flow. Core points:

1. Basic loop of single Agent: Think → Act → Observe. Set a step limit, avoid infinite loops.
2. Workflow vs Agent: Use Workflow if you can, not Agent — simplest first.
3. Directed graph modeling: Use nodes and edges to define execution flow, supporting loops, branches, and parallelism.
4. Human in the loop: Have humans intervene at key nodes, not at every step.
5. Multi-Agent collaboration: Each has suitable scenarios. Multi-Agents have costs; optimize by using small models for inner loops.

The next chapter covers the second subsystem of Harness: Tools. How Agents “use” external capabilities.