AI agent frameworks: choose by the harness, not features

Key takeaways

• At least a dozen active open-source AI agent frameworks are in play as of July 2026, from LangGraph to the Claude Agent SDK.
• Several widely-cited rankings still describe a 2024-2025 field: a 2025 enterprise list, tutorial code against gpt-4o-mini and AutoGen v0.2.25, and Swarm still benchmarked after its early-2025 deprecation.
• Score fit on four harness dimensions, context management, orchestration, tool approval, and memory and checkpointing, not the feature table.
• You get a method and a lens here, the identical-minimal-agent test, not our own benchmark numbers yet.

You came here to pick one of the AI agent frameworks and stop reading listicles. The problem is that most of those listicles rank on the same thing: a feature table and a "best for X" label. That table cannot tell you the one thing that decides whether the tool survives contact with your codebase. So this guide does something the ranking set does not. It names the live field, shows you which rankings are describing a stack that has already moved on, and hands you a test you run yourself.

The honest limit up front: we give you the lens and the method, not our own published benchmark numbers. We have not run every framework and timed it. When you finish, you will have a way to rank any candidate on the surface that matters, and a protocol that produces your own dataset instead of someone else's demo.

What an agent framework actually is, and how it differs from an SDK and a harness

Strip away the marketing and an agent framework is simple to define. It is the layer of prebuilt building blocks between a raw LLM API and a production agent. It is the software platform teams use to develop, deploy, and manage agents that reason, plan, and execute tasks. IBM's definition and the way practitioners use the term agree on this much.

The word that does the real work, though, is harness. Microsoft Learn, in its own product docs, names the harness as a first-class capability category. It defines it as an opinionated agent with batteries-included capabilities for long, multi-step tasks: planning and todo tracking, context compaction, file access and memory, don't-ask-again tool approval, and observability. Read that list again. None of it shows up in a feature table, and all of it decides how your agent behaves at run time.

Vendors muddy this on purpose. They use "framework," "SDK," and "harness" loosely, and often interchangeably. A product can call itself an SDK and ship a full harness, or call itself a framework and hand you a thin wrapper. The label on the box tells you almost nothing about the runtime inside it. That is why you cannot shop by name, and why the rest of this page is about the runtime.

The active AI agent frameworks field as of July 2026

The field is crowded, not settled. Building agents used to be a patchwork of scripts, prompt engineering, and trial and error. Now there is a real landscape of open source AI agent frameworks built to help agents reason, plan, and run tasks. As of July 2026, at least a dozen active options share the same space:

LangGraph, LangChain DeepAgents, the OpenAI Agents SDK, the Claude Agent SDK, Google ADK, Pydantic AI, CrewAI, Strands Agents, Mastra, the Vercel AI SDK, the Microsoft Agent Framework, Agno, and Smolagents.

That is your agentic AI frameworks list, and it is longer than most rankings admit. If you want examples to anchor it: LangGraph is the download leader, and the Claude Agent SDK and Pydantic AI are recent entrants that many 2025 lists never mention.

On the "best github" and adoption question, the numbers are lopsided. Firecrawl's roundup puts LangGraph at roughly 34.5 million monthly downloads and Dify at about 144,000 GitHub stars. Those are real signals of momentum. They are also not a verdict. Adoption is not fit. The most-downloaded framework is not automatically right for your harness needs, and a star count on a repo tells you a project is popular, not that it handles your workload the way you need. So read those figures as where the crowd is standing, not as where you should stand.

Why the published rankings disagree, and which describe a superseded field

Search "best AI agent framework 2026" and you get a wall of near-identical lists that somehow reach different conclusions. A big reason is age. Many of them are SEO refreshes of a 2024 field, re-dated but not re-reported.

You can spot a stale ranking without trusting anyone. Look at what it benchmarks and what code it ships. One widely-cited enterprise list, dated 2025, centers LangChain, Semantic Kernel, CrewAI, and AutoGen as "the top frameworks." A leading tutorial still ships its starter code against gpt-4o-mini and installs AutoGen at v0.2.25. Follow either one in mid-2026 and you are building against a snapshot that has moved.

The pattern goes further. Some rankings still benchmark OpenAI Swarm, which was deprecated in early 2025, and recommend AutoGen without noting it has been in maintenance mode since late 2025. Meanwhile they omit Mastra, Pydantic AI, and the Claude Agent SDK entirely. If you landed here from a "best framework 2026" Reddit or GitHub thread hunting for the consensus pick, that is the test to apply to it: not who wins the popularity argument, but whether the ranking still describes the current field or a leftover from last year's.

One caution on this, in both directions. Version states like "deprecated" and "maintenance mode" are what the field reports, not something we independently re-verified line by line. Treat them as a strong signal to check, not gospel. Before you commit to any framework, open its own release notes and read the last three months. If the ranking that recommended it never did, that is your answer about the ranking.

Rank by the harness surface, not the feature list

This is the reframe the whole page turns on. Microsoft's own product docs name the harness as a first-class capability category: the batteries-included runtime for long, multi-step tasks, covering planning and todo tracking, context compaction, file access and memory, don't-ask-again tool approval, and observability. None of that shows up in a feature table, and all of it is behavior you can watch at run time.

Follow that list to its conclusion and the reframe writes itself. If one framework compacts context aggressively and another lets it sprawl, or one runs a trusted tool unattended while another stops to ask on every call, then two frameworks wrapping the exact same model are not automatically interchangeable. That is a reasoned read of the capability list, not a benchmarked law with a published curve behind it, so treat it as a hypothesis you confirm on your own workload rather than a verdict you inherit. And Microsoft naming the harness a category in its own product doc is not neutral; take the source's self-interest with a grain of salt. The dimensions hold anyway, because each one names run-time behavior you can observe directly.

So score candidates on four harness dimensions:

• Context management. How it compacts, trims, and carries state across a long task without losing the thread.
• Orchestration. How it plans, sequences, and coordinates steps and tools. This is the core of any agent orchestration framework.
• Tool approval. Whether it can run don't-ask-again once you trust a tool, or stops to ask on every call.
• Memory and checkpointing. Whether it can save state, resume from a checkpoint, and recover instead of restarting.

The published rankings do not score any of this. Instead, the most decision-oriented one proves its picks with "thousands of teams." That is social proof, not a method you can rerun. A number of teams is not a measurement of your workload.

The at-a-glance decision table, scored on the harness surface

Use this to shortlist, not to crown a winner. Every framework below is open source. The harness cells are marked "run the test" because we have not independently benchmarked each one, and inventing scores would defeat the purpose, so treat the table as directional until you fill those cells with your own numbers. The last column flags the active options that many 2024-2025 rankings quietly leave out, so you do not shortlist from a list that already dropped them.

One column the table leaves out on purpose is language and stack, because it varies by project and you should confirm it in each repo rather than trust a table. That leads straight into the criteria.

Criteria and thresholds: single vs multi-agent, your stack, and open source vs proprietary

Turn the lens into decisions you can make today.

Single agent or multi-agent? Start here, because it is the choice most likely to cost you a rewrite. A single-agent system needs a prompt, a model, and maybe some tools. That is it. A multi agent framework adds coordination primitives: message passing, shared state, handoffs between roles. Those primitives are power, and they are also overhead you may never recover if you do not need them. Worse, pick the wrong orchestration model early and you can end up rewriting your whole orchestration layer within months. So do not reach for an ai agent orchestration framework before your problem actually has multiple cooperating agents. The rewrite risk cuts both ways: over-building coordination is as expensive as under-building it, and the six-month figure is a rule of thumb, not a measured law.

Your stack. Match the framework to the language your team already ships in, whether that is Python, TypeScript, or .NET. A framework that fights your build, your types, and your deploy pipeline loses on day one, no matter how it scored elsewhere. This is the honest answer to "best AI agent framework Python": the best Python option is the one that passes your harness test in your Python codebase, not the one at the top of a generic list.

Open source vs proprietary. This is a real axis, not a philosophy debate. An open source AI framework gives you control, self-hosting, and the ability to read the code before you trust it. A proprietary one can carry managed compliance and support you would otherwise build. Weigh it against where your data has to live, what you have to integrate, and what you have to prove to an auditor. For most teams evaluating open source AI agent frameworks, the deciding factor is not the license itself but whether they can run and inspect the runtime where their data sits.

Settle it yourself: the identical-minimal-agent test

This is the part you keep. Instead of trusting a feature table, produce your own comparable dataset. The protocol is deliberately small so nothing but the framework changes.

1. Build one identical minimal agent in each shortlisted framework. One custom tool, one instruction, nothing fancy. The agent must be functionally the same in every framework. Only the framework differs.
2. Run it against one fixed model. Same model for all of them, so the model is a constant and the harness is the variable.
3. Run each one a fixed number of times. Ten runs each is a reasonable floor. More runs, more signal.
4. Keep everything. Every latency number, every error message, every retry. Do not summarize as you go. Save the raw output.

What you get is one dataset instead of a pile of "best for X" assertions. You will see which framework's context handling degrades on the long task, which one's tool approval stalls, and which one throws errors you would have discovered in production. That is a comparison you can defend, because you can rerun it.

The honest limit again: we describe this protocol, but we have not yet published our own filled-in run across the field. So on this page, the proof is the dataset you generate, not one we hand you. When we publish ours, it will replace the "run the test" cells in the table above with real numbers.

Objections and edge cases

"Can't I just pick the popular one?" LangGraph's roughly 34.5 million monthly downloads are a real lead, and popularity lowers your risk of being alone with a bug. But popularity is not coverage. The widely-cited rankings review only a narrow, self-interested slice. One reviews just seven frameworks. Short lists like that routinely leave out active options such as the Claude Agent SDK, Pydantic AI, and Mastra, so "the popular pick" only means popular among the options a given list bothered to include. Read the adoption figure as momentum, not as a guarantee your workload is anywhere in it.

Enterprise vs coding-agent. These are not the same buyer. An enterprise case leans hard on the compliance and integration side of the open-source-vs-proprietary axis, and on observability and tool approval in the harness. A coding-agent case leans on context management and checkpointing, because the tasks are long and you cannot afford to lose state mid-run. Same four dimensions, different weights. The lens holds; you just tune it to your job.

Your next step, by where you are

If you already have a shortlist, run the identical-minimal-agent test on your top two frameworks this week and keep the dataset. That single artifact will outrank every listicle you have bookmarked, because it scores your candidates on the harness surface the rankings never touch.

If you are earlier and still framing the problem, read the agent harness guide first and score your candidates on the four harness dimensions before you touch code. From there, the agent orchestration tools breakdown helps you decide whether you actually need multi-agent coordination yet, and the notes on autonomous AI agents and building agentic AI systems cover what the harness has to hold once you ship.

A word on where this comes from, and where it does not. Rifty is a research lab working on harness engineering: the control layers that keep an operator's judgment in the loop while agents do the work. We are not a framework vendor. We do not sell, rank, or benchmark the tools above, and if what you need today is an open-source library to install this afternoon, pick one from the field and run the test. What Rifty is for is the layer above the framework, the part that stays legible, steerable, and reversible as the agent acts. If that is the problem you are actually solving, the harness reading is your next step, and the product itself is by introduction.