Advisor Swarm Example

​

How Advisor Swarm Works

1. The user task is added to a shared Conversation.
2. Before each executor turn, if advisor_uses < max_advisor_uses, the advisor reads the full conversation and writes strategic guidance back to it.
3. The executor reads the same conversation — task, any prior output, and any advisor guidance — and produces its turn output.
4. Steps 2–3 repeat for max_loops executor turns.
5. The formatted conversation history is returned per output_type.

​

Key Characteristics

• Executor-driven loop: the executor runs every turn; the advisor is optional.
• Budgeted advisor calls: max_advisor_uses caps how often the expensive model is invoked.
• Shared context: both agents see the same conversation, so guidance compounds across turns.
• Provider-agnostic: any LiteLLM-supported model works for either role.
• Tools on executor only: the executor can be a pre-configured Agent with tools or MCP; the advisor stays tool-free.

​

Basic Example: Code Review

from swarms import AdvisorSwarm

swarm = AdvisorSwarm(
    executor_model_name="claude-sonnet-4-6",  # cheap, does the work
    advisor_model_name="claude-opus-4-6",     # expensive, sets direction
    max_advisor_uses=2,
    max_loops=3,
    verbose=True,
)

result = swarm.run(
    """
    Review this Python function for correctness, security, and style:

    def get_user(user_id):
        query = f"SELECT * FROM users WHERE id = {user_id}"
        return db.execute(query).fetchone()

    Identify all issues, rank them by severity, and propose fixes.
    """
)

print(result)

​

What happens each turn

​

Custom Executor with Tools

from swarms import Agent, AdvisorSwarm


def search_codebase(query: str) -> str:
    """Search the codebase for a pattern. Returns matching lines."""
    # Implementation here — call ripgrep, your code search, etc.
    return f"Results for: {query}"


def read_file(path: str) -> str:
    """Read a file from disk."""
    with open(path) as f:
        return f.read()


executor = Agent(
    agent_name="CodebaseReviewer",
    model_name="claude-sonnet-4-6",
    max_loops=1,
    tools=[search_codebase, read_file],
)

swarm = AdvisorSwarm(
    executor_agent=executor,
    advisor_model_name="claude-opus-4-6",
    max_advisor_uses=3,
    max_loops=4,
)

result = swarm.run(
    "Audit src/auth/ for missing input validation. Search the directory, "
    "read each handler, and report any endpoints that accept user input "
    "without validating it."
)

​

Tuning the Advisor Budget

​

Mixing Providers

from swarms import AdvisorSwarm

# Cheap OpenAI executor, expensive Anthropic advisor
swarm = AdvisorSwarm(
    executor_model_name="gpt-5.4-mini",
    advisor_model_name="claude-opus-4-6",
    max_advisor_uses=2,
    max_loops=3,
)

result = swarm.run("Draft a launch announcement for our new product")

​

When to Use AdvisorSwarm

• Cost-sensitive workloads where most turns are routine but a few decisions matter
• Long-running tasks where periodic strategic re-checks add value
• Tasks with tools or MCP where you want a smaller tool-using executor plus a tool-free strategic overseer
• Domains where direction matters more than throughput — code review, research planning, document polish

​

When NOT to Use AdvisorSwarm

• Single-shot prompts where one model call is enough — use a bare Agent
• Pure parallel workloads with no inter-turn strategy — use ConcurrentWorkflow or MixtureOfAgents
• Strict sequential pipelines with fixed roles per stage — use SequentialWorkflow
• All turns equally critical — just use the strong model directly

​

Related Architectures

• MixtureOfAgents: Parallel experts with aggregation — peers, not executor/advisor
• HierarchicalSwarm: Director-worker with task distribution — many workers, not one paired advisor
• SequentialWorkflow: Fixed pipeline of agents — no on-demand consultation

​

Learn More

• AdvisorSwarm API Reference
• “The advisor strategy: Give agents an intelligence boost” (Anthropic, April 2026)
• Multi-Agent Architectures Overview