Before you start
4- You know what an AI agent is: a model that decides which steps or tools to use to reach a goal.
- You have a concrete project or use case in mind, with a task you can describe in a few sentences.
- You can run a short script with a recent Python 3 interpreter (the script uses only the standard library), or you are happy to do the scoring on paper.
- No agent framework is required. This guide does not name or depend on any.
A single-agent system puts one autonomous entity in charge of all tasks. A multi-agent system divides the work between several agents. The question is not which is more advanced. The question is which one your task needs.
Start with the simpler design. One agent is easier to build, easier to debug and easier to reason about, because there is one place where decisions are made and one trace to read. Add agents only when you can name a specific problem that one agent does not solve.
This guide gives you five steps. You describe the task, run it with one agent, look for concrete reasons to split the work, score those reasons, and record the decision together with the evidence that would change it.
The signals and the scoring rule in this guide are a working heuristic, not a standard. Adjust them to your project. Product-specific details, such as how a given framework defines or connects agents, are not covered here. Check that framework's official documentation for those.
Step 1 of 5: Describe the task and its subtasks
Write the goal of the project in one sentence, then list every subtask the system must perform, one per line.
This list is your evidence base. Without it, the decision rests on preference. With it, you can point at the exact subtasks that justify a split, or show that none do.
For each subtask, note three things: the tools or data it touches, the permissions it needs, and whether it depends on the output of another subtask. Keep notes short. A table with four columns is enough.
Step 2 of 5: Run the whole task with one agent
Build the simplest version in which one agent handles every subtask, and run it on a small set of realistic inputs.
This gives you a baseline. A design that is more complex than needed costs you build time, debugging time and coordination overhead, so you should know what the simple version actually does before you reject it.
Record where it fails. Write down the failure itself, for example a wrong tool choice, forgotten instructions in a long run, or a result nobody checked. Vague notes such as "too complicated" do not help in the next step.
Step 3 of 5: Check each failure and subtask for a split signal
Go through your notes and ask whether any of the five signals below is present. Answer yes only when you can point to a specific subtask or failure.
- The subtasks need different tool sets or permissions. Separating them limits what each agent can do.
- The subtasks can run in parallel and doing so saves real time.
- One agent cannot hold all the instructions and data it needs at once, and the run degrades as a result.
- An independent reviewer should check the work of the agent that produced it.
- Different parts of the system are owned and maintained by different teams.
Each signal describes a problem that a single agent handles badly. If none applies, a second agent adds cost without removing a problem.
Step 4 of 5: Score the signals with a short script
Copy the script below, set each answer to True or False from step 3, and run it. It counts the signals and prints a recommendation.
Writing the rule down makes the decision repeatable. Anyone on your team can rerun it with their own answers and compare results.
The rule is deliberate: no signals means one agent; exactly one signal means one agent first, with that single problem handled inside it; two or more means a multi-agent design is worth prototyping.
SIGNALS = [
"subtasks need different tool sets or permissions",
"subtasks can run in parallel and save real time",
"one agent cannot hold all instructions and data at once",
"an independent reviewer should check the producer's work",
"different parts are owned by different teams",
]
# Set one answer per signal, in the same order as SIGNALS.
ANSWERS = [True, False, False, True, False]
def recommend(answers):
present = [s for s, a in zip(SIGNALS, answers) if a]
if len(present) == 0:
verdict = "single agent"
elif len(present) == 1:
verdict = "single agent first, handle the one signal inside it"
else:
verdict = "multi-agent, prototype it"
return present, verdict
if __name__ == "__main__":
present, verdict = recommend(ANSWERS)
print(f"Signals present: {len(present)} of {len(SIGNALS)}")
print(f"Recommendation: {verdict}")
for s in present:
print(f"- {s}")
Step 5 of 5: Record the decision and what would change it
Write a short decision record: the task sentence, the signals you found, the recommendation, and one measurable trigger for revisiting it.
The trigger keeps the decision honest. For example: "Revisit if the single agent fails the same kind of case in more than a set share of test runs." Choose your own threshold from your baseline in step 2.
If you chose multi-agent, also write down which signal each agent exists to address. An agent with no matching signal is a candidate for removal.
Expected result
Running the script with the example answers prints the following: ``` Signals present: 2 of 5 Recommendation: multi-agent, prototype it - subtasks need different tool sets or permissions - an independent reviewer should check the producer's work ``` You also have a one-page decision record with the task sentence, the signals, the recommendation and a revisit trigger.
Frequently asked questions
What is the difference between a single-agent and a multi-agent system?
A single-agent system puts one autonomous entity in charge of all tasks. A multi-agent system divides the tasks between several agents.
Should I start with a multi-agent system?
No. Start with one agent and a baseline. Move to several agents only when you can name a specific signal, such as different permissions or a need for independent review, that one agent does not handle.
How many signals justify a multi-agent design?
In this guide's heuristic, two or more. One signal can usually be handled inside a single agent. The threshold is a working rule, so adjust it to your project.
Does this guide depend on a specific framework?
No. The steps and the script work without one. For framework-specific setup, use that framework's official documentation.
From Grokem: https://www.grokem.com/ai-and-machine-learning/ai-agents/multi-agent-systems/single-or-multi-agent-ai-system-a-five-step-test-for-your-projects-needs







