# Agentic Frameworks Compared: LangGraph, CrewAI & More
Table of Contents
Introduction to the Agentic Framework Series
Lately it feels like the world of AI moves so fast that if you blink, you miss an entire generation of breakthroughs. As someone who loves digging into emerging technologies, I finally gathered the courage to steal a little time from a busy schedule and kick off a series I’ve been wanting to write for ages. And what better place to start than the booming world of agentic frameworks? With LangGraph, LlamaIndex Agents, OpenAI’s Agents SDK, Google’s ADK, and Microsoft’s Agent Framework all evolving at lightning speed, the agentic AI ecosystem is turning into a full-on 2025 “Agent War.” Since I’m constantly tracking these updates anyway, I figured—why not share the journey and explore this rapidly shifting landscape together?
What Is an Agentic Framework?
An agentic framework is a software toolkit designed to help developers build AI agents—systems that can reason, take actions, use tools, and complete multi-step tasks with a level of autonomy. Instead of treating an LLM as a “single prompt in, single answer out” model, an agentic framework gives it structure: memory, tools, workflows, decision loops, and the ability to interact with data or external systems. Frameworks like LangGraph, LlamaIndex Agents, OpenAI’s Agent SDK, and Google’s ADK make it possible to create agents that can research, retrieve information, write code, operate APIs, and even coordinate with other agents. In short, an agentic framework transforms a passive model into an active problem-solver.
BTW, agentic frameworks — often called AI agent frameworks as well.
Enough talk — let’s get to it!
Let’s Summon Popular Agentic Frameworks
LangChain + LangGraph
Positioning:
Probably still the most widely recognized OSS agent stack; LangChain for the agent loop and tools, LangGraph for durable, stateful workflows. Link: LangChain Blog
Latest status (late 2025):
-
LangChain and LangGraph both hit v1.0 with a tightened “core agent loop” and a middleware system for flexible control.
-
LangGraph adds graph-structured workflows, persistence, debugging, and visual tools for complex agent interactions and long-running processes.
Best for:
General-purpose agent apps: RAG copilots, workflow agents, multi-step tool use, where you want a large ecosystem and lots of examples.
LlamaIndex (LlamaAgents & Workflows)
Positioning:
Started as a data/RAG library, now a full “data-centric agent framework” with strong connectors, parsing (LlamaParse), and high-quality RAG pipelines.Links: LlamaIndex+2
Latest status:
-
LlamaAgents early-access: full-stack templates for building agents, including TypeScript workflows and CopilotKit integrations.
-
2025 comparisons show improved retrieval quality and strong performance for document-heavy workloads.
Best for:
Knowledge-intensive agents: enterprise search copilots, contract analysis, tech docs assistants, any system where the “data plane” is the hard part.
OpenAI Agents SDK (successor to Swarm)
Positioning:
OpenAI’s first-party agentic framework for building agents over their Responses API: a minimal set of primitives (agents, handoffs, guardrails, sessions) with tight GPT integration. Link: OpenAI Agents SDK
Latest status:
-
Designed as a production-ready agentic framework of the earlier “Swarm” multi-agent experiment.
-
Integrated with OpenAI’s new Responses API (web search, computer use, document search), replacing the older Assistants API over 2025-26.
Best for:
Teams already standardized on OpenAI: quick path to agents with web search, tools, and multi-agent delegation without heavy orchestration code.
Microsoft Agent Framework (AutoGen + Semantic Kernel)
Positioning:
Microsoft is merging AutoGen’s multi-agent orchestration with Semantic Kernel’s enterprise integration into a single “Microsoft Agent Framework” for Python and .NET. Link: Microsoft Agent Framework
Latest status:
-
AutoGen is now in maintenance mode; new feature development is happening in Microsoft Agent Framework.
-
Provides agents, planners, and orchestration with hooks into Azure/OpenAI, Office 365, and other Microsoft services.
Best for:
Enterprise .NET/Python shops on Azure that want multi-agent workflows tied into existing Microsoft infra, identity, and DevOps.
Google Agent Development Kit (ADK) / Vertex AI Agent Builder
Positioning:
Google’s open-source Agent Development Kit plus Vertex AI Agent Builder: ADK for local/dev usage, Agent Builder for managed, scalable deployment. Link: Google Agent Build
Latest status:
-
ADK announced in 2025 as a modular, model-agnostic agentic framework (though optimized for Gemini and Google Cloud).
-
Recent updates add prebuilt plugins (including “self-heal”), more language support (Go, Python, Java), and richer observability & security for production agents.
Best for:
GCP-centric teams: data & MLOps agents (BigQuery, Dataflow, etc.), multi-system enterprise agents, and workloads that need Vertex AI governance features.
CrewAI
Positioning:
A popular OSS “multi-agent crew” agentic framework: define specialized agents (roles), share context, and let them collaborate on tasks. Link: CrewAI
Latest status:
-
Active development and strong marketing as a “multi-agent platform” with business-oriented workflows.
-
Frequently cited (alongside LangChain & AutoGen) as a top choice in 2025 industry roundups because of its clean Python API and real-world focus.
Best for:
Multi-agent experiments and startup-style stacks: e.g., “researcher + planner + executor” teams for content, lead-gen, or coding tasks.
Haystack
Positioning:
RAG + agentic framework aimed squarely at production: modular pipelines and “agents” that can call tools, retrieve data, and generate answers.Link: Heystack
Latest status:
-
Marketed specifically for “agentic, compound AI systems” with end-to-end observability and debugging.
-
Supports agents that choose between web search, vector stores, and other tools to resolve complex queries.
Best for:
Teams that want a transparent, production-grade RAG/agent stack with strong search roots (Elastic/OpenSearch, vector DBs) and clear pipelines.
OpenHands Software Agent SDK (software-dev agents)
Positioning:
A toolkit spun out of the popular OpenHands code-assistant framework, specifically for reliable software development agents (coding, debugging, PRs). Link: OpenHands Software Agent SDK
Latest status:
- 2025 paper describes a redesigned SDK for flexible, secure software agents: sandboxed execution, multi-LLM routing, and integration with editors (VS Code, browser, CLI).
Best for:
Engineering teams wanting production code agents (e.g., SWE-Bench style tasks) with strong execution sandboxes and lifecycle controls.
Research / Training-oriented frameworks (Agent Lightning, etc.)
Positioning:
These are less “app frameworks” and more training stacks, but relevant for anyone planning RL-fine-tuned agents. The paper link is here.
- Agent Lightning: RL training framework that decouples training from agent execution, plugging into existing agent stacks like LangChain, AutoGen, OpenAI Agents SDK with minimal changes.
Best for:
R&D teams working on agent RL, evaluation, and fine-tuning rather than pure orchestration.
Dominant Use Cases
Across vendors and OSS, you see a few consistent patterns:
-
RAG copilots / knowledge assistants
-
Internal “Chat with docs” for policies, support docs, codebases (LangChain, LlamaIndex, Haystack).
-
Industry: customer support, legal analysis, technical documentation.
-
-
Agentic Process Automation (APA) / workflow agents
-
Multi-step agents that call APIs, write files, trigger workflows, etc. (LangGraph, CrewAI, OpenAI Agents SDK, MS Agent Framework, Google ADK). Link: Top 7 AI Agentic Frameworks in 2025: The Ultimate Guide.
-
Example: end-to-end lead processing, back-office ops, report generation.
-
-
Software engineering agents
- Coding, refactoring, test-generation, PR review (OpenHands SDK; OpenAI computer-use agents; some AutoGen/CrewAI patterns).
-
Data & analytics agents
-
Data engineering/data science agents in the cloud (Google’s Data Engineering Agent, Data Science Agent; ADK/Vertex AI).
-
SQL-query agents, interactive dashboards, ETL automation.
-
-
Ops / infra & enterprise workflows
- Cloud management, monitoring, and remediation (GCP’s new ops agents, Azure/AKS workflows, security & governance hooks).
Agentic Frameworks at a Glance
| Framework | Languages | Best for | Trade-off |
|---|---|---|---|
| LangGraph (with LangChain) | Python, TypeScript | Complex, stateful, long-running workflows with fine-grained control | More orchestration code to design up front |
| LlamaIndex | Python, TypeScript | Data-heavy and RAG agents over your documents | Less focused on general workflow orchestration |
| OpenAI Agents SDK | Python, TypeScript | Fast, lightweight agents with handoffs, guardrails and tracing | Complex workflows need extra infrastructure around it |
| Microsoft Agent Framework (AutoGen + Semantic Kernel) | Python, .NET | Enterprise teams on Azure and the Microsoft stack | Heavier, best inside the Microsoft ecosystem |
| Google ADK | Python, Java | Gemini and Google Cloud / Vertex AI deployments | Strongest when you already live on GCP |
| CrewAI | Python | Role-based multi-agent “crews” for content and ops workflows | Less low-level control than graph-based frameworks |
| Haystack | Python | Production search and RAG pipelines | Agent features are newer than its pipeline core |
Also worth a look: PydanticAI for type-safe Python agents, Mastra for full-stack TypeScript, and Hugging Face smolagents for small code agents running local models.
Agentic AI Coding Frameworks
The frameworks above are general-purpose: you use them to build your own agent. A second family has grown up just as fast — agentic AI coding frameworks, where the agent is already built and its job is to work on a codebase. Instead of autocompleting a line, a coding agent reads the repository, plans a change, edits several files, runs the tests or the build, reads the errors and tries again until the task is done or it needs you.
Under the hood they use the same loop as any agent — model, tools, memory, a stop condition — but the tools are a developer’s: read file, edit file, search the repo, run a shell command, open a pull request.
| Tool | How you use it | What makes it different |
|---|---|---|
| Claude Code (Anthropic) | Terminal CLI, IDE extensions, desktop and web | Works directly in your repo and shell; extensible with MCP servers, hooks and custom slash commands. Its engine is also published as the Claude Agent SDK, so you can build your own agents on the same loop |
| Codex CLI (OpenAI) | Terminal CLI, open source | Runs commands in a sandbox with approval modes, so you choose how much it may do without asking |
| Gemini CLI (Google) | Terminal CLI, open source | Gemini models in the terminal, with MCP support |
| OpenHands | Web UI, CLI and the Software Agent SDK covered above | Open-source and model-agnostic; runs the agent inside a sandboxed container |
| Aider | Terminal CLI, open source | Git-first pair programmer: every change lands as a commit you can review or undo |
| Cline | VS Code extension, open source | Plan/act modes inside the editor, approving each file edit and command |
How to pick one:
- You want an assistant on your own machine, today: start with one of the CLIs (Claude Code, Codex CLI, Gemini CLI or Aider) in a repo with good tests — the tests are what let the agent check its own work.
- You want coding agents in CI or a product: look at the SDKs — the Claude Agent SDK or the OpenHands Software Agent SDK — rather than wiring a general framework to a shell yourself.
- You need strict isolation: prefer tools that run commands in a sandbox or container, and keep secrets out of the working directory.
Repo-level workflow frameworks
A third group sits on top of the coding agents rather than replacing them. These are collections of rules, skills and workflow files that you drop into a repository so that agents such as Claude Code, Codex CLI or Cursor follow the same process every time: analyse, plan, implement, test, review. They usually rely on the cross-tool AGENTS.md convention (or a tool-specific file such as CLAUDE.md) for project instructions, and add git hooks or CI checks so that “done” has to be backed by evidence like a passing test run. Examples include Agentic Code and Agentic OS. They are young and opinionated, so treat them as a starting template to adapt, not a standard.
Whichever you choose, the same habits pay off: give the agent a short project instructions file (build, test and style commands), keep tasks small enough to review, and read the diff before you merge. Features and pricing change monthly, so check each project’s own docs for what it supports right now.
How an Agentic Framework Works: Core Building Blocks
Strip away the branding and almost every agentic framework is built from the same five pieces. Knowing them makes the differences between frameworks much easier to read.
- Model layer. An adapter to one or more LLMs. Some frameworks are tied to a single provider; others let you swap models behind one interface.
- Tools. Functions the model can call, described by a name, a description and a JSON schema for the arguments. Tool use is what turns text generation into action.
- State and memory. Short-term state is the message history and intermediate results of the current run. Long-term memory is anything persisted across runs: user preferences, past decisions, a vector store of documents.
- Control flow. The loop that decides what happens next: call the model, run the tool calls it asked for, feed results back, stop when done. This is where frameworks differ most (see below).
- Observability and guardrails. Tracing of every model and tool call, input and output validation, and limits on steps, tokens and cost. You do not notice them in a demo and you cannot live without them in production.
Orchestration Patterns You Will See
The control-flow layer usually implements one or more of these patterns:
- ReAct loop. The model alternates between reasoning and tool calls until it decides it has an answer. Simple and flexible, but the path is decided by the model at run time, so it is hard to predict and test.
- Plan-and-execute. One step produces a plan, later steps carry it out and the plan is revised if something fails. Better for long tasks, at the price of an extra planning call.
- Workflow (graph) orchestration. You define the steps and the allowed transitions as a graph or state machine, and the model makes decisions only inside nodes. LangGraph and LlamaIndex Workflows work this way. It is the most predictable option and supports checkpointing and human approval steps.
- Supervisor / handoff multi-agent. A coordinator routes work to specialist agents, or an agent hands the conversation to another one. The OpenAI Agents SDK is built around handoffs, and CrewAI models this as a crew of role-based agents.
- Human-in-the-loop. The run pauses at a risky step, waits for approval, then resumes from saved state. This only works well when the framework can persist and restore state.
A practical rule: use the least autonomy that solves the problem. A fixed workflow with one model call per node is cheaper, faster and easier to debug than a free-roaming agent, so reach for open-ended loops only where the path really cannot be known in advance.
Protocols: MCP and A2A
Two open protocols increasingly decide how portable your agent is:
- MCP (Model Context Protocol) standardises how an agent connects to tools and data sources. Instead of writing a custom integration per framework, you expose a tool once as an MCP server and any MCP-capable client can use it. See What Is an MCP Server? for the details.
- A2A (Agent2Agent) standardises how independent agents, possibly built on different frameworks by different teams, discover each other and exchange tasks. MCP connects an agent to tools; A2A connects an agent to other agents.
When comparing frameworks, check which of these they support natively, because it determines how much glue code you write later.
How to Choose an Agentic Framework
Do not pick by GitHub stars or by which demo looked best. Work through these questions in order:
| Question | Why it matters |
|---|---|
| How much of the control flow must be deterministic? | Regulated or high-stakes workflows favour explicit graphs (LangGraph); exploratory tasks tolerate free-form loops. |
| Does a run last seconds or hours? | Long-running agents need checkpointing and resume after a crash or an approval pause. |
| Which language and cloud do you already use? | The Microsoft Agent Framework fits .NET and Azure, Google ADK fits GCP, most others are Python-first with a TypeScript option. |
| Are you locked to one model provider? | Provider SDKs are fastest to start with, but cost you flexibility when prices or quality shift. |
| Can you see what the agent did? | Look for built-in tracing and evaluation hooks, or plan to add them yourself. |
| How stable is the project? | Check release cadence and migration notes; this space has seen breaking changes between major versions. |
| What does a task cost? | Track tokens and tool calls per successful task, not per call, and set hard step limits. |
A sensible path for most teams: prototype with the simplest option (the OpenAI Agents SDK or CrewAI), keep the tools behind MCP so they are not tied to a framework, and move the parts that need control, durability or auditing to a graph framework like LangGraph once the requirements are clear.
What is the best AI agent framework ?!
Haha! I know you will ask this question!
Choosing the best AI agent framework isn’t as simple as crowning a single winner—because the “best” depends entirely on what you’re building. LangGraph excels at complex, stateful workflows with fine-grained control. LlamaIndex dominates when your agent needs powerful data retrieval and document intelligence. OpenAI’s Agents SDK is unbeatable for rapid development with built-in web search, tool use, and multi-agent orchestration. Google’s ADK shines in enterprise environments that lean heavily on GCP data pipelines. And Microsoft’s Agent Framework integrates seamlessly with Azure and the broader Microsoft ecosystem. Instead of looking for a universal champion, the smarter question is: Which agentic framework aligns with your stack, your data, and your use case? Because in 2025’s Agent War, “context”—not hype—decides the winner.
FAQ
What is an agentic framework?
A toolkit for building AI agents: it wraps an LLM with tools, memory, control flow and often multi-agent coordination, so the model can plan and carry out multi-step tasks instead of answering a single prompt.
Is LangChain an agentic framework?
LangChain provides the agent loop, model and tool integrations; LangGraph, from the same team, is the agentic framework for stateful, graph-structured workflows. Most production LangChain agents today are built on LangGraph.
What is an agentic AI coding framework?
A coding agent that works on a real repository: it reads code, edits files, runs commands and tests, and iterates on the results until the task is done. Claude Code, Codex CLI, Gemini CLI, OpenHands, Aider and Cline are common examples; the Claude Agent SDK and OpenHands Software Agent SDK let you build your own on the same loop.
Is an AI coding agent the same as an agentic framework?
Not quite. An agentic framework (LangGraph, CrewAI, OpenAI Agents SDK) is a toolkit for building any kind of agent. A coding agent is a finished agent specialised for software work — though several of them also ship their engine as an SDK.
What is the difference between an agentic framework and MCP?
They solve different problems. An agentic framework runs the agent: the loop, state and orchestration. MCP is a protocol for connecting that agent to tools and data. Most modern frameworks can act as an MCP client, so you can write a tool once and reuse it across them.
Single agent or multi-agent?
Start with a single agent and a handful of well-described tools. Split into multiple agents only when one agent’s prompt and tool list grow too large to behave reliably, or when different steps need different models or permissions. Every extra agent adds latency, cost and a new place for errors to compound.
Which agentic framework should a beginner start with?
The OpenAI Agents SDK or CrewAI get a working agent running with the least code. Move to LangGraph when you need explicit control over state, branching and long-running processes.
Where we can go deeper next ?
We’ve only scratched the surface of what the agentic ecosystem is becoming. From production-ready orchestration with LangGraph, to data-centric workflows in LlamaIndex, to OpenAI’s emerging Agent SDK and Google’s ADK reshaping enterprise automation—the real excitement starts when we dig into how these agentic frameworks actually behave in the wild.
In the next episodes, I’d like to break down architectures, explore real-world use cases, and walk through hands-on builds you can follow step by step. If the 2025 “Agent War” or “Agentic Framework War” or whatever has your curiosity sparked, stick around—this is just the beginning, and the most interesting battles are still ahead.
