Best AI Agent Frameworks (2026): Open-Source Options for Production

Quick picks

Every licence, release and feature below was checked on GitHub and in each project’s documentation on 6 October 2026.

What an agent framework gives you, and what it leaves to you

An agent framework packages the loop around a model: call the model, run the tools it asks for, feed results back, and stop. Most now add multi-agent patterns, memory and tracing on top. Our explainer on AI agent frameworks covers the concept. This page compares the main options.

The questions that separate frameworks for production are narrower:

• State. Can a run that waits for a person, or crashes halfway, resume where it stopped?
• Human-in-the-loop. Can a tool call be held for approval, and for how long?
• Tools. Does it speak the Model Context Protocol, and where are tool permissions decided?
• Tracing. Where do traces go by default, and can you send them to your own backend?
• Maturity. Is there a 1.0 release, and how often do breaking changes arrive?

AI agent frameworks compared

A dash means the documentation we read did not cover that capability; it is unconfirmed rather than missing.

Notes on each framework

LangGraph

LangGraph is a low-level orchestration library for long-running, stateful agents. Its README lists durable execution that resumes from the point of failure, human-in-the-loop interrupts that let you inspect and modify state mid-run, and both short-term working memory and long-term memory across sessions. It reached 1.0 on 17 October 2025 alongside LangChain 1.0. MCP support now lives in LangChain’s own langchain.mcp namespace; the separate adapters repository was archived in September 2026. Tracing and deployment are sold separately as LangSmith and LangSmith Deployment. For the trade-offs between LangGraph and CrewAI specifically, see our LangGraph and CrewAI comparison.

CrewAI

CrewAI is a standalone Python framework with two models: Crews, where role-based agents collaborate with some autonomy, and Flows, event-driven workflows for precise control that can call Crews. The README lists tools, memory, knowledge, checkpointing, async execution and MCP and A2A support, and tasks can include human review. It reached 1.0 on 20 October 2025. Telemetry is on by default and collects anonymous usage data such as versions, agent roles and tool names, never prompts or outputs unless you opt in with share_crew. Set CREWAI_DISABLE_TELEMETRY=true or OTEL_SDK_DISABLED=true in private networks. Managed deployment, tracing and governance are in the commercial CrewAI AMP suite, which also offers on-premises deployment.

Microsoft Agent Framework, and what happened to AutoGen

Microsoft Agent Framework reached 1.0 for Python and .NET on 2 April 2026, and a Go SDK is in public preview. Microsoft’s overview calls it the direct successor to AutoGen and Semantic Kernel, built by the same teams: AutoGen’s agent abstractions plus Semantic Kernel’s session state, middleware and telemetry, with graph-based workflows added. Workflows support sequential, concurrent, handoff and group patterns with checkpointing, streaming, human-in-the-loop and time travel, and OpenTelemetry is built in. Agents can use MCP servers and run on Foundry, Azure OpenAI, OpenAI, Anthropic, Ollama and other providers. AutoGen’s README now carries a maintenance-mode banner: no new features, community managed, migrate to Agent Framework. Semantic Kernel’s README points to Agent Framework as its successor as well.

OpenAI Agents SDK

OpenAI’s SDK is a lightweight framework in Python and TypeScript built around agents, handoffs, guardrails, sessions, human-in-the-loop, sandbox agents for long tasks, and voice. It is provider-agnostic, supporting OpenAI’s Responses and Chat Completions APIs and more than 100 other models. Two points matter for enterprises. It is still versioned below 1.0. And tracing is enabled by default, exporting traces to OpenAI’s backend; disable it with OPENAI_AGENTS_DISABLE_TRACING=1, or replace the default processors with your own. The documentation notes that tracing is unavailable to organisations using OpenAI’s APIs under Zero Data Retention.

Google ADK

Google’s Agent Development Kit is Apache 2.0 and available in Python, TypeScript, Go, Java and Kotlin, which makes it the broadest choice for multi-language organisations. ADK 2.0 for Python shipped on 19 May 2026 with a graph-based workflow runtime covering routing, fan-out and fan-in, loops, retries, state and human-in-the-loop, plus a Task API for structured delegation between agents. Tool calls can require explicit confirmation. It supports MCP tools and the A2A protocol, has an evaluation framework with user and environment simulation, and emits logs, metrics and traces. It is optimised for Gemini but model-agnostic, and deploys to any container platform as well as Google Cloud.

Pydantic AI

Pydantic AI is a typed Python agent framework from the Pydantic team, at version 2 since 23 June 2026. Its distinctive feature is durable execution on eight engines, including Temporal, DBOS and Prefect, so agents survive restarts and run for days on infrastructure you may already operate, with human-in-the-loop tool approval built in. MCP is part of the core, instrumentation is OpenTelemetry-native and works with any backend as well as Pydantic’s commercial Logfire, and Pydantic Evals tests agent behaviour. Models swap with a string, including local models through Ollama.

LlamaIndex Agent Workflows

LlamaIndex’s agent layer, now branded LlamaAgents, is built on Agent Workflows: an event-driven library where steps are async Python functions that emit and consume events, with branching, loops, parallel steps and persistence you can back with a file or a database. llama-agents-server wraps a workflow as a REST API with streaming, persistence and human-in-the-loop support. The project now positions itself for document-centric agents, which fits teams already using LlamaIndex for retrieval; our list of RAG frameworks covers that side.

smolagents

Hugging Face’s smolagents keeps the agent logic to about 1,000 lines. Its CodeAgent writes its actions as Python code rather than JSON tool calls, and that code can run in sandboxes on Blaxel, E2B, Modal or Docker. It is model-agnostic, from local Transformers and Ollama models to hosted providers through LiteLLM, and can load tools from MCP servers, LangChain or the Hugging Face Hub. The latest release is 1.26.0 from 29 May 2026, a slower pace than most of this list, although commits continued into late September.

Strands Agents

Strands Agents, Apache 2.0, is a model-driven agent loop in Python and TypeScript that runs in your process with no hosted control plane. Both SDKs now live in one monorepo, renamed harness-sdk, alongside a pre-assembled “Strands harness”; the old TypeScript repository is archived. MCP, streaming, multi-agent patterns and structured output are built in, interrupts pause a run for human input, and a session manager persists that state. Traces are OpenTelemetry spans that go only to an exporter you configure. It supports Bedrock, Anthropic, OpenAI, Gemini, Ollama and others.

Mastra

Mastra is the TypeScript-first option: agents, graph-based workflows with .then(), .branch() and .parallel(), conversation history and longer-term memory, RAG, evals and observability, plus model routing across more than 40 providers. Human-in-the-loop works by suspending an agent or workflow, storing its state and resuming when the input arrives, however long that takes. Mastra can also author MCP servers that expose agents and tools. Check the licence split: the core is Apache 2.0, while code in any ee/ directory is source-available under the Mastra Enterprise License and needs a licence for production use.

Also worth knowing

• Agno (Apache 2.0, Python, 3.1.1) pairs an SDK with the AgentOS runtime and a management UI, with JWT-based role-based access control.
• AG2 (Apache 2.0, 1.1.2) continues multi-agent work under its own name; its README notes that the classic autogen import name and agent classes moved to a separate “AG2 Classic” namespace.
• Vercel AI SDK (Apache 2.0) is a provider-agnostic TypeScript toolkit for AI applications and agents across Next.js, React, Svelte, Vue and Node.js.
• Claude Agent SDK for Python builds agents on Anthropic’s Claude models; its README states that use is governed by Anthropic’s Commercial Terms of Service, so check those terms alongside the repository licence.

What production-ready means for an agent framework

A demo needs a loop and a tool. A production agent needs these, and each framework covers a different subset:

1. Durable state. A run waiting two days for an approval must survive a deployment. LangGraph, Pydantic AI and Microsoft Agent Framework document this most fully.
2. Approvals with an audit trail. Pausing is not enough; you need a record of who approved what, on which evidence. Our explainer on human-in-the-loop oversight covers the patterns.
3. Tool permissions outside the prompt. MCP makes tools easy to connect, so decide where the allowlist lives. An MCP gateway keeps grants per role in a registry rather than in each agent’s code.
4. Traces you control. Know each default: OpenAI’s SDK exports traces to OpenAI, CrewAI sends anonymous telemetry, Strands sends nothing until you configure an exporter. Our LLM observability tools list compares the backends.
5. Sandboxed execution. Agents that write or run code need a container or micro-VM without production credentials.
6. Release discipline. Prefer 1.x APIs, pin versions, and read each changelog: several projects here renamed packages or moved repositories in 2026.

How to choose an AI agent framework

1. Start from the language your team ships. Python has the widest choice; .NET points to Microsoft Agent Framework; TypeScript to Mastra, or the TypeScript editions of the OpenAI, Google and Strands SDKs.
2. Match your cloud, but check the exits. ADK, Strands and Agent Framework each deploy most smoothly to their vendor’s cloud, yet all three run on any container platform and support local models.
3. Decide how much control flow you want to write. Graphs (LangGraph, ADK workflows, Agent Framework workflows, Mastra) make paths explicit; role-based crews and model-driven loops trade control for speed.
4. Prototype the hardest path, not the happy one. Force a crash mid-run, hold an approval overnight and revoke a tool, then see what each candidate does.
5. Price the layers the framework leaves out. Identity, permissions, audit, evaluation, deployment and on-call support all sit outside the library. Our breakdown of the costs of building on frameworks itemises them.

How VDF AI fits

A framework is the right tool when one team embeds an agent in its own product and wants full control of the code. A governed platform pays off when many teams need agents that touch sensitive systems, because the missing layers then have to be built once and shared, and audited.

VDF AI Networks provides that layer on a visual canvas with more than 14 node types, including Agent, Multi-Agent, Human Approval, Verification, MCP Action and Run Code nodes, the last running Python or JavaScript with configurable limits and secrets. Every run keeps a full execution trace of inputs, outputs, model routing decisions and their rationale, plus a provenance record of which agents, models and tools produced each output. Tools come through the MCP gateway’s admin-governed registry, where an agent inherits only the tools granted to its role and each call is audited.

Role-based access control is included on every plan. Networks deploys on your own infrastructure, in a sovereign cloud or fully air-gapped, with the orchestrator, model adapters, vector storage, knowledge vault and audit log sink inside your perimeter.

Sources

Verified 6 October 2026.

• LangGraph repository
• LangGraph releases
• LangChain MCP adapters, archived
• CrewAI repository
• CrewAI telemetry
• Microsoft Agent Framework repository
• Microsoft Agent Framework overview
• AutoGen repository
• Semantic Kernel repository
• OpenAI Agents SDK repository
• OpenAI Agents SDK for TypeScript
• OpenAI Agents SDK tracing
• Google ADK for Python
• Google ADK documentation
• Pydantic AI repository
• LlamaAgents and Agent Workflows repository
• smolagents repository
• Strands Agents repository
• Strands interrupts
• Strands observability and evaluation
• Mastra repository and licence
• Agno repository
• AG2 repository
• Vercel AI SDK repository
• Claude Agent SDK for Python