Blog-Writer Agent using Swarm Pattern

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

model = BedrockModel(
    model_id="us.anthropic.claude-haiku-4-5-20251001-v1:0",
    region_name="us-west-2",
)

researcher = Agent(
    name="researcher",
    model=model,
    system_prompt=(
        "You are the RESEARCHER in a 5-agent blog-writing swarm "
        "(researcher, outliner, writer, editor, seo_factchecker). "
        "Gather accurate facts, sources, and statistics on the given topic. "
        "Do NOT outline or write prose yourself. When you have enough facts, "
        "call handoff_to_agent to hand off to 'outliner', and put your FULL "
        "research notes verbatim in the message."
    ),
)

outliner = Agent(
    name="outliner",
    model=model,
    system_prompt=(
        "You are the OUTLINER in a 5-agent blog-writing swarm. Using the "
        "researcher's notes (must be in the handoff message you received), "
        "produce a structured outline: a hook line, section headers with "
        "one-line descriptions, and a takeaway line. When done, call "
        "handoff_to_agent to hand off to 'writer', and put your FULL outline "
        "verbatim in the message."
    ),
)

writer = Agent(
    name="writer",
    model=model,
    system_prompt=(
        "You are the WRITER in a 5-agent blog-writing swarm. Using the "
        "outline handed to you (must be in the handoff message you "
        "received), draft the post section by section, following the "
        "outline's structure. When your draft is complete, call "
        "handoff_to_agent to hand off to 'editor', and put the FULL draft "
        "text verbatim in the message — a summary is not enough. You may "
        "receive a draft back from EITHER 'editor' (for thin or unclear "
        "sections) or 'seo_factchecker' (for a specific factual claim "
        "that failed its check) — either way, fix exactly what was "
        "flagged, correcting or removing any claim you cannot support "
        "from the research notes, and hand off to 'editor' again with "
        "the FULL updated draft so it goes through review again."
    ),
)

editor = Agent(
    name="editor",
    model=model,
    system_prompt=(
        "You are the EDITOR in a 5-agent blog-writing swarm. You will "
        "receive the writer's full draft text in the handoff message. "
        "Tighten language, fix flow, and enforce tone/style. You have TWO "
        "options: (1) if a section is thin or needs real rework, call "
        "handoff_to_agent to send it BACK to 'writer' with specific notes "
        "on exactly what to fix — do this at most once, to avoid an "
        "endless back-and-forth; (2) once the draft is solid, call "
        "handoff_to_agent to send it FORWARD to 'seo_factchecker' with "
        "the FULL edited draft text verbatim in the message. Do not "
        "finalize yourself — the swarm isn't done until the "
        "seo_factchecker signals publish-ready."
    ),
)

seo_factchecker = Agent(
    name="seo_factchecker",
    model=model,
    system_prompt=(
        "You are the SEO/FACT-CHECKER in a 5-agent blog-writing swarm, and "
        "the FINAL stage. You will receive the editor's full draft text in "
        "the handoff message. Check every factual claim against the "
        "research notes visible in shared history. You have TWO options: "
        "(1) if ANY claim is unsupported by the research notes, contradicts "
        "them, or looks fabricated, call handoff_to_agent to send the draft "
        "BACK to 'writer' with the specific claim quoted and exactly why it "
        "fails the check — do NOT silently note the problem and publish "
        "anyway; (2) if and only if every claim checks out, suggest "
        "relevant keywords, write a meta description, and present the "
        "FINAL publish-ready blog post (full text) plus keywords and meta "
        "description as your output, and do NOT call handoff_to_agent — "
        "ending your turn without a handoff is what signals the swarm is "
        "publish-ready and done."
    ),
)

# Real constructor signature:
#   Swarm(
#       nodes: list[Agent],
#       *,
#       entry_point: Agent | None = None,
#       max_handoffs: int = 20,
#       max_iterations: int = 20,
#       execution_timeout: float = 900.0,
#       node_timeout: float = 300.0,
#       repetitive_handoff_detection_window: int = 0,
#       repetitive_handoff_min_unique_agents: int = 0,
#   )
blog_swarm = Swarm(
    [researcher, outliner, writer, editor, seo_factchecker],  # positional list
    entry_point=researcher,          # explicit for clarity, even though it matches list order
    max_handoffs=10,                 # custom override, NOT the default (library default is 20)
    max_iterations=10,               # custom override, NOT the default (library default is 20)
    execution_timeout=240.0,         # custom override: 4 min total, NOT the default (900.0)
    node_timeout=60.0,               # custom override: 1 min per agent turn, NOT the default (300.0)
    repetitive_handoff_detection_window=4,   # look at the last 4 handoffs
    repetitive_handoff_min_unique_agents=2,  # require at least 2 distinct agents in that window
)

result = blog_swarm("Write a blog post about why idempotency keys matter for reliable API design.")

print(result.status)             # e.g. COMPLETED / FAILED
print(result.execution_count)    # number of node executions
print(result.execution_time)     # wall-clock time for the run
print(result.accumulated_usage)  # accumulated token usage across all agents

# There is no result.final_response — that attribute does not exist on
# SwarmResult. The last agent to run holds the final output:
last_node = result.node_history[-1]
print(last_node.node_id)  # which agent produced the final output

# Inspect result.node_history to see the full handoff sequence, e.g.:
for node in result.node_history:
    print(node.node_id)

async def run_blog_swarm(topic: str):
    result = await blog_swarm.invoke_async(f"Write a blog post about {topic}.")
    print(result.status)
    for node in result.node_history:
        print(node.node_id)
    return result