Comparisons / Anthropic Agent SDK vs CrewAI
Anthropic Agent SDK vs CrewAI: Which Agent Framework to Use?
Anthropic Agent SDK the anthropic agent sdk packages claude code's agent loop as a library. CrewAI crewai organizes work into agents, tasks, and crews. Here is how they compare — and what the same patterns look like in plain Python.
By the numbers
Anthropic Agent SDK
3.1k
582
Python
MIT
2023-01-17
Anthropic
Google, Spark Capital
Yes
CrewAI
48.0k
6.5k
Python
MIT
2023-10-27
João Moura
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | Anthropic Agent SDK | CrewAI | Plain Python |
|---|---|---|---|
| Agent | Claude agent with built-in tools, MCP servers, and system prompt | Agent(role, goal, backstory, tools, llm) | A function that POSTs to /messages and returns the response |
| Tools | Built-in tools (bash, file read/write, web) + MCP server connections | Tool registration with @tool decorator, custom Tool classes | A dict of callables: tools = {"bash": run_command, "read": read_file} |
| Agent Loop | SDK's internal agentic loop with automatic tool dispatch | Internal to Agent execution, hidden from user | A while loop: call LLM, check for tool_use blocks, execute, repeat |
| Sub-Agents | Agents invoke other agents as tools via the SDK | — | A function that calls another function: result = research_agent(query) |
| Lifecycle Hooks | 18 hook events: pre/post tool call, message, error, etc. | — | if/else checks inside your loop: if should_log: log(event) |
| MCP Integration | One-line MCP server config for Playwright, Slack, GitHub, etc. | — | HTTP client calls to each service: requests.post(slack_url, payload) |
| Task Delegation | — | Crew(agents, tasks, process=sequential/hierarchical) | A task queue processed in a while loop with a budget cap |
| Memory | — | ShortTermMemory, LongTermMemory, EntityMemory | A dict injected into the system prompt |
| State | — | Task output passed between agents via Crew orchestration | A dict tracking tool calls and results |
What both do in plain Python
Every concept in the table above — agent, tools, loop, memory, state — maps to a handful of Python primitives: a function, a dict, a list, and a while loop. Both Anthropic Agent SDK and CrewAI wrap these primitives in their own class hierarchies and APIs. The underlying pattern is the same ~60 lines of code. The difference is how much ceremony each framework adds on top.
When to use Anthropic Agent SDK
The Anthropic Agent SDK's real value is packaging Claude Code's battle-tested agent loop with built-in tools and MCP integration. If you want a production agent that reads files, runs commands, and connects to services, it saves significant plumbing. For understanding how agents work, the plain version is more instructive.
What the Anthropic Agent SDK does
The Anthropic Agent SDK takes Claude Code — the coding agent used by hundreds of thousands of developers — and ships it as a Python and TypeScript library. You get the same agent loop, built-in tools (bash execution, file read/write, web search), and context management that Claude Code uses internally. The standout feature is MCP (Model Context Protocol) integration: connect Playwright, Slack, GitHub, databases, and hundreds of other servers with a single config line. The SDK also provides 18 lifecycle hooks that let you intercept tool calls, messages, errors, and other events. This gives you fine-grained control over agent behavior without modifying the core loop. It's less a framework and more a productized agent runtime.
The plain Python equivalent
The agent loop is a while loop that POSTs to the /messages API, checks for tool_use blocks in the response, executes the matching function from a tools dict, appends the result to messages, and repeats. Built-in tools are just functions: bash is subprocess.run(), file reading is open().read(), web search is an HTTP call to a search API. MCP integration is HTTP client calls to each service — there's nothing magical about connecting to Slack or GitHub beyond knowing their API endpoints. Lifecycle hooks are if/else checks at specific points in your loop. The entire agent — tool dispatch, sub-agent delegation, logging — fits in about 60 lines. The SDK's value isn't in the pattern (which is simple) but in the pre-built tool implementations and MCP plumbing.
When to use CrewAI
CrewAI shines for multi-agent setups where you want named roles ("researcher", "writer"). But the core mechanics — tool dispatch, the agent loop, task scheduling — are the same patterns you can build in plain Python.
What CrewAI does
CrewAI models multi-agent systems as a crew of specialists. Each Agent has a role ("Senior Researcher"), a goal ("Find the best data sources"), a backstory that shapes its behavior, and a set of tools it can use. Tasks define discrete units of work with expected outputs. The Crew orchestrates execution — sequentially, hierarchically, or with a custom process. CrewAI also provides memory systems (short-term, long-term, entity) and delegation, where one agent can hand off subtasks to another. The mental model is a team of people collaborating on a project. For prototyping multi-agent workflows where you want to reason about roles and responsibilities, it provides a clean vocabulary.
The plain Python equivalent
An Agent in CrewAI is a function with a system prompt that includes the role, goal, and backstory. The tools dict maps names to callables. Task delegation is a list of tasks processed in order — each task calls the assigned agent function with the task description appended to the messages. Hierarchical execution is a manager agent that decides which sub-agent to call next (just another tool choice). Memory is a dict injected into the system prompt. The entire crew pattern — multiple agents, task queue, delegation — is a for-loop over tasks, where each iteration calls the right agent function. No Crew class, no process kwarg. Just functions calling functions with a shared state dict passed between them.
Or build your own in 60 lines
Both Anthropic Agent SDK and CrewAI implement the same 8 patterns. An agent is a function. Tools are a dict. The loop is a while loop. The whole thing composes in ~60 lines of Python.
No framework. No dependencies. No opinions. Just the code.
Build it from scratch →