Agent Squad: routing and orchestrating multiple AI agents in Python, TypeScript and Swift

The routing problem Agent Squad exists to solve

Most teams do not start with one agent. They start with a support bot, then add a billing bot, then a technical bot, and end up with three endpoints and a pile of if-statements deciding which one to call. Agent Squad replaces that dispatch layer. You register agents with a name and a description, and a Classifier reads those descriptions plus the conversation history to decide which agent handles the current turn. The orchestrator then stores the exchange and returns the response. The intended user is a team that already has specialized agents and wants a single entry point that keeps one coherent conversation across all of them. The README frames the value as routing each query to the most suitable specialized agent while maintaining context across agents and sessions. That is a narrower and more honest claim than "build an AI workforce": the framework assumes you bring the agents.

How the classifier, orchestrator and storage fit together

The documented flow has four steps. User input is analyzed by a Classifier. The Classifier uses the agents' descriptions and the conversation history to select the best agent for the turn. The selected Agent processes the input, calling tools as needed. The Orchestrator saves the exchange and returns the response. Two design consequences follow. First, agent descriptions are not documentation, they are routing input, so vague descriptions produce vague routing. Second, because history feeds the classifier, a long session can shift routing behavior over time even if the user's intent has not changed. The framework exposes seams for custom agents, classifiers, storage and retrievers, so you can replace the classifier with your own logic if the default one misroutes. On top of this base, SupervisorAgent coordinates a team of specialized agents in parallel using an agent-as-tools architecture with shared context, and can itself be registered in the classifier to build hierarchical teams. GroundedAgent splits the work between a gatherer that calls tools but never speaks to the user and an isolated presenter that writes the reply from the curated tool output alone. That two-model split is the framework's stated anti-hallucination pattern, and it is available in all three runtimes.

Installing Agent Squad and routing a first request

The Python package installs with an extra that selects the provider SDKs you need. The README shows aws, anthropic, openai and all as the available extras, so pick the one matching your agent types rather than pulling everything.

pip install "agent-squad[aws]"

A minimal Python program creates an orchestrator, registers one Bedrock-backed agent with a description, and routes a question. Note that the description string is what the classifier actually reads, so write it as routing criteria rather than marketing copy.

import asyncio
from agent_squad.orchestrator import AgentSquad
from agent_squad.agents import BedrockLLMAgent, BedrockLLMAgentOptions, AgentStreamResponse

orchestrator = AgentSquad()
orchestrator.add_agent(BedrockLLMAgent(BedrockLLMAgentOptions(
    name="Tech Agent",
    description="Specializes in technology: software, hardware, AI, cybersecurity, cloud.",
    streaming=True,
)))

Then call route_request with a user id and a session id. The session id is what keeps context across turns, and passing the same one back is what makes the conversation coherent rather than a series of unrelated questions.

async def main():
    response = await orchestrator.route_request("What is AWS Lambda?", "user123", "session456", {}, True)
    print(f"> Agent: {response.metadata.agent_name}\n")

asyncio.run(main())

The response carries metadata naming the agent that was selected, which is the fastest way to debug misrouting: if the wrong agent answers, the metadata tells you so before you read a single token of output. On the TypeScript side the package is agent-squad on npm, and the Swift runtime is added as a package dependency pointing at the repository on branch main. The Swift README is the place to look for the full quick start, and it lists iOS 16+ and macOS 14+ as the platform floor.

Where Agent Squad is the wrong tool

The framework assumes routing is the hard part. If your application has exactly one agent, the classifier is pure overhead: an extra model call per turn whose only job is to return the agent you already knew you wanted. Similarly, if your dispatch logic is deterministic (an account tier, a product SKU, a language code), a classifier that guesses is worse than a switch statement that does not. The other boundary is context. Because conversation history is an input to routing, agents that need deep, long-running state in a single thread can behave unpredictably when the classifier re-evaluates on every turn. The README does not document rollback or a way to pin a session to one agent permanently, so if you need that guarantee you should check the docs before building on it. Finally, GroundedAgent's two-model split doubles the model calls for any answer that needs grounding. That is a deliberate trade for answers that cannot drift from your data, but it is a cost, and for open-ended chat where grounding does not matter it buys nothing.

Agent Squad compared with Strands and LangGraph

The comparison people search for most is Agent Squad versus Strands, and the two sit at different layers. Agent Squad is an orchestrator: its central object is a set of agents plus a classifier that picks one per turn, and its built-in patterns are SupervisorAgent for parallel team coordination and GroundedAgent for grounded answers. Strands is an agent SDK, so the unit of work is a single agent and its tool loop, and you compose multiple agents yourself. If your problem is "which of my six specialists should answer this," Agent Squad models that directly. If your problem is "how do I write one agent with a deep tool loop," the orchestrator adds a layer you may not want. Against LangGraph, the difference is graph versus classifier. LangGraph makes you declare the control flow as an explicit graph of nodes and edges, which is more work up front and more predictable at runtime. Agent Squad decides the path at runtime from agent descriptions and history, which is less work up front and less predictable. The repository also ships an examples/strands-agents-demo directory, which suggests the two are meant to be used together rather than chosen between.

Maintenance, licensing and upgrade cost

The project is Apache-2.0, which permits commercial use and modification, and the repository includes a LICENSE file and a CODE_OF_CONDUCT.md and CONTRIBUTING.md at the top level. That is a normal permissive setup, and the licence text itself is the thing to read rather than any summary. On maintenance, the last push to the default branch was on 2026-09-10, so the repository is being touched, but the most recent tagged releases are the TypeScript 1.1.4 and Python 1.1.3 releases from 2026-07-14. The version numbers move independently per runtime, which is worth knowing before you pin dependencies: a TypeScript patch release does not imply a matching Python or Swift release. The migration note in the README matters more than most. The project was previously hosted at awslabs/agent-squad and was formerly named multi-agent-orchestrator, and the README asks readers to update bookmarks, clone URLs and dependencies. If you have an older dependency or a stale import path, that rename is the first thing to check before filing a bug.

Editorial conclusion

Adopt Agent Squad when you already have several distinct agent roles and want a classifier to pick between them per turn, and when you want the same orchestration model in Python, TypeScript or on-device Swift. Skip it if you need a single agent with a long tool loop, or if your routing decision depends on business rules you would rather write as plain code. Before committing, verify the current package names and install extras against the docs, confirm which agent types exist in the runtime you plan to ship, and check the Swift README for the minimum platform versions your app targets.

Frequently asked questions

Official sources

1. 2FastLabs/agent-squad on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases