TL;DR — CrewAI is a solid Python framework. We evaluated it, liked it, and built something different anyway. squads-cli targets a different use case: multi-agent teams that aren’t inside a Python app, need git-native config, and want persistent memory without a vector database.
Why We Evaluated CrewAI First
When we started building automated operations at Agents Squads — marketing agents, finance agents, engineering reviewers — CrewAI was the obvious starting point. Mature Python library, active community, clean task-role model. We ran crews, shipped a few internal automations, and learned a lot.
Then we hit the edges of what it was designed for.
We weren’t building a Python application. We were building an organization — a set of domain-aligned teams that would run indefinitely, accumulate knowledge, hand off work to each other, and stay auditable as the company evolved. CrewAI is excellent at task pipelines. It isn’t designed for persistent org-level operations.
So we built squads-cli. This is what we found along the way.
What CrewAI Does Well
Before making the case for an alternative, it’s worth being honest about what you’d be giving up.
Task orchestration is first-class. CrewAI’s sequential/hierarchical/consensual process model is well-thought-out. Complex handoffs between agents work cleanly with the context=[previous_task] pattern:
research_task = Task(
description="Research the top 5 AI agent frameworks in 2026",
expected_output="Framework comparison with pros/cons",
agent=researcher
)
writing_task = Task(
description="Write a comparison guide based on the research",
expected_output="Publication-ready article",
agent=writer,
context=[research_task]
)
crew = Crew(
agents=[researcher, writer],
tasks=[research_task, writing_task],
process=Process.sequential
)Python ecosystem access. Every Python library is available as a tool. LangChain integrations, custom functions, vector databases — if it’s in PyPI, you can plug it in.
LLM flexibility. One crew can mix GPT-4, Claude, and local models. If you have strong opinions about model routing that cross provider lines, CrewAI handles this natively.
These are real strengths. If you’re building a Python service that needs embedded multi-agent logic, CrewAI is hard to beat.
What Doesn’t Fit
The limits we hit aren’t bugs — they’re design choices that make CrewAI what it is. But they were the wrong choices for our use case.
Agents live in code, not files. In CrewAI, an agent is a Python object defined in a .py file. Changing agent behavior means editing code, running through a deployment pipeline, and hoping nothing broke. We wanted agents to be files — markdown files you can diff, review in a PR, and change without touching a deployment.
No native memory across runs. CrewAI’s built-in memory works within a crew lifecycle. Cross-run persistence requires you to wire up a vector database or external storage. We wanted agents that simply remember what happened last week without additional infrastructure.
Task model, not team model. A Crew is designed around a set of tasks that complete and terminate. We needed agents that run on a cadence, hand off context to each other across squad boundaries, and track org-level goals — not task completion.
Python runtime dependency. If you want a non-Python agent (a bash script, a Node.js tool, a Claude Code session), you’re wrapping it in a Python shim. squads-cli treats any subprocess as a first-class agent.
What squads-cli Does Differently
Agents Are Files
Every agent in squads-cli is a markdown file:
<!-- .agents/squads/marketing/seo-writer.md -->
---
name: seo-writer
squad: marketing
model: claude-sonnet-4-6
trigger: manual
---
# SEO Content Writer
## Purpose
Create search-optimized content based on keyword research.
## Instructions
1. Pull the current keyword list from `.agents/memory/marketing/priorities.md`
2. Research the top-ranking articles for the target keyword
3. Write comprehensive content that addresses search intent
4. Save to `src/content/publications/` with full SEO frontmatterYou commit agent definitions to git. PRs become the review mechanism for agent behavior changes. The diff is the changelog. This is the pattern we describe in more detail in our CLI-first architecture guide.
Persistent Memory by Default
squads-cli uses file-based memory in .agents/memory/{squad}/. Every agent reads its squad’s state before running and writes back what it learned:
<!-- .agents/memory/marketing/state.md -->
# Marketing Squad State
## Current Focus
Q1 2026: SEO comparison content targeting framework keywords.
## In Progress
- "crewai alternative" article — draft complete, pending PR review
- Internal link audit — 16 articles missing cross-links
## Learnings
- Comparison posts (squads-cli vs X) drive 3x more organic clicks than
general guides. Prioritize competitive content.
- Long-form articles (>2000 words) get 40% more time-on-page.This isn’t vector similarity search — it’s plain text that agents read and write. Less sophisticated, but fully auditable via git log. No infrastructure to manage. No embeddings to regenerate.
Memory compounds across runs. Each agent cycle adds to the squad’s knowledge base. We cover the mechanics in memory systems for autonomous agents.
The IDP Layer
squads-cli ships with an Internal Developer Platform built in. Run squads catalog and you get a live service catalog of every squad, agent, and dependency in your org. Run squads scorecard before merging and you catch breaking changes before they propagate.
This doesn’t have a direct equivalent in CrewAI. It’s the layer that makes squads-cli work as organizational infrastructure rather than a task runner.
$ squads catalog
┌─────────────┬──────────────┬────────────┬──────────────────────────────────┐
│ Squad │ Agents │ Status │ Last Run │
├─────────────┼──────────────┼────────────┼──────────────────────────────────┤
│ marketing │ 3 agents │ healthy │ 2026-03-29 10:05 (seo-writer) │
│ engineering │ 4 agents │ healthy │ 2026-03-29 09:12 (code-reviewer) │
│ finance │ 2 agents │ stale │ 2026-03-22 14:30 (reporter) │
└─────────────┴──────────────┴────────────┴──────────────────────────────────┘Any Language, Any Runtime
squads-cli runs agents via subprocess. The agent definition specifies what to invoke — a Claude Code session, a bash script, a Python module, a Node.js process. No Python wrapper required:
---
name: build-checker
squad: engineering
trigger: on-pr
executor: bash
---
# Build Checker
Run test suite and report failures to the PR.For teams that aren’t Python-native, this matters. The CLI is the common interface.
Side-by-Side
| Dimension | squads-cli | CrewAI |
|---|---|---|
| Agent definition | Markdown files | Python objects |
| Version control | Native (files = diffs) | Possible (code in repo) |
| Cross-run memory | Built-in (filesystem) | Requires vector DB or custom |
| Language support | Any (subprocess) | Python primary |
| Scheduling | Built-in cron triggers | External (cron, Celery) |
| LLM diversity | Claude-primary | Provider-agnostic |
| Deployment | None (files + npm) | Python runtime |
| Service catalog | Built-in (IDP) | Not built-in |
| Community | Early stage | Large, active |
| Learning curve | Low (markdown config) | Medium (Python patterns) |
When to Use CrewAI Instead
Be honest with yourself here. CrewAI is the better choice when:
You’re building a Python service. If multi-agent logic lives inside a FastAPI app, a Django worker, or a Python data pipeline — CrewAI integrates cleanly without a subprocess boundary.
You need LLM provider flexibility. Mix GPT-4o, Claude, and Mistral in one workflow. squads-cli works best with Claude.
Your team is Python-native. Code-based configuration is more expressive. Developers comfortable with Python will find CrewAI’s model more natural.
You need complex delegation patterns. Hierarchical crews with manager agents that dynamically delegate are a first-class concept in CrewAI. squads-cli’s lead-worker pattern is simpler.
Getting Started with squads-cli
# Install via npm
npm install -g squads-cli
# Initialize in your project
squads init
# Create your first squad
squads create marketing
# Run an agent
squads run marketing/seo-writerFull documentation: github.com/agents-squads/squads-cli
If you’re already running a CrewAI setup and want to understand the migration path in detail, see squads-cli vs CrewAI: Architecture Comparison for a deeper technical walkthrough including code samples for both directions.
Want to see the agent workflow that produced this article? It ran in our marketing squad — same squads-cli system we’re describing here. The running a company with AI agent squads post covers what that looks like in practice.
