Concepts / Designing Multi-Agent Systems

Designing Multi-Agent Systems

The source recommends not reaching for multi-agent systems in a first build; the practical starting point is one agent or, more likely, just a workflow.

  • Programming

The Instinct to Design Big First

When people first build an AI system, a common instinct is to design the most capable version they can imagine from the beginning. For many, that means several cooperating agents, each with its own role, passing work to one another. The intuition is understandable: if the problem is hard, it seems that a sophisticated architecture should be the starting point.

The source argues that this instinct is a misconception. This article walks through what the source recommends instead: build something simple first, watch how it behaves on real cases, and only then decide where an agent is actually needed. Along the way you will see how each stage of that sequence feeds the next, and how the agent's job is pinned down before it is built.

Starting With a Workflow

The source's recommendation is tighter than simply choosing a smaller system. For the first slice of work, it says not to reach for multi-agent designs at all. The default move is to build one agent or, more likely according to the source, no agent at all, just a workflow.

A workflow is the simpler starting point because the sequence of steps is set up in advance, and the system follows that structure. A multi-agent system, by contrast, involves several agents with their own roles that hand work to one another. The workflow is easier to reason about because its path is fixed before it runs. The source also points out that building a workflow first gives you something concrete that can actually run.

Read the diagram as a column comparison. The left column describes the workflow, where the path is decided beforehand. The right column describes a multi-agent system, where several agents with separate roles coordinate. The source's advice is that the left column is where a first build should begin, because it is the design you can get running and study before adding anything more complex.

Tracing the Build Cycle

The source describes a sequence of stages rather than a single decision. First, the workflow is built. Second, it is deployed to production so its real behavior can be observed. Third, the production traces are examined. Fourth, the agent's job is specified. Only after that is an agent built. Each stage depends on the one before it: the workflow must exist before it can be observed, and the observations must exist before the agent's job can be specified.

The diagram shows the five stages as a chain, with the last arrow returning from the built agent to the observation stage. The source writes the sequence as a chain that ends in an agent. The return arrow is a reasonable reading rather than an explicit rule from the source: once an agent is running, its production traces can be examined in the same way, so the observation step can repeat. Treat the loop as a way of keeping every new agent tied to evidence from real use.

Reading Production Traces

Once the workflow is live, the source says to watch the production traces. A trace is the record of how the workflow handled actual cases in production. The source relies on these records to decide where an agent should go. The key idea is that the cases the workflow handles poorly will indicate where the agent is needed. In other words, the weak spots of the workflow point toward the job the agent should take on.

This changes what a good agent proposal looks like. Instead of asking where an agent might be interesting, you ask which specific cases the workflow fails to handle and what decision would resolve them. The trace supplies the evidence for both questions.

Worked example

Locating an Agent Need in a Refund Workflow

A hypothetical team runs a fixed workflow that handles customer refund requests. The steps are: read the request, check the order date, and approve the refund if the order is within the return window. Production traces show that most requests are handled correctly, but a cluster of requests mentions a damaged item and a partial shipment, and the workflow rejects them because they fall outside the simple date rule. Where does an agent belong?

  1. 1
    Read the trace for the failing cases

    The traces show the workflow handles the ordinary date-based cases well. The failures cluster on requests that mention damage or partial shipments.

  2. 2
    Name the decision the workflow cannot make

    The workflow has no step that judges whether a damage description justifies a refund. That judgment is the weak spot the traces expose.

  3. 3
    Locate the agent's place in the sequence

    The agent's job is to make that one judgment at the point where the fixed date rule stops being sufficient, and nothing else needs to change yet.

Result

The agent is justified by the observed failure cluster, not by a guess that refunds need an intelligent system. Its job is narrow and grows directly out of the traces.

Specifying an Agent's Job

After observation, the source says the agent has a clear job. That job is stated in three parts: a specific decision the agent makes, the specific tools it uses, and the specific human escalation path it follows. Each part narrows the agent's responsibility. The decision defines what the agent is responsible for choosing. The tools define what it can act with. The escalation path defines when a human must take over.

The concept map shows the agent job at the top with its three parts beneath it. Read each edge as a question the specification must answer. The decision answers what the agent chooses. The tools answer what it can act with. The escalation path answers when control returns to a person. A specification that leaves any one of these vague is not yet a concrete design.

What do you think happens?

Two agents are proposed. One is designed into the original architecture before any deployment. The other is built after production traces showed where the workflow fails, and its job is specified as one decision, specific tools, and a human escalation path. Which is more likely to work, and why?

  • The agent designed into the original architecture, because it was planned from the start

  • The agent built from observed shortcomings, because its purpose was defined precisely

Reveal answer
Answer:

The agent built from observed shortcomings, with its job precisely specified, has a much higher chance of working.

The source compares the two designs and says the difference is not in how sophisticated the agent is. It lies in how precisely the agent's purpose was defined before it was built, and that purpose comes from observed shortcomings.

Mistakes When Starting Big

  • Common mistake

    Reaching for a multi-agent design in the first build

    Why it fails

    The source says that for the first slice of work, multi-agent designs should not be reached for at all. A first build of several cooperating agents adds complexity before there is evidence that it is needed.

    Do this instead

    Build a workflow first, or at most one agent, and get something concrete running.

  • Common mistake

    Designing the agent before the workflow is deployed

    Why it fails

    Until the workflow runs against real inputs, there is little evidence about where it struggles. An agent designed earlier is justified by assumption rather than by observed problems.

    Do this instead

    Deploy the workflow to production so its real behavior can be observed before deciding on an agent.

  • Common mistake

    Treating a vague wish for an agent as a design

    Why it fails

    The source states that the agent's job should be specified as one decision, with specific tools and a specific human escalation path. A general wish for something intelligent specifies none of these.

    Do this instead

    Write down the one decision, the tools it needs, and the point at which a human takes over before building anything.

  • Common mistake

    Judging an agent by how sophisticated it is rather than how precisely its purpose is defined

Applying the Cycle to a New Problem

MEDIUM

A team wants to automate the sorting of incoming support messages. Describe the first thing you would build, what you would look for in production traces, and then write a three-part specification for a possible agent: its one decision, its tools, and its human escalation path. Use the observations from production to justify the agent.

Hints
  • Start by asking what the simplest runnable version of the system is, following the source's advice about workflows.
  • Look for the cases the workflow handles poorly in the traces, since those indicate where an agent is needed.
  • Keep the decision narrow so that the tools and escalation path follow from it.

Key Takeaways

  • The source recommends not reaching for multi-agent systems in a first build; the practical starting point is one agent or, more likely, just a workflow.
  • The build sequence is a chain: build a workflow, deploy it to production, observe its traces, specify the agent's job, and then build the agent.
  • Production traces reveal the cases a workflow handles poorly, and those weak spots indicate where an agent is needed.
  • An agent's job is specified as one decision, a set of specific tools, and a specific human escalation path, and precision of purpose matters more than sophistication.