swarms/docs/swarms/structs/swarm_templates.md

SwarmTemplates

A comprehensive library of pre-built, production-ready swarm templates for common use cases. Each template includes professionally designed agents with optimized prompts and proven orchestration patterns.

Overview

SwarmTemplates provides instant access to enterprise-grade multi-agent systems that solve real-world business problems. Instead of building agent teams from scratch, you can leverage battle-tested templates that have been optimized for specific use cases.

Key Benefits

Benefit	Description
Instant Deployment	Get production-ready swarms in seconds, not hours
Best Practices Built-in	Templates use proven prompts and orchestration patterns
Customizable	Easy to customize with your own models and parameters
Production-Tested	Each template has been tested and optimized for real use
Comprehensive Coverage	Templates for research, content, code, finance, and more

Available Templates

1. Research-Analysis-Synthesis

Use Case: Academic research, market research, competitive analysis

Workflow: Research Specialist → Analysis Expert → Synthesis Specialist

Best For:

• Comprehensive topic investigation
• Market research reports
• Competitive analysis
• Academic literature reviews

from swarms import SwarmTemplates

swarm = SwarmTemplates.research_analysis_synthesis(
    model_name="gpt-4o-mini"
)

result = swarm.run("Analyze the impact of AI on healthcare")
print(result)

---

2. Content Creation Pipeline

Use Case: Blog posts, articles, marketing content, documentation

Workflow: Content Strategist → Content Writer → Editor → SEO Specialist

Best For:

• Blog post creation
• Article writing
• Marketing content
• Technical documentation
• SEO-optimized content

from swarms import SwarmTemplates

swarm = SwarmTemplates.content_creation_pipeline(
    model_name="gpt-4o-mini"
)

result = swarm.run("Create a blog post about AI agents in customer service")
print(result)

---

3. Code Development Team

Use Case: Software development, feature implementation, code review

Workflow: Requirements Analyst → Software Developer → QA Engineer → Code Reviewer

Best For:

• Feature development
• Code generation
• Technical implementation
• Code quality review
• Bug fixing

from swarms import SwarmTemplates

swarm = SwarmTemplates.code_development_team(
    model_name="gpt-4o-mini"
)

result = swarm.run("Create a REST API for user authentication")
print(result)

---

4. Financial Analysis Team

Use Case: Investment analysis, financial reporting, risk assessment

Workflow: Data Collector → Financial Analyst → Risk Assessor → Report Writer

Best For:

• Investment analysis
• Financial performance evaluation
• Risk assessment
• Financial reporting
• Due diligence

from swarms import SwarmTemplates

swarm = SwarmTemplates.financial_analysis_team(
    model_name="gpt-4o-mini"
)

result = swarm.run("Analyze Tesla's Q4 2024 financial performance")
print(result)

---

5. Marketing Campaign Team

Use Case: Marketing campaigns, product launches, brand awareness

Workflow: Marketing Strategist → Content Creator → Creative Director → Distribution Specialist

Best For:

• Campaign planning
• Product launches
• Marketing strategy
• Content marketing
• Multi-channel campaigns

from swarms import SwarmTemplates

swarm = SwarmTemplates.marketing_campaign_team(
    model_name="gpt-4o-mini"
)

result = swarm.run("Create a product launch campaign for an AI fitness app")
print(result)

---

6. Customer Support Team

Use Case: Customer service, technical support, issue resolution

Workflow: Support Triage → Technical Support → Customer Success

Best For:

• Customer inquiries
• Technical troubleshooting
• Issue resolution
• Customer satisfaction
• Support ticket handling

from swarms import SwarmTemplates

swarm = SwarmTemplates.customer_support_team(
    model_name="gpt-4o-mini"
)

result = swarm.run("Customer reports login issues after password reset")
print(result)

---

7. Legal Document Review

Use Case: Contract review, legal compliance, risk analysis

Workflow: Legal Analyst → Compliance Specialist → Risk Assessor → Summary Writer

Best For:

• Contract review
• Legal compliance checking
• Risk assessment
• Due diligence
• Legal document analysis

from swarms import SwarmTemplates

swarm = SwarmTemplates.legal_document_review(
    model_name="gpt-4o-mini"
)

result = swarm.run("Review this SaaS service agreement")
print(result)

---

8. Data Science Pipeline

Use Case: Data analysis, ML pipelines, business intelligence

Workflow: Data Collector → Data Cleaner → Data Analyst → Visualization Specialist

Best For:

• Data analysis projects
• ML pipeline design
• Business intelligence
• Predictive analytics
• Data visualization

from swarms import SwarmTemplates

swarm = SwarmTemplates.data_science_pipeline(
    model_name="gpt-4o-mini"
)

result = swarm.run("Analyze customer churn data and identify key factors")
print(result)

---

Class Reference

SwarmTemplates

Main class providing access to all swarm templates.

Class Methods

list_templates()

Get a list of all available swarm templates with descriptions.

Returns:

• List[Dict[str, str]]: List of templates with metadata

Example:

from swarms import SwarmTemplates

templates = SwarmTemplates.list_templates()

for template in templates:
    print(f"{template['name']}: {template['description']}")

Output:

research_analysis_synthesis: Research → Analysis → Synthesis workflow
content_creation_pipeline: Planning → Writing → Editing → SEO workflow
code_development_team: Requirements → Development → Testing → Review workflow
...

---

get_template_info(template_name: str)

Get detailed information about a specific template.

Parameters:

• template_name (str): Name of the template

Returns:

• Dict[str, Any]: Detailed template information

Raises:

• ValueError: If template name is not found

Example:

from swarms import SwarmTemplates

info = SwarmTemplates.get_template_info("research_analysis_synthesis")

print(f"Description: {info['description']}")
print(f"Use Case: {info['use_case']}")
print(f"Agents: {info['agents']}")

---

create(template_name, model_name, max_loops, verbose, custom_params)

Universal method to create any swarm template.

Parameters:

• template_name (str): Name of the template to create
• model_name (str): LLM model to use for all agents (default: "gpt-4o-mini")
• max_loops (int): Maximum loops for agent execution (default: 1)
• verbose (bool): Enable verbose logging (default: True)
• custom_params (Optional[Dict[str, Any]]): Additional custom parameters

Returns:

• Configured swarm workflow (type depends on template)

Raises:

• ValueError: If template name is not found

Example:

from swarms import SwarmTemplates

# Create a template by name
swarm = SwarmTemplates.create(
    template_name="research_analysis_synthesis",
    model_name="gpt-4o-mini",
    max_loops=1,
    verbose=True
)

result = swarm.run("Analyze quantum computing trends")
print(result)

---

Template-Specific Methods

Each template also has its own dedicated method:

Method Signatures:

@classmethod
def research_analysis_synthesis(
    model_name: str = "gpt-4o-mini",
    max_loops: int = 1,
    verbose: bool = True,
) -> SequentialWorkflow:
    ...

@classmethod
def content_creation_pipeline(
    model_name: str = "gpt-4o-mini",
    max_loops: int = 1,
    verbose: bool = True,
) -> SequentialWorkflow:
    ...

# Similar signatures for all other templates

Common Parameters:

• model_name (str): LLM model to use
• max_loops (int): Maximum loops per agent
• verbose (bool): Enable verbose logging

Returns:

• Configured SequentialWorkflow instance

---

Usage Patterns

Pattern 1: Quick Start

Use the universal create() method for quick instantiation:

from swarms import SwarmTemplates

swarm = SwarmTemplates.create("content_creation_pipeline")
result = swarm.run("Write a blog post about AI")

Pattern 2: Direct Method Call

Use template-specific methods for type hints and IDE support:

from swarms import SwarmTemplates

swarm = SwarmTemplates.research_analysis_synthesis(
    model_name="gpt-4o",
    verbose=True
)

result = swarm.run("Research renewable energy trends")

Pattern 3: Discovery and Selection

List templates and select based on use case:

from swarms import SwarmTemplates

# List all templates
templates = SwarmTemplates.list_templates()

# Find template for your use case
for template in templates:
    if "financial" in template['use_case'].lower():
        print(f"Found: {template['name']}")
        
        # Get detailed info
        info = SwarmTemplates.get_template_info(template['name'])
        
        # Create and use
        swarm = SwarmTemplates.create(template['name'])

Pattern 4: Custom Model Configuration

Use different models for different needs:

from swarms import SwarmTemplates

# High-quality model for critical analysis
financial_swarm = SwarmTemplates.financial_analysis_team(
    model_name="gpt-4o"  # Premium model
)

# Cost-effective model for routine tasks
content_swarm = SwarmTemplates.content_creation_pipeline(
    model_name="gpt-4o-mini"  # Economy model
)

Pattern 5: Batch Processing

Process multiple tasks with the same template:

from swarms import SwarmTemplates

# Create template once
swarm = SwarmTemplates.customer_support_team()

# Process multiple support tickets
tickets = [
    "Customer can't reset password",
    "Billing question about invoice",
    "Feature request for dark mode"
]

for ticket in tickets:
    result = swarm.run(ticket)
    print(f"Resolution: {result}\n")

---

Customization

Custom Models

All templates support any LLM model that works with Swarms:

from swarms import SwarmTemplates

# OpenAI models
swarm = SwarmTemplates.create("research_analysis_synthesis", 
    model_name="gpt-4o"
)

# Anthropic models  
swarm = SwarmTemplates.create("code_development_team",
    model_name="claude-sonnet-4-5"
)

# Local models
swarm = SwarmTemplates.create("content_creation_pipeline",
    model_name="ollama/llama3"
)

Max Loops Configuration

Control agent iteration depth:

from swarms import SwarmTemplates

# Single-pass workflow (default)
swarm = SwarmTemplates.research_analysis_synthesis(
    max_loops=1
)

# Multi-iteration with refinement
swarm = SwarmTemplates.code_development_team(
    max_loops=3  # Allows for iteration and improvement
)

Verbose Logging

Control logging verbosity:

from swarms import SwarmTemplates

# Detailed logging (default)
swarm = SwarmTemplates.financial_analysis_team(
    verbose=True
)

# Silent operation
swarm = SwarmTemplates.content_creation_pipeline(
    verbose=False
)

---

Best Practices

1. Choose the Right Template

Select templates based on your specific use case:

# For research and analysis
research_swarm = SwarmTemplates.research_analysis_synthesis()

# For content generation
content_swarm = SwarmTemplates.content_creation_pipeline()

# For technical tasks
code_swarm = SwarmTemplates.code_development_team()

2. Provide Clear, Detailed Tasks

Give agents comprehensive context:

# ❌ Too vague
result = swarm.run("Analyze the company")

# ✅ Clear and detailed
result = swarm.run("""
Analyze Company XYZ's financial performance including:
- Revenue growth trends (last 3 years)
- Profitability metrics
- Cash flow analysis
- Key risk factors
- Competitive positioning
""")

3. Use Appropriate Models

Match model capability to task complexity:

# Complex analysis → Premium model
financial_swarm = SwarmTemplates.financial_analysis_team(
    model_name="gpt-4o"
)

# Routine tasks → Economy model
support_swarm = SwarmTemplates.customer_support_team(
    model_name="gpt-4o-mini"
)

4. Handle Outputs Appropriately

Process and validate results:

from swarms import SwarmTemplates

swarm = SwarmTemplates.data_science_pipeline()

result = swarm.run("Analyze customer data")

# Validate output
if result and len(result) > 100:
    # Process valid result
    with open("analysis_report.txt", "w") as f:
        f.write(result)
else:
    # Handle insufficient output
    print("Warning: Analysis incomplete")

5. Reuse Templates for Similar Tasks

Create once, use multiple times:

from swarms import SwarmTemplates

# Create template instance
content_swarm = SwarmTemplates.content_creation_pipeline()

# Reuse for multiple content pieces
topics = ["AI in Healthcare", "Future of Work", "Climate Tech"]

for topic in topics:
    article = content_swarm.run(f"Write article about {topic}")
    # Save or process article

---

Production Deployment

Error Handling

Implement robust error handling:

from swarms import SwarmTemplates

def run_swarm_safely(template_name, task):
    """
    Safely execute swarm with error handling
    """
    try:
        swarm = SwarmTemplates.create(
            template_name=template_name,
            model_name="gpt-4o-mini",
            verbose=True
        )
        
        result = swarm.run(task)
        
        if not result:
            raise ValueError("Empty result from swarm")
            
        return {"success": True, "result": result}
        
    except ValueError as e:
        return {"success": False, "error": str(e)}
    except Exception as e:
        return {"success": False, "error": f"Unexpected error: {str(e)}"}

# Usage
response = run_swarm_safely(
    "research_analysis_synthesis",
    "Analyze market trends"
)

if response["success"]:
    print(response["result"])
else:
    print(f"Error: {response['error']}")

Performance Monitoring

Track template performance:

import time
from swarms import SwarmTemplates

def run_with_monitoring(template_name, task):
    """
    Run swarm with performance tracking
    """
    start_time = time.time()
    
    swarm = SwarmTemplates.create(template_name)
    result = swarm.run(task)
    
    execution_time = time.time() - start_time
    
    return {
        "result": result,
        "execution_time": execution_time,
        "template": template_name
    }

# Track performance
metrics = run_with_monitoring(
    "financial_analysis_team",
    "Analyze Q4 results"
)

print(f"Completed in {metrics['execution_time']:.2f}s")

Logging and Auditing

Implement comprehensive logging:

import logging
from swarms import SwarmTemplates

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def run_with_logging(template_name, task, user_id=None):
    """
    Run swarm with comprehensive logging
    """
    logger.info(f"Starting swarm: {template_name}")
    logger.info(f"User: {user_id}, Task: {task[:100]}")
    
    try:
        swarm = SwarmTemplates.create(template_name)
        result = swarm.run(task)
        
        logger.info(f"Swarm completed successfully")
        logger.info(f"Result length: {len(result)} characters")
        
        return result
        
    except Exception as e:
        logger.error(f"Swarm failed: {str(e)}")
        raise

# Usage with logging
result = run_with_logging(
    template_name="research_analysis_synthesis",
    task="Market analysis",
    user_id="user_123"
)

---

FAQ

Q: Can I modify the agent prompts in templates?

A: Templates use pre-optimized prompts. For custom prompts, create agents manually using the Agent class.

Q: Which template should I use for my use case?

A: Use SwarmTemplates.list_templates() to see all options with use cases, or refer to the template descriptions above.

Q: Can templates work with local models?

A: Yes! Templates support any model compatible with Swarms:

swarm = SwarmTemplates.create(
    "content_creation_pipeline",
    model_name="ollama/llama3"
)

Q: How do I handle long-running tasks?

A: Increase max_loops for iterative refinement:

swarm = SwarmTemplates.create(
    "code_development_team",
    max_loops=3  # Allow multiple iterations
)

Q: Are templates suitable for production?

A: Yes! Templates are production-tested and optimized. Implement proper error handling and monitoring for production deployments.

Q: Can I mix agents from different templates?

A: Templates return workflow objects. For custom agent combinations, use Agent and workflow classes directly.

Q: How much do template operations cost?

A: Cost depends on your chosen model and task complexity. Templates use sequential workflows, so expect 3-4 agent calls per task.

---

Examples

See comprehensive examples in /examples/swarm_templates_examples.py

Run examples:

cd examples
python swarm_templates_examples.py

---

Support

For issues, questions, or feature requests:

• GitHub Issues: https://github.com/kyegomez/swarms/issues
• Discord: https://discord.gg/EamjgSaEQf
• Documentation: https://docs.swarms.world