AWS Agent Squad: The Open-Source Framework That Actually Gets Multi-Agent Orchestration Right

When AWS Labs dropped Agent Squad (formerly the Multi-Agent Orchestrator), my first reaction was skepticism. Another agent framework? Really? We’ve got LangGraph, AutoGen, CrewAI, and a dozen others already cluttering the landscape. But after spending several weeks building with it, deploying it to production, and watching it handle the kinds of chaotic multi-agent scenarios that make other frameworks crumble, I’ve changed my tune.

Agent Squad isn’t trying to be everything to everyone. It’s solving one problem exceptionally well: intelligent routing and orchestration of multiple specialized AI agents. And it does this with a clarity of purpose and architectural elegance that’s genuinely refreshing in a space drowning in complexity.

This article is going to walk you through what Agent Squad actually is, why it matters for production systems, the core architectural decisions that make it work, practical use cases where it excels, and — critically — how to productionize it without the usual enterprise deployment nightmares.

The Problem: Multi-Agent Systems Are Harder Than They Look

Before we dive into Agent Squad itself, let’s talk about why multi-agent orchestration is legitimately difficult. The promise sounds great: instead of one monolithic agent trying to do everything, you have specialized agents that excel at specific tasks. A travel agent handles bookings, a weather agent handles forecasts, a medical agent handles health queries. Simple, right?

Wrong. The complexity isn’t in the agents themselves — it’s in the orchestration layer. How do you:

Route intelligently: When a user says “I need to book a flight to Chicago and check if I’ll need an umbrella,” which agent(s) handle this? Both? In what order?
Maintain context: When the user follows up with “Actually, make it next Tuesday instead,” does the system remember we’re talking about that Chicago flight?
Handle failures gracefully: What happens when the weather API is down but the booking system is fine?
Scale efficiently: Can you add a tenth agent without rewriting your routing logic?
Stay fast: Can you classify intent and route to the right agent in under 100ms?

I’ve seen production systems where teams hard-coded routing logic with endless if-else statements. I’ve seen others that used pure embeddings-based routing and ended up with unpredictable behavior when query phrasing changed slightly. I’ve watched systems lose context because conversation state wasn’t properly scoped to both user and agent.

Agent Squad was built by engineers who clearly encountered these same problems in production AWS systems and decided to solve them properly.

What Agent Squad Actually Is

At its core, Agent Squad is a lightweight orchestration framework that sits between your users and your specialized agents. It provides:

Intelligent classification: An LLM-powered classifier that analyzes user input, agent descriptions, and conversation history to route requests to the optimal agent
Context management: Automatic handling of conversation state, properly scoped by user ID, session ID, and agent ID
Universal agent interface: A standardized way to integrate agents regardless of their underlying technology (Bedrock, OpenAI, LangChain, Lex bots, Lambda functions, etc.)
Flexible storage: Pluggable conversation storage supporting DynamoDB, SQL databases, or in-memory stores
Streaming support: Native handling of both streaming and non-streaming agent responses

The framework is fully implemented in both Python and TypeScript, so you can use whichever fits your stack. This isn’t a minor detail — many frameworks pick one language and then half-ass the other. Agent Squad treats both as first-class citizens.

The Architecture: Why It Works

The beauty of Agent Squad is in what it doesn’t do. It’s not trying to be an LLM framework, a tool execution engine, a workflow orchestrator, or a deployment platform. It’s doing one thing: intelligent routing with context preservation.

The Classification Layer

The classifier is the brain of the system. When a user sends a request, the classifier:

Analyzes the user’s input text
Reviews descriptions and characteristics of all available agents
Examines conversation history across all agents for this user and session
Uses an LLM to select the most appropriate agent

This is subtle but important: the classifier has a global view of conversation history across agents, but individual agents only see their own conversation history. This architecture allows the classifier to understand context like “we were just talking about flights with the travel agent, so this ‘change to Friday’ probably relates to that” while keeping agents focused on their specific domain.

The framework ships with two built-in classifier implementations:

Bedrock Classifier: Uses Amazon Bedrock’s Converse API with Claude or other foundation models
OpenAI Classifier: Uses GPT-4 or other OpenAI models

Both classifiers expose extensive configuration options:

Temperature and inference parameters
Custom system prompts for specialized routing logic
Fallback behavior when confidence is low
Multi-intent handling (routing to multiple agents for compound queries)

You can also implement custom classifiers if you need something more specialized — like using embeddings-based routing as a first pass before LLM classification, or implementing business logic guards.

Agent Abstraction

This is where Agent Squad really shines. Every agent implements the same interface:

class Agent:
    async def process_request(
        self, 
        input_text: str,
        user_id: str,
        session_id: str,
        additional_params: Optional[Dict] = None
    ) -> AgentResponse:
        # Agent-specific logic here
        pass

It doesn’t matter if your agent is:

A Bedrock LLM with tool use
An Amazon Bedrock Agent with action groups
A Lex bot handling structured intents
A Lambda function with custom business logic
A LangChain agent with external tools
An OpenAI GPT with function calling

They all implement the same interface, and the orchestrator treats them identically. This standardization is huge for production systems. You can:

Swap agents without touching orchestration logic
A/B test different agent implementations
Add new agents without deployment coordination
Mix and match technologies based on what each agent does best

Context and Storage

Agent Squad handles conversation storage automatically. After each agent processes a request, the orchestrator:

Saves the user’s input message
Saves the agent’s response
Updates the conversation history for that specific agent, user, and session

The storage layer is pluggable:

DynamoDB: For serverless AWS deployments with automatic scaling
SQL databases: PostgreSQL, MySQL, SQLite for traditional architectures
In-memory: For development, testing, or ephemeral sessions

The conversation history structure is intelligent. Each message is tagged with:

user_id: Who sent the message
session_id: Which conversation thread
agent_id: Which agent handled it
Timestamp and token counts for analytics

This makes it trivial to:

Show conversation history to users
Analyze which agents are most engaged
Implement conversation retention policies
Debug routing decisions

Real Use Cases Where Agent Squad Excels

Let me walk through some production scenarios where Agent Squad’s architecture provides clear advantages.

Enterprise Customer Support

Imagine a SaaS company with multiple support domains:

Billing Agent: Handles payment issues, invoices, subscription changes
Technical Agent: Troubleshoots product issues, API errors, integration problems
Sales Agent: Answers pricing questions, feature comparisons, upgrade paths
Account Agent: Manages user profiles, authentication, team management

A customer message like “My API key isn’t working and I think my account was charged twice” needs to route to both Technical and Billing agents. Agent Squad’s classifier can:

Recognize this is a multi-intent query
Route first to Technical to resolve the API issue
Then to Billing to investigate the charge
Maintain context so the Billing agent knows about the API problem

The orchestrator handles this automatically without hard-coded rules.

Healthcare Triage System

A healthcare platform needs specialized agents:

Symptom Checker: Initial triage based on reported symptoms
Appointment Scheduler: Books with appropriate specialists
Pharmacy Agent: Handles prescriptions and refills
Insurance Agent: Verifies coverage and handles claims

Agent Squad’s conversation scoping is critical here. If a patient is discussing symptoms with the Symptom Checker and then asks about appointment availability, the classifier understands this is related to the ongoing symptom discussion and routes to the Scheduler with appropriate context.

The HIPAA compliance team loves that conversation history is properly scoped and stored with audit trails.

Financial Services Platform

A wealth management platform needs:

Market Analysis Agent: Provides research and market insights
Portfolio Agent: Handles positions, allocations, rebalancing
Trade Execution Agent: Processes buy/sell orders with compliance checks
Tax Agent: Estimates tax implications and optimization strategies

Agent Squad’s ability to maintain separate conversation threads with each agent while having a unified classifier view is exactly what’s needed. When a client asks “What are the tax implications of selling that tech stock we discussed yesterday?”, the classifier:

Recognizes this relates to a previous Portfolio Agent conversation
Retrieves that context (the specific tech stock)
Routes to Tax Agent with the necessary position details
Maintains compliance logs of all agent interactions

E-commerce Support Simulator

The Agent Squad repository includes a comprehensive e-commerce demo that showcases real-world complexity:

Product Agent: Answers questions about inventory, features, specifications
Order Agent: Tracks shipments, processes returns, handles modifications
Recommendation Agent: Suggests products based on preferences and history
Support Agent: Handles general inquiries and escalations

What makes this demo impressive is that it handles scenarios like:

“I ordered a laptop last week but now I want the upgraded model instead”
Classifier routes to Order Agent to find the order
Then to Product Agent to compare models
Back to Order Agent to process the exchange

This kind of multi-agent choreography is exactly where simple routing breaks down and Agent Squad’s architecture shines.

Productionizing Agent Squad: The Real Work

Building a demo with Agent Squad is straightforward. Taking it to production where it handles thousands of concurrent users, maintains SLAs, scales automatically, and provides observability? That’s where the real engineering happens.

Deployment Patterns

Serverless on AWS Lambda

The most natural fit for Agent Squad is AWS Lambda with API Gateway:

# lambda_handler.py
from agent_squad.orchestrator import AgentSquad
from agent_squad.agents import BedrockLLMAgent
from agent_squad.storage import DynamoDBChatStorage

# Initialize once outside handler for warm starts
orchestrator = AgentSquad(
    storage=DynamoDBChatStorage(
        table_name="agent-squad-conversations",
        region="us-east-1"
    )
)

# Register agents
orchestrator.add_agent(
    BedrockLLMAgent(
        name="Travel Agent",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        description="Handles flight bookings, hotel reservations, travel planning"
    )
)

async def handler(event, context):
    body = json.loads(event['body'])
    
    response = await orchestrator.route_request(
        user_input=body['message'],
        user_id=body['user_id'],
        session_id=body['session_id']
    )
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'agent': response.metadata.agent_name,
            'response': response.output,
            'streaming': response.streaming
        })
    }

This setup gives you:

Automatic scaling to thousands of concurrent requests
Pay-per-invocation pricing
Integration with CloudWatch for logging
VPC connectivity to databases if needed

Containerized on ECS/EKS

For scenarios requiring persistent connections, custom networking, or tighter control:

# main.py
from fastapi import FastAPI, WebSocket
from agent_squad.orchestrator import AgentSquad

app = FastAPI()
orchestrator = AgentSquad()

# Register agents once at startup
@app.on_event("startup")
async def setup_agents():
    orchestrator.add_agent(...)

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    
    while True:
        data = await websocket.receive_json()
        
        # Stream responses back to client
        async for chunk in orchestrator.route_request_streaming(
            user_input=data['message'],
            user_id=data['user_id'],
            session_id=data['session_id']
        ):
            await websocket.send_json({
                'type': 'chunk',
                'content': chunk
            })

Deploy this as a container on ECS Fargate or EKS, and you get:

WebSocket support for streaming
Persistent connections and stateful sessions
Blue/green deployments
Integration with service meshes like App Mesh

Observability: You Can’t Improve What You Can’t Measure

Agent Squad includes callback support for observability, but you need to instrument it properly:

from agent_squad.callbacks import Callback
import time

class ProductionMetricsCallback(Callback):
    async def on_llm_start(self, agent_id: str, input: str):
        self.start_time = time.time()
        cloudwatch.put_metric(
            'AgentSquad',
            'RequestStarted',
            1,
            dimensions={'AgentId': agent_id}
        )
    
    async def on_llm_end(self, agent_id: str, output: str):
        latency = time.time() - self.start_time
        cloudwatch.put_metric(
            'AgentSquad',
            'Latency',
            latency,
            dimensions={'AgentId': agent_id}
        )
        
    async def on_classification_complete(self, selected_agent: str, confidence: float):
        cloudwatch.put_metric(
            'AgentSquad',
            'ClassificationConfidence',
            confidence,
            dimensions={'SelectedAgent': selected_agent}
        )

orchestrator = AgentSquad(
    callbacks=[ProductionMetricsCallback()]
)

Critical metrics to track:

Classification latency: How fast is routing?
Agent latency: Per-agent response times
Classification confidence: Is the classifier certain or guessing?
Agent selection distribution: Are some agents getting all the traffic?
Error rates: Per agent, per user, per session
Token consumption: For cost optimization
Context window usage: Are we approaching limits?

Set up CloudWatch alarms for:

Classification latency > 200ms (classifier might be overloaded)
Agent latency > 3s (agents need scaling or optimization)
Average confidence < 0.7 (classifier needs tuning or more agents)
Error rate > 1% (investigate agent failures)

Handling Agent Failures

Production systems fail. Agents go down, APIs timeout, rate limits hit. Agent Squad doesn’t automatically handle these (by design — it’s not trying to be a retry/circuit breaker framework), so you need to:

class ResilientAgent(Agent):
    def __init__(self, primary_agent, fallback_agent):
        self.primary = primary_agent
        self.fallback = fallback_agent
        
    async def process_request(self, input_text, user_id, session_id):
        try:
            return await self.primary.process_request(
                input_text, user_id, session_id
            )
        except Exception as e:
            logger.error(f"Primary agent failed: {e}, trying fallback")
            return await self.fallback.process_request(
                input_text, user_id, session_id
            )

# Use it
resilient_tech_agent = ResilientAgent(
    primary_agent=BedrockAgent("primary-tech-agent"),
    fallback_agent=LambdaAgent("fallback-tech-agent")
)

This pattern gives you:

Graceful degradation when primary agents fail
Ability to use cheaper/faster fallback agents
Time to fix issues before users notice

Cost Optimization

Agent Squad’s classification step uses an LLM, which means every request incurs some cost. For high-traffic systems:

# Use cheaper models for classification
classifier = BedrockClassifier(
    model_id="anthropic.claude-3-haiku-20240307-v1:0",  # Faster, cheaper
    inference_config={
        "maxTokens": 100,  # Classification needs fewer tokens
        "temperature": 0.1  # More deterministic
    }
)

# Cache classification results for common queries
from functools import lru_cache

@lru_cache(maxsize=10000)
def classify_common_query(query_hash):
    return orchestrator.classify(query)

Monitor your CloudWatch cost explorer and set budgets. A well-optimized system should keep classification costs under 10% of total agent costs.

Security and Compliance

For enterprise deployments:

Network Isolation

# Use VPC-enabled Lambda
orchestrator = AgentSquad(
    storage=DynamoDBChatStorage(
        table_name="conversations",
        region="us-east-1",
        endpoint_url="https://dynamodb.us-east-1.amazonaws.com"  # VPC endpoint
    )
)

Data Encryption

# Enable encryption at rest for DynamoDB
storage = DynamoDBChatStorage(
    table_name="conversations",
    kms_key_id="arn:aws:kms:us-east-1:123456789:key/..."
)

Audit Logging

class AuditCallback(Callback):
    async def on_request(self, user_id, session_id, input):
        audit_logger.info({
            'event': 'agent_request',
            'user_id': user_id,
            'session_id': session_id,
            'input_hash': hashlib.sha256(input.encode()).hexdigest(),
            'timestamp': datetime.utcnow().isoformat()
        })

Comparison: Agent Squad vs. The Alternatives

vs. LangGraph

LangGraph is a powerful framework for building stateful, multi-step agent workflows with complex control flow. It’s great when you need:

Explicit state machines with conditional branching
Complex multi-agent collaboration patterns
Programmatic control over agent execution order

Agent Squad is better when you need:

Simple, intelligent routing based on user intent
Quick setup without defining explicit graphs
Language-agnostic agents (Bedrock, Lex, Lambda, etc.)
Straightforward conversation context management

Use LangGraph for: Complex workflows where agents need to collaborate in specific patterns Use Agent Squad for: Intelligent routing to specialized agents without complex orchestration

vs. Microsoft Agent Framework (AutoGen)

Microsoft’s Agent Framework (formerly AutoGen) focuses on collaborative agents that can delegate tasks to each other and have multi-turn discussions. It’s excellent for:

Agents that need to debate or collaborate
Code generation scenarios with multiple specialized agents
Research and analysis workflows

Agent Squad is better for:

Production systems with clear agent specialization
Lower latency requirements (no multi-agent discussion overhead)
Integration with AWS services and serverless architectures
Scenarios where you want the orchestrator to make routing decisions, not the agents

Use Agent Framework for: Collaborative multi-agent systems where agents delegate to each other Use Agent Squad for: Fast routing to specialized agents in production applications

vs. CrewAI

CrewAI emphasizes role-based agents working together like a crew, with explicit task assignment and delegation. Great for:

Simulating organizational structures
Multi-step workflows with clear roles
Scenarios where agents should have autonomy in task distribution

Agent Squad is better for:

User-facing applications where routing needs to be fast and predictable
Production deployments on AWS infrastructure
Scenarios where you want centralized classification rather than distributed delegation
TypeScript environments (CrewAI is Python-only)

Use CrewAI for: Simulating human-like teams and organizational workflows Use Agent Squad for: Production multi-agent systems with intelligent routing

The Limitations: What Agent Squad Doesn’t Do

Let’s be clear about what Agent Squad isn’t:

It’s not a complete agent framework: Agent Squad doesn’t provide tool use, memory management, or planning capabilities. It assumes your agents already have these capabilities.

It’s not a workflow engine: If you need explicit control flow, conditional branching, or complex agent collaboration patterns, you want LangGraph or similar.

It’s not a deployment platform: Agent Squad is a library, not a managed service. You’re responsible for deployment, scaling, and operations.

It doesn’t handle multi-turn agent collaboration: Agents don’t talk to each other — they respond to users through the orchestrator. If you need agents to collaborate, use Agent Framework or LangGraph.

It’s still young: The project went 1.0 in October 2024 and recently rebranded from Multi-Agent Orchestrator to Agent Squad. Documentation is improving but not comprehensive yet.

These aren’t criticisms — they’re design choices. Agent Squad has a clear, focused purpose, and it does that one thing well.

Getting Started: A Practical Example

Let me walk you through building a simple but production-ready Agent Squad system. We’ll create a financial assistant with three specialized agents.

Installation

# For Python
pip install agent-squad[aws]  # Includes AWS integrations

# For TypeScript
npm install @aws/agent-squad

Define Your Agents

from agent_squad.orchestrator import AgentSquad
from agent_squad.agents import BedrockLLMAgent, BedrockLLMAgentOptions
from agent_squad.storage import DynamoDBChatStorage
from agent_squad.classifiers import BedrockClassifier

# Initialize the orchestrator
orchestrator = AgentSquad(
    storage=DynamoDBChatStorage(
        table_name="financial-assistant-conversations"
    ),
    classifier=BedrockClassifier(
        model_id="anthropic.claude-3-sonnet-20240229-v1:0"
    )
)

# Add a market research agent
market_agent = BedrockLLMAgent(
    BedrockLLMAgentOptions(
        name="Market Research Agent",
        description="""Expert in stock analysis, market trends, economic indicators.
        Handles queries about market performance, stock recommendations, sector analysis,
        and macroeconomic factors affecting markets.""",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        streaming=True,
        inference_config={
            "maxTokens": 1000,
            "temperature": 0.3  # More factual for market data
        }
    )
)

# Add a portfolio management agent
portfolio_agent = BedrockLLMAgent(
    BedrockLLMAgentOptions(
        name="Portfolio Agent",
        description="""Manages investment portfolios, asset allocation, rebalancing strategies.
        Handles queries about portfolio composition, diversification, risk management,
        and performance analysis.""",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        streaming=True,
        inference_config={
            "maxTokens": 1500,
            "temperature": 0.4
        }
    )
)

# Add a tax optimization agent
tax_agent = BedrockLLMAgent(
    BedrockLLMAgentOptions(
        name="Tax Agent",
        description="""Specializes in tax implications of investments, tax-loss harvesting,
        capital gains strategies, and tax-efficient portfolio management.
        Handles queries about tax optimization, deductions, and reporting.""",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        streaming=True,
        inference_config={
            "maxTokens": 1200,
            "temperature": 0.2  # Very factual for tax matters
        }
    )
)

orchestrator.add_agent(market_agent)
orchestrator.add_agent(portfolio_agent)
orchestrator.add_agent(tax_agent)

Handle Requests

import asyncio

async def handle_user_query(user_input, user_id, session_id):
    response = await orchestrator.route_request(
        user_input=user_input,
        user_id=user_id,
        session_id=session_id
    )
    
    print(f"Routed to: {response.metadata.agent_name}")
    print(f"Confidence: {response.metadata.confidence}")
    print(f"Response: {response.output}")
    
    return response

# Test it out
asyncio.run(handle_user_query(
    user_input="What are the top performing tech stocks this quarter?",
    user_id="user123",
    session_id="session456"
))
# Routed to: Market Research Agent

asyncio.run(handle_user_query(
    user_input="How should I rebalance my 60/40 portfolio?",
    user_id="user123",
    session_id="session456"
))
# Routed to: Portfolio Agent

asyncio.run(handle_user_query(
    user_input="What's the tax impact of selling my NVIDIA shares?",
    user_id="user123",
    session_id="session456"
))
# Routed to: Tax Agent

Add Streaming Support

async def handle_streaming_query(user_input, user_id, session_id):
    async for chunk in orchestrator.route_request_streaming(
        user_input=user_input,
        user_id=user_id,
        session_id=session_id
    ):
        if chunk.type == "chunk":
            print(chunk.content, end="", flush=True)
        elif chunk.type == "metadata":
            print(f"\n\nAgent: {chunk.agent_name}")
            print(f"Confidence: {chunk.confidence}")

asyncio.run(handle_streaming_query(
    user_input="Explain the current Fed interest rate policy and market implications",
    user_id="user123",
    session_id="session456"
))

Advanced Patterns

Custom Agent Implementation

You’re not limited to Bedrock agents. Implement the Agent interface for anything:

from agent_squad.agents import Agent, AgentResponse
import httpx

class CustomAPIAgent(Agent):
    def __init__(self, name, api_endpoint):
        super().__init__(name, "Custom API integration")
        self.api_endpoint = api_endpoint
    
    async def process_request(self, input_text, user_id, session_id, additional_params=None):
        async with httpx.AsyncClient() as client:
            response = await client.post(
                self.api_endpoint,
                json={
                    "query": input_text,
                    "user_id": user_id,
                    "session_id": session_id
                }
            )
            
            return AgentResponse(
                output=response.json()["result"],
                streaming=False,
                metadata={"api_latency": response.elapsed.total_seconds()}
            )

# Use your custom agent
custom_agent = CustomAPIAgent(
    name="Legacy System Agent",
    api_endpoint="https://api.yourcompany.com/legacy-agent"
)
orchestrator.add_agent(custom_agent)

Multi-Intent Handling

Sometimes users ask compound questions that need multiple agents:

# Enable multi-intent in classifier
classifier = BedrockClassifier(
    model_id="anthropic.claude-3-sonnet-20240229-v1:0",
    inference_config={
        "maxTokens": 200,
        "temperature": 0.1
    }
)

# Classifier can now return multiple agents
response = await orchestrator.route_request(
    user_input="What's Tesla's stock price and should I add it to my portfolio?",
    user_id="user123",
    session_id="session456",
    allow_multi_agent=True
)

# Response will aggregate outputs from both Market and Portfolio agents

Conversation History Management

# Retrieve conversation history for a user
history = await orchestrator.storage.fetch_chat(
    user_id="user123",
    session_id="session456",
    agent_id="Market Research Agent"
)

for message in history:
    print(f"{message.role}: {message.content}")

# Implement conversation retention policy
async def cleanup_old_conversations():
    # Get all sessions
    sessions = await orchestrator.storage.fetch_all_chats(user_id="user123")
    
    # Delete sessions older than 30 days
    cutoff = datetime.now() - timedelta(days=30)
    for session in sessions:
        if session.updated_at < cutoff:
            await orchestrator.storage.delete_chat(
                user_id="user123",
                session_id=session.session_id
            )

The Bigger Picture: Where Multi-Agent Systems Are Heading

Agent Squad represents a maturation in how we think about AI systems. We’re moving away from the “one model to rule them all” approach toward specialized, composable agents orchestrated intelligently.

The economics make sense: Instead of fine-tuning a massive model to handle every domain, you can use smaller, specialized models (or even rule-based systems) for specific tasks, with an orchestrator routing intelligently. This is often cheaper and more maintainable.

The engineering makes sense: Separating routing logic from agent logic makes systems easier to test, deploy, and evolve. You can update the travel agent without touching the medical agent.

The user experience makes sense: Users don’t want to learn different interfaces for different tasks. They want to talk naturally and have the system figure out who should help them.

Agent Squad’s approach — centralized classification with decentralized execution — feels like the right architecture for a large class of problems. It’s not the answer for everything (complex multi-agent collaboration still needs frameworks like LangGraph), but for intelligent routing and orchestration, it’s remarkably well-designed.

Conclusion: Should You Use Agent Squad?

After weeks of production use, here’s my assessment:

Use Agent Squad if:

You have multiple specialized AI capabilities (agents, bots, tools) that need intelligent routing
You need production-grade performance with latency under 200ms for classification
You’re building on AWS and want native integration with Bedrock, Lex, Lambda
You need both Python and TypeScript support with feature parity
You want explicit control over how agents are selected and conversations are managed
You value simplicity and focused design over feature completeness

Don’t use Agent Squad if:

You need complex multi-agent collaboration patterns (agents talking to agents)
You need explicit workflow control with conditional branching
You’re looking for a complete agent framework with tool use, planning, and memory built-in
You need mature, comprehensive documentation (it’s improving but not there yet)
You want a managed service rather than a library you deploy yourself

For me, Agent Squad has earned a permanent spot in my production stack. It does one thing exceptionally well, it’s architected for production use, and it doesn’t try to be more than it is. In a space full of frameworks trying to solve every problem, that focus is refreshing.

The team at AWS Labs clearly built this out of real production needs, and it shows. If you’re dealing with multi-agent orchestration challenges, it’s worth a serious look.

About the Author
Brian Curry is a Kansas City based Data Scientist, Artificial Intelligence expert and founder of Vector1 Research, a part time passion project, where he explores the frontier of Artificial Intelligence, SEO, Agentic Systems, Machine Learning, Economic Systems, Marketing Modeling, and Econometrics. His work focuses on building intelligent systems that reveal the causal structures driving performance across marketing, content, and economics, and he is the creator of Papilon, an open-source framework for complex system optimization; Daedalus, a platform for causal and economic analysis; and the scientist behind Memory-Node Encapsulation (MNE), a revolutionary data structure for artificial episodic memory and cognitive AI reasoning.

Contact: brian at vector1.ai | Vector1 AI Economics Lab

Resources

GitHub: https://github.com/awslabs/agent-squad
Documentation: https://awslabs.github.io/agent-squad/
Python Package: https://pypi.org/project/agent-squad/
TypeScript Package: https://www.npmjs.com/package/@aws/agent-squad
Demo Applications: Check the /examples directory in the GitHub repository
Community: GitHub Discussions for questions and feature requests

Have you used Agent Squad in production? I’d love to hear about your experiences — successes, challenges, and lessons learned. Drop a comment or reach out.