LangGraph vs CrewAI vs AutoGen: Best Agent Frameworks 2026

The honest, data-verified comparison of AI agent frameworks as they actually stand in July 2026: who won, who merged, who died, and what to build on now.

AutoGen is now legacy software. The framework that anchored a thousand "top agent frameworks" listicles was folded into Microsoft Agent Framework 1.0, which reached general availability in April 2026 with long-term support, while the original AutoGen repository quietly went into maintenance mode - Microsoft. In the same six months, CrewAI crossed roughly 2 billion agentic executions across a trailing twelve-month window - CrewAI. LangGraph shipped 1.0 and then kept shipping, reaching v1.2.8 by July 6, 2026 - PyPI. And OpenAI announced it is killing AgentKit's visual Agent Builder less than a year after launching it - OpenAI.

If you last compared agent frameworks in 2025, your mental map is wrong in at least five important places. The category leaders changed. The protocols underneath them changed. Two of the ten frameworks that dominated last year's rankings are effectively dead. And a completely new paradigm, the agent harness, emerged as a genuine alternative to orchestration graphs and role-based crews.

This guide is the July 2026 state of the union for agent frameworks. It covers what changed and when, a re-ranked top 10 with hard data (GitHub stars pulled via the GitHub API on July 8, 2026, verified download volumes, verified pricing), a migration path for AutoGen users, the MCP and A2A protocol layer that now defines interoperability, real benchmark numbers, and a decision framework for choosing between LangGraph, CrewAI, Microsoft Agent Framework, OpenAI's Agents SDK, Claude Agent SDK, Google ADK and the rest of the field. Every statistic links to a primary source. Where the data is a vendor's own claim, we say so.

Contents

1. What Changed Since January 2026
2. The Top 10 in Hard Numbers
3. LangGraph: The Production Default
4. Microsoft Agent Framework: AutoGen Is Now Legacy
5. OpenAI Agents SDK: Survivor of OpenAI's Great Cleanup
6. CrewAI: Two Billion Executions Later
7. The Harness Era: Claude Agent SDK
8. Google ADK: Five Languages, One Graph Runtime
9. The Challengers: Pydantic AI, smolagents, Mastra, Agno
10. n8n and the No-Code Bridge
11. The Protocol Layer: MCP and A2A
12. Agent Benchmarks: The July 2026 Numbers
13. Enterprise Adoption: Boom and Backlash
14. The Graveyard: What Died Since the Last Edition
15. Verified Pricing Reality Check
16. How to Choose: A Decision Framework

The Master Assessment: Top 10 Agent Frameworks, July 2026

Before the deep profiles, here is the single table that answers the headline question. Ten frameworks, four weighted criteria, one final score. Production maturity (30%) measures whether the framework has a stable 1.0+, long-term support, and named production deployments at scale. Ecosystem and interop (25%) measures MCP and A2A support, integrations, and how well the framework plays outside its own walled garden. Developer experience (25%) measures API clarity, debugging, documentation, and time-to-first-working-agent. Momentum (20%) measures release cadence, star and download growth, and corporate commitment as of July 2026. Every cell contains the score and the reason for it.

Scores reflect the framework as measured on July 8, 2026, not historical reputation. Two things jump out of the table. First, the top three are separated by 0.4 points: LangGraph wins on ecosystem breadth and proven production scale, not because the alternatives are weak. Second, AutoGen does not appear at all. Its successor does, at #3, and section 4 explains exactly what happened and what to do about it. AutoGPT, SuperAGI, and Fixie, all fixtures of 2025 lists, are also gone: they live in the graveyard section, with evidence for why they no longer belong here.

1. What Changed Since January 2026

A comparison article is only as good as its date. This one is anchored to July 8, 2026, and the fastest way to update your mental model is a changelog. The last eighteen months delivered more structural change to the agent framework landscape than the three years before them: consolidation at Microsoft, deprecation at OpenAI, protocol standardization under the Linux Foundation, and a wave of credible new entrants that did not exist as production options when most "best frameworks" articles were written.

The consolidation story matters most. In 2025, Microsoft maintained two competing agent frameworks, AutoGen (research-born, multi-agent conversations) and Semantic Kernel (enterprise-born, .NET-first). Developers had to bet on one. That bet is now resolved: Microsoft Agent Framework 1.0 reached general availability on April 2-3, 2026, merging both codebases into a single framework with long-term support for .NET and Python - Visual Studio Magazine. The industry-wide timeline looks like this:

• October 22, 2025: LangChain and LangGraph 1.0 ship together, with the create_agent API and middleware
• April 2-3, 2026: Microsoft Agent Framework 1.0 GA, AutoGen and Semantic Kernel become legacy
• April 2026: Google ADK 1.0 graduates at Cloud Next; OpenAI ships the Agents SDK sandbox update (April 15)
• May 2026: LangGraph 1.2 adds per-node timeouts; n8n valued at $5.2B after SAP investment
• June 3, 2026: OpenAI announces AgentKit Agent Builder deprecation (shutdown November 30, 2026); Microsoft announces Agent Harness and CodeAct at Build 2026

Each of those bullets gets a full section below, but the pattern deserves a paragraph of interpretation, because it is the article's core thesis. The agent framework market is maturing the way every platform market matures: early proliferation, then consolidation around a few winners with corporate backing, then standardization of the connective tissue so the winners can interoperate. The Model Context Protocol moving to the Linux Foundation's Agentic AI Foundation in December 2025 and the A2A protocol hitting 1.0 under Linux Foundation governance are the standardization step - A2A Protocol. The practical consequence for anyone choosing a framework in July 2026: framework lock-in matters less than it did, because tools increasingly live in MCP servers that any framework can consume, and agent-to-agent communication increasingly happens over A2A rather than proprietary buses. You are no longer choosing a walled garden. You are choosing an orchestration style and a deployment path.

One more change cuts across everything: the models underneath. The January 2026 edition of this comparison still benchmarked frameworks against GPT-5-era models. The July 2026 frontier is GPT-5.5 (released April 23, 2026), Claude Opus 4.8 (May 28, 2026), Gemini 3.1 Pro, and Grok 4.3 - Fello AI. Claude Opus 4.8 currently tops the Artificial Analysis Intelligence Index at 61.4, with its biggest gains on agentic benchmarks - Artificial Analysis. Meanwhile OpenAI has scheduled older GPT-5 and o3 snapshots for retirement in October and December 2026. Any framework tutorial that hardcodes a 2025 model name is already broken or about to be, which is itself an argument for frameworks with clean model-abstraction layers. For the current model landscape in detail, see our GPT-5.5 complete guide and the Claude Opus 4.8 benchmark breakdown.

2. The Top 10 in Hard Numbers

Rankings without data are opinions. This section is the data. All GitHub star counts below were measured on July 8, 2026 via the GitHub API, and download figures come from Firecrawl's independently compiled 2026 framework survey - Firecrawl. Two caveats apply, and they are the same caveats every honest comparison should carry. First, stars measure attention, not production use: AutoGPT holds 185,432 stars and almost nobody runs its original CLI in production anymore. Second, downloads skew toward CI pipelines and transitive dependencies, so treat them as a relative signal, not an absolute census of developers.

With those caveats stated, the numbers still tell a clear story about where the gravity is. LangGraph's 34.5 million monthly downloads against its modest 36.8k stars is the signature of a production workhorse: unglamorous, everywhere. CrewAI's 55.2k stars with 5.2M downloads shows a broader hobbyist-to-professional funnel. And Microsoft Agent Framework's 11.9k stars understate it badly, because most of its adoption arrives through Azure SDK channels rather than the open-source repo.

The stars chart shows attention. The downloads chart below shows usage, and the two disagree in instructive ways. LangGraph out-downloads every dedicated agent framework combined, despite ranking seventh on stars among the projects above. That divergence is the strongest single piece of evidence in this article for a claim you will read often and should still scrutinize: LangGraph is the default choice for production agent orchestration in 2026, in the boring, load-bearing sense of "default."

For scale context on the market these numbers live in: the AI agent market was measured at $7.84 billion in 2025 and is projected to reach $52.62 billion by 2030 in the survey Firecrawl cites - Firecrawl. Projections that far out deserve skepticism, but the direction is corroborated by harder evidence later in this guide: Gartner's enterprise-app forecast, CrewAI's execution volumes, and n8n's valuation jump.

3. LangGraph: The Production Default

LangGraph earns the top slot for a reason that has nothing to do with hype: it is the framework you find when you look inside companies that run agents at scale. LangChain's own 1.0 announcement names Uber, LinkedIn, Klarna, JP Morgan, BlackRock, and Cisco among production users, and the broader LangChain package family sees roughly 90 million monthly downloads - LangChain. The January edition of this article still described LangGraph as a pre-1.0 project inside "the LangChain ecosystem." That framing is now doubly wrong: LangGraph 1.0 went GA on October 22, 2025, and the project has kept a brisk cadence since, with v1.2.8 released July 6, 2026 - GitHub Releases.

The conceptual model is the durable state graph. You define nodes (steps: an LLM call, a tool invocation, a human approval gate) and edges (transitions, including conditional and cyclic ones), and LangGraph executes the graph with checkpointed state at every step. That checkpointing is the killer feature for production: an agent that crashes mid-task resumes from its last state instead of restarting, a property LangChain calls durable execution. The 1.0 redesign added the create_agent entry point and a middleware system for cross-cutting concerns: human-in-the-loop approval, conversation summarization when context grows too long, and PII redaction before model calls - LangChain. The old kitchen-sink LangChain abstractions were split off into a langchain-classic package, which quietly resolved the most common 2024-era criticism of the ecosystem: too many wrappers, too much magic. LangGraph 1.2 (May 2026) added per-node timeouts and DeltaChannel for finer streaming control, both direct responses to production operator complaints. Python 3.10+ is required.

What does it cost? The framework itself is MIT-licensed and free. The commercial layer is LangSmith, the observability and deployment platform: a $0 Developer tier with 5,000 base traces per month, a Plus tier at $39 per seat per month with 10,000 traces, then $2.50 per 1,000 base traces (14-day retention) or $5.00 per 1,000 extended traces (400-day retention) beyond the allowance, with deployment runs at $0.005 each - LangChain Pricing. Those are verified July 2026 numbers from the official pricing page, and they replace the guesswork that circulated in older comparisons.

What does building on it actually feel like? A representative production pattern is a support escalation graph: an intake node classifies the ticket, a conditional edge routes simple cases to a resolution node and hard cases to a research node with retrieval tools, a human-approval node gates any refund above a threshold, and the whole thing checkpoints to Postgres so a deploy mid-conversation loses nothing. The parts that feel like overkill on day one (typed state schemas, explicit reducers, interrupt points) are exactly the parts that make the system auditable six months later, when compliance asks why the agent approved a specific refund and you can replay the exact state at every step. This is the structural reason LangGraph over-indexes in banking, insurance, and healthcare deployments relative to its general market share: regulated industries do not get to say "the model decided."

The honest trade-offs: LangGraph's graph model demands more upfront design thinking than a role-based crew or a harness. Developers coming from simple chain-style code report a real learning curve around state schemas, reducers, and conditional edges. And while LangGraph is model-agnostic, the ecosystem's observability best practices assume LangSmith, which is a soft form of vendor pull. Teams that want LangGraph's rigor with a gentler API increasingly generate their graph scaffolding with AI coding tools; teams that want the outcomes without the engineering staff look at hosted agent platforms instead, a category we compared in our CrewAI alternatives roundup. The strongest proof point for the whole category remains Klarna: its LangGraph-adjacent support agent handles two-thirds of customer service inquiries, work equivalent to roughly 853 full-time employees, saving an estimated $60 million per year - Firecrawl. Numbers like that, not GitHub stars, are why LangGraph is #1.

4. Microsoft Agent Framework: AutoGen Is Now Legacy

This is the section that would have been a footnote in January and is now the biggest single story in the field. AutoGen, the framework this article's URL is named after, is no longer the thing you should adopt. Microsoft merged AutoGen and Semantic Kernel into Microsoft Agent Framework, which hit 1.0 general availability on April 2-3, 2026 as a production-ready framework for .NET and Python with long-term support - Visual Studio Magazine. The evidence that AutoGen itself is in maintenance mode is unambiguous if you check the repositories: microsoft/autogen's last push was April 15, 2026, while microsoft/agent-framework ships continuously - GitHub.

Why did Microsoft do this? The first-principles answer is that maintaining two overlapping agent frameworks was a strategy tax. AutoGen came out of Microsoft Research with the best multi-agent conversation patterns in the industry: group chats, nested agents, agents debating their way to answers. Semantic Kernel came out of the Azure side with what enterprises actually demanded: typed APIs, .NET support, compliance posture, stability guarantees. Every serious customer conversation ended with "which one should we build on?", and for eighteen months Microsoft's answer was effectively "both, sorry." Agent Framework is the resolution: AutoGen's orchestration patterns running on Semantic Kernel's enterprise plumbing, with migration assistants shipped for existing Semantic Kernel users and documented migration paths for AutoGen codebases.

The Build 2026 announcements (June 3) show where this is going, and they are worth knowing even if you never touch Azure, because they preview features every framework will copy. Agent Harness brings production patterns to the framework core: context compaction when conversations grow long, file-based memory, and task tracking. Foundry Hosted Agents gives Agent Framework code a managed runtime with scale-to-zero economics and per-session VM isolation. And CodeAct on Hyperlight micro-VMs lets agents write and execute code in lightweight sandboxes, with Microsoft claiming a 52.4% latency reduction and 63.9% token savings versus conventional tool-calling loops on internal workloads - Microsoft. Treat those two percentages as vendor benchmarks until independently reproduced, but the architectural direction (agents writing code instead of emitting JSON tool calls) matches what Hugging Face found with smolagents, so it is unlikely to be pure marketing.

So what should you actually do if you run AutoGen today? Three honest paths, in descending order of effort-to-payoff. If you are on AutoGen's core conversation patterns (AssistantAgent, group chat), migrate to Agent Framework: the concepts map closely, Microsoft publishes migration guides, and you gain LTS, observability, and A2A/MCP support. If your AutoGen usage is thin (a single agent with a few tools), consider whether you need Microsoft's stack at all: porting to LangGraph or the OpenAI Agents SDK is often a week of work, and we cataloged the realistic destinations in our AutoGen alternatives guide. And if the system is stable and internal, doing nothing for now is defensible: maintenance mode means bug fixes stop flowing eventually, not that your code stops working tomorrow. What is not defensible is starting a new project on AutoGen in July 2026. Every month of new AutoGen code is migration debt with a known due date.

5. OpenAI Agents SDK: Survivor of OpenAI's Great Cleanup

OpenAI's agent story in 2026 is a tale of one product thriving while everything around it gets shut down. The Agents SDK (the open-source successor to the Swarm experiment) received a major update on April 15, 2026 that added sandboxed execution and a model-native harness for long-horizon file and tool work, shipping Python-first with TypeScript following - TechCrunch. The SDK sits at 27,732 GitHub stars and roughly 10.3 million monthly downloads, second only to LangGraph among dedicated agent frameworks. Its documentation lives at the openai-agents-python site and remains some of the most approachable in the field - OpenAI.

The design philosophy is minimalism. Where LangGraph asks you to think in graphs, the Agents SDK gives you three primitives: agents (a model plus instructions plus tools), handoffs (one agent delegating to another), and guardrails (validation that runs alongside the agent). There is no separate orchestration DSL; control flow is Python. This is why it wins the developer experience column in our assessment table: a working multi-agent system fits in a screen of code, and the built-in tracing UI shows every step without extra instrumentation. The April 2026 update pushed it beyond toy territory: sandboxed execution means agents can now run generated code safely, and the harness support means the SDK can drive computer-use and long-horizon tasks using the same model-native approach Anthropic pioneered. Realtime voice agents run on gpt-realtime-2.1. Pricing is simply standard OpenAI API pricing: the SDK is free and MIT-licensed, you pay for tokens.

The comparison against LangGraph is the one developers ask about most, and it comes down to where you want your complexity to live. In LangGraph, complexity lives in the graph definition: explicit, inspectable, verbose. In the Agents SDK, complexity lives in the handoff chain and the model's judgment: terse, fast to write, harder to audit. For a two-agent triage-and-answer bot, the Agents SDK version is a third the code and ships in an afternoon. For a twelve-step process with human gates and replay requirements, the same minimalism becomes a liability, because the SDK gives you no durable state store or time-travel debugging out of the box; you build or bolt on your own. Most teams that run both use the SDK for edge agents (fast, user-facing, disposable) and LangGraph for core processes (long-lived, audited, expensive to get wrong), which is a more useful division than picking a single winner.

Now the cleanup, because it is essential context for anyone betting on OpenAI's agent stack. On June 3, 2026, OpenAI announced it is deprecating AgentKit's visual Agent Builder and the Evals platform, with full shutdown on November 30, 2026 and evals going read-only October 31 - OpenAI Deprecations. The Assistants API shuts down August 26, 2026 in favor of the Responses and Conversations APIs. Older GPT-5 and o3 snapshots retire on October 23 and December 11, 2026, with gpt-5.5 as the designated migration target. That is three agent-adjacent products with end dates announced in a single quarter.

What should a rational builder conclude from this? Two things, and they pull in opposite directions. First, the deprecations are a vote of confidence in the Agents SDK: OpenAI is killing its no-code builder and its bolted-on Assistants abstraction because the code-first SDK plus the Responses API won internally. The surviving stack is clearer than anything OpenAI has offered before. Second, the episode is a reminder that OpenAI deprecates aggressively. Teams that built visual workflows in Agent Builder during 2025 have until November to rebuild them somewhere else. If your organization cannot absorb that kind of forced migration, weight the Momentum column of our assessment table accordingly, or keep your orchestration layer framework-neutral so the model provider is a swappable component rather than the foundation. Our guide to building AI agents in 2026 covers that neutrality pattern in depth.

6. CrewAI: Two Billion Executions Later

CrewAI's pitch has not changed: model your automation as a crew of role-playing agents (a researcher, an analyst, a writer) executing tasks in sequence or hierarchy. What changed is the evidence that the pitch works at enterprise scale. In January 2026, CrewAI published "Lessons From 2 Billion Agentic Workflows," reporting roughly 2 billion agentic executions over the trailing twelve months and usage inside more than 60% of the Fortune 500, with named customers including PepsiCo, Johnson & Johnson, PwC, the US Department of Defense, DocuSign, and AB InBev - CrewAI. The same post claims AB InBev routes "$30 billion in decisions through AI annually" and that one client targets $1 billion in savings plus $1 billion in new revenue over five years. Standard caveat: these are vendor-reported figures on the vendor's own blog. The named-customer list makes them more credible than typical startup numbers (you do not casually name the DoD as a customer), but no independent audit exists, so treat magnitudes as directional.

The framework itself sits at 55,150 GitHub stars and about 5.2 million monthly downloads, was selected to the 2026 Enterprise Tech 30, and remains MIT-licensed Python - GitHub. The core abstractions (Agent, Task, Crew, and Flows for event-driven control) hit a sweet spot that explains CrewAI's durable popularity with business-adjacent teams: a product manager can read a CrewAI file and understand what the automation does, which is not something you can say about a LangGraph state schema. Flows, added to answer the "crews are too loose for production" critique, give deterministic control flow around the fuzzy agent parts. We maintain a full CrewAI orchestration guide covering the architecture in practical depth, and an even longer insider deep dive if you are evaluating it seriously.

Pricing was verified on the official page in July 2026: the Basic plan is free and includes the visual editor, an AI copilot, GitHub integration, and 50 workflow executions per month; the Enterprise tier is custom-quoted and adds private infrastructure, advanced security, and 50 hours of development support monthly - CrewAI Pricing. The free tier's 50-execution cap tells you the commercial strategy: the open-source framework is the funnel, the hosted platform (CrewAI AMP) is the business.

What did two billion executions teach, according to CrewAI's own retrospective? The lessons in the post are less about framework features and more about deployment sociology, and they generalize beyond CrewAI. The workflows that survive in production are boring on purpose: narrow scope, deterministic guardrails around the agentic core, and a named business owner who treats the crew like a team member with a job description rather than a magic box. The workflows that die are the demos: broad mandates, no ground truth to evaluate against, and nobody accountable when output quality drifts. CrewAI's enterprise motion increasingly sells this operational discipline (templates, evaluation, the AMP management layer) rather than the open-source library itself, which is the correct read of where the actual scarcity is. The framework was never the hard part; knowing which fifty workflows to automate first is.

The trade-offs are the mirror image of the strengths. Role-based crews are wonderful for workflows that decompose like org charts (research pipelines, content production, structured back-office processes) and awkward for tasks that need tight, stateful control loops, where LangGraph's explicit graphs or a harness's native autonomy fit better. Heavy users also report that stacking many agents multiplies token costs: every inter-agent message is a model call. The teams getting the most from CrewAI in 2026 use small crews (2-4 agents) with sharply scoped roles, and push deterministic work into Flows or plain code rather than giving it to an agent. That discipline, more than any framework feature, separates the production stories from the abandoned prototypes.

7. The Harness Era: Claude Agent SDK

The most important conceptual shift of 2026 is not a framework release. It is a different answer to the question "what is an agent framework for?" The orchestration school (LangGraph, CrewAI, Agent Framework) says: the developer designs the workflow, the model fills in the steps. The harness school says: give a highly capable model a computer (a filesystem, a shell, a browser) and a loop, and let the model plan its own work. Anthropic's Claude Agent SDK is the purest expression of the harness idea, and its rise tracks the rise of agentic model capability itself.

The Claude Agent SDK is the renamed Claude Code SDK: the same engine that powers Anthropic's terminal agent, exposed as a library. It ships in Python (pip install claude-agent-sdk, Python 3.10+) and TypeScript (@anthropic-ai/claude-agent-sdk, with a bundled native binary), with built-in Read, Write, Edit, Bash, and WebSearch tools, lifecycle hooks, subagents for parallel work, MCP server support, and session resumption - Anthropic. The difference from orchestration frameworks is visceral the first time you use it: you do not define tools for file editing or shell access, because the harness already has them, hardened by millions of hours of real-world Claude Code usage. You write a system prompt, set permission boundaries, and the model does the rest. For production deployment without managing infrastructure, Anthropic offers hosted Managed Agents, which we covered in our Claude Managed Agents guide.

Two 2026 developments matter for anyone budgeting a harness-based system. First, Anthropic changed its subscription credit policy on June 15, 2026: SDK and other non-interactive runs on subscription plans now draw from a separate monthly credit pool ($20 on Pro, $100 on Max 5x, $200 on Max 20x) rather than the interactive usage allowance, which makes hobby-scale automation predictable but means serious workloads belong on API billing. Our Claude Agent SDK deep dive walks through the cost math. Second, the model side got dramatically better at exactly the skills harnesses need: Claude Opus 4.8 (May 28, 2026) posted its largest benchmark gains on agentic evaluations, +6.8 points on Terminal-Bench Hard and +5.9 on tau2-bench Telecom versus Opus 4.7, at $5/$25 per million tokens with a 1M-token context window - Artificial Analysis.

A concrete example makes the paradigm difference tangible. Suppose the task is "produce a weekly competitive pricing report." The orchestration version: you design a graph with a scraping node, a normalization node, a comparison node, and a formatting node, wire the tools, and maintain that pipeline forever as competitor sites change. The harness version: you give the Claude Agent SDK a working directory, an instructions file describing the report format, and web access; the agent writes its own scraping scripts into the directory, fixes them when sites change, and leaves both the report and its tooling on disk where you can inspect everything it did. The second version is self-maintaining in a way the first is not, because maintenance itself is just another task the harness can perform. The cost is variance: each run may take a different path, consume a different token budget, and occasionally requires the permission system to stop it from being too creative. Hooks and permission rules are the throttle, and learning to set them well is the actual skill of harness engineering.

When does the harness paradigm win? First-principles answer: when the task's structure is unknowable in advance. A support-ticket triage flow has known structure; build it as a graph. "Investigate why the build is failing and fix it" has structure that only emerges during execution; no graph you draw beforehand survives contact with the problem, and a harness with filesystem access will beat an orchestrated pipeline every time. The inverse also holds: harnesses are less predictable and harder to bound than explicit graphs, which is why regulated workflows still default to orchestration. OpenAI's April 2026 SDK update, with its sandboxed execution and model-native harness support, is direct competitive confirmation that both camps now believe the harness is a permanent part of the landscape, not a curiosity. Expect the paradigms to hybridize: LangGraph nodes that contain entire harness runs are already a documented pattern.

8. Google ADK: Five Languages, One Graph Runtime

Google spent 2024 and 2025 as the odd company out in agent frameworks: enormous model capability, no framework story beyond Vertex AI plumbing. The Agent Development Kit (ADK) fixed that, and its graduation to 1.0 general availability at Cloud Next in April 2026 made it a legitimate top-10 entry rather than a curiosity - ADK. The headline differentiator is language breadth no competitor matches: Python (google-adk), TypeScript (@google/adk), Go, Java, and Kotlin, all with first-class support and shared concepts, documented at adk.dev. For enterprises with polyglot backends (a Java order system, a Go infrastructure layer, Python ML services), ADK is the only framework where all three teams use the same agent runtime natively.

Architecturally, ADK lands between LangGraph's explicit graphs and CrewAI's role crews: it offers graph-based workflow agents (sequential, parallel, loop) composed with LLM-driven agents, plus context management, built-in evaluation tooling, and deployment paths to Cloud Run and GKE. It sits at 20,521 GitHub stars (Python repo) with roughly 3.3 million monthly downloads, healthy for a framework this young. Google also co-authored the A2A protocol and made ADK its reference implementation, which means agent-to-agent interop is native rather than bolted on: an ADK agent exposes an A2A card that a Microsoft Agent Framework agent can discover and call.

The framework's evaluation story deserves specific mention because it addresses the most common failure mode in agent development: shipping on vibes. ADK bakes in an eval harness that runs agents against recorded test cases and scores trajectories, not just final answers, so a change that makes the agent take twelve steps instead of four gets caught even when the end result stays correct. Combined with Cloud Run's per-request billing and GKE's control for heavier workloads, the deployment path from laptop prototype to production endpoint is shorter than anything outside the vendor-hosted platforms. Google's incentive alignment is transparent: ADK exists to make Gemini 3.1 Pro consumption easy, the same way the OpenAI Agents SDK exists to sell OpenAI tokens. It nevertheless runs other models cleanly through its model abstraction, and its Apache 2.0 license means the runtime itself carries no lock-in.

The honest assessment: ADK's production track record is the youngest of the top six, its conventions are unmistakably Google-flavored (which some teams love and others find heavy), and choosing it makes most sense when you are already committed to Google Cloud or genuinely need the multi-language story. Its evaluation tooling and the Gemini 3.1 Pro integration path are strong; its community, while growing fast, still produces fewer third-party tutorials, integrations, and Stack Overflow answers than LangGraph or CrewAI when you hit an edge case at 2am. Watch it closely: of everything in this list, ADK has the steepest institutional backing relative to its current mindshare, which historically predicts a climb up rankings like this one.

9. The Challengers: Pydantic AI, smolagents, Mastra, Agno

The frameworks in this section would each have merited a top-five slot in a 2024 landscape, and their absence from January's edition of this article was its single biggest coverage gap. They matter because they represent distinct philosophies, not just smaller market shares, and for specific teams each of them is the correct first choice over everything ranked above.

Pydantic AI (18,277 stars, v1.x stable) is what happens when the team behind Python's most-used validation library builds an agent framework. Every agent has typed inputs and typed outputs, validated at runtime; if the model returns garbage, you get a validation error and an automatic retry with the error message in context, not a silent downstream failure - GitHub. It is model-agnostic, integrates with the Logfire observability platform, and feels like FastAPI for agents: minimal magic, maximal type safety. Teams already living in the Pydantic/FastAPI world report the lowest-friction adoption of any framework here. Its production story is younger and its multi-agent patterns are thinner than LangGraph's, which is what the assessment table reflects.

smolagents (28,247 stars) is Hugging Face's minimalist bet on a specific technical idea: agents should write code, not emit JSON tool calls. A smolagents CodeAgent responds to a task by writing a Python snippet that calls its tools, which executes in a sandboxed environment. Hugging Face reports this cuts LLM calls by roughly 30% on multi-step tasks, because one code block composes several tool calls that JSON-mode agents would spread across separate model round-trips - GitHub. The core is around a thousand lines of readable code, which makes it the best framework in this list for actually understanding how agents work. Microsoft's CodeAct announcement at Build 2026 validates the approach at enterprise scale. The trade-off is that smolagents deliberately stays small: durable state, complex orchestration, and enterprise governance are your problem.

Mastra (25,950 stars, 1.77 million monthly npm downloads) is the TypeScript-native choice, built by the former Gatsby team - GitHub. It bundles agents, tool-calling, workflows with suspend/resume, RAG primitives, and evals into one coherent DX aimed at web developers who do not want to run a Python sidecar. If your product is a Next.js app and your team thinks in TypeScript, Mastra is the path of least resistance, and its momentum through 2026 has been remarkable for a project this young. Its ceiling today is ecosystem depth: fewer integrations, fewer battle-tested deployment patterns, and a JS-only worldview.

Agno (41,053 stars) rounds out the challengers as the performance-focused full-stack option: agents with memory, knowledge, and reasoning built in, plus a claim to dramatically faster agent instantiation than LangGraph in its own benchmarks. It has quietly accumulated more stars than LangGraph itself, though downloads and named production deployments still trail. Also worth a mention in the adjacent open-source space is Dify (~144k stars), which is less a code framework than a self-hostable LLM-app platform with visual agent workflows; teams comparing it are usually really choosing between code-first and visual-first development models, the same axis explored in our top open-source AI coders guide.

The practical takeaway from this whole tier: match the philosophy to your constraint. Type-safety culture picks Pydantic AI. Token-cost sensitivity and transparency pick smolagents. TypeScript-only teams pick Mastra. None of these choices are wrong; they are just optimizations for different bottlenecks, and all four interoperate with the same MCP tool ecosystem as the market leaders.

10. n8n and the No-Code Bridge

Every previous edition of this article treated no-code automation as a sidebar. n8n's 2026 numbers ended that framing. The workflow automation platform sits at 195,663 GitHub stars, the largest of any project in this guide, and was valued at $5.2 billion in May 2026 when SAP invested, more than doubling its $2.5 billion October 2025 Series C valuation (a $180M raise, $240M total funding), with over 1,400 enterprise customers - n8n. When the market prices a visual workflow tool at $5.2B in the middle of an agent framework boom, it is telling you something about where the demand actually is: most business automation does not need a hand-coded agent graph. It needs a reliable workflow with an agent node in the middle.

That is precisely n8n's 2026 shape. The platform's AI agent nodes let a workflow hand a step to an LLM-driven agent (with tools, memory, and any major model), while everything around that step stays deterministic: triggers, integrations across 1,100+ services, error handling, retries. The pricing is verified July 2026 and materially different from the "$20-50" hand-waving in older comparisons: Starter at EUR 20/month (2,500 executions, 2,300 AI credits), Pro at EUR 50/month (10,000 executions), both billed annually, Business at EUR 667/month self-hosted (40,000 executions, SSO, Git integration), and custom Enterprise, with unlimited users and workflows on every plan because n8n charges per execution, not per seat - n8n Pricing. The self-hosted community edition remains free under a sustainable-use license.

Where does n8n genuinely beat the code frameworks? Integration-heavy, structure-known automation: lead enrichment, notification routing, document pipelines, CRM hygiene. A workflow that touches Gmail, Slack, HubSpot, and a database is an afternoon in n8n and a week of authentication plumbing in Python. Where does it lose? Deeply stateful, open-ended agent behavior: multi-turn reasoning loops, dynamic planning, code execution. Bolting five agent nodes together in a visual canvas produces systems that are hard to test and harder to debug, exactly the terrain where LangGraph's checkpointing or a harness's native autonomy earn their complexity. The same boundary applies one level up at platforms that operate full AI workforces rather than single workflows: O-mega, for example, sits in that adjacent category, giving businesses autonomous agents that browse, use tools, and execute multi-step work without the founder writing orchestration code, an option worth knowing about if your real requirement is outcomes rather than infrastructure. The mapping from business processes to agentic automation is a topic we unpack in agentic business process automation.

11. The Protocol Layer: MCP and A2A

The single biggest structural difference between the 2025 framework landscape and the 2026 one is invisible in any star count: the connective tissue got standardized. In 2025, every framework had its own tool format, its own agent-communication scheme, and its own integration catalog, so choosing a framework meant choosing an ecosystem you could not leave. In 2026, two Linux Foundation-governed protocols dissolve most of that lock-in, and understanding them matters more than memorizing any single framework's API.

The Model Context Protocol (MCP) standardizes how agents connect to tools and data. Anthropic created it, but the decisive move came in December 2025, when Anthropic donated MCP to the Linux Foundation's Agentic AI Foundation, co-founded with Block and OpenAI, converting a vendor spec into neutral infrastructure - MCP Manager. Adoption followed the shape of a standard, not a product: from roughly 100,000 monthly SDK downloads at launch to approximately 97 million monthly SDK downloads by March 2026, with thousands of MCP servers published for everything from Postgres to Figma. Every framework in our top 10 now consumes MCP servers. The practical meaning: when you write a tool once as an MCP server, it works from LangGraph, CrewAI, Claude Agent SDK, ADK, Agent Framework, and the OpenAI Agents SDK without modification. We keep a working catalog in the 50 best MCP servers, and if you want to publish your own capabilities, our MCP server build guide walks through it end to end.

It is worth pausing on how anomalous that 97-million-download curve is, because standards usually fail. The historical pattern for vendor-donated protocols is polite committee death: the donor keeps de facto control, competitors implement grudgingly and partially, and fragmentation returns within two years. MCP escaped that fate for a structural reason: every party's alternative was worse. Model providers needed third-party tools to make their agents useful; tool vendors could not afford to build and maintain five proprietary integrations; and enterprises refused to buy anything that deepened lock-in. When Block and OpenAI co-founded the Agentic AI Foundation alongside Anthropic's donation, the signal was that even Anthropic's chief competitor preferred a neutral standard it does not control over a fragmented landscape it might partially win. That alignment of incentives, more than any technical property of the protocol, is why betting your tool layer on MCP in 2026 is a low-regret decision.

A2A (Agent2Agent) standardizes the layer above: how agents discover and talk to each other, across frameworks, vendors, and organizations. Google authored it, donated it, and the protocol reached version 1.0 under Linux Foundation governance with a Technical Steering Committee that includes AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow, Apache 2.0 licensed - A2A Protocol. An A2A-compliant agent publishes an agent card describing its capabilities; other agents discover it and delegate tasks over a standard interface, whether the counterparty runs on ADK, Agent Framework, or a homegrown stack. It is early (real-world A2A traffic is a fraction of MCP's), but the governance roster is the tell: every major enterprise vendor is on the committee, because none of them can sell agents into enterprises that fear single-vendor lock-in.

The first-principles reading of the protocol layer is the most important strategic paragraph in this guide. When connective standards emerge, value migrates from the framework to two other places: the models (which do the reasoning) and the capability layer (the tools and data agents can reach). Frameworks become thinner and more substitutable, which is good for builders and brutal for framework vendors' moats, and it explains why LangChain monetizes observability (LangSmith), CrewAI monetizes a hosted platform, and Microsoft monetizes Azure hosting: nobody can charge for the orchestration code itself anymore. For your architecture, the actionable rule is: put your engineering investment in MCP-shaped capabilities and clean state design, and treat the framework as a replaceable execution engine. Teams that did this in 2025 migrated between frameworks in days during the 2026 consolidation. Teams that did not are still untangling AutoGen group chats.

12. Agent Benchmarks: The July 2026 Numbers

Framework comparisons love to imply that framework choice drives task performance. The benchmark data says otherwise, and honesty about that is rare enough in this genre to be a differentiator. The scores below measure model plus harness capability on agentic tasks; the orchestration framework you wrap around the model typically moves outcomes far less than the model generation does. Use benchmarks to pick models. Use the rest of this article to pick frameworks.

The headline agentic numbers as of July 2026: Claude Opus 4.8 leads the Artificial Analysis Intelligence Index at 61.4, beating GPT-5.5's xhigh configuration by 1.2 points, with its biggest jumps on Terminal-Bench Hard (+6.8) and tau2-bench Telecom (+5.9) over its own predecessor - Artificial Analysis. On software agency, Claude Opus 4.8 posts 88.6% on SWE-bench Verified. The cadence is as notable as the scores: GPT-5.5 arrived April 23, 2026, and Opus 4.8 followed just 42 days later, Anthropic's fastest Opus turnaround ever - Fello AI.

The most interesting leaderboard of 2026, though, is tau-bench, which measures tool-using dialogue agents in realistic customer-service domains. The top of the July 2026 table is not American frontier labs: Step-3.5-Flash leads at 88.2%, followed by GLM-4.7 at 87.4%, MiMo-V2-Flash at 80.3%, and MiniMax M2 at 77.2% - Steel.dev leaderboard. Chinese open-weight models dominating a tool-use benchmark has direct framework implications: every framework in this guide is model-agnostic in principle, but the ones with the cleanest model abstraction (LangGraph, Pydantic AI, smolagents) make it trivial to route tau-bench-style workloads to a cheap open-weight model while keeping frontier models for hard reasoning, a cost lever that single-vendor SDKs structurally resist.

Benchmark literacy also means knowing what the numbers do not say, and three caveats apply to everything in this section. First, contamination pressure is real: benchmarks that live on the public internet leak into training data, which inflates scores over time in ways nobody can fully correct for, and it is one reason held-out and frequently refreshed suites like Terminal-Bench Hard carry more signal than older static sets. Second, task distribution bias: tau-bench measures polite, well-specified customer dialogues; your users are neither, and a model that scores 88% there can still faceplant on your ambiguous internal tickets. Third, harness sensitivity: the same model can swing double-digit points on agentic suites depending on the scaffold it runs in, which paradoxically is the one place framework choice does show up in benchmark numbers. Published scores use the vendor's best harness; your production numbers will use yours.

Beyond these two, the benchmarks worth tracking for agentic work are GAIA (general assistant tasks requiring tool use and multi-step reasoning), OSWorld (full operating-system control, still far from saturated), and Terminal-Bench (command-line agency, the harness paradigm's home turf). We maintain a dedicated ranking of computer-use performance in our computer-use benchmarks guide. The meta-lesson across all of them: scores improve when models improve, and framework-level tricks (better prompts, better retry logic) add single-digit points at best. Budget your attention accordingly.

13. Enterprise Adoption: Boom and Backlash

Any 2026 framework guide that only reports the boom is doing marketing, not analysis. The adoption data is genuinely two-sided, and both sides come from the same analyst. Gartner forecasts that 40% of enterprise applications will feature task-specific AI agents by the end of 2026, up from under 5% in 2025, an extraordinary integration curve for a two-year window - Gartner. The same firm separately predicts that over 40% of agentic AI projects will be canceled by the end of 2027 on cost, unclear value, or risk grounds, and its 2026 CIO survey finds only 17% of organizations have actually deployed agents so far. Both forecasts can be true simultaneously, and probably are: agents embed everywhere as features while standalone "agent transformation" projects fail at roughly the rate ambitious IT projects always fail.

The verified success stories share a pattern worth extracting. Klarna's support agent (two-thirds of inquiries, ~853 FTE-equivalents, ~$60M annual savings) automates a high-volume, well-bounded process with clear success criteria - Firecrawl. CrewAI's named enterprise deployments (PepsiCo, J&J, PwC, DoD) run specific workflows, not general-purpose digital employees. AB InBev's "$30 billion in decisions" flows through defined decision pipelines. The failures Gartner is forecasting, by contrast, cluster around open-ended mandates ("deploy agents across the org") with no process owner and no metric. The lesson is not that agents underdeliver; it is that agents are process automation, and process automation has always required knowing which process you are automating.

How do you land on the right side of Gartner's 40%-canceled prediction? The successful deployments visible across this guide suggest a sequencing discipline rather than a technology choice. Start with a process that already has a measurable baseline (tickets resolved per day, hours per report, cost per lead), because an agent project without a baseline cannot prove value and becomes a budget-review casualty by default. Constrain the first deployment to the read-and-recommend level before granting write access to production systems; most of the observed failure stories involve granting an agent authority its evaluation regime had not earned. And instrument from day one: every framework in the top 10 now ships or integrates tracing precisely because the teams that survived 2025's pilots were the ones who could answer "what did the agent do and why" in under a minute. None of this is glamorous, which is exactly why it correlates with survival.

There is also a market-structure signal in where the money went. SAP's investment valuing n8n at $5.2 billion, CrewAI's Enterprise Tech 30 selection, and Microsoft, Google, OpenAI, and Anthropic all shipping first-party agent stacks in a single year mean the framework layer is now strategically contested by the largest software companies on earth. For buyers, that guarantees the category survives its hype cycle. It also predicts more consolidation: when the giants commit, independent frameworks either find a durable monetization wedge (LangSmith, CrewAI AMP) or get absorbed the way AutoGen and Semantic Kernel were. If you are betting a multi-year architecture on an independent framework, check that its commercial engine is real; the graveyard section below shows what happens when it is not.

14. The Graveyard: What Died Since the Last Edition

Listing what to use is half a guide's job. The other half is naming what to stop using, with evidence, because stale recommendations from 2025 listicles keep routing real engineering time into dead ends. Everything in this section was either a top-10 fixture or a headline product within the last 24 months.

OpenAI Swarm was superseded more than a year ago by the Agents SDK; any tutorial still teaching Swarm patterns is an archaeology exhibit. AgentKit's Agent Builder and the Evals platform were deprecated on June 3, 2026 and shut down entirely on November 30, 2026, with evals read-only from October 31; the Assistants API dies August 26, 2026 in favor of Responses and Conversations - OpenAI Deprecations. If you have production traffic on any of these, the migration clock is running as you read this.

SuperAGI, a top-10 entry in most 2025 rankings including the previous edition of this one, is unmaintained: the repository's last push was January 22, 2025 (verified via the GitHub API on July 8, 2026), there have been no releases since early 2024, and issues go unanswered - GitHub. Its 17,609 stars are a monument, not a signal. Fixie pivoted away from its agent platform and is no longer a credible entry. AutoGPT's original CLI, the project that ignited the 2023 agent craze, is archived as "Classic"; the project pivoted to a hosted no-code AutoGPT Platform, and while the repo still carries a colossal ~185k stars, the thing those stars were given to no longer exists as a maintained product. And AutoGen itself, as covered in section 4, is in maintenance mode with a designated successor, which is a softer death than SuperAGI's but a death for new-project purposes all the same.

The pattern across the graveyard is worth one analytical paragraph, because it is your best defense against the next generation of stale advice. Every dead project here died the same way: the maintainer's business model stopped requiring the open-source project. OpenAI killed Swarm and AgentKit because better internal bets won. SuperAGI's company moved on. AutoGPT's team followed the revenue to a hosted platform. The survivors, without exception, have a live commercial engine attached to the framework itself. When you evaluate any framework not on this list, or this list a year from now, the first question is not "how many stars?" but "who is paid to maintain this, and by what revenue?" Stars measure the past. Payrolls predict the future.

15. Verified Pricing Reality Check

Pricing claims are where framework comparisons rot fastest, and the January edition of this article carried unverified numbers (a "$99/month" Lindy figure, a "$25/user" Vellum figure) that we could not substantiate against official pages. This edition takes the opposite approach: the table below contains only prices verified on official pricing pages in July 2026, each with its source link. Where a vendor's pricing is genuinely custom-only, we say so rather than inventing a number.

Three observations turn this table from reference into strategy. First, every framework's code is free; you pay for tokens, observability, or hosting, so cost modeling is about usage patterns, not license fees. A CrewAI crew of five chatty agents can cost 10x a lean LangGraph graph on the same task purely through inter-agent messages. Second, trace-based pricing (LangSmith) and execution-based pricing (n8n, CrewAI) scale differently: traces grow with agent complexity, executions grow with business volume, and you should match the meter to whichever of those your product grows along. Third, the model bill usually dominates everything in this table at production scale, which is why the $5/$25 per million tokens of Opus 4.8 or routing routine steps to cheap open-weight models (see the tau-bench section) moves your economics more than any platform-tier decision. We track the full model price landscape in our model benchmarks and pricing guide.

16. How to Choose: A Decision Framework

Ranking tables answer "what is best on average." Real decisions are conditional, and after everything above, the conditions reduce to three questions: what language does your team ship, what shape is your problem, and where will this run? Answer those three and the top-10 list collapses to one or two candidates without any agonizing.

Language first, because it is the hardest constraint. Python teams have the full menu: LangGraph, CrewAI, OpenAI Agents SDK, Claude Agent SDK, ADK, Pydantic AI, smolagents. TypeScript-first teams realistically choose between Mastra, the Claude Agent SDK, LangGraph's JS port, and ADK's TypeScript package. .NET shops have exactly one serious answer, Microsoft Agent Framework, and that is fine because it is a good one. Java, Go, and Kotlin teams have ADK and essentially nothing else first-class, which is Google's quiet wedge into enterprises the Python frameworks cannot reach.

Problem shape is the second filter, and the diagram above compresses this guide's core argument. Known structure with compliance requirements wants explicit graphs: LangGraph if you want ecosystem depth, Microsoft Agent Framework if you live on Azure and LTS matters, ADK if you live on Google Cloud. Work that decomposes into roles (research, produce, review) fits CrewAI's mental model better than anything else. Emergent-structure work (debugging, open-ended research, building things) belongs to harnesses, where the Claude Agent SDK is the most complete expression and the OpenAI Agents SDK the fastest to adopt. Integration-heavy business workflows want n8n's visual canvas or, if you would rather buy outcomes than build systems at all, a managed agent workforce platform like O-mega, where the orchestration, browsing, and tool execution come pre-assembled and the interface is simply telling agents what you need done. For a deeper conceptual treatment of when to reach for multi-agent designs at all, see our guide to multi-agent orchestration.

Deployment target is the tiebreaker. Self-hosting everything favors the pure open-source cores (LangGraph OSS, smolagents, self-hosted n8n). Managed-platform comfort favors LangSmith deployments, CrewAI AMP, Foundry Hosted Agents, Vertex, or Anthropic's Managed Agents. And whichever branch you take, the single most future-proof decision available in July 2026 is protocol discipline: build your tools as MCP servers, keep state schemas framework-neutral, and treat A2A as your inter-agent boundary. The teams that did this sailed through the year's consolidation; the teams that welded themselves to AutoGen's internals are reading migration guides.

One reasonable objection deserves a direct answer before closing: is this all moving too fast to commit to anything? No, and the graveyard is actually the evidence. What died were products without business models and abstractions the model providers outgrew. What survived and won (LangGraph, CrewAI, the vendor SDKs, n8n) all have paid maintainers, real deployments, and now shared protocols underneath. The layer has stabilized in the way that matters: your skills and your MCP-shaped capabilities transfer even when an individual framework loses. That was not true in 2024. It is the quiet good news of 2026.

About the author: Yuma Heymans (@yumahey) is the founder and CEO of O-mega and co-founder of HeroHunt.ai. He has spent the past several years building multi-agent orchestration into a production AI workforce platform, which is exactly the vantage point from which framework claims in this guide were pressure-tested.

This guide reflects the agent framework landscape as of July 8, 2026. GitHub star counts were measured via the GitHub API on that date; pricing was verified against official pricing pages the same week. This market moves monthly: verify current versions, prices, and deprecation dates before committing to an architecture.