Building Modular Multi-Agent Architectures Using Strands Agents

Introduction

Building sophisticated AI systems often means combining the strengths of multiple specialized agents. Strands Agents makes it easy to build modular, collaborative agent systems with a few well-defined patterns. Let’s explore the core collaboration styles:

Router + Specialists (Orchestrator)
Agent‑as‑Tool (Hierarchical Delegation)
Graph-based Workflows
Swarm Collaboration (Peer Teams)

These styles are directly supported in Strands 1.0, offering flexible, composable multi-agent architectures.

Pioneers in Cloud Consulting & Migration Services

Reduced infrastructural costs
Accelerated application deployment

Get Started

Router + Specialists (Orchestrator)

In this pattern, a central “orchestrator” agent receives user requests and “routes” them to the most capable specialist, much like a team lead directing tasks.

Built by wrapping specialized agents with the @tool decorator so they can be invoked as tools.
The orchestrator chooses the right specialist based on the request and compiles the final answer.

Example:

from strands import Agent, tool
from strands_tools import calculator

@tool
def MathExpert(q: str) -> str:
    return str(Agent("Solve math step-by-step", tools=[calculator])(q))

@tool
def PolicyExpert(q: str) -> str:
    return str(Agent("Explain company policies clearly.")(q))

router = Agent(
    system_prompt="Route math queries to MathExpert, policy questions to PolicyExpert.",
    tools=[MathExpert, PolicyExpert]
)

from strands import Agent, tool

from strands_tools import calculator

@tool

def MathExpert(q: str) -> str:

return str(Agent("Solve math step-by-step", tools=[calculator])(q))

@tool

def PolicyExpert(q: str) -> str:

return str(Agent("Explain company policies clearly.")(q))

router = Agent(

system_prompt="Route math queries to MathExpert, policy questions to PolicyExpert.",

tools=[MathExpert, PolicyExpert]

)

This pattern provides centralized control, easy debugging, and modular design.

Agent as Tool (Hierarchical Delegation)

This design lets any agent use another agent as a tool, embedding deep functionality within a broader workflow.

Enables hierarchical delegation: one agent can rely on another expert agent without reimplementing logic.
Encourages clean separation and reusability of agent roles.

Example:

from strands import Agent, tool

ComplianceAgent = Agent("Check drafts for policy violations.")

@tool
def check_policy(text: str) -> str:
    return str(ComplianceAgent(text))

DraftAgent = Agent(
    system_prompt="Write a policy summary, then use check_policy before presenting it.",
    tools=[check_policy]
)

from strands import Agent, tool

ComplianceAgent = Agent("Check drafts for policy violations.")

@tool

def check_policy(text: str) -> str:

return str(ComplianceAgent(text))

DraftAgent = Agent(

system_prompt="Write a policy summary, then use check_policy before presenting it.",

tools=[check_policy]

)

Graph Workflows (Agent Networks)

Graph-based workflows connect agents bidirectionally or hierarchically, not just in a linear chain, forming complex processing pipelines.

Supports links across agents representing task flows.
Ideal for modular, branching processes such as document pipelines or multi-role orchestration.

Example:

from strands import Agent

Ingestor = Agent("Ingest files.")
Extractor = Agent("Extract text.")
Analyzer = Agent("Analyze content.")
Redactor = Agent("Redact sensitive terms.")

# Conceptual graph: Ingestor → Extractor → Analyzer → Redactor

from strands import Agent

Ingestor = Agent("Ingest files.")

Extractor = Agent("Extract text.")

Analyzer = Agent("Analyze content.")

Redactor = Agent("Redact sensitive terms.")

# Conceptual graph: Ingestor → Extractor → Analyzer → Redactor

You can dynamically change paths or branch workflows, making this pattern highly adaptable.

This way, you get detailed feedback from IoT in your HTTP response.

Swarm Collaboration (Peer Teams)

Here, teams of agents collaborate dynamically, passing tasks among themselves with shared context rather than central control.

Swarms are self-organizing, with shared working memory and autonomous handoffs.
Multiple agents can be engaged iteratively, enabling emergent, collective problem-solving.

Example:

from strands import Agent
from strands.multiagent import Swarm

Researcher = Agent("Research facts.")
Designer = Agent("Draft plan from research.")
Implementer = Agent("Write solution per plan.")
Reviewer = Agent("Critique and refine the solution.")

swarm = Swarm(
    [Researcher, Designer, Implementer, Reviewer],
    max_handoffs=10,
    max_iterations=15
)

from strands import Agent

from strands.multiagent import Swarm

Researcher = Agent("Research facts.")

Designer = Agent("Draft plan from research.")

Implementer = Agent("Write solution per plan.")

Reviewer = Agent("Critique and refine the solution.")

swarm = Swarm(

[Researcher, Designer, Implementer, Reviewer],

max_handoffs=10,

max_iterations=15

)

Which Pattern to Use?

Mix and Match: Hybrid Architectures

Strands is designed for versatility, you can combine patterns easily:

A Router might call a Swarm as one of its tools.
A Swarm agent can invoke other agents as Tools mid-process.
A Graph node could itself be a Swarm.

These combinations offer powerful ways to scale and adapt workflows.

Conclusion

Strands empowers you to build agent teams with clear structure, adaptable flow, and production-ready features like observability and A2A communication.

Whether your workflow needs centralized routing, modular specialization, branching graphs, or peer collaboration, Strands supports it seamlessly.

Drop a query if you have any questions regarding Strands and we will get back to you quickly.

Empowering organizations to become ‘data driven’ enterprises with our Cloud experts.

Reduced infrastructure costs
Timely data-driven decisions

Get Started

About CloudThat

CloudThat is an award-winning company and the first in India to offer cloud training and consulting services worldwide. As a Microsoft Solutions Partner, AWS Advanced Tier Training Partner, and Google Cloud Platform Partner, CloudThat has empowered over 850,000 professionals through 600+ cloud certifications winning global recognition for its training excellence including 20 MCT Trainers in Microsoft’s Global Top 100 and an impressive 12 awards in the last 8 years. CloudThat specializes in Cloud Migration, Data Platforms, DevOps, IoT, and cutting-edge technologies like Gen AI & AI/ML. It has delivered over 500 consulting projects for 250+ organizations in 30+ countries as it continues to empower professionals and enterprises to thrive in the digital-first world.

FAQs

1. What is the difference between the Orchestrator and Agent-as-Tool patterns?

ANS: – The Orchestrator pattern uses a central agent to route tasks to specialist agents based on the request type. The Agent-as-Tool pattern allows one agent to use another agent’s expertise directly as a modular, callable tool, enabling deeper, reusable workflows.

2. When should I use a Swarm collaboration instead of a Router or Graph?

ANS: – Use Swarm collaboration when your workflow benefits from iterative, peer-to-peer teamwork, such as brainstorming, research, or tasks that require multiple rounds of refinement. Swarm agents dynamically hand off work and build on each other’s outputs.

3. Can I combine multiple collaboration patterns in one Strands application?

ANS: – Yes! Strands are flexible, it’s common to mix patterns. For example, an Orchestrator can call a Swarm for complex tasks, or a node in a Graph can be a Swarm or invoke agents-as-tools for modularity.

WRITTEN BY Rishi Raj Saikia

Rishi works as an Associate Architect. He is a dynamic professional with a strong background in data and IoT solutions, helping businesses transform raw information into meaningful insights. He has experience in designing smart systems that seamlessly connect devices and streamline data flow. Skilled in addressing real-world challenges by combining technology with practical thinking, Rishi is passionate about creating efficient, impactful solutions that drive measurable results.