Agents Squads
Coordinate multi-model AI teams with persistent memory, verification, and feedback loops.
- Source repo
- agents-squads/squads-cli
- Stars
- ★ 53
- Last updated
- 3d ago
- License
- MIT
- Primary language
- TypeScript
- FA score
- 73/100 · Some gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformClaude Code
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- An engineering lead wants planners, implementers, and verifiers to collaborate on one goal while retaining an auditable Git history.
- Not a fit if
- Teams unable to install Claude Code
- Teams requiring state management without Git or local files
- Users seeking a hosted, serverless platform
- Source review
- 73/100 · Some gaps
What does this agent do, and when should you use it?
Agents Squads is a TypeScript CLI framework for organizing AI teams across engineering, marketing, finance, and operations. It stores business context, system rules, squad identities, goals, learnings, and feedback as Markdown under `.agents/` in a Git repository, with no database, server, or custom DSL. Before each run, it builds a role-sensitive context cascade from company strategy, squad goals, previous feedback, and active work; leads plan, workers execute, and verifiers inspect the result. The CLI shells out to native tools such as `claude`, `gemini`, and `aider`, allowing different agents to use different models. Users start squad or bounded tasks with `squads run` and resolve approval, rejection, or deferral decisions through `squads inbox`; the repository description also identifies status, memory, goals, feedback, and a dashboard as management features. Execution and state remain on the user's machine, although the setup requires Node.js, Git, Claude Code, and credentials for the selected AI providers.
Squads reads business context from .agents/BUSINESS_BRIEF.md, shared rules from .agents/config/SYSTEM.md, SQUAD.md and individual agent definitions from .agents/squads/, and strategy, goals, learnings, and feedback from .agents/memory/. It assembles these inputs into a role-tuned context cascade, keeping scanner contexts lighter while giving leads a broader view. squads run research performs a squad conversation covering plan, work, review, and verification, while squads run intelligence --task "Scan X" starts a directed, bounded task. During execution it shells out to native AI CLIs including claude, gemini, and aider, so roles can be routed to different models. Feedback from one cycle is injected into the next, while Markdown files and Git history retain team state and its audit trail. squads inbox gathers items that require the user to approve, reject, or defer them.
- An engineering lead wants planners, implementers, and verifiers to collaborate on one goal while retaining an auditable Git history.
- A research team wants a lower-cost model to scan, a deeper reasoning model to build, and another model to verify the output.
- A marketing or operations lead needs business context and squad goals to persist across runs so agents do not repeat completed work.
- A local-first team wants multi-agent workflows to run on its own machine and API keys without deploying a database or server.
- A manager wants a single inbox for agent work that still requires a human approval, rejection, or deferral decision.
How do you install or deploy this agent?
Install Node.js 20 or newer, Git, and Claude Code first. Claude Code must be installed and authenticated with claude /login; other providers are optional. Then install the CLI and initialize a Git-backed workspace:
npm install -g squads-cli
mkdir my-workforce && cd my-workforce
git init
squads init
squads run demo hello-worldCheck the machine and required Claude Code setup with:
squads doctorFor source development, use:
git clone https://github.com/agents-squads/squads-cli.git
cd squads-cli
npm install
npm run build && npm link
npm testHow do you use this agent?
After initialization and the demo run, start the first practical agent:
squads run research/analystRun the complete research squad conversation, including planning, work, review, and verification:
squads run researchGive the intelligence squad a bounded task:
squads run intelligence --task "Scan X"Open the queue of decisions awaiting human action:
squads inboxSquad definitions, business context, rules, and memory live under .agents/ and can be managed through Markdown and normal Git workflows.
What are this agent's strengths and limitations?
- Markdown and Git provide both state and an audit trail without requiring a database, persistent server, or custom DSL.
- The documented lead-worker-verifier structure implements a plan-work-review-verify loop and feeds each cycle's feedback into the next.
- Native
claude,gemini, andaiderCLI execution permits different models to be assigned to different roles. - The context cascade varies by role, supporting lightweight scanners without depriving leads of broader team context.
- The project states that execution, data, and keys stay on the user's machine, with no project-specific cloud login or telemetry.
- The first run explicitly requires Claude Code to be installed and authenticated, even though other providers are available as options.
- Adoption requires Node.js 20 or newer, Git, local filesystem access, and provider credentials, making setup heavier than a hosted chat product.
- Markdown and Git are the state layer, so teams requiring database transactions, centralized service state, or Git-free workflows must change their operating model.
- Mixed-model use depends on multiple external native CLIs, leaving provider installation, authentication, and usage charges to the user.
- The supplied material gives no dashboard launch command, interface details, or deployment procedure, so that feature cannot be evaluated in depth.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Agents Squads This agent | 73 · Some gaps | CLIFree + model costs | ★ 53 | 3d ago | TypeScript | Claude Code |
| AI DevOps Framework (aidevops) | 65 · Some gaps | CLIFree + model costs | ★ 400 | 1d ago | Shell | OpenAI API · Claude API |
| VCP ToolBox | 11 · Major gaps | Self-hosted serviceFree + model costs | ★ 2.3k | 1d ago | JavaScript | OpenAI API · Claude API |
| taOS Self-Hosted Agent OS | 71 · Some gaps | Self-hosted serviceFree | ★ 550 | today | Python | Claude Code · OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The evidence shows default-deny contracts, role-scoped tools and write paths, runtime and cost ceilings, and rejection of consequential grants without a gate; the branching test also keeps work products off main, so least privilege is handled thoroughly. README inbox approvals and contract HITL gates support user confirmation, but the supplied files do not establish that every externally consequential command is uniformly confirmed. The README explains local Git state, context consumed by agents, and delegation to external AI CLIs, giving adequate data-flow visibility, but it does not enumerate provider payload fields, retention, or network endpoints. SECURITY.md gives concrete guidance for credentials, file permissions, prompt injection, encryption, and secure deletion, although enforcement by default is not demonstrated. CI runs npm audit at critical severity and dependencies are constrained, but no lockfile, stronger supply-chain pinning evidence, or audit result is supplied. Git branch isolation, audit history, and consequential gates constrain effects, yet agents may execute system commands and bare Bash is accepted as an enforceable tool. Git provides a rollback foundation, but no dedicated undo procedure or automatic failure recovery is shown. Author, repository, issue channel, and license attribution are clear; however, the publisher is not registry-verified and the files provide no independently established maintainer identity chain.
README, package metadata, CI, and tests are broadly consistent about Node versions, CLI naming, local Git state, and provider prerequisites, with drift guards for generated clients and command references. Deductions apply because some smoke commands are followed by “|| true,” the branching test relies on a fixed delay, and no execution results are available. Dependency availability is addressed through npm ci, Node 20/22 matrices, doctor checks, and a nonzero exit code for a missing provider CLI, but normal operation still requires separately installed and authenticated Claude Code, while other providers are not verified by the supplied evidence. Failure handling includes missing-file diagnostics, drift errors, a security-reporting route, and machine-detectable provider failure; a complete user-facing error taxonomy, retry policy, and recovery messaging are not shown.
Engineering, marketing, finance, operations, and scanner, worker, lead, and verifier roles are clearly identified, with both conversational and directed execution scenarios, justifying full audience-and-scenario credit. Role contracts, allowed tools, write scopes, budgets, timeouts, and context layers define ordinary capability boundaries, but bare Bash remains broad and the runtime implementation needed to confirm every boundary is absent. Squad/agent addressing, --task, --dry-run, and provider selection offer reasonable trigger precision, though ambiguity handling and dangerous-intent rejection for natural-language tasks are not demonstrated. Node, Git, Claude Code, a local file layout, doctor, and the multi-provider design support environment fit, but the claim that additional providers work out of the box is not fully substantiated by the supplied configuration or end-to-end evidence.
The README supplies a clear directory tree, operating model, documentation map, requirements, development steps, and contribution path, earning full information-architecture credit. Global installation, initialization, an end-to-end demo, local development, and prerequisites are directly actionable, so install notes are thorough. Commands, directories, and role terminology remain consistent across the files, with a generated-reference drift guard, but the product is still 0.x and no compatibility guarantee is shown. Examples cover first use, directed tasks, approval, and development, while an FAQ and broader troubleshooting examples are absent. SECURITY.md documents prompt injection, command execution, and sensitive memory limitations, and README discloses the default-provider requirement, but there is no consolidated and comprehensive limitations section. MIT metadata matches the complete license text, supporting full license credit. Changesets automation and version 0.9.0 establish an update mechanism, but no actual changelog or release notes are included. Security and general contact addresses, issue tracking, and a security-update process identify maintenance routes; deductions reflect the lack of a registry-verified publisher, named maintainers, or governance details rather than treating unknown identity as suspicious.
Human-oriented status, context, inbox, dry-run, and doctor commands, together with machine-detectable failure and reviewable Git/Markdown artifacts, support ordinary output usability. No representative real output or full interaction implementation is supplied, preventing a thorough score. Shared context, persistent memory, feedback loops, verifier roles, and mixed-model routing plausibly add value over a single agent, but reduced duplication and improved quality remain largely asserted without comparative evidence. Per-role cost and time ceilings and the use of cheaper models for scanning show cost awareness, while claims about API-call-only economics lack benchmarks, scale measurements, or total-cost analysis.
Several behaviors trace to concrete tests, issue references, CI guards, and configuration fields, including missing-CLI exit status, contract constraints, initialization artifacts, and branch isolation. Promotional capabilities are not all connected to supplied implementation or tests, so traceability is adequate rather than complete. README, package metadata, SECURITY.md, workflows, and tests strongly corroborate installation requirements, local Git architecture, version, license, permission controls, and maintenance processes. The material often distinguishes requirements, recommendations, and tested assertions, especially in SECURITY.md, but claims such as out-of-the-box provider support, avoidance of duplicate work, and no telemetry surprises lack direct implementation evidence, leaving some facts and inferences insufficiently separated.
- Agents can invoke native AI CLIs and system commands; use sandboxing, inspect tool grants, and avoid bare Bash when processing untrusted prompts or repositories.
- Persistent memory and business context live in the Git workspace and may contain sensitive data; restrict .agents/ permissions, exclude secrets, and consider long-term exposure through commit history.
- The claims of local-only operation, no telemetry surprises, and out-of-the-box multi-provider support are not fully verified by the supplied implementation; inspect actual network traffic and provider configuration before deployment.
- Git branches provide a recovery basis, but no uniform undo or failure-recovery mechanism is shown; establish tested backups, approvals, and rollback procedures before consequential runs.
- CI blocks only critical npm audit findings, and no lockfile or audit result is supplied; perform a complete dependency and supply-chain review at the pinned revision before adoption.
FAQ
Is the software itself paid?
Can I use it without Claude Code?
claude /login before the first run. Gemini, Aider, and other CLIs can also be invoked, but the source does not document removing the initial Claude Code requirement.Does it need a database or background server?
Does project data go to the vendor's cloud?
How do I diagnose missing dependencies or authentication?
squads doctor. It checks the machine and Claude Code setup and reports what is missing; further recovery behavior is not documented in the supplied material.