Everything covered so far in this series' AgentScope posts — the unified message system, the ReAct-based agent abstraction, memory, tools, and model integration — comes together most concretely when building an actual multi-agent application. This post walks through what that process looks like in practice, from deciding on an architecture to getting a coordinated system running.
Step 1: Decide Whether Multi-Agent Is Actually Justified
Before writing any code, revisit the question covered in the single-agent-vs-multi-agent post: does this task genuinely benefit from specialization or parallelism, or would a single, well-designed agent handle it just as well with less complexity? A common, well-suited example for multi-agent design: a content research and drafting pipeline, where a research agent gathers information, a writing agent drafts content based on that research, and a review agent checks the draft against quality criteria — three genuinely distinct roles, each benefiting from its own focused prompt, tools, and possibly even a different underlying model (as covered in the model integration post).
Step 2: Define Each Agent's Role and Scope
For each agent in the system, define what it does, what tools it needs, and what it explicitly should not be responsible for — connecting directly to the tool design and clarity principles covered earlier in this series:
- Research agent — has access to web search and document retrieval tools (potentially backed by the vector search and RAG techniques covered earlier in this series); its job ends at gathering and organizing relevant information, not drafting content.
- Writing agent — takes the research agent's output as input and produces a draft; has no search tools of its own, keeping its role tightly scoped to writing.
- Review agent — evaluates the draft against a defined rubric (connecting to the prompt testing strategies post's emphasis on written evaluation criteria) and either approves it or sends it back with specific feedback.
Step 3: Design the Communication Flow
Using the message-passing patterns covered in the agent communication post, decide how these agents actually hand work to each other:
A sequential handoff pattern fits this example well: research agent completes its work and passes results to the writing agent, which passes its draft to the review agent, which either approves or sends feedback back to the writing agent for revision.
Because AgentScope represents all of this through the same unified Msg object (covered in the architecture post), this handoff logic doesn't require a separate communication protocol — it's built from the same structures used throughout the rest of the framework.
Step 4: Configure an Orchestrating Layer
For anything beyond the simplest fixed pipeline, it's often useful to have a coordinating agent (or explicit orchestration logic) responsible for routing work between specialized agents, handling the review agent's approve/revise decision, and determining when the overall task is actually complete — connecting to the "knowing when to stop" challenge covered in the autonomous agents post. This orchestration layer is where the higher-level task logic lives, distinct from any individual specialized agent's own reasoning.
Step 5: Set Up Memory Scoping
As covered in the AgentScope memory post, decide what each agent needs to remember and what should stay scoped to its own role. The writing agent needs the research agent's findings, but likely doesn't need the research agent's full search history and dead-end queries — only the relevant, distilled output. Getting this scoping right keeps each agent's context focused and avoids the token cost and potential confusion of passing unnecessary information downstream.
Step 6: Choose Models Per Agent
Using AgentScope's model-agnostic integration (covered in the previous post), assign models appropriate to each agent's role — perhaps a faster, cheaper model for the research agent's more mechanical retrieval work, and a more capable model for the writing and review agents' more nuanced reasoning. This kind of per-agent tuning is one of the more practical benefits of multi-agent design covered in the single-agent-vs-multi-agent post.
Step 7: Add Human Checkpoints Where Warranted
Connecting to the human-confirmation principle covered in the prompt injection prevention post: even in a largely autonomous pipeline, it's often worth adding a human review step before a final draft is published or acted upon — especially early in a system's life, before its reliability has been established through the kind of systematic testing covered in the prompt testing strategies post.
Step 8: Test and Debug Using AgentScope's Tooling
As covered in the architecture post, AgentScope's visual studio and evaluation tooling give direct visibility into each agent's reasoning, message exchanges, and tool calls — genuinely useful for a multi-agent system specifically, where debugging by log-reading alone (as noted in the agent communication post) gets difficult fast once several agents are interacting. Running the full pipeline against a representative, deliberately varied set of test inputs — echoing the prompt testing strategies post — before relying on it in production is worth the same discipline applied to any other AI system in this series.
A Simplified Illustration
research_agent = ReActAgent(name="researcher", model=fast_model, tools=[web_search, retrieve_docs])
writer_agent = ReActAgent(name="writer", model=capable_model, tools=[])
reviewer_agent = ReActAgent(name="reviewer", model=capable_model, tools=[])
def run_pipeline(topic):
research = research_agent(Msg(name="user", content=f"Research: {topic}"))
draft = writer_agent(Msg(name="researcher", content=research.content))
review = reviewer_agent(Msg(name="writer", content=draft.content))
if review.metadata.get("approved"):
return draft
return writer_agent(Msg(name="reviewer", content=review.content)) # revise based on feedback
This sketch captures the shape of the pattern — sequential handoff through consistent Msg objects, each agent scoped to its own role — even though a real implementation would add more robust error handling, iteration limits, and human checkpoints.
The Bottom Line
Building a multi-agent application with AgentScope means applying the framework's core components — the unified message system, ReAct-based agents, scoped tools and memory, and flexible model integration — to a task deliberately decomposed into distinct, well-scoped roles, connected through clear communication patterns and, where warranted, human oversight. The framework's consistent underlying abstractions mean this process is an extension of the same principles used for a single agent, not a fundamentally different set of tools — making the jump from single-agent to coordinated multi-agent systems a matter of composition rather than a rebuild.