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 model | Who decides the next step | Typical frameworks | Good at | Watch out for |
|---|---|---|---|---|
| Graph | Edges you define in code; the model decides only at branch points | LangGraph, Google ADK 2.0, Microsoft Agent Framework workflows, Mastra workflows | Repeatable processes, audits, resuming after failure | More upfront design; graphs grow fast |
| Role-crew | A team of role-based agents with goals and tasks | CrewAI Crews | Business processes that map to job roles | Less control over each step and its cost |
| Handoff | The current agent passes control to a specialist | OpenAI Agents SDK, LlamaIndex AgentWorkflow, Strands swarm | Triage and routing, customer-facing flows | Hard to reason about long chains of handoffs |
| Code-loop | The model, turn by turn, inside one loop | Claude Agent SDK, Pydantic AI, smolagents, Strands, GoGogot | Open-ended tasks on files, code and the web | Needs 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.
- 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.
- 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.
- LangGraph went stable. LangGraph 1.0 shipped on 22 October 2025 alongside LangChain 1.0, whose
create_agentruns on LangGraph under the hood. The core graph API did not change. - 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.
- 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.
| Framework | Maker | Release line, 13 Nov 2026 |
|---|---|---|
| LangGraph | LangChain | 1.2 (Python), 1.7 (JS) |
| OpenAI Agents SDK | OpenAI | 0.24 (Python), 0.22 (JS) |
| Claude Agent SDK | Anthropic | 0.2 (Python), 0.3 (TypeScript) |
| Google ADK | 2.14 (Python), 2.5 (TypeScript) | |
| Microsoft Agent Framework | Microsoft | 1.26 (Python) |
| CrewAI | CrewAI | 1.15 |
| LlamaIndex Workflows | LlamaIndex | 2.26 |
| Pydantic AI | Pydantic | 2.68 |
| Mastra | Mastra | 1.83 (core) |
| Strands Agents | AWS | 1.64 (Python), 1.24 (TypeScript) |
| smolagents | Hugging Face | 1.26 (last release 29 May 2026) |
| GoGogot | Our 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.
| Framework | Orchestration | Language | State & durability | Multi-agent | MCP / A2A | Observability | Licence | Best fit |
|---|---|---|---|---|---|---|---|---|
| LangGraph | Graph | Python, TypeScript | Checkpointers, durable execution, human-in-the-loop, time travel | Agents as nodes and subgraphs | MCP via adapters; MCP and A2A endpoints on Agent Server (LangSmith deployment) | LangSmith | MIT | Long-running, auditable workflows |
| OpenAI Agents SDK | Handoff, agents as tools | Python, TypeScript | Sessions; sandbox agents keep workspace state; Temporal integration for durability | Handoffs between agents | MCP; no A2A in core docs | Built-in tracing, third-party processors | MIT | Few primitives, fast to production, voice |
| Claude Agent SDK | Code-loop (Claude Code harness) | Python, TypeScript | Sessions you can resume or fork | Subagents | MCP, including in-process servers; no A2A in core docs | Hooks at lifecycle points | Anthropic Commercial Terms (Python package MIT) | Agents that work on files, shells and code |
| Google ADK | Graph workflows and agent hierarchies | Python, TypeScript, Go, Java, Kotlin | Session state; workflow runtime with retry and human-in-the-loop | Hierarchies, Task API delegation | MCP client in every language; A2A | Dev UI, adk eval, Cloud Trace and partner tools | Apache 2.0 | Polyglot teams, Google Cloud |
| Microsoft Agent Framework | Graph workflows, plus sequential, concurrent, handoff and group patterns | Python, .NET (Go in preview) | Agent sessions, workflow checkpointing, Durable Task extension | Workflow orchestration patterns | MCP clients; A2A hosting | OpenTelemetry, DevUI | MIT | .NET and Azure shops, SK and AutoGen users |
| CrewAI | Role-crew plus event-driven Flows | Python | Flow state, checkpointing | Crews of role-based agents | MCP and A2A | Tracing in CrewAI AMP (commercial) | MIT (AMP is commercial) | Business processes modeled as teams |
| LlamaIndex Workflows | Event-driven steps; AgentWorkflow handoffs | Python (TypeScript workflow core) | Pluggable durability: save and resume from a file or database | AgentWorkflow with a root agent | MCP via tools package; no A2A in core docs | OpenTelemetry integration | MIT | Document-heavy agents |
| Pydantic AI | Typed agent loop; Pydantic Graph for graphs | Python | Durable execution on Temporal, DBOS, Prefect and others | Delegation and graphs | MCP; no A2A in core docs | OpenTelemetry-native, Logfire | MIT | Typed Python services |
| Mastra | Graph workflows plus agents | TypeScript | Suspend and resume backed by storage | Agents, workflows, remote A2A agents as subagents | MCP client and server; A2A | Built-in tracing, evals, Studio | Apache 2.0 core; ee directories under enterprise licence | TypeScript and Next.js product teams |
| Strands Agents | Model-driven loop; agents as tools, swarm, graph | Python, TypeScript | Sessions and memory managers | Swarm, graph, handoffs | MCP; A2A | OpenTelemetry traces and metrics, evals | Apache 2.0 | AWS and Bedrock teams |
| smolagents | Code-loop (agent writes Python actions) | Python | Step memory within a run | Managed agent hierarchies | MCP tools; no A2A in core docs | OpenTelemetry run inspection | Apache 2.0 | Research and code-action prototypes |
| GoGogot | Single agent loop | Go | Persistent markdown memory; scheduler survives restarts | Single agent | 27 built-in tools | Structured events for model calls, tools and errors | MIT | Self-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.
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.
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.
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.
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.
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 underee/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.
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 team | Start with | Runner-up | Why |
|---|---|---|---|
| Python team, long-running processes with approvals | LangGraph | Pydantic AI + Temporal | Durable state and human-in-the-loop are built in |
| Building on OpenAI models, wants few concepts | OpenAI Agents SDK | LangGraph | Handoffs, guardrails and tracing with minimal code |
| Building on Claude, agents that touch files or code | Claude Agent SDK | Pydantic AI | Claude Code's tools and loop as a library |
| .NET, Azure, or existing SK/AutoGen code | Microsoft Agent Framework | LangGraph | Direct successor, migration guides, C# support |
| Polyglot services or Google Cloud | Google ADK | Microsoft Agent Framework | Five languages, A2A between them |
| TypeScript product team | Mastra | OpenAI Agents SDK (JS) | TypeScript-first workflows, memory and evals |
| AWS and Bedrock | Strands Agents | LangGraph | In-process loop, Bedrock by default |
| Ops automation that maps to job roles | CrewAI | LangGraph | Crews read like an org chart |
| Document-heavy pipelines | LlamaIndex Workflows | Pydantic AI | Event-driven steps next to document parsing |
| Research and prototypes | smolagents | Strands Agents | Small core, code-writing agents |
| Solo developer, self-hosted personal agent | GoGogot | smolagents | One 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.
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.
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.
Filter by language, cloud and licence. Check that the licence matches how you will ship, especially for commercial products.
One real task, end to end, with real tools. Keep prompts identical so you compare frameworks, not prompts.
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.
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.
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.