Choosing an agent framework

Who this is for

This guide is for people who want to build an agent: a program that calls a language model, gives it tools and keeps track of what happens across several steps. Most examples use Python. By the end you should be able to install each framework, run its smallest example and know which one to try first.

What the six are

LangGraph is a low-level orchestration framework and runtime for long-running, stateful agents ^[2]. Its overview describes a workflow as a graph built from shared state, nodes and edges ^[2]. The same overview describes Deep Agents, an agent harness with planning and subagents built on LangGraph ^[2].

CrewAI is an open-source Python framework with high-level abstractions and low-level APIs for building production-ready multi-agent workflows ^[4]. It offers two ways of working. Crews give developers autonomous collaboration between agents, and Flows give precise, event-driven control ^[4].

OpenAI Agents SDK is a lightweight framework for multi-agent workflows. It works across the OpenAI Responses and Chat Completions APIs and more than 100 other LLMs ^[5]. Its core concepts are Agents, Handoffs, Tools, Guardrails, Sessions and Tracing ^[5].

AutoGen is a framework for multi-agent AI applications that can act autonomously or work alongside humans ^[7]. It is organised in layers: a Core API, an AgentChat API and an Extensions API ^[7]. Read the project status section below before you start with it.

Dify is an open-source LLM app development platform. Its interface combines AI workflow, a RAG pipeline, agent capabilities, model management and observability ^[8]. Unlike the other five, it is a platform you run as a service rather than a library you import into your own code.

Google's Agent Development Kit (ADK) is an open-source, code-first Python framework for building, evaluating and deploying agents ^[11]. The project's README is titled Agent Development Kit (ADK) 2.0, and the same project also provides ADK Java, ADK Kotlin, ADK Go and ADK Typescript ^[11].

Before you start

Each framework has its own runtime requirements, and they differ a lot.

• LangGraph installs with pip install -U langgraph ^[1]. The same README points to LangGraph.js for an equivalent JavaScript and TypeScript library ^[1].
• CrewAI requires Python >=3.10 and <3.14 ^[4].
• OpenAI Agents SDK requires Python 3.10 or newer ^[5], and its examples need the OPENAI_API_KEY environment variable ^[5].
• AutoGen requires Python 3.10 or later ^[7]. The project supports .NET as well as Python ^[7].
• Google ADK requires Python 3.11+ for the stable release ^[11].
• Dify requires at least 2 CPU cores and 4 GiB of RAM, plus Docker Compose v2.35.0 or later and OpenSSL ^[8]. Its quick start is built around Docker Compose, so the setup is a different kind of job from installing a Python package.

Pick one Python version for all the experiments. Use a virtual environment or uv so that the packages of one framework do not disturb another.

Your first run

LangGraph

Install the package first:

pip install -U langgraph

The official overview gives this minimal graph ^[2]:

from langgraph.graph import StateGraph, MessagesState, START, END

def mock_llm(state: MessagesState):
    return {"messages": [{"role": "ai", "content": "hello world"}]}

graph = StateGraph(MessagesState)
graph.add_node(mock_llm)
graph.add_edge(START, "mock_llm")
graph.add_edge("mock_llm", END)
graph = graph.compile()

graph.invoke({"messages": [{"role": "user", "content": "hi!"}]})

The graph has one node, mock_llm, which returns a fixed message and does not call a model. START and END connect the node into the graph, and graph.invoke runs it on one user message. To make it useful, you replace the body of the node with a real model call. The shape of the graph stays the same.

CrewAI

The CrewAI command-line tool installs with uv tool install crewai ^[4]. The simple-crew example in the README defines an agent in agents/researcher.jsonc ^[4]:

{
  "role": "{topic} Senior Data Researcher",
  "goal": "Uncover cutting-edge developments in {topic}",
  "backstory": "You're a seasoned researcher who finds relevant information and presents it clearly.",
  "llm": "openai/gpt-4o",
  "tools": ["SerperDevTool"],
  "settings": {
    "verbose": true
  }
}

The file describes the agent's role, goal and backstory. {topic} is a placeholder that appears in both the role and the goal. The llm field names openai/gpt-4o, the tools list names SerperDevTool, and settings turns on verbose output.

OpenAI Agents SDK

Install the SDK with pip install openai-agents or uv add openai-agents ^[5]. Set the OPENAI_API_KEY environment variable before you run the examples ^[5]. The official "Run a text agent" quick start uses this minimal example ^[5]:

from agents import Agent, Runner

agent = Agent(name="Assistant", instructions="You are a helpful assistant")

result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)

# Code within the code,
# Functions calling themselves,
# Infinite loop's dance.

An Agent takes a name and instructions. Runner.run_sync runs it synchronously, and the answer is read from result.final_output.

AutoGen

Install the two packages with ^[7]:

pip install -U "autogen-agentchat" "autogen-ext[openai]"

The official "Hello World" quick start uses this example ^[7]:

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1")
    agent = AssistantAgent("assistant", model_client=model_client)
    print(await agent.run(task="Say 'Hello World!'"))
    await model_client.close()

asyncio.run(main())

The example names gpt-4.1 as the model, runs one task on an AssistantAgent, and closes the model client at the end. AutoGen also ships AutoGen Studio, a no-code GUI, which starts like this ^[7]:

autogenstudio ui --port 8080 --appdir ./my-app

Dify

The Dify quick start begins in the repository root with these commands ^[8]:

cd docker
cp .env.example .env
openssl rand -hex 32

The quick start then has you set DIFY_AGENT_LOCAL_SANDBOX_AUTH_TOKEN in .env, and start the services with docker compose up -d ^[8]. After that, most of the work happens in Dify's web interface, not in code.

Google ADK

Install ADK with pip install google-adk, or with pip install "google-adk[extensions]" for the extras ^[11]. The official quick start gives this minimal agent, which uses gemini-3.5-flash ^[11]:

from google.adk import Agent

root_agent = Agent(
    name="greeting_agent",
    model="gemini-3.5-flash",
    instruction="You are a helpful assistant. Greet the user warmly.",
)

Run it locally with adk run path/to/my_agent ^[11]. To deploy the same agent to Cloud Run with a web UI, the docs use adk deploy cloud_run --with_ui <agent-folder> ^[11].

How to choose

These picks come from what each project says it is for, not from a benchmark.

• If your workflow is a set of steps that must keep state over a long run, start with LangGraph. Its own description is exactly that: long-running, stateful agents ^[2].
• If you need several agents with roles that collaborate, CrewAI covers both free collaboration through Crews and event-driven control through Flows ^[4].
• If you want a light SDK with handoffs and guardrails, and you want the option of models from many providers, look at the OpenAI Agents SDK ^[5].
• If you do not want to write code and want workflows, RAG and agents in one interface, Dify is built for that ^[8].
• If you want a code-first Python framework with an evaluation story and a path to Cloud Run, look at ADK ^[11].
• For a new project, do not start with AutoGen. Microsoft has archived it and no longer maintains it actively, and it recommends Microsoft Agent Framework to new users ^[7].

Limits and common questions

• AutoGen is archived. Microsoft advises against using it in production ^[7]. The docs are under Creative Commons Attribution 4.0 and the code under the MIT License ^[7].
• The first LangGraph example calls no model. Real work needs your own model call inside the node, which is a small change once the graph shape is clear.
• Dify from source needs Node.js v24 (LTS) and PNPM v12 for the web frontend. The backend uses uv sync --dev and then uv run flask run --host 0.0.0.0 --port=5001 --debug ^[10].
• Licences differ. LangGraph is under the MIT License ^[3], CrewAI's README gives the MIT License ^[4], and the OpenAI Agents SDK is also MIT ^[6]. Dify uses the Dify Open Source License, which is based on Apache 2.0 with additional conditions ^[8]. ADK is under the Apache 2.0 License ^[11]. Read the licence before you ship a product on top of any of them.
• CrewAI also sells a commercial product, the CrewAI AMP Suite. It adds managed deployment, observability, governance, security and enterprise support for organisations that need a commercial control plane ^[4].

Next steps

Pick the framework that fits your first project, then read its official overview. LangGraph's overview is the best starting point for its concepts ^[2]. The CrewAI README covers Crews and Flows ^[4]. The OpenAI Agents SDK README covers its concepts and examples ^[5]. The AutoGen README covers its layers and Studio ^[7]. The Dify quick start covers the Docker setup ^[8]. The ADK README covers the agent classes and deployment ^[11].