Squad¶
At a Glance¶
| Field | Value |
|---|---|
| Full Name | Squad |
| Category | Multi-Agent Orchestration |
| Source | bradygaster/squad / bradygaster.github.io/squad |
| Author/Org | Brady Gaster (Microsoft) |
| License | MIT |
| First Released | 2025 |
| Current Version | v0.11.0 (June 30, 2026) |
| Stars / Popularity | ~3,100 stars · 475 forks; repository activity continued after the release |
| Supported Tools | GitHub Copilot (CLI and VS Code) |
Compatible Coding Agents¶
| Agent | Support |
|---|---|
| GitHub Copilot (VS Code) | ✅ Primary — native CLI and VS Code integration |
| GitHub Copilot Coding Agent (github.com) | ✅ Supported — can be added as a team member (@copilot) |
| Claude Code | ❌ Not supported — tightly coupled to Copilot ecosystem |
| Cursor | ❌ Not supported |
| OpenAI Codex (CLI) | ❌ Not supported |
| Windsurf | ❌ Not supported |
| Gemini CLI | ❌ Not supported |
| Roo Code | ❌ Not supported |
Overview¶
Squad is an AI agent orchestration system that creates a persistent, coordinated team of AI agents working within your repository. Created by Brady Gaster at Microsoft, it shifts AI-assisted development from "one brain talking to one brain" to a multi-agent architecture where specialized agents — frontend, backend, testing, documentation — work in parallel with explicit roles, clear boundaries, and written coordination.
The system applies Conway's Law to AI development: rather than trying to produce better output from a single agent through better prompts, Squad changes the structure. It introduces role separation, shared memory, decision tracking, and autonomous work monitoring. The agents don't just execute tasks — they accumulate knowledge, follow team decisions, and coordinate through a shared repository-based state.
Pros & Cons at a Glance¶
| Pros | Cons |
|---|---|
| ✅ True parallel multi-agent orchestration | ❌ Copilot-only — doesn't work with Claude Code, Cursor, etc. |
| ✅ Persistent memory across sessions (decisions, history, governed memory) | ❌ Still pre-1.0 (v0.11.0) — expect API changes |
| ✅ Autonomous work management via Ralph (Work Monitor) | ❌ Requires GitHub CLI authentication for full feature set |
| ✅ Full GitHub lifecycle integration (issues → PRs → merge) | ❌ Node.js dependency for the CLI |
| ✅ Reviewer rejection protocol enforces genuine review | |
| ✅ Extensible — human members, @copilot agent, custom agents |
In one sentence: Squad is Conway's Law applied to AI — persistent teams with real coordination, effective for GitHub-centric Copilot users from solo developers to teams of 10+ who want agents that remember, coordinate, and never stop working.
Core Concepts¶
Coordinator Pattern. A central Coordinator orchestrates all work. It receives user requests, routes them to the appropriate agent(s), manages parallel fan-out, and synthesizes results. The Coordinator never does domain work itself — it delegates.
Persistent Agent Identity. Each agent has a charter (charter.md) defining its role and boundaries, and a personal history (history.md) where it accumulates learnings. These files live in the repo and persist across sessions, giving agents continuity that ephemeral AI sessions lack.
Decisions-as-Memory and Governed Memory. A shared decisions.md file acts as the team's collective brain. When an agent makes a decision that affects others (architecture choices, naming conventions, library selections), it gets recorded here. All agents read this file at spawn time, ensuring consistency. Version 0.10.0 added more explicit governed memory, provider boundaries, diagnostics, and CLI validation.
Casting System. Agents receive character names drawn from fictional universes — an easter egg naming convention that makes the team feel distinct without introducing role-play or character behavior. Names are persistent identifiers, not personas.
Ralph (Work Monitor). An autonomous agent that continuously scans GitHub for issues, PRs needing review, CI failures, and untriaged work. Ralph keeps the pipeline moving by routing work to the right agents without waiting for human direction.
How It Works¶
Squad creates a .squad/ directory in the repository containing the team's state:
.squad/
├── team.md # Agent roster with roles
├── routing.md # Work assignment rules
├── decisions.md # Shared decision ledger
├── ceremonies.md # Structured team meetings
├── agents/
│ ├── {name}/charter.md # Agent identity and boundaries
│ └── {name}/history.md # Agent's accumulated knowledge
├── orchestration-log/ # Who did what, when, and why
└── log/ # Session logs
Team Assembly. Squad assembles a team based on the project description — typically Lead, Frontend Dev, Backend Dev, Tester, and Scribe (the silent logger). The Coordinator handles routing, model selection, and parallel orchestration.
Work Routing. When a user gives a task, the Coordinator decomposes it, identifies which agents can start immediately, and spawns them in parallel. A tester can write test cases from requirements while the implementer builds the feature. Background agents report results; the Coordinator synthesizes and launches follow-up work.
GitHub Integration. Squad manages the full issue → branch → PR → merge lifecycle. Agents create branches (squad/{issue-number}-{slug}), make commits referencing issues, push, and open PRs via the GitHub CLI. Ralph monitors the queue and keeps work moving.
SDK and state backends. Squad offers type-safe team configuration through builder functions (defineTeam(), defineAgent(), defineRouting()). The v0.10.0 line added state backend documentation, governed memory, presets, import/export, and broader Copilot CLI skill-path scanning.
Version 0.11.0. The current stable release added squad preset install <source> for GitHub URLs and local paths, cross-Squad discovery, Copilot App sub-sessions, memory tools through squad_state, and slimmer satellite skills. It also replaced hire terminology with cast; older workflows continue to work. Repository pushes after June 30 represent unreleased activity and should not be described as shipped features.
Additional features include Ceremonies (structured team meetings — design reviews, retrospectives, standups), Worktree Support (git worktrees for isolated issue work), PRD Mode (ingest product requirement documents as work source), Human Team Members (mix AI and human participants), Per-Agent Model Selection (a multi-layer system for optimizing cost and quality per task), and a built-in RAI reviewer agent, Rai.
Strengths¶
- True parallel orchestration. Multiple agents work simultaneously on different parts of a problem, each in their own context. This is not sequential delegation — it is concurrent fan-out with dependency-aware scheduling.
- Persistent memory across sessions. Agent histories, team decisions, governed memory, and orchestration logs persist in the repository. An agent picking up an issue today has access to what the team decided and learned yesterday. This is unique among the techniques compared here.
- Autonomous work management (Ralph). Ralph continuously scans for work — untriaged issues, CI failures, stalled PRs, approved merges — and routes it without human prompting. This enables a degree of autonomy that other frameworks leave to the user.
- Full GitHub lifecycle integration. Issues, branches, PRs, and merges are part of the core workflow, not an afterthought. Squad agents interact with GitHub natively via the CLI.
- Reviewer rejection protocol. Rejected work must be revised by a different agent — the original author is locked out. This enforces genuine review rather than rubber-stamping.
- Extensible team composition. Human team members, the GitHub Copilot coding agent (@copilot), and new AI agents can be added to the roster at any time.
Limitations¶
- Copilot-only. Squad is tightly coupled to the GitHub Copilot ecosystem — CLI and VS Code. It does not work with Claude Code, Cursor, or other AI coding tools directly.
- Still pre-1.0. At v0.11.0, the API and workflow structure may still change. Early adopters should expect iteration.
- Directory overhead. The
.squad/directory contains team files, agent charters, histories, decision ledgers, orchestration logs, casting state, and session logs. The setup is automated by the Coordinator, but the infrastructure footprint is nontrivial. - Requires GitHub authentication. The full feature set (Ralph, issue routing, PR lifecycle) depends on GitHub CLI authentication. Without it, Squad loses its autonomous capabilities.
- Node.js dependency. The CLI requires npm and Node.js, which may be a friction point for teams not already in the Node ecosystem.
Best For¶
- Teams building with GitHub Copilot who want structured multi-agent orchestration with persistent memory and autonomous work management.
- Projects managed through GitHub Issues and PRs. Squad's lifecycle integration (issue → branch → PR → merge) is most valuable when GitHub is the central project management platform.
- Medium-to-large projects with multiple concerns. Projects where frontend, backend, testing, and documentation are all active simultaneously benefit from Squad's parallel agent model.
- Teams that want autonomous background work. Ralph's continuous monitoring and work routing is valuable for teams that want their AI agents to pick up work proactively, not just when prompted.
Not Ideal For¶
- Non-Copilot environments. If the team uses Claude Code, Cursor, or another AI tool as their primary agent, Squad's Copilot dependency is a hard blocker.
- Projects without GitHub. Squad's strengths — work routing, Ralph, issue lifecycle — assume a workflow centered on GitHub. Without issues and PRs, much of Squad's value is unused.
- Teams needing enterprise governance. Squad has reviewer protocols but lacks the formal constraint enforcement, policy-as-code, and audit trail capabilities of HVE.
Community & Ecosystem¶
Squad is backed by Brady Gaster at Microsoft and offers a CLI, SDK, documentation site, and workshop materials. Version 0.11.0 merged 104 pull requests from 8 authors and updated its toolchain, including the GitHub Copilot SDK, TypeScript, Vitest, Ink, and OpenTelemetry. The repository had roughly 3.1K stars and 475 forks on August 8, 2026. Its last stable release remained June 30 even though repository activity continued.
Comparison Notes¶
vs. BMAD: Both use multi-agent architectures, but the implementation is fundamentally different. BMAD simulates a team through agent personas within a user's AI session. Squad creates parallel agent instances with persistent memory, shared decision ledgers, and autonomous work monitoring. BMAD is richer in structured agile process; Squad is richer in coordination infrastructure.
vs. GSD: Different paradigms solving different problems. GSD is spec-driven, focused on context engineering and parallel task execution within a structured lifecycle. Squad is orchestration-focused, managing a persistent team with roles, memory, and autonomous work routing. GSD is lighter and documents multiple host integrations, with Claude Code as its deepest integration; Squad is heavier and Copilot-native. They occupy different categories entirely — Spec-Driven vs. Multi-Agent Orchestration.
vs. HVE: Both target structured, multi-agent development but at different scales. HVE is enterprise-grade with a large repository inventory of agents, instructions, prompts, and skills plus the RPI workflow. Squad is team-scale with persistent memory and GitHub-centric work management. HVE emphasizes governance and audit trails; Squad emphasizes coordination and work routing.
vs. Superpowers: Squad orchestrates a team of specialized AI agents with persistent memory, shared decisions, and autonomous work monitoring. Superpowers enhances a single agent's discipline through composable behavioral skills (TDD, debugging, code review). They operate at different levels: Squad coordinates who does what; Superpowers defines how each agent works. They're complementary — a Squad agent could use Superpowers skills internally. Squad is Copilot-only; Superpowers supports Claude Code, Cursor, Codex, Copilot CLI, Gemini CLI, and OpenCode.