# AI Agent Frameworks Compared: LangGraph, CrewAI, OpenAI Agents SDK, Microsoft Agent Framework and When to Skip Them

URL: https://vrisic.com/blog/ai-agent-frameworks-compared/
Last updated: 2026-11-11

**Short answer:** An agent framework is a code library that runs the loop of model calls, tool calls, state and tracing. A simple agent with two or three tools does not need one. For multi step work with approvals and resumable state, LangGraph or Microsoft Agent Framework fit best; for quick role based prototypes, CrewAI; for the shortest path on OpenAI models, the OpenAI Agents SDK. Whatever you pick, keep your tools, prompts and tests outside it, because those matter more than the framework.

In this guide

1. What a framework actually does
2. Workflow or agent? Decide this first
3. Do you need a framework at all?
4. The main frameworks, side by side
5. When each one fits and when it does not
6. The criteria that matter, with a weighted example
7. Open standards: MCP and A2A
8. What matters more than the framework
9. How to run a two day bake off
10. Keeping the framework replaceable
11. Mistakes we see
12. Decision table
13. How Vrisic can help
14. Sources

Framework lists date quickly: projects merge, rename and retire within months. This guide gives you both a snapshot of the main options, with facts we checked in October 2026, and criteria that stay useful after the snapshot goes stale. We build [AI agents for businesses](https://vrisic.com/services/ai-agent-development/) and we use several of these tools, so we have views. Where something is our judgement rather than a verified fact, we say so.

## What does an agent framework actually do?

A framework wraps the repetitive plumbing around a language model so you write less of it. Strip away the branding and most provide the same six things.

- **The loop.** The model decides, a tool runs, the result goes back to the model, repeat until done or a limit is hit.
- **Tool definitions.** A standard way to describe functions, validate inputs and call them, often including MCP servers.
- **State and memory.** Conversation history, intermediate results and sometimes saved checkpoints so a run can resume.
- **Orchestration.** Handing work between several agents or steps, in sequence, in parallel or by delegation.
- **Guardrails and human approval.** Checks on inputs and outputs, and pause points where a person confirms an action.
- **Tracing.** A record of every model call and tool call, so you can see why a run went wrong.

None of these is magic, and none of them is where an agent’s quality comes from. Quality comes from the model, the tools’ design, your rules and the test set, covered in the section on what matters more. If you are new to the idea, begin with [what an AI agent is](https://vrisic.com/blog/what-is-an-ai-agent/) .

## Should you build a workflow or an agent? Decide this before any framework

Anthropic’s engineering guidance separates two things that vendors blur. Workflows orchestrate models and tools through predefined code paths. Agents let the model dynamically direct its own process and tool use. The same guidance lists five workflow patterns that, in our experience, cover a large share of real business tasks: prompt chaining, routing, parallelisation, orchestrator workers and evaluator optimiser loops.

This matters because most business processes, such as invoice coding, appointment booking or ticket triage, are better served by a workflow with a model inside certain steps than by a free ranging agent. Workflows are easier to test, cheaper to run and more predictable. The more of the path you can fix in code, the less you need an agent framework’s dynamic machinery. We reach for a true agent loop only where the path genuinely cannot be written down in advance, such as open ended research or troubleshooting.

Our [chatbot vs agent](https://vrisic.com/blog/ai-chatbot-vs-ai-agent/) guide and [how to build an AI agent](https://vrisic.com/blog/how-to-build-an-ai-agent/) cover the same split from the product side.

## Do you need a framework at all?

Often no. Anthropic’s guidance on building effective agents recommends starting by calling model APIs directly, because many patterns take only a few lines of code. It warns that frameworks add abstraction layers that can hide the underlying prompts and responses, making debugging harder, and that they can tempt you to add complexity you do not need. If you do use one, the guidance says, understand the code underneath it, since wrong assumptions about what is under the hood are a common source of errors.

A rough rule from our own builds, which is a judgement rather than a measured statistic:

- **Skip the framework** when the agent has up to about five tools, one model provider, a single run path and one or two developers. A direct implementation is a few hundred lines and every line is yours to read.
- **Use a framework** when you need durable state that survives crashes and restarts, human approval steps that can pause for hours or days, several cooperating agents, or a team larger than three who need shared patterns and a common tracing view.

The costs of a framework are real but spread out: a dependency to keep updated, a learning curve for every new developer, and an upgrade path that can force rewrites. The costs of no framework are also real: you will end up writing your own state store, retry logic and tracing. Neither is free. The aim is to pay for the one that matches your workload.

Four leading frameworks, one honest comparison. Sources: project repositories and docs; *third-party directory (DEV.co). Stars as seen Oct 2026

## What do the main frameworks look like side by side?

The table lists facts from each project’s own page or documentation where we could fetch it, and from named third party summaries where we could not. Star counts move daily and are shown only to indicate community size at the time we looked.

| Framework | Core idea | Languages and licence | Notes (October 2026) |
| --- | --- | --- | --- |
| LangGraph | Stateful graph of nodes and edges; checkpoints, human in the loop interrupts | Python first, with a separate JavaScript version; MIT (per a third party directory) | About 36.7k GitHub stars and release 1.2.8 in July 2026 per that directory; optional use with LangChain; deployment complexity rated high |
| CrewAI | Crews of role based agents, plus Flows for event driven control | Python 3.10 to below 3.14; MIT | About 59.7k stars; standalone, not built on LangChain; a commercial platform (AMP) adds managed deployment and governance |
| OpenAI Agents SDK | Agents, handoffs, guardrails, sessions, human in the loop and built in tracing | Python 3.10 or newer, plus a separate JavaScript version; MIT | About 28.6k stars; documented as provider agnostic, with support for 100+ other models |
| Microsoft Agent Framework | Single agent abstraction, graph workflows with checkpointing, sequential, concurrent, handoff, group chat and Magentic One orchestration | .NET and Python; open source | Version 1.0 announced 3 April 2026; combines Semantic Kernel and AutoGen; MCP and A2A support; providers include Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Gemini and Ollama |
| Google Agent Development Kit | Workflow agents for predictable pipelines and agent coordinated routing | Python, TypeScript, Go and Java; open source | Runs locally or on Cloud Run, GKE and Google’s agent runtime; the documentation page does not state which non Google models are supported, so check |
| AutoGen | Conversational multi agent dialogue | Python, with .NET interoperability | A third party summary says Microsoft points new users to Agent Framework and positions AutoGen for maintenance and critical fixes |

LangGraph and AutoGen details come from third party summaries rather than the project pages, so confirm licences and versions on the repositories before you commit. We did not rank these on a single score because the right answer depends on your team and workload.

Two shifts are worth noting. First, the model vendors now ship their own SDKs, so choosing a framework is partly choosing how closely you want to track one vendor. Second, Microsoft folding AutoGen and Semantic Kernel into one successor is a reminder that “popular today” is a weak signal. AutoGen was widely used for multi agent experiments, and by 2026 new users were being directed elsewhere.

## When does each framework fit, and when does it not?

### LangGraph

**Fits when** the process is a state machine in disguise: steps, branches, retries, and human approval that can sit pending for a day and then resume. Its checkpointing and interrupt model is built for that. A claims or procurement agent that must wait for a manager’s approval and then continue from the exact point is a natural match.

**Does not fit when** you are building a simple tool calling assistant. Modelling a two step interaction as a graph is overkill, and the abstraction is denser than competitors, which raises the learning curve. Independent reviews also say it expects some platform engineering discipline from the team.

### CrewAI

**Fits when** you want a quick multi agent prototype with intuitive roles such as researcher, writer and reviewer, or when a business user needs to read the structure. Flows add more deterministic, event driven control for production use.

**Does not fit when** you need fine grained control over every transition or deep observability out of the box; reviewers place it behind LangGraph on both. Be aware that some enterprise features sit in the commercial platform, so check what you would be paying for.

### OpenAI Agents SDK

**Fits when** you want the fastest route from idea to working agent, with handoffs, guardrails, sessions and tracing built in and small amounts of code. It is documented as provider agnostic, which reduces the lock in people assume.

**Does not fit when** your orchestration is complex enough to need explicit graph control, or when your team wants every capability tested with non OpenAI models before relying on it. Confirm how you will export its traces to your own monitoring stack.

### Microsoft Agent Framework

**Fits when** you are a .NET or Azure shop, or you already run Semantic Kernel or AutoGen and want a supported path. It reached 1.0 in April 2026 with stable APIs and a stated long term support commitment, graph workflows with checkpointing, middleware hooks and A2A and MCP support.

**Does not fit when** you want a large community of examples. It is newer than the others, and several features, including DevUI and some Foundry integrations, were still labelled preview at 1.0.

### Google Agent Development Kit

**Fits when** your cloud is Google Cloud, you need Go or Java, or you want one toolkit across four languages.

**Does not fit when** you are model agnostic by policy and cannot verify support for your providers. Test before committing.

### No framework

**Fits when** the agent is small, the team is small and you value being able to read every line between your code and the model. **Does not fit when** you would have to rebuild checkpointing, approvals and tracing, in which case you are writing a framework and should adopt one.

## Which criteria matter, and how do you weigh them?

Choose on how well the framework serves your workload, not on stars. These six criteria cover most of what goes wrong in practice.

| Criterion | Ask | Red flag |
| --- | --- | --- |
| Language fit | Is it first class in the language your team writes daily? | A port with “feature parity not guaranteed” |
| Testing and replay | Can you replay a recorded run and score it automatically? | Only manual chat testing |
| Observability | Can you see every step and export traces to your own tools? | Traces visible only in the vendor’s dashboard |
| Lock in | Can you swap the model, and move tools out? | Tools defined in a proprietary format |
| Maintenance health | Is there an LTS or release policy, and what happened to the last framework from this vendor? | Rapid breaking changes, or a successor project announced |
| Security and permissions | Can you limit each tool by user, record and amount, and require approval? | All tools available to every agent |

### Worked example: scoring three options

This is an illustrative example, using our judgement and not benchmark data. Imagine a Python team building an expense approval agent that must pause for a manager, resume after hours, run in the client’s cloud and keep the option of switching model providers. Weight the criteria out of 100, score each option from 1 to 5, and multiply.

| Criterion (weight) | LangGraph | OpenAI Agents SDK | Direct code |
| --- | --- | --- | --- |
| Language fit (20) | 5 = 100 | 5 = 100 | 5 = 100 |
| Testing and replay (20) | 5 = 100 | 3 = 60 | 4 = 80 |
| Observability (15) | 5 = 75 | 4 = 60 | 3 = 45 |
| Lock in (15) | 4 = 60 | 3 = 45 | 5 = 75 |
| Maintenance health (15) | 4 = 60 | 4 = 60 | 3 = 45 |
| Security and permissions (15) | 3 = 45 | 3 = 45 | 4 = 60 |
| **Total out of 500** | **440 (88%)** | **370 (74%)** | **405 (81%)** |

LangGraph wins here because this workload needs pause and resume, which the others would make you build. Change the workload to a two tool support agent that runs in one request and the weights shift: testing and observability matter less, simplicity matters more, and direct code or the SDK would likely win. The exercise is useful because it forces you to write the weights down before you fall in love with a demo.

Open standards now carry real weight. Sources: Anthropic (Dec 2025); Anthropic, Building effective agents; SD Times (Jun 2025)

## Which open standards protect you from lock in?

Two protocols reduce the cost of changing framework, and both now sit under neutral governance. The Model Context Protocol (MCP) standardises how agents connect to tools and data. On 9 December 2025 Anthropic announced it was donating MCP to the Agentic AI Foundation, a fund hosted by the Linux Foundation, alongside Block’s goose and OpenAI’s AGENTS.md, with Google, Microsoft, AWS, Cloudflare and Bloomberg as supporters. The announcement cited more than 10,000 active public MCP servers and adoption by ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code.

Agent2Agent (A2A), launched by Google in April 2025 and donated to the Linux Foundation, standardises how agents talk to other agents. SD Times describes it as complementing MCP: MCP connects agents to data sources and applications, A2A connects agents to each other.

The practical rule: expose your business tools as MCP servers or plain HTTP APIs with typed schemas, not as functions defined inside one framework’s decorators. Then a framework change touches the orchestration layer only. Microsoft Agent Framework 1.0 supports both MCP and A2A, and the OpenAI Agents SDK lists MCP among its tool types. Check the specific version you plan to use, since support varies and A2A 1.0 support was still listed as coming soon in Microsoft’s release post.

The framework is one thin layer of a working agent. Vrisic analysis

## What matters more than the framework?

In our experience agent quality is decided by five things before orchestration style comes into it. If you are comparing quotes, ask where the effort goes.

| Factor | Why it matters | Typical failure if neglected |
| --- | --- | --- |
| Model choice | Capability, cost and latency differ by an order of magnitude between tiers | Using the biggest model for every step, or a small one for a hard step |
| Tool design | Clear names, narrow functions, typed inputs and helpful error messages | One giant tool, so the model misuses it |
| Deterministic rules | Limits, approvals and policy belong in code, not in a prompt | “Never refund over $50” written as a sentence the model sometimes ignores |
| Evaluation set | Real cases, scored automatically on every change | Prompt tweaks that fix one case and quietly break three |
| Logging and review | You can reconstruct why an action happened | An incident nobody can explain |

A framework can make some of these easier, such as tracing and approval pauses. It cannot supply the rules, the tests or the judgement about what the agent should be allowed to do. That is where [architecture work](https://vrisic.com/services/ai-architecture-engineering/) earns its fee. Where the agent must reach your systems, the [integration layer](https://vrisic.com/services/ai-integration/) usually takes more time than the orchestration does.

## How do you run a two day bake off?

Do not decide from documentation. Give two candidates the same small task and compare. Here is the protocol we use.

1. **Pick one real task** with two tools, one approval step and one failure path, such as “look up an order, propose a refund, wait for approval.”
2. **Write 20 test cases** including five awkward ones, with the expected tool calls and outputs.
3. **Build it in each candidate** in one day each, by a developer who is new to that framework, and record the time.
4. **Kill it mid run** after the approval step and see whether it resumes cleanly. This single test separates the frameworks quickly.
5. **Read the trace** for a failed case. Time how long it takes to find the cause.
6. **Swap the model provider** and count the lines you had to change.
7. **Score** with the weighted table above and write down the reasoning.

The two days cost far less than a wrong choice carried through a 10 week build, and the test cases you write are reusable whichever framework wins.

## How do you keep the framework replaceable?

Treat the framework as the thinnest layer you can. A portable agent has a clear shape:

- **Prompts in files** in your repository, versioned, not pasted in a dashboard.
- **Tools as services.** Each business capability is an API or MCP server with its own tests and permissions, callable from any orchestrator.
- **Rules in code.** Approval limits, allowed actions and validation sit in functions the framework calls, not in the framework’s configuration.
- **A thin adapter** between your code and the model provider, so a provider swap is a config change.
- **An evaluation harness** that runs the same test set against the whole agent, whatever is inside it.

With that structure, moving from one framework to another is a bounded task of days, not a rewrite. It is also the structure our [custom builds](https://vrisic.com/blog/ai-agent-builder-vs-custom-development/) aim for, and the reason we say you own the code, prompts and test data.

## What mistakes do teams make with frameworks?

- **Picking by stars or a conference talk.** Popularity predicts community answers, not fit for your workload.
- **Starting multi agent.** Several agents multiply cost, latency and failure modes. Begin with one agent and split only when a single prompt cannot hold the job.
- **Believing the demo.** Framework demos use clean tasks. Test your worst cases.
- **Burying rules in prompts.** They are then invisible to testing and easy to break.
- **Ignoring the cost of the loop.** Each extra model turn costs tokens and seconds. Cap iterations and log cost per run. Our [agent cost guide](https://vrisic.com/blog/ai-agent-development-cost/) shows how those costs build up.
- **Skipping upgrade planning.** Pin versions, read release notes and schedule time each quarter. The AutoGen to Agent Framework shift shows a framework can change direction under you.

## Decision table: which route fits your situation?

| Your situation | Where we would start |
| --- | --- |
| One agent, few tools, small team, one model provider | Direct API code, plus a small tracing helper |
| Long running workflow with approvals and resume | LangGraph or Microsoft Agent Framework |
| .NET or Azure organisation | Microsoft Agent Framework |
| Fast prototype of a role based multi agent idea | CrewAI, then re-evaluate for production |
| Primarily OpenAI models, want the least code | OpenAI Agents SDK |
| Google Cloud, or Go and Java teams | Google ADK, after testing model support |
| Strict data residency or private models | Any framework that runs in your cloud and accepts your model endpoint; verify before choosing |
| No developers in house | Consider a builder platform; see [builder vs custom](https://vrisic.com/blog/ai-agent-builder-vs-custom-development/) |

**Want a second opinion on your stack?** Tell us the task, your team’s language and where the agent must run, and we will give you an honest recommendation, including when you should not use a framework.

[Request a free scoping call](https://vrisic.com/contact/?need=framework-review#form)

## How Vrisic can help

We choose the framework, or none, after a free scoping call, and we write the choice down with the reasons so your team can challenge it. Agents are built at a fixed price, run in your cloud account with your own model keys, and you own the code, prompts and test data. There are no per seat fees. We are a remote team in India working US, UK and UAE hours. See [how we work](https://vrisic.com/how-we-work/) .

If you want to test an architecture on your real task first, the [AI Pilot](https://vrisic.com/ai-pilot/) costs $1,500 (£1,200, AED 5,500), takes 10 business days and is credited in full against a build started within 60 days. You can also [book a free scoping call](https://vrisic.com/contact/) or message us on WhatsApp at +91 63777 67206.

## Sources

1. [Building effective agents](https://www.anthropic.com/research/building-effective-agents) (Anthropic)
2. [openai-agents-python repository](https://github.com/openai/openai-agents-python) (OpenAI, GitHub)
3. [CrewAI repository](https://github.com/crewAIInc/crewAI) (CrewAI Inc, GitHub)
4. [Microsoft Agent Framework Version 1.0](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/) (Microsoft DevBlogs), April 2026
5. [Semantic Kernel and Microsoft Agent Framework](https://devblogs.microsoft.com/agent-framework/semantic-kernel-and-microsoft-agent-framework/) (Microsoft DevBlogs), October 2025
6. [Agent Development Kit overview](https://docs.cloud.google.com/gemini-enterprise-agent-platform/build/adk) (Google Cloud documentation)
7. [LangGraph framework profile](https://dev.co/ai/frameworks/langgraph) (DEV.co)
8. [LangGraph vs LangChain vs CrewAI vs AutoGen: a 2026 CTO’s guide](https://radar.firstaimovers.com/langgraph-vs-langchain-crewai-autogen-2026) (First AI Movers), updated April 2026
9. [LangGraph vs CrewAI vs AutoGen vs OpenAI Agents SDK](https://aiagentrank.io/blog/langgraph-vs-crewai-vs-autogen-vs-openai-agents-sdk-2026) (AI Agent Rank), May 2026
10. [Donating the Model Context Protocol and establishing the Agentic AI Foundation](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation) (Anthropic), December 2025
11. [Google’s Agent2Agent protocol finds new home at the Linux Foundation](https://sdtimes.com/ai/googles-agent2agent-protocol-finds-new-home-at-the-linux-foundation/) (SD Times), June 2025

Framework versions, licences and star counts change often and were checked in October 2026. The weighted scoring example is Vrisic’s own illustration, not a benchmark.

## Frequently asked questions

### Which AI agent framework is best?

None is best for every job. LangGraph and Microsoft Agent Framework suit long running workflows with approvals and checkpoints, CrewAI suits quick role based prototypes, and the OpenAI Agents SDK suits the shortest path on OpenAI models. Score candidates on language fit, testing, observability, lock in and maintenance, then run a two day bake off on one real task.

### Do I need a framework to build an AI agent?

Not for a small one. Anthropic’s guidance recommends starting with direct model API calls because many patterns need only a few lines of code. Adopt a framework when you need durable state, human approvals that can pause for days, several cooperating agents, or a larger team that benefits from shared patterns and tracing.

### What happened to AutoGen?

Microsoft combined Semantic Kernel and AutoGen into Microsoft Agent Framework, which reached version 1.0 on 3 April 2026 for .NET and Python. A third party analysis says AutoGen is positioned for maintenance and critical fixes while new users are pointed to Agent Framework. Existing AutoGen projects should plan a migration using Microsoft’s guides.

### Will my framework choice lock me in?

It can, mostly through how you define tools and where prompts and traces live. Reduce lock in by keeping prompts in files, exposing tools as MCP servers or typed APIs, putting business rules in your own code and testing with a framework independent evaluation set. With that structure a framework swap takes days, not a rewrite.

### Is the OpenAI Agents SDK limited to OpenAI models?

Its repository describes it as provider agnostic, supporting OpenAI’s Responses and Chat Completions APIs and 100+ other models. It is MIT licensed and available in Python and JavaScript. Confirm that the specific features you rely on, such as tracing and hosted tools, work with your chosen provider before committing to it, ideally with a small test.

### What are MCP and A2A, and do they matter for framework choice?

MCP standardises how agents connect to tools and data, and A2A standardises how agents talk to each other. Anthropic donated MCP to the Linux Foundation’s Agentic AI Foundation in December 2025, citing more than 10,000 active public servers. Building tools as MCP servers keeps them usable across frameworks, which lowers switching cost.

### Is a multi agent framework worth it?

Only when one agent with a good prompt and tools cannot hold the job. Each added agent multiplies cost, latency and failure modes, and makes testing harder. Start with a single agent or a fixed workflow, measure where it fails, and split into specialised agents only where evidence shows a clear gain. Our multi agent builds start at $60,000.

---
Vrisic · https://vrisic.com/ · Contact: info@vrisic.com · Book a call: https://vrisic.com/contact/