Agentic AI Frameworks Compared: What to Pick in 2026

Agentic AI frameworks for 2026: LangGraph, OpenAI, Claude, ADK, Microsoft and 7 more by orchestration, MCP/A2A and licence. Pick the RIGHT one now.

Quick Answer: The agentic AI frameworks worth shortlisting in November 2026 are LangGraph, the OpenAI Agents SDK, the Claude Agent SDK, Google ADK, Microsoft Agent Framework, CrewAI, LlamaIndex Workflows, Pydantic AI, Mastra, Strands Agents and smolagents, plus GoGogot as a minimal Go runtime. Pick by orchestration model first (graph, role-crew, handoff or code-loop), then by language and durability. For one agent with a few tools, a plain loop may be enough.


Agentic AI frameworks have changed fast since late 2025. LangGraph turned 1.0. Microsoft folded AutoGen and Semantic Kernel into one agentic framework. Google rebuilt ADK around a graph runtime and shipped it in five languages, and almost every model vendor now ships its own SDK.

That leaves teams with a long list and very little guidance on how the options actually differ. This guide compares twelve frameworks on the things that decide a production build: how they orchestrate work, which languages they run in, how they keep state, whether they speak MCP and A2A, how you see inside a run, and what licence you accept.

It ends with a pick by team profile and with the case for using no framework at all. If what you need is the finished work rather than an agent to build, cowork.ink gives each AI coworker its own computer, so it hands you the result instead of instructions.


What is an agentic AI framework?

An agentic AI framework is a library that runs the loop in which a model plans, calls tools, reads the results and decides the next step, and that handles everything around that loop. "Everything around it" is most of the code: saving state, retrying failed calls, pausing for a human, handing work between agents and recording what happened.

The words get used loosely. An "agentic framework" and an "AI agent framework" usually mean the same kind of library. "Agentic" stresses the behavior: the model chooses its own path instead of following a fixed script. Anthropic's widely cited Building effective agents guide draws the same line between workflows, where code fixes the path, and agents, where the model directs it.

The real difference between frameworks is the orchestration model: who decides what runs next. There are four.

Orchestration modelWho decides the next stepTypical frameworksGood atWatch out for
GraphEdges you define in code; the model decides only at branch pointsLangGraph, Google ADK 2.0, Microsoft Agent Framework workflows, Mastra workflowsRepeatable processes, audits, resuming after failureMore upfront design; graphs grow fast
Role-crewA team of role-based agents with goals and tasksCrewAI CrewsBusiness processes that map to job rolesLess control over each step and its cost
HandoffThe current agent passes control to a specialistOpenAI Agents SDK, LlamaIndex AgentWorkflow, Strands swarmTriage and routing, customer-facing flowsHard to reason about long chains of handoffs
Code-loopThe model, turn by turn, inside one loopClaude Agent SDK, Pydantic AI, smolagents, Strands, GoGogotOpen-ended tasks on files, code and the webNeeds turn limits, budgets and a sandbox

Most frameworks now support more than one model. ADK, Microsoft Agent Framework and Strands all mix graphs with handoffs. Our guide to agentic design patterns covers the patterns these models are built from.


What changed in agentic frameworks in the past year?

Consolidation, graph runtimes and batteries-included harnesses. Five shifts since autumn 2025 matter if you last compared frameworks a year ago.

  1. Microsoft merged its two projects. Microsoft Agent Framework reached 1.0 for .NET and Python in April 2026. Microsoft's own docs call it the direct successor to Semantic Kernel and AutoGen, built by the same teams, and publish migration guides from both.
  2. Google rebuilt ADK around graphs. ADK 2.0 adds a graph workflow runtime with routing, fan-out, loops, retry and human-in-the-loop. Google's October 2026 post, One Agent Development Kit, five languages, covers Python, Go, TypeScript, Java and Kotlin.
  3. LangGraph went stable. LangGraph 1.0 shipped on 22 October 2025 alongside LangChain 1.0, whose create_agent runs on LangGraph under the hood. The core graph API did not change.
  4. Harnesses arrived. Microsoft added a Harness Agent with planning, context compaction and memory. Strands ships a harness with benchmarked defaults, and Pydantic AI has a Harness of its own. OpenAI added sandbox agents that work in a container over long tasks. Vendors now ship a ready-made agent, not only a toolkit.
  5. MCP became table stakes; A2A is spreading. Every major framework in this guide connects to MCP tools in some form. Built-in A2A (agent-to-agent) support is now in ADK, Microsoft Agent Framework, Strands, Mastra and CrewAI.

Version numbers say something too. As of 13 November 2026, the OpenAI Agents SDK and the Claude Agent SDK are still below 1.0, while LangGraph, ADK, Microsoft Agent Framework, Pydantic AI, Mastra and Strands are on stable major lines.

FrameworkMakerRelease line, 13 Nov 2026
LangGraphLangChain1.2 (Python), 1.7 (JS)
OpenAI Agents SDKOpenAI0.24 (Python), 0.22 (JS)
Claude Agent SDKAnthropic0.2 (Python), 0.3 (TypeScript)
Google ADKGoogle2.14 (Python), 2.5 (TypeScript)
Microsoft Agent FrameworkMicrosoft1.26 (Python)
CrewAICrewAI1.15
LlamaIndex WorkflowsLlamaIndex2.26
Pydantic AIPydantic2.68
MastraMastra1.83 (core)
Strands AgentsAWS1.64 (Python), 1.24 (TypeScript)
smolagentsHugging Face1.26 (last release 29 May 2026)
GoGogotOur team (open source)Single Docker image

Versions come from PyPI and npm on the date above. Several of these projects publish a release almost every day, so check before you pin.


Agentic framework comparison: the big table

This table compares the twelve agentic AI frameworks on the eight things that decide a production build. "No A2A in core docs" means we found no built-in A2A support in the official documentation as of November 2026; a community package may still exist.

FrameworkOrchestrationLanguageState & durabilityMulti-agentMCP / A2AObservabilityLicenceBest fit
LangGraphGraphPython, TypeScriptCheckpointers, durable execution, human-in-the-loop, time travelAgents as nodes and subgraphsMCP via adapters; MCP and A2A endpoints on Agent Server (LangSmith deployment)LangSmithMITLong-running, auditable workflows
OpenAI Agents SDKHandoff, agents as toolsPython, TypeScriptSessions; sandbox agents keep workspace state; Temporal integration for durabilityHandoffs between agentsMCP; no A2A in core docsBuilt-in tracing, third-party processorsMITFew primitives, fast to production, voice
Claude Agent SDKCode-loop (Claude Code harness)Python, TypeScriptSessions you can resume or forkSubagentsMCP, including in-process servers; no A2A in core docsHooks at lifecycle pointsAnthropic Commercial Terms (Python package MIT)Agents that work on files, shells and code
Google ADKGraph workflows and agent hierarchiesPython, TypeScript, Go, Java, KotlinSession state; workflow runtime with retry and human-in-the-loopHierarchies, Task API delegationMCP client in every language; A2ADev UI, adk eval, Cloud Trace and partner toolsApache 2.0Polyglot teams, Google Cloud
Microsoft Agent FrameworkGraph workflows, plus sequential, concurrent, handoff and group patternsPython, .NET (Go in preview)Agent sessions, workflow checkpointing, Durable Task extensionWorkflow orchestration patternsMCP clients; A2A hostingOpenTelemetry, DevUIMIT.NET and Azure shops, SK and AutoGen users
CrewAIRole-crew plus event-driven FlowsPythonFlow state, checkpointingCrews of role-based agentsMCP and A2ATracing in CrewAI AMP (commercial)MIT (AMP is commercial)Business processes modeled as teams
LlamaIndex WorkflowsEvent-driven steps; AgentWorkflow handoffsPython (TypeScript workflow core)Pluggable durability: save and resume from a file or databaseAgentWorkflow with a root agentMCP via tools package; no A2A in core docsOpenTelemetry integrationMITDocument-heavy agents
Pydantic AITyped agent loop; Pydantic Graph for graphsPythonDurable execution on Temporal, DBOS, Prefect and othersDelegation and graphsMCP; no A2A in core docsOpenTelemetry-native, LogfireMITTyped Python services
MastraGraph workflows plus agentsTypeScriptSuspend and resume backed by storageAgents, workflows, remote A2A agents as subagentsMCP client and server; A2ABuilt-in tracing, evals, StudioApache 2.0 core; ee directories under enterprise licenceTypeScript and Next.js product teams
Strands AgentsModel-driven loop; agents as tools, swarm, graphPython, TypeScriptSessions and memory managersSwarm, graph, handoffsMCP; A2AOpenTelemetry traces and metrics, evalsApache 2.0AWS and Bedrock teams
smolagentsCode-loop (agent writes Python actions)PythonStep memory within a runManaged agent hierarchiesMCP tools; no A2A in core docsOpenTelemetry run inspectionApache 2.0Research and code-action prototypes
GoGogotSingle agent loopGoPersistent markdown memory; scheduler survives restartsSingle agent27 built-in toolsStructured events for model calls, tools and errorsMITSelf-hosted personal agent on a small VPS

For a deeper, code-level look at four of these, see our AG2 vs. CrewAI vs. LangGraph vs. OpenAI Agents SDK showdown. For the wider open-source field, including older projects such as AutoGPT and Haystack, compare open-source agent frameworks in our earlier roundup.


The best agentic AI frameworks in 2026, one by one

In our view, five frameworks are the safest starting points for most production teams: LangGraph, the OpenAI Agents SDK, the Claude Agent SDK, Google ADK and Microsoft Agent Framework. The ratings below are our editorial judgement of fit for a typical production team, based on the documentation and the comparison above. They are not benchmark results.

LangGraph: the graph standard

LangGraph is the default choice when a workflow must be explicit, resumable and auditable. You define a state graph; nodes are model calls, tools or whole sub-agents, and edges fix what can happen next. Checkpointers save state after each step, so a run can stop for a human approval and resume days later, or pick up after a crash.

The trade-off is design time. You draw the graph before you write the agent, and large graphs need discipline. Agent Server, the deployment product in LangSmith, adds MCP and A2A endpoints; those come with the deployment, not with the MIT library itself. Our LangGraph tutorial walks through a first multi-agent graph.

4.5/5.0

Pick it for processes you would otherwise draw as a flowchart: approvals, onboarding, claims, research pipelines with review steps.

Pros
  • Durable execution and human-in-the-loop are first-class
  • Python and TypeScript at 1.x
  • Model-agnostic; LangChain agents run on it
Cons
  • Most upfront design of any option here
  • Tracing and managed hosting live in LangSmith, a separate commercial product

OpenAI Agents SDK: the fewest concepts

The OpenAI Agents SDK is the quickest route from idea to a working multi-agent app. It has a short list of primitives: agents, tools, handoffs, guardrails, sessions and tracing. One agent hands the conversation to a specialist, and tracing, which is on by default, records each step.

It works with OpenAI's Responses and Chat Completions APIs and, through adapters such as LiteLLM, with more than 100 other models. Durable execution comes from outside: Temporal maintains an official integration that runs the agent loop inside a Temporal workflow. Our OpenAI Agents SDK guide has runnable examples.

4.5/5.0

Pick it for customer-facing triage, support routing and assistants where handoffs between specialists are the core pattern.

Pros
  • Small API, quick to learn
  • Sandbox agents for long tasks in a container
  • Voice and realtime agents in the same SDK
Cons
  • Still below 1.0 in November 2026
  • Durability depends on a separate engine such as Temporal

Claude Agent SDK: Claude Code as a library

The Claude Agent SDK gives you the same agent loop, tools and context management that power Claude Code, in Python and TypeScript. Out of the box the agent can read and edit files, run shell commands and search the web. You add hooks, subagents, permission rules and MCP servers, including tools defined in-process.

That makes it strong for agents whose work happens in a filesystem or a codebase. It is built for Claude models, and its licence differs from the rest of this list: use is governed by Anthropic's Commercial Terms, even though the Python package on PyPI is marked MIT.

4/5.0

Pick it for coding agents, data-wrangling agents and anything that needs a real working directory.

Pros
  • Production-grade tools for files, shells and code from day one
  • Sessions you can resume or fork
  • Subagents and hooks without extra glue
Cons
  • Built around Claude models
  • Commercial terms rather than an open-source licence

Google ADK: one kit, five languages

Google ADK is the most language-flexible agentic framework in this comparison. Python is the reference implementation, and Go, TypeScript, Java and Kotlin follow it. ADK 2.0 adds a graph workflow runtime next to its hierarchies of agents. A Task API handles structured delegation between them.

ADK is optimized for Gemini but model-agnostic, and Python ships adapters for Anthropic, OpenAI and LiteLLM. It ships an MCP client in every language and supports A2A, so agents written in different languages or frameworks can talk to each other over HTTP. It suits Google Cloud deployments best, with scaffolds for Cloud Run and GKE.

4/5.0

Pick it if your services are not all Python, or if you deploy on Google Cloud.

Pros
  • Python, TypeScript, Go, Java and Kotlin
  • Graph workflows plus agent hierarchies
  • A2A and MCP built in
Cons
  • Feature depth varies by language; Kotlin graphs are experimental
  • Deepest integrations assume Google Cloud

Microsoft Agent Framework: the merger

Microsoft Agent Framework is the successor to both Semantic Kernel and AutoGen, and the obvious pick for .NET teams. It combines AutoGen's agent abstractions with Semantic Kernel's sessions, middleware and telemetry. On top sit graph-based workflows with sequential, concurrent, handoff and group-collaboration patterns, plus checkpointing.

OpenTelemetry is built in, DevUI helps you debug, and agents can be declared in YAML. If you run Semantic Kernel or AutoGen code today, the migration guides are the place to start.

4/5.0

Pick it if you are a C# shop, run on Azure, or have existing Semantic Kernel or AutoGen code.

Pros
  • Python and .NET at 1.x, Go in preview
  • Workflows, checkpointing and OpenTelemetry built in
  • Clear migration path from SK and AutoGen
Cons
  • Smoothest on Azure and Foundry
  • Some surfaces, such as Go, are still in preview

The specialists

The other seven are strong in narrower lanes.

  • CrewAI models work as a crew of role-based agents with goals and tasks, and adds event-driven Flows when you need precise control. It reads naturally to non-engineers. The commercial AMP suite adds managed deployment and tracing. Our CrewAI vs. LangChain breakdown covers when roles beat graphs.
  • LlamaIndex Workflows is an event-driven engine where steps are async Python functions. It is at its best on document-heavy jobs such as parsing, extraction and review, next to LlamaParse.
  • Pydantic AI brings type safety to the agent loop and the longest list of durable engines in this comparison: nine, including Temporal, DBOS and Prefect. It fits teams that already use Pydantic and FastAPI.
  • Mastra is the TypeScript-first option, with graph workflows that read like code (.then(), .branch(), .parallel()), suspend-and-resume, memory, evals and A2A. Its core is Apache 2.0; code under ee/ directories needs an enterprise licence in production.
  • Strands Agents from AWS gives you an in-process loop with lifecycle controls, sessions, OpenTelemetry tracing and multi-agent swarms and graphs. Amazon Bedrock is its default provider, with Anthropic, OpenAI, Google and Ollama also supported.
  • smolagents from Hugging Face keeps the core logic to about 1,000 lines. Its CodeAgent writes actions as Python code, which you must run in a sandbox such as Docker, E2B or Modal. Its last release on PyPI was in May 2026, a slower pace than the rest.
  • GoGogot is our own open-source runtime and the minimal end of this list: one Go binary of about 10 MB, controlled through Telegram, with 27 built-in tools, a scheduler and persistent memory. It is a single agent loop, not a multi-agent framework.
Where AutoGen and Semantic Kernel went

Semantic Kernel still ships releases (1.47 in November 2026), while AutoGen's last release on PyPI was in September 2025. Microsoft calls Agent Framework the direct successor to both and publishes migration guides. If you are starting fresh in 2026, start there rather than on either predecessor.


Which agentic AI framework should you pick?

Choose by team profile, not by GitHub stars: your language, your cloud and the shape of the work narrow twelve options to two.

Your teamStart withRunner-upWhy
Python team, long-running processes with approvalsLangGraphPydantic AI + TemporalDurable state and human-in-the-loop are built in
Building on OpenAI models, wants few conceptsOpenAI Agents SDKLangGraphHandoffs, guardrails and tracing with minimal code
Building on Claude, agents that touch files or codeClaude Agent SDKPydantic AIClaude Code's tools and loop as a library
.NET, Azure, or existing SK/AutoGen codeMicrosoft Agent FrameworkLangGraphDirect successor, migration guides, C# support
Polyglot services or Google CloudGoogle ADKMicrosoft Agent FrameworkFive languages, A2A between them
TypeScript product teamMastraOpenAI Agents SDK (JS)TypeScript-first workflows, memory and evals
AWS and BedrockStrands AgentsLangGraphIn-process loop, Bedrock by default
Ops automation that maps to job rolesCrewAILangGraphCrews read like an org chart
Document-heavy pipelinesLlamaIndex WorkflowsPydantic AIEvent-driven steps next to document parsing
Research and prototypessmolagentsStrands AgentsSmall core, code-writing agents
Solo developer, self-hosted personal agentGoGogotsmolagentsOne Docker command, runs on a small VPS

Then run a short bake-off before you commit. Here is a process that fits in one working week.

1
Write the job down in one paragraph

Name the trigger, the tools, the output and who approves it. If you cannot describe the path, you need an agent; if you can draw it, you may need a graph or plain code.

2
Pick the orchestration model

Graph for fixed processes, handoff for routing, role-crew for team-shaped work, code-loop for open-ended tasks. This cuts the list in half.

3
Shortlist two frameworks

Filter by language, cloud and licence. Check that the licence matches how you will ship, especially for commercial products.

4
Build the same thin slice in both

One real task, end to end, with real tools. Keep prompts identical so you compare frameworks, not prompts.

5
Break it on purpose

Kill the process mid-run, deny a tool call, feed it a malformed result. See which one resumes, which one tells you what happened, and which one you can debug from the trace.

6
Price the exit

Prefer tools exposed over MCP and agents exposed over A2A, so a later switch moves the orchestration, not every integration.

For how coordination works once you have more than one agent, see our guide to coordinating multiple agents.


When you don't need an agentic framework at all

If one agent with a handful of tools can do the job, a plain loop over a model API is often the better design. Microsoft's own Agent Framework overview goes one step further and questions the agent itself: "If you can write a function to handle the task, do that instead of using an AI agent." Anthropic's guide makes the case for the loop: start with direct model API calls and the simplest design that works, and add complexity only when it pays for itself.

The core of every agentic framework is a loop you can write yourself:

def run_agent(task, tools, max_turns=20):
    messages = [{"role": "user", "content": task}]
    for _ in range(max_turns):
        reply = call_model(messages, tools=tools)     # any chat API with tool calling
        messages.append(reply)
        if not reply.tool_calls:
            return reply.text                         # the model says it is done
        for call in reply.tool_calls:
            result = tools[call.name](**call.args)    # your own plain functions
            messages.append(tool_result(call.id, result))
    raise RuntimeError("turn limit reached")

That sketch covers a surprising share of real agents: a research assistant, an inbox sorter, a nightly report. You can read every line, and there is no abstraction between you and the model.

You have outgrown the loop when one of these shows up:

  • Runs must survive a crash or a deploy. Rebuilding durable state by hand is where most homemade loops break.
  • A human must approve a step, possibly days later. Pausing and resuming cleanly is a framework job.
  • Several agents need different tools and permissions. Coordination, handoffs and isolation add up fast.
  • You need an audit trail. Traces of every model call and tool call, kept and searchable.
  • The work branches and joins. Parallel steps with fan-in are what graph runtimes exist for.
The framework is not the hard part

In our experience, agent projects stall more often on tools, evaluation and permissions than on orchestration. Whatever you pick, budget more time for the tools the agent calls and for testing its output than for the framework itself.

GoGogot shows how far a single loop goes: one agent, a scheduler, memory and built-in tools, in a small Go binary. It is a reasonable reference if you want to see a minimal runtime before you adopt a large one.


Build the Engine, or Hand Off the Work

Agentic AI frameworks are for teams that want to build and operate agents themselves. If that is you, and you want the minimal open version, GoGogot gets you a self-hosted agent in one Docker command: MIT-licensed, about $0.02 per session with DeepSeek, and your keys stay on your server.

If your team needs the reports, research and follow-ups done, rather than another framework to run, cowork.ink is the managed version of that same engine. You set up as many AI coworkers as you need, each with its own cloud machine with a browser, files and a code runtime. Tell a coworker what it is for, connect Slack or Telegram and give it the first task, which takes about three minutes. Finished work arrives on your schedule, and every run leaves a transcript you can check.

It costs $25 a month billed yearly, or $29 monthly, with every coworker, machine and model included and a 15-day money-back guarantee.

Frequently Asked Questions

What is an agentic AI framework?
An agentic AI framework is a library that runs the loop in which a language model plans, calls tools, reads the results and decides what to do next. It also handles the parts around that loop: state, retries, pauses for human approval, coordination between several agents and tracing of every step.
What is the best agentic AI framework in 2026?
There is no single best one. LangGraph is the common pick for long-running, auditable workflows, the OpenAI Agents SDK and Claude Agent SDK are the quickest routes on their own models, Microsoft Agent Framework fits .NET and Azure teams, and Google ADK fits polyglot teams. Match the orchestration model to the job first, then the language.
Is LangChain an agentic framework?
Yes. LangChain 1.0 gives you a ready-made agent loop through create_agent, and that loop runs on LangGraph, the lower-level agentic framework from the same company. Use LangChain for standard agents and LangGraph when you need custom control flow; our [LangGraph tutorial](/blog/langgraph-tutorial/) shows the second path.
Which agentic frameworks are open source?
LangGraph, the OpenAI Agents SDK, Microsoft Agent Framework, CrewAI, LlamaIndex Workflows and Pydantic AI are MIT-licensed. Google ADK, Strands Agents and smolagents use Apache 2.0, and Mastra's core does too. The Claude Agent SDK is governed by Anthropic's Commercial Terms. GoGogot is a minimal MIT-licensed agent runtime written in Go.
Do you need a framework to build an AI agent?
Not always. A single agent with a handful of tools fits in a short loop over any model API with tool calling. A framework starts paying for itself when runs must survive crashes, pause for human approval, or coordinate several agents with different permissions.
Home Blog Company