AI agents — systems where a language model decides what actions to take, executes them, observes results, and iterates — have moved from research curiosity to production reality. The tooling has matured, and several serious frameworks are now competing for adoption.

The problem is that each framework has different strengths and different opinions about how agents should work. Picking the wrong one costs weeks. Here’s a practical comparison based on building with most of the major options.

What We Mean By “Agent”

An agent is a system where a language model receives a task and available tools, decides which tool to call, executes it, incorporates the result, and decides the next step. This loop repeats until the task is complete. It’s different from a chain (linear steps) or a chatbot (responds without external actions). The defining feature is the model making decisions based on intermediate results.

LangGraph

LangGraph models agent workflows as graphs — nodes represent actions and edges represent transitions.

Strengths: Explicit control flow makes complex workflows easier to debug. Built-in state management and checkpointing for long-running agents. Strong human-in-the-loop support for production environments where fully autonomous agents are too risky.

Weaknesses: Overkill for simple agents. The LangChain ecosystem coupling can feel awkward if you’re not already in that world. Significant learning curve for the graph model and state schemas. The LangGraph documentation has improved but still assumes LangChain familiarity.

Best for: Complex multi-step workflows with branching logic and human oversight requirements.

CrewAI

CrewAI models agents as teams of specialised roles working together — a researcher, a writer, an editor collaborating on a task.

Strengths: Intuitive mental model that non-technical stakeholders understand immediately. Fast prototyping — simple agent teams set up in under an hour. Natural role specialisation with different prompts, tools, and models per agent.

Weaknesses: Limited control over execution and debugging when things go wrong. Multi-agent systems are inherently token-intensive, with costs escalating quickly. Less battle-tested in production than LangGraph.

Best for: Rapid prototyping and use cases that naturally map to team-based delegation.

Anthropic’s Agent SDK

Anthropic takes a minimalist approach — tool definitions, conversation management, and orchestration primitives without heavy abstractions.

Strengths: Small API surface with straightforward concepts. Naturally optimised for Claude’s tool use and reasoning. Lightweight primitives compose well for custom architectures.

Weaknesses: Designed for Claude, requiring adaptation for other models. You build more yourself — state management, error handling, orchestration for complex workflows.

Best for: Teams using Claude who want tight control over agent behaviour and prefer composing from primitives.

OpenAI Agents SDK

OpenAI consolidates function calling, Assistants API, and orchestration into a unified SDK.

Strengths: Optimised for GPT-4o and o3. Built-in file handling, code interpreter, and retrieval. Enterprise features including audit logging and compliance. OpenAI’s platform documentation covers integration well.

Weaknesses: Tightly coupled to OpenAI’s ecosystem. Assistants API storage and retrieval add costs beyond tokens. Some orchestration patterns require more custom code than LangGraph.

Best for: Teams committed to OpenAI with enterprise requirements.

How to Choose

Start with constraints. If your organisation is committed to a model provider, use the corresponding SDK. Fighting framework-model alignment creates unnecessary friction.

Match complexity to abstraction. Single-agent tool-using systems don’t need LangGraph’s graphs or CrewAI’s multi-agent model. Start simple.

Consider your team. LangGraph has the most documentation and community examples. Available learning resources matter for teams new to agents.

Design for portability. Keep tool implementations and business logic separate from your agent framework. The space is evolving fast, and clean separation makes migration manageable.

The framework matters less than the quality of your tools, prompts, and evaluation. A well-designed tool performs well in any framework. A poorly designed tool fails in all of them. Build the tools right first.