Comparisons / CrewAI vs Pydantic AI
CrewAI vs Pydantic AI: Which Agent Framework to Use?
CrewAI crewai organizes work into agents, tasks, and crews. Pydantic AI pydantic ai is a type-safe agent framework built by the pydantic team. Here is how they compare — and what the same patterns look like in plain Python.
By the numbers
CrewAI
48.0k
6.5k
Python
MIT
2023-10-27
João Moura
Pydantic AI
16.1k
1.9k
Python
MIT
2024-06-21
Pydantic (Samuel Colvin)
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | CrewAI | Pydantic AI | Plain Python |
|---|---|---|---|
| Agent | Agent(role, goal, backstory, tools, llm) | Agent() class with typed result_type, system prompt, and model parameter | A function with a system prompt and a tools dict |
| Tools | Tool registration with @tool decorator, custom Tool classes | @agent.tool decorator with typed parameters and Pydantic validation | A dict: tools[name](**args) |
| Agent Loop | Internal to Agent execution, hidden from user | agent.run() handles the tool-call loop internally with typed dispatch | A while loop over messages with tool_calls check |
| 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 |
| Structured Output | — | result_type=MyModel enforces Pydantic model on final LLM response | Parse the LLM response as JSON, pass to a validation function, retry on failure |
| Model Switching | — | Swap model='openai:gpt-4o' to model='anthropic:claude-sonnet' in one line | Change the API endpoint URL and adjust the request/response format mapping |
| Dependencies | — | RunContext[DepsType] injects typed dependencies into tools at runtime | Pass a deps dict to your agent function, tools access it via closure or argument |
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 CrewAI and Pydantic AI 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 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.
When to use Pydantic AI
Pydantic AI adds genuine value if you want compile-time type checking across your agent's tools, outputs, and dependencies. If you already use Pydantic in your stack, it fits naturally. But the core agent logic — loop, dispatch, validate — is still ~60 lines of Python you can own entirely.
What Pydantic AI does
Pydantic AI wraps the agent pattern in Pydantic's type system. You define an Agent with a result_type (a Pydantic model), register tools with typed parameters via decorators, and call agent.run() to execute the tool-call loop. The framework validates tool arguments against their type hints, validates the final response against your result model, and retries on validation failures. It supports 25+ model providers through a unified interface, so switching from OpenAI to Anthropic is a one-line change. Dependencies are injected via typed RunContext, giving your tools access to databases, API clients, or configuration without global state. The real value is that your IDE catches type errors before runtime.
The plain Python equivalent
Type-safe tool dispatch in plain Python means validating tool arguments before calling the function. Parse the LLM's tool_call arguments as JSON, check types with isinstance or a simple schema, and raise on mismatch. Structured output is the same: parse the final response as JSON, validate against expected keys and types, retry if it fails. Model switching means swapping the API URL and adjusting the request format — a dict mapping provider names to endpoint configs. Dependency injection is passing a deps dict to your agent function that tools access via closure. The full typed agent is about 60 lines, plus maybe 20 for validation helpers. No decorators, no base classes — just functions with type checks.
Or build your own in 60 lines
Both CrewAI and Pydantic AI 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 →