Skip to content

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 v1.1.0 stable (October 20, 2026); v2.0.0 prerelease channel active (v2.0.0-preview.2)
Stars / Popularity ~3,300 stars · 490+ 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 creates a persistent team of AI agents within your repository. Created by Brady Gaster at Microsoft, it assigns explicit roles and work boundaries to agents for frontend, backend, testing, documentation, and other tasks. Agents can work in parallel and coordinate through repository files.

Agent histories and team decisions persist across sessions. An autonomous work monitor routes issues, reviews, and CI failures to the team.

Pros & cons at a glance

Pros Cons
✅ Parallel multi-agent orchestration ❌ Copilot-only — doesn't work with Claude Code, Cursor, etc.
✅ Persistent memory across sessions (decisions, history, governed memory) ❌ Stable since v1.0.0, but the v2.0.0 prerelease line is already reworking the gh-aw lifecycle — pin a version before standardizing
✅ 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 assigns revisions to a different agent
✅ Extensible — human members, @copilot agent, custom agents

Squad coordinates persistent AI teams for GitHub-centric Copilot users, with shared decisions, parallel work, and autonomous queue monitoring.

Core concepts

Coordinator Pattern. The Coordinator receives requests, assigns work, runs agents in parallel, and combines their results. It delegates domain work rather than doing it itself.

Persistent Agent Identity. Each agent has a role and boundaries in charter.md and records what it learns in history.md. Both files persist in the repository across sessions.

Decisions-as-Memory and Governed Memory. A shared decisions.md file records architecture choices, naming conventions, library selections, and other decisions that affect multiple agents. All agents read it when spawned. Version 0.10.0 added 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.

Reaching 1.0. Squad crossed 1.0.0 on October 3, 2026, after an extended 0.x line (preset install, cross-Squad discovery, Copilot App sub-sessions, squad_state memory tools, and the hire → cast terminology change all landed pre-1.0). The v1.1.0 stable release (October 20, 2026) followed with documentation refresh and no breaking API changes. A v2.0.0 prerelease channel (currently v2.0.0-preview.2) is active in parallel, hardening GitHub Agentic Workflows (gh-aw) integration — deterministic upserts, lifecycle state handling, versioned health checks, and a tighter GitHub Actions permissions model for workflows that run Squad unattended. Treat v2.0.0 as a prerelease: pin v1.1.0 for production use until it stabilizes.

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

  • Parallel orchestration. Multiple agents work simultaneously in separate contexts, with dependency-aware scheduling.
  • Persistent memory across sessions. Agents can consult prior histories, team decisions, governed memory, and orchestration logs stored in the repository.
  • 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. Agents manage issues, branches, PRs, and merges through the GitHub CLI.
  • Reviewer rejection protocol. A different agent must revise rejected work; the original author is locked out.
  • 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.
  • Short stable-release history. Squad reached 1.0 in October 2026. The parallel v2.0.0 prerelease channel (gh-aw lifecycle work) means teams standardizing on it should pin a version rather than track dev.
  • Directory overhead. The Coordinator automates setup, but .squad/ adds team configuration, agent histories, decisions, and logs that must be maintained.
  • 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. The project reached 1.0.0 on October 3, 2026, and v1.1.0 followed on October 20. The repository had roughly 3.3K stars and 490 forks on October 27, 2026. A v2.0.0 prerelease channel is active in parallel, focused on gh-aw (GitHub Agentic Workflows) lifecycle integration — issue-triggered teams that open PRs for human merge before their workflows go live.

Comparison notes

vs. BMAD: BMAD simulates roles through agent personas within a user's session. Squad creates parallel agent instances with persistent memory, shared decisions, and autonomous work monitoring. BMAD provides more agile process structure; Squad provides more coordination infrastructure.

vs. GSD: GSD structures project work through specs, fresh context, and planned execution. Squad manages a persistent team with roles, memory, and autonomous work routing. GSD is lighter and documents multiple hosts, with Claude Code as its deepest integration. Squad adds coordination infrastructure and requires Copilot.

vs. HVE: HVE adds the RPI workflow, domain collections, governance, and audit trails. Squad focuses on team coordination, persistent memory, and GitHub 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.