Multi-Agent collaboration patterns with Strands Brokers and Amazon Nova

Multi-agent generative AI methods use a number of specialised AI brokers working collectively to deal with advanced, multi-faceted duties that exceed the capabilities of any single mannequin. By combining brokers with completely different expertise or modalities (for instance, language, imaginative and prescient, audio, video), these methods can deal with duties in parallel or sequence, yielding extra strong outcomes. Recent research shows that multi-agent collaboration can significantly improve success rates on complex goals (as much as 70% larger vs. single-agent approaches). There are completely different patterns for such multi-agent collaborations. Whether or not it’s a manager-agent delegating specialised duties (Agent as instruments), a swarm of brainstormers (Swarms), a fastidiously wired graph of professional brokers (Agent Graph), or a structured pipeline (agent workflow), the precise design sample mixed with the precise tooling will considerably improve the system’s effectiveness.

The problem with multi-agent methods, nevertheless, lies of their computational calls for. Trendy multi-agent purposes can problem 1000’s of prompts per consumer request as brokers brainstorm, critique, and refine each other’s solutions. This intensive workflow creates two essential necessities: excessive throughput (tokens-per-second) and price effectivity (dollars-per-million-tokens). That is exactly the place Amazon Nova turns into a really appropriate basis mannequin (FM) selection for multi-agent architectures:

• Blazing throughput: Nova Micro streams over 200 tokens per second with sub-second first-token latency, preserving even giant swarms of brokers conscious of end-users.
• Constant structured output: With the newest constrained decoding implementation, Amazon Nova fashions can produce constant structured outputs and enhance tool-calling accuracy.
• Extremely-low price: Groups can afford the token quantity that multi-agent reasoning calls for with the low prices of Nova Micro and Nova Lite.

As a result of each agent name stays cheap, builders are free to let orchestration frameworks such because the open-source Strands Brokers SDK spin up task-specific Nova brokers, retry or cross-verify solutions, and iterate till they converge on one of the best outcome—all with out runaway inference payments.Conversely, multi-agent generative AI methods unlock the complete potential of Amazon Nova by:

• Iterative self-improvement: Brokers can ask Nova to mirror by itself reply, critique weaknesses, and regenerate typically lifting success charges by double-digit percentages with none fine-tuning.
• Redundancy and fail-over: Working a number of Nova brokers in parallel (similar to consensus or swarm patterns) will increase reply high quality and resilience—one weak response is out-voted or retried routinely.

On this put up, we discover 4 key collaboration patterns for multi-agent, multimodal AI methods – Brokers as Instruments, Swarms Brokers, Agent Graphs, and Agent Workflows – and focus on when and find out how to apply every utilizing the open-source AWS Strands Brokers SDK with Amazon Nova fashions. As an agent orchestration framework, Strands is constructed to be light-weight and simple to study – it makes use of solely a handful of ideas and leans on Python’s native constructions for composing brokers. One other power is its model-driven method: Strands encourages you to let the FM determine the sequence of steps (the agent loop consults the FM for what to do subsequent moderately than hardcoding a stream). This harnesses the highly effective reasoning of FM for orchestration choices, decreasing the quantity of mounted code logic. Every of the next sample sections offers a conceptual overview with a diagram, real-world use instances, execs and cons, and code examples for instance implementation.

Brokers as Instruments sample

The Brokers as Instruments sample wraps specialised AI brokers as callable instruments {that a} main orchestrator agent can invoke. This creates a hierarchical workforce construction: a top-level agent acts like a supervisor, delegating particular queries to professional sub-agents after which integrating their outputs. Every instrument agent focuses on a selected area or modality, whereas the orchestrator decides which instrument to name for every a part of the consumer’s request. This setup mimics a human state of affairs the place a workforce lead consults numerous specialists as an alternative of making an attempt to do all the pieces alone. By offloading work to professional brokers, the orchestrator can present extra correct and multi-faceted responses than a monolithic agent.

Determine 1: Multimodal Brokers as Instruments – An orchestrator agent (supervisor) makes use of specialised “instrument” brokers (consultants) to deal with completely different sub-tasks, then aggregates their outcomes right into a remaining reply.

Use instances, execs, and cons

This sample is good when a consumer question naturally breaks down into distinct subtasks requiring completely different experience. As an illustration:

• A multi-domain assistant that solutions questions involving, say, journey planning, product suggestions, and analysis–the orchestrator can route parts to a Journey Planner, Product Recommender, or Researcher agent respectively.
• Multimodal duties the place one agent handles picture or speech enter whereas one other handles textual content (the orchestrator chooses the precise modality-specific agent as a instrument).
• Any system requiring specialised expertise or instruments (for instance, an academic tutor agent invoking a code execution agent for programming questions, or a customer support bot calling a database-query agent).

Professionals:

• Separation of issues: Every agent has a centered position/experience, making the general system simpler to grasp and lengthen.
• Modularity: Specialists (instruments) could be added or up to date independently with out affecting others, so long as the orchestrator’s interface to them stays constant.
• Hierarchical decision-making: The orchestrator offers a transparent chain of command, deciding which professional to make use of for every process, which may enhance reliability.
• Optimized efficiency: Every agent can have a tailor-made immediate, mannequin, or instrument for its particular process, probably yielding higher accuracy or effectivity than a generalist agent.

Cons:

• Orchestrator complexity: The highest-level agent should appropriately determine which instrument agent to invoke and find out how to combine outcomes. This requires cautious immediate engineering or routing logic (threat of errors if the orchestrator misinterprets the question).
• Single level of failure: The orchestrator agent turns into a essential element; if it fails or provides a foul resolution, the entire system’s output could endure.
• Context sharing and integration: Specialised brokers usually obtain solely the knowledge explicitly included of their particular queries, limiting their entry to broader context. Due to this fact, the orchestrator should consolidate outputs from completely different brokers. Making certain a coherent remaining reply (avoiding contradictions or gaps) could be difficult if the specialists work in isolation.

Strands SDK instance

The Strands Brokers SDK makes it straightforward to implement Brokers as Instruments utilizing the @instrument decorator to show python features into callable instruments. Every tool-agent is actually an LLM (or different service) with its personal immediate or directions and is uncovered as a callable perform. When invoked, the specialist agent receives solely the knowledge handed by the orchestrator (usually the precise subtask immediate) and returns its output. The orchestrator then makes use of that output in context, presumably calling additional instruments or producing a remaining reply. Within the following code, we outline a specialised analysis assistant agent as a instrument, then create an orchestrator that makes use of it (together with different domain-specific brokers) to reply a question with both listed information or internet search data:

from strands import Agent
from strands_tools import retrieve, http_request

# Outline a specialised Analysis Assistant agent as a instrument
RESEARCH_ASSISTANT_PROMPT = (
    "You're a specialised analysis assistant. Present factual, cited solutions."
)

@instrument
def research_assistant(question: str) -> str:
    """Present well-sourced analysis solutions for a given question."""
    attempt:
        # Create an agent with a research-focused immediate and instruments
        research_agent = Agent(
            system_prompt=RESEARCH_ASSISTANT_PROMPT,
            instruments=[retrieve, http_request]  # e.g. multimodal information base retrieval, internet retrieval instruments
        )
        response = research_agent(question)
        return str(response)
    besides Exception as e:
        return f"Error in analysis assistant: {e}"

In an analogous approach, you may also outline different instrument brokers, for instance an editor_assistant or image_creation_assistant, every with their very own system immediate and instruments for his or her area. As soon as the specialist brokers are outlined, the orchestrator agent can embrace them in its instrument checklist:

# Outline the orchestrator agent with all specialised instruments
MAIN_SYSTEM_PROMPT = "You might be an orchestrator coordinating a number of area consultants."

orchestrator = Agent(
    system_prompt=MAIN_SYSTEM_PROMPT,
    instruments=[research_assistant, editor_assistant, image_creation_assistant]
)

# Course of a posh consumer question by the orchestrator
question = "I am planning a mountaineering journey to Patagonia and wish the precise gear."
response = orchestrator(question)
print(response)

On this instance, the orchestrator will delegate elements of the question to the related specialists – for instance, use analysis assistant then move that context to the editor assistant to provide content material primarily based on the supplied context, and eventually synthesize a mixed reply for the consumer. The Brokers as Instruments sample allows a strong composition of consultants, all managed by easy perform calls in Strands.

The entire code instance and answer diagram of this multimodal e mail author assistant that is able to run and deploy is supplied on this Github repository.

Determine 2: Answer diagram of the multimodal e mail author assistant with Brokers as Instruments sample.

See the agents-as-tools documentation for extra data.

Swarm sample

The swarm sample entails a gaggle of peer brokers working collectively on a process, exchanging data immediately and iteratively. That is impressed by swarm intelligence in nature (like ant colonies or bee swarms) the place many easy models work together to provide advanced, emergent habits. In an AI swarm, every agent may method the issue from a special perspective (or with completely different knowledge or mode) and share its findings in order that different brokers can refine their very own outcomes. No central controller is micromanaging the method; as an alternative, coordination is decentralized and sometimes occurs by a shared reminiscence or message house. The swarm thus collectively explores the answer house and converges on a solution by a number of rounds of communication.

Determine 3: Swarms Brokers – A decentralized mesh of brokers (e.g. Analysis, Artistic, Important, Summarizer) all talk with one another to collaboratively clear up an issue. There isn’t a single orchestrator; intelligence emerges from brokers sharing and refining concepts collectively.

Key traits of swarms embrace data sharing, agent specialization, redundancy, and the potential for emergent intelligence past the sum of particular person brokers. Importantly, management is decentralized–there isn’t a single agent deciding roles for others. Brokers observe comparatively easy native guidelines (“share my outcome with others, then revise my reply after seeing others’ outcomes”) and sophisticated world habits emerges from these interactions. For instance, one agent may concentrate on artistic brainstorming, one other on factual accuracy, one other on critiquing options, and a remaining one on summarizing; collectively, by two or extra rounds of exchanging concepts, they produce a balanced and well-vetted consequence.

Use instances, execs, and cons

Swarm patterns are helpful when an issue advantages from various views or parallel exploration:

• Brainstorming and ideation: A number of generative brokers can suggest concepts or options in parallel (some is perhaps wild and inventive, others extra conservative), then collectively refine them. This could yield extra modern outcomes than a single agent’s reply.
• Complicated reasoning duties: Brokers can construct upon one another’s work by structured handoffs. For instance, one agent analyzes an issue, palms off to a different for answer design, then to a 3rd for validation and refinement. This sequential collaboration typically produces higher-quality outcomes than parallel approaches.
• Multi-stage workflows: Totally different brokers can deal with distinct phases of a posh process. In monetary evaluation, a analysis agent gathers knowledge, palms off to an evaluation agent for insights, then to a reporting agent for remaining presentation. Every handoff contains context and intermediate outcomes.
• Iterative enchancment: By means of a number of iterations and handoffs, swarms can progressively refine options. An preliminary draft from one agent will get enhanced by subsequent brokers, with every iteration constructing on earlier work inside configurable time home windows.
• Fault-tolerant processing: With timeout controls and handoff mechanisms, swarms can gracefully deal with agent failures. If one agent instances out, the swarm can proceed with obtainable outcomes or retry with completely different brokers.

Professionals:

• Variety of thought: Every agent can pursue a singular technique or viewpoint, yielding a richer pool of concepts. The ultimate outcome could be extra complete and balanced by incorporating inputs from all brokers.
• Emergent enchancment: By means of iterative communication, swarms typically refine options higher than a single-pass method. Brokers can right one another’s errors or construct on one another’s partial options, resulting in high-quality outcomes.
• No single failure level: Since there’s no central orchestrator, the system is perhaps extra fault-tolerant – if one agent underperforms, others can compensate (and there isn’t a single agent whose failure collapses the method).

Cons:

• Timeout sensitivity: Aggressive timeout settings may minimize off productive work, and unfastened timeouts can result in inefficient useful resource utilization if brokers get caught.
• Iteration overhead: A number of iterations can accumulate prices and latency, particularly with giant language fashions, requiring cautious stability between high quality and effectivity.

Strands SDK instance

Within the following instance, the swarm has three following collaborative brokers:

• research_agent: finds factual data
• analysis_agent: analyzes stay market knowledge through API
• writer_agent: compiles the ultimate reply

from strands import Agent
from strands.fashions import BedrockModel
from strands.multiagent import Swarm

# Create specialised brokers for various duties
research_agent = Agent(
    identify="researcher",
    system_prompt="Analysis and collect data, then hand off to analyst.",
    mannequin=BedrockModel(model_id="us.amazon.nova-pro-v1:0", area="us-east-1"),
    instruments=[web_search, knowledge_base]
)

analysis_agent = Agent(
    identify="analyst", 
    system_prompt="Analyze analysis knowledge and hand off to author.",
    mannequin=BedrockModel(model_id="us.amazon.nova-pro-v1:0", area="us-east-1"),
    instruments=[data_analysis, financial_metrics]
)

writer_agent = Agent(
    identify="author",
    system_prompt="Create remaining report primarily based on analysis and evaluation.",
    mannequin=BedrockModel(model_id="us.amazon.nova-pro-v1:0", area="us-east-1"),
    instruments=[editor, formatter]
)

# Configure swarm with handoff and timeout controls
swarm = Swarm(
    brokers=[research_agent, analysis_agent, writer_agent],
    max_handoffs=2,           # Enable as much as 2 handoffs between brokers
    max_iterations=3,         # As much as 3 rounds of refinement
    execution_timeout=300.0,  # Complete swarm timeout (5 minutes)
    node_timeout=60.0        # Particular person agent timeout (1 minute)
)

# Execute collaborative workflow
outcome = swarm("Analyze Q3 monetary efficiency and create govt abstract")
print(f"Closing outcome: {outcome.final_response}")
print(f"Collaboration path: {[node.node_id for node in result.node_history]}")

This method eliminates the necessity for guide coordination code and offers fine-grained management over collaboration patterns. The swarm routinely manages handoffs between brokers, tracks dialog historical past, and confirms that execution completes inside specified timeouts. Brokers can concentrate on their specialised duties whereas the swarm framework handles the advanced orchestration, shared reminiscence administration, and fault tolerance mechanisms. The important thing benefit is that advanced multi-agent workflows change into so simple as configuring a number of parameters, whereas nonetheless supporting subtle collaboration patterns by the handoff and iteration mechanism.

The entire code instance and answer diagram of a monetary assistant swarm agent that is able to run and deploy is supplied in this Github repository.

Determine 4: Answer diagram of a monetary assistant swarm agent. 

See the swarms documentation for extra data.

Graph sample

An agent graph defines a structured community of brokers with directed connections that decide how data flows between them. In contrast to the free-form mesh of a swarm, an agent graph is often designed by the developer to suit a particular workflow or organizational hierarchy. Every node within the graph is an agent with a well-defined position, and every edge represents a communication or handoff channel (which is perhaps a technique or bidirectional). This sample helps you implement exact management over the sequence and course of inter-agent interactions. For instance, you may organize brokers in a multi-level hierarchy: a top-level govt agent breaks a process into elements, passes sub-tasks to intermediate supervisor brokers, which in flip delegate to low-level specialist brokers, and outcomes stream again up the chain. Alternatively, you possibly can outline a star topology the place a central agent coordinates a set of peripheral brokers (just like Brokers as Instruments, however probably with suggestions loops), or any customized graph topology (tree, acyclic graph) that fits the issue area.

Determine 5: Illustration of a Graph agent sample. 

The agent graph is proven within the following diagram. (Topology Instance – Hierarchical): Brokers related in a multi-level graph. The planner agent delegates a question to a strong supervisor agent, after which delegates to mid-level brokers Agent 1, Agent 2, Agent 3 and Agent 4; every of these oversees a workforce of specialised brokers. Info flows alongside directed edges. The department can incorporate enterprise logic to determine which agent to make use of primarily based on the conditional edge. The important thing good thing about agent graphs is predictability and management. By explicitly connecting brokers in a graph, builders can confirm {that a} fact-checker agent all the time validates outputs from a era agent earlier than they attain the ultimate reporter agent, or that data solely flows in authorized methods (helpful for security, to forestall sure brokers from seeing delicate knowledge except wanted). This sample excels once you want customized communication patterns, distinct specialised roles, and fine-grained data stream administration.

Use instances, execs, and cons

Agent graph patterns shine particularly when:

• You’ve gotten advanced, multi-stage resolution processes, similar to an enterprise workflow the place a lead agent delegates to separate evaluation brokers (monetary, technical, social impression evaluation) and every evaluation agent may additional delegate to sub-agents. The graph construction can mirror organizational charts or resolution bushes so that every step’s output is reviewed and built-in at larger ranges.
• You want managed instrument entry and knowledge stream: Suppose you’ve sure brokers that may name exterior instruments or APIs and others that ought to not (for safety or price causes). By structuring the graph, you possibly can isolate tool-using brokers and produce other brokers funnel requests by them.
• To keep away from free-for-all communication: If the duty requires tight coordination and clear roles, an agent graph is preferable over a swarm. As an illustration, in a buyer help system with a number of brokers (billing, technical help, gross sales), you won’t need all of them speaking to one another arbitrarily. A graph can implement that each one communication goes by a central coordinator or follows outlined escalation paths (like a star or tree topology).

Professionals:

• Effective-grained management: Builders explicitly outline who communicates with whom. This prevents unintended interactions and makes the system’s habits simpler to purpose about, similar to when you already know the Report Aggregator Agent solely receives enter from the Reality-Checker and Evaluation brokers and nothing else.
• Context and state administration: Graph edges could be considered persistent channels–probably sustaining state or utilizing message queues. That is helpful for long-running contexts.
• Predictable execution stream: In contrast to a swarm (the place timing and order of exchanges are emergent), an agent graph follows a extra deterministic stream. That is helpful for workflows that require deterministic outputs or step-by-step monitoring. It’s simpler to hint how an enter strikes by the system utilizing the graph’s pathways.

Cons:

• Design effort: Deciding on the precise graph topology could be difficult. You could perceive the issue area nicely with a view to partition duties and organize brokers successfully. Over-designing the graph may result in rigidity; under-designing won’t reap the advantages of the sample.
• Much less dynamic adaptability: A set graph shouldn’t be as spontaneously adaptive as a swarm. If a question barely exterior the anticipated sample is available in, the orchestrated pathways won’t deal with it gracefully (except you construct in numerous logic for routing). In distinction, a swarm or instruments method may dynamically regulate by merely making an attempt completely different instruments or brokers.
• Latency in deep graphs: If the graph has many ranges (like a tall hierarchy), data has to move by a number of brokers sequentially, which may enhance latency. Every hop provides overhead. For instance, in a three-level hierarchy, a message may stream down by two intermediate brokers after which again up–that’s extra spherical journeys than a flatter structure.

Strands SDK instance

The GraphBuilder class, obtainable within the Strands SDK, presents a streamlined solution to implement agent graph patterns. It handles the complexities of agent communication and community topology administration, serving to builders concentrate on agent habits. It offers built-in help to outline graph topologies, messages dealing with (the mechanism for transferring knowledge) and course (one-way or bidirectional data stream) between brokers. For every agent, builders can implement enterprise logic to deal with fallback mechanism and agent response analysis.

from strands import Agent
from strands_tools import agent_graph

builder = GraphBuilder()

# Add nodes
builder.add_node(coord_agent, "analysis")
builder.add_node(get_stock_prices_agent, "stock_price_search")
builder.add_node(fin_web_searcher_agent, "fin_web_searcher")
builder.add_node(report_writer_agent, "report")
builder.add_node(image_generator_agent, "create_display_img")

# Add edges (dependencies) - star topology with coordinator at heart
builder.add_edge("analysis", "stock_price_search")
builder.add_edge("analysis", "fin_web_searcher")
builder.add_edge("analysis", "report")
builder.add_edge("analysis", "create_display_img")

# Set entry level
builder.set_entry_point("analysis")

# Construct the graph
graph = builder.construct()

# Run the graph
outcome = graph("Analyze Q3 monetary efficiency and create govt abstract")

Use the GraphBuilder to outline nodes, edges, and entry factors to your multi-agent workflows. From this basis, you possibly can create subtle patterns by numerous mixtures:

• Dynamic workflows: Add conditional logic to edges that route primarily based on runtime choices
• Nested architectures: Embed total graphs or swarms as nodes inside bigger graph constructions

These examples signify only a fraction of the limitless architectural prospects obtainable when constructing with graphs within the Strands SDK.

The entire code instance of this agent graph that is able to run and deploy is supplied on this Github repository.

See the graphs documentation for extra data.

Workflow sample

The workflow sample orchestrates a number of brokers in a predefined sequence or dependency graph of duties–very like a classical workflow or pipeline, however with AI brokers executing the steps. On this sample, the emphasis is on process ordering and dependency administration: you explicitly break a posh job right into a sequence of discrete duties assigned to completely different brokers, and outline how these duties rely upon one another (some duties may run in parallel, others should look forward to sure outputs). Within the workflow sample, every agent does its half on the proper time, passing its output as enter to the subsequent related agent within the chain.

Determine 6: the workflow agent sample. A directed acyclic graph of brokers executing a multi-step course of. On this instance, A0 (entry level) splits the question into three brokers (to Brokers 1, 2, 3), which then feed into subsequent steps (Brokers 4, 5, 6, 7), and eventually converge at Agent 8 which produces the response. This illustrates express process dependencies and execution order forming a workflow.

You possibly can consider an agent workflow as a directed acyclic graph (DAG) of duties, the place every process is executed by an agent. That is just like an agent graph, however workflow usually implies a stronger concentrate on one-off execution of a course of from begin to end (like a pipeline run), whereas an agent graph is perhaps a persistent community of brokers dealing with ongoing duties. Workflows are nice for processes which have clear stage-wise construction–for instance, knowledge processing pipelines, multi-step reasoning with checkpoints, or any scenario the place sure steps (duties) should occur in a strict order or solely after sure conditions are met. The workflow sample additionally aligns nicely with methods that require monitoring, logging, or error restoration at every step of a posh job (since every process’s execution could be tracked independently).

Use instances, execs, and cons

Use agent workflows when coping with advanced multi-step duties with well-defined levels:

• Content material era with assessment: One agent drafts an article, one other agent (or instrument) fact-checks it, one other agent edits for type, and one other approves or publishes. These steps occur so as (presumably with some parallel checks) and is perhaps repeated on failure.
• Conditions requiring coordination and dependency dealing with: If sure duties can run in parallel, the workflow can department; if some duties should converge, the workflow can be a part of. For instance, a job software screening might need one AI agent rating the resumé and one other agent carry out a ability check in parallel, then a remaining agent makes use of each outcomes to decide.
• Lengthy-running or monitored processes: With workflows, you possibly can pause, resume, or retry on the process stage. If a selected agent fails or a step must be repeated, you possibly can reset that step with out redoing the entire workflow–helpful for strong manufacturing pipelines.

Professionals:

• Clear construction and reliability: The specific definition of order and dependencies signifies that the execution path is predictable and repeatable. That is important for processes the place correctness and auditability matter (you possibly can log every step’s enter and output).
• Parallel effectivity: Workflows can specify parallel branches for impartial duties, making higher use of assets (not like a single agent doing all the pieces sequentially). The framework will synchronize when branches want to hitch.
• Error dealing with and restoration: As a result of duties are discrete, a workflow controller can catch if an agent fails on a step and implement a retry or fallback only for that step. There’s no must restart all the course of. This localized error dealing with improves robustness.
• Specialised brokers per step: Much like Brokers as Instruments, every step can use an agent finest suited to that subtask (for instance, a translation agent adopted by a summarizer agent). Workflows guarantee these specialised brokers run within the right sequence with the correct knowledge.
• State administration: The workflow can preserve state context throughout steps explicitly (similar to carrying ahead a process ID or amassing outputs). Strands’ workflow instrument helps monitoring progress, pausing, and even resuming workflows that persist past a single session.

Cons:

• Much less flexibility for novel conditions: A workflow handles anticipated sequences nicely, but when a consumer question doesn’t match the pre-defined course of, the system won’t adapt. It’s not as exploratory as a swarm or as dynamically routed as an agent graph. Basically, workflows are solely as sensible because the predefined stream.
• Up-front effort: It’s essential to decompose the duty and outline the dependencies. If this evaluation is mistaken or incomplete, the workflow may fail or produce suboptimal outcomes. Designing a great workflow may require area experience to determine the proper breakdown.
• Potential under-utilization: If a workflow has many sequential steps, it could possibly be slower than an agent that may carry out some steps in parallel. For instance, a single giant language mannequin may internally summarize whereas studying textual content, whereas a strictly sequential workflow forces a full hand-off between studying and summarizing brokers, presumably incurring overhead.
• Overhead of orchestration: Managing the execution of a number of brokers (particularly with a normal workflow engine) introduces overhead. In easy instances, a single agent may obtain the aim with immediate engineering. Workflows shine in advanced situations, however for trivial duties the orchestration overhead is pointless.

Strands SDK instance

The Strands Agent SDK doesn’t implement a strict dialog amongst all brokers–you must program the stream–however its minimal abstractions make parallel or sequential orchestration simple (as seen within the earlier instance working three poet brokers in parallel with plain Python async code). One other benefit of utilizing Strands Agent SDK is the hierarchical agent idea: utilizing the @instrument decorator, you possibly can construct a hierarchy of brokers naturally, as proven earlier, making it intuitive to implement the supervisor/sub-agent sample. Let’s illustrate a easy guide workflow: three brokers (researcher, analyst, author) performing a sequence of steps.

from strands import Agent
from strands.fashions import BedrockModel

# Create specialised brokers for every step
researcher = Agent(
    system_prompt="You're a analysis specialist. Discover key data.",
    mannequin=BedrockModel(model_id="us.amazon.nova-pro-v1:0", area="us-east-1")
)

analyst = Agent(
    system_prompt="You analyze analysis knowledge and extract insights.",
    mannequin=BedrockModel(model_id="us.amazon.nova-pro-v1:0", area="us-east-1")
)

author = Agent(
    system_prompt="You create polished stories primarily based on evaluation.",
    mannequin=BedrockModel(model_id="us.amazon.nova-pro-v1:0", area="us-east-1")
)

# Outline the workflow perform
def process_workflow(matter: str):
    # Step 1: Analysis
    research_results = researcher(f"Analysis the newest developments in {matter}")
    
    # Step 2: Evaluation
    evaluation = analyst(f"Analyze these findings: {research_results}")
    
    # Step 3: Reporting
    final_report = author(f"Write a report primarily based on this evaluation: {evaluation}")
    
    return final_report

# Execute the workflow
outcome = process_workflow("synthetic intelligence in healthcare")
print(outcome)

On this code, we explicitly name every agent in flip, passing the output of 1 because the enter to the subsequent. The process_workflow perform orchestrates the sequence. If the researcher agent returns a considerable amount of knowledge, we would refine or truncate it earlier than passing to the analyst agent, and so forth, however the sample is evident: a linear hand-off.

One nice working instance of agentic workflow is clever doc processing (IDP) workflow. An IDP workflow is a superb instance of an agentic workflow as a result of it naturally entails a number of discrete but interdependent steps that profit from task-specialized brokers, dynamic coordination, and adaptive decision-making. The code pattern of a typical IDP workflow is supplied on this solution guidance.

See the workflows documentation for extra data.

Conclusion

Multi-agent collaboration unlocks generative AI capabilities {that a} single mannequin can not match—particularly when every agent can draw on Amazon Nova’s low-latency, low-cost token era and coordinate seamlessly by the open-source Strands Brokers SDK. Nova’s ultra-low pricing—fractions of a cent per thousand tokens—mixed with excessive throughput of over 200 tokens per second means groups can experiment freely with deeper reasoning loops, redundancy, and gear use with out worrying about runaway prices. Strands provides just-enough orchestration: a Pythonic API for Brokers as Instruments, swarms, graphs, and workflow patterns, built-in Bedrock mannequin wrappers, shared reminiscence for context change, and built-in telemetry. Whether or not you might be constructing a multimodal Q&A system, an autonomous document-processing pipeline, or a artistic brainstorming assistant, pairing Amazon Nova with Strands helps you scale from a single prototype agent to production-grade multi-agent architectures—all whereas sustaining the velocity, accuracy, and price profile demanded by trendy enterprise workloads. Now could be the perfect time to use these patterns and watch your generative AI purposes obtain outcomes that really are better than the sum of their Nova-powered elements.

Concerning the authors

Julia Hu Julia Hu is a Sr. AI/ML Options Architect at Amazon Internet Companies, presently centered on the Amazon Bedrock workforce. Her core experience lies in agentic AI, the place she explores the capabilities of basis fashions and AI brokers to drive productiveness in Generative AI purposes. With a background in Generative AI, Utilized Knowledge Science, and IoT structure, she companions with clients—from startups to giant enterprises—to design and deploy impactful AI options.

Rui Cardoso is a companion options architect at Amazon Internet Companies (AWS). He’s specializing in AI/ML and IoT. He works with AWS Companions and help them in growing options in AWS. When not working, he enjoys biking, mountaineering and studying new issues.

Jessie-Lee Fry is a Product and Go-to Market (GTM) Technique govt specializing in Generative AI and Machine Studying, with over 15 years of worldwide management expertise in Technique, Product, Buyer success, Enterprise Improvement, Enterprise Transformation and Strategic Partnerships. Jessie has outlined and delivered a broad vary of merchandise and cross-industry go- to-market methods driving enterprise development, whereas maneuvering market complexities and C-Suite buyer teams. In her present position, Jessie and her workforce concentrate on serving to AWS clients undertake Amazon Bedrock at scale enterprise use instances and adoption frameworks, assembly clients the place they’re of their Generative AI Journey.

Bhavya Sruthi Sode is a Technical Account Supervisor at Amazon Internet Companies, centered on Generative AI and Machine Studying. She helps clients design resilient, scalable, and safe cloud architectures whereas driving profitable outcomes of their enterprise cloud environments. With a background in Machine Studying, she is keen about serving to organizations remodel their AI aspirations into sensible options.

David Rostcheck is a Sr. Specialist Options Architect at Amazon Internet Companies, centered on AI/ML, Bedrock, and agent options. He enjoys serving to our clients ship efficient AI-based options to manufacturing.