The best open source frameworks for building AI agents in 2026

TL;DR

• Ten open source agent frameworks compared: LangGraph, OpenAI Agents SDK, AutoGen, CrewAI, Google ADK, Dify, Mastra, Smolagents, Semantic Kernel, and Haystack
• LangGraph leads in enterprise adoption (34.5M monthly downloads), Dify leads in GitHub stars (144k)
• Smolagents (Hugging Face) is the fastest path to a single-agent loop; Semantic Kernel is the go-to for .NET/enterprise teams; Haystack is purpose-built for RAG pipelines
• Firecrawl's /agent endpoint handles web data collection for any framework
• 10 best practices from Anthropic, OpenAI, and McKinsey for deploying agents in production
• Comparison table and decision guide help you pick the right framework for your use case

According to Markets And Markets, the global agent market reached $7.84 billion in 2025 and is projected to hit $52.62 billion by 2030, at a CAGR of 46.3%. Gartner predicts that 40% of enterprise applications will feature task-specific AI agents by end of 2026, up from less than 5% in 2025.

Choosing the right framework to build those agents has become one of the more consequential decisions developers face. This article examines the ten most widely adopted open source agent frameworks in 2026: their technical features, adoption numbers, and the use cases each one is best suited for.

Enhance Your Agents: Combine agent frameworks with RAG systems for knowledge-augmented responses. Use web scraping libraries and browser automation tools for data collection.

Related Guides: For converting websites into agents, see our website to agent tutorial and website to LangGraph agent guide. For OpenAI-specific implementations, check OpenAI agent builders and Firecrawl. For a deep dive into AI agent architecture and the types of AI agents used in production, see our comprehensive guide.

To find the best agent frameworks, we used clear metrics and practical requirements. We gathered data from GitHub, PyPI downloads, documentation, and industry articles, looking for frameworks that can handle reasoning tasks, work together as multiple agents, and use tools effectively.

We evaluated each framework based on:

• GitHub metrics: Stars, active contributors, and regular updates
• Adoption: Monthly download numbers
• Technical features: Ability to reason, collaborate between agents, and use tools
• Documentation: Clear guides and tutorials for developers
• Real-world use: Proven cases in actual production environments
• Industry use: How they work across different sectors like finance and customer service
• Backing organizations: Support from established companies for ongoing development

The ten frameworks we selected show real value based on these criteria and provide solid options for developers building AI agents in 2026.

Here are the ten most effective open source frameworks for building AI agents in 2026, ranked by their proven success in real-world applications and developer adoption.

LangGraph is a specialized agent framework within the LangChain ecosystem. Released in 2024, it has over 33,900 GitHub stars and 34.5 million monthly downloads. It focuses on building controllable, stateful agents that maintain context throughout interactions. LangGraph integrates with LangSmith for monitoring agent performance.

Core capabilities:

• Stateful agent orchestration with streaming support
• Support for single-agent, multi-agent, hierarchical, and sequential control flows
• Long-term memory and human-in-the-loop workflows
• Integration with LangChain products like LangSmith

Around 400 companies now use LangGraph Platform to deploy agents in production, including Cisco, Uber, LinkedIn, BlackRock, and JPMorgan. Klarna's customer support bot handles two-thirds of all customer inquiries, doing the work of 853 employees and saving the company $60 million. AppFolio's Copilot Realm-X improved response accuracy by 2x, while Elastic uses it for AI-powered threat detection in SecOps tasks. For a step-by-step implementation, see our LangGraph agent tutorial.

A note on LangChain: LangGraph is built on top of LangChain, and developer opinions on LangChain are mixed. It's widely used as a starting point, but as projects grow in complexity, many teams find the abstraction layers work against them.

A Hacker News commenter put the trade-off clearly:

Newbies that want to play with LLMs don't know where to start or what the major building blocks even are... Going from total ignorance and confusion to now having a rough understanding of loading a prompt with chat history, using an embeddings database, calling a completions endpoint, etc. will make people feel accomplished. And then LangChain has earned some loyalty just because they were there for you first.

A Reddit user in r/LangChain echoed a common complaint:

Unnecessary complexity due to over abstraction which in turn impacts maintainability, customization and productivity. I've used it in my Open API for NotebookLM project but it's slowly becoming a pain.

LangChain is a reasonable place to start when you're learning how agents work. But as projects scale, many teams find it easier to reach for LangGraph directly (for stateful workflows) or drop the LangChain layer altogether in favor of frameworks with less indirection.

The OpenAI Agents SDK is a lightweight Python framework released in March 2025 with over 26,900 GitHub stars and 10.3 million monthly downloads. It focuses on creating multi-agent workflows with tracing and guardrails. The framework is provider-agnostic and compatible with over 100 LLMs.

Main features:

• Lightweight design for multi-agent workflows
• Comprehensive tracing and guardrails
• Provider-agnostic compatibility with 100+ LLMs
• Low learning curve for Python developers

The SDK has gained traction due to OpenAI's reputation and the framework's versatility. Its documentation provides clear tutorials and API references, and the low learning curve makes it accessible to any Python developer already working with OpenAI's API. For a practical application example, see Converting Websites into Agents with Firecrawl and OpenAI Agents SDK, which demonstrates how to transform web content into interactive knowledge agents.

AutoGen is a multi-agent conversation framework developed by Microsoft Research. Released in September 2023, it has grown to over 58,700 GitHub stars and 856,000 monthly downloads. AutoGen uses an event-driven architecture for complex interactions between AI agents and integrates with various LLMs while maintaining structured conversation flows.

Key features include:

• Multi-agent conversation framework with event-driven architecture
• Scalable workflows for complex collaborative tasks
• Extensive documentation with tutorials and migration guides
• Outperforms single-agent solutions on GAIA benchmarks

The framework has gained traction in data science and education sectors, with Novo Nordisk implementing it for data science workflows. In October 2025, Microsoft merged AutoGen with Semantic Kernel into the unified Microsoft Agent Framework, with GA targeted for end of Q1 2026. AutoGen itself is now in maintenance mode, receiving only bug fixes and security patches, though existing projects continue to work.

CrewAI orchestrates role-playing AI agents for collaborative tasks. Launched in early 2024, it has over 52,800 GitHub stars and 5.2 million monthly downloads. Independent from LangChain, CrewAI offers simpler implementation for developers who want to build multi-agent systems without complex dependencies.

Main features:

• Role-playing agent orchestration with defined responsibilities
• Independence from LangChain for simpler implementation
• Minimal code required for agent setup
• Popular in customer service and marketing sectors

CrewAI's straightforward approach has contributed to its rapid adoption. Streaming tool call events were added in January 2026, addressing the earlier limitation around real-time task performance. For a hands-on walkthrough, see our CrewAI multi-agent tutorial.

CrewAI is a favorite for high-level multi-agent orchestration precisely because the role-based design maps naturally to how people think about team workflows. The trade-off is that once you hit production complexity, the abstractions start working against you.

A developer comparing the two in r/AI_Agents put the friction clearly:

With CrewAI, it honestly feels like an immature framework right now: no proper out-of-the-box observability, you can't clearly see what prompts are actually being passed to the LLM, and once abstractions kick in, you start losing control. At my company, we're using CrewAI in production, and under the hood it's causing real trouble — architecture feels rigid and opaque, debugging is painful because engineers don't know what's being sent to the LLM.

That said, the same thread captures the flip side: LangGraph's control comes at a cost.

I found it harder to feel comfortable in LangGraph at the beginning. The entry barriers with CrewAI felt lower.

CrewAI is a reasonable choice for getting a multi-agent system running quickly, especially if the task fits neatly into defined roles. For production systems where you need full visibility into the agent-to-LLM boundary, LangGraph's explicit graph model gives you more to work with.

The Google Agent Dev Kit (ADK) was announced in April 2025 and has grown to 20,000 GitHub stars with 3.3 million monthly downloads. This modular framework integrates with the Google ecosystem, including Gemini and Vertex AI. It supports hierarchical agent compositions and custom tools.

ADK features:

• Modular framework with Google ecosystem integration
• Support for hierarchical agent compositions
• Custom tool development capabilities
• Efficient development requiring less than 100 lines of code

Google uses the ADK in their Agentspace platform and for customer engagement solutions. The framework has a moderate to steep learning curve due to Google Cloud integration, but comes with detailed documentation. It's well-suited for customer engagement applications and Google Cloud workflow automation. See our Google ADK tutorial for a practical implementation guide.

Dify is a low-code platform for creating AI agents with over 144,000 GitHub stars. Its visual interface makes it accessible to non-technical users while still offering capabilities for experienced developers. Dify supports hundreds of LLMs and includes RAG, Function Calling, and ReAct strategies.

Key capabilities:

• Low-code visual interface for agent development
• Built-in RAG, Function Calling, and ReAct strategies
• Support for hundreds of different LLMs
• TiDB's Serverless vector search for scalability

Dify is used across various sectors, from enterprises implementing LLM gateways to startups creating rapid prototypes. Its document generation and financial report analysis features make it valuable in business contexts.

Mastra is a TypeScript-first agent framework built by the team behind Gatsby (the React static site generator). It launched in August 2024 and hit version 1.0 in January 2026, pulling in over 1.77 million monthly NPM downloads since then. The framework is backed by Y Combinator and a $13M seed round from investors including Paul Graham and Guillermo Rauch. Where most agent frameworks on this list target Python developers, Mastra fills the gap for JavaScript and TypeScript teams who want to build agents without switching ecosystems.

Main features:

• Workflows run as graphs with .then(), .branch(), and .parallel() primitives, and they can suspend/resume for human-in-the-loop patterns
• Any agent can become a routing agent through the .network() method, delegating tasks to sub-agents and tools
• The memory system has four tiers: message history, working memory, semantic recall, and RAG
• Works with 81 LLM providers and 2,436+ models through the Vercel AI SDK
• Ships with a local dev playground in the browser for testing agents, visualizing workflow graphs, and running evaluations

Mastra has picked up real production traction. Replit uses it in Agent 3 (their AI coding assistant that spins up isolated Docker sandboxes to write and test code), where it improved task success rates from 80% to 96% across thousands of daily sessions. Marsh McLennan deployed a Mastra-based search tool to 75,000 employees, and SoftBank built their Satto Workspace platform on it.

The main trade-off is that it's TypeScript-only, so Python-heavy ML teams won't be able to adopt it. Its integration ecosystem is also still growing compared to more established frameworks like LangGraph. For a practical Mastra tutorial that builds a changelog tracker with Firecrawl tools, see the step-by-step walkthrough.

Smolagents is Hugging Face's take on what an agent framework should look like at its simplest. Released in January 2025, it has grown to over 27,700 GitHub stars. Rather than building elaborate prompt chains or orchestration graphs, smolagents has the LLM write Python code to complete tasks. Each reasoning step produces executable code that runs in a sandboxed environment, replacing the need for JSON function calls and complex tool-use scaffolding.

Core capabilities:

• Code-first "CodeAgent" loop where the LLM writes Python to invoke tools
• Minimal setup requiring fewer than 50 lines of configuration
• Works with Hugging Face models, OpenAI, Anthropic, Mistral, and any OpenAI-compatible endpoint
• Built-in sandboxed code execution for security
• ToolCallingAgent variant for teams that prefer standard JSON function calling

Smolagents shines for single-agent automation scripts, data extraction workflows, and research tasks where you want the model to have direct access to Python libraries. It is not designed for complex multi-agent orchestration or enterprise state management, but it is the fastest path from zero to a working agent loop. Hugging Face actively maintains it and ships updates frequently.

Semantic Kernel is Microsoft's enterprise-oriented agent framework and the only one on this list with first-class support for C#, Python, and Java. Released originally for .NET teams, it organizes AI capabilities as "skills," which are a mix of AI prompts and regular code functions that a Planner component chains into multi-step workflows. Semantic Kernel integrates deeply with Azure OpenAI Service and is the primary choice for organizations embedding AI into existing enterprise infrastructure.

Key features:

• Multi-language SDK: C#, Python, and Java
• Deep Azure OpenAI Service and Microsoft 365 integration
• Skill-based architecture that combines AI prompts with traditional code functions
• Enterprise security, compliance, and access control tooling
• Being merged with AutoGen into the unified Microsoft Agent Framework, with GA targeted for mid-2026

Semantic Kernel's strength is adding AI to existing enterprise systems without rearchitecting them. .NET teams can wrap existing business logic as skills and let the Planner decide when to call them. The trade-off is a steeper initial learning curve than Python-first frameworks, and the ongoing merger with AutoGen means the long-term API is still stabilizing for teams starting greenfield projects.

Haystack by deepset is the most RAG-native framework on this list. Where other frameworks treat retrieval-augmented generation as one feature among many, Haystack builds everything around it. The pipeline abstraction lets you compose components (document stores, embedders, retrievers, readers, and generators) into end-to-end graphs that process text at scale. Haystack has been in production since 2020 and supports Elasticsearch, Weaviate, Pinecone, Qdrant, OpenSearch, and most other vector databases.

Key capabilities:

• Pipeline-based architecture for composing NLP components end to end
• First-class connectors for all major document stores and vector databases
• Built-in tools for PDF ingestion, chunking, embedding, and hybrid search
• Supports multiple LLMs as generators, including open source models via Hugging Face
• Haystack 2.x introduced a more composable API with typed connections between components

Haystack is the right choice when your agent's primary job is searching, retrieving, and synthesizing information from large document collections: internal knowledge bases, legal search, technical documentation assistants, or financial report analysis. For general-purpose agents that need RAG as one capability among many, the other frameworks handle it adequately. But for document-first workloads, Haystack's purpose-built pipeline tooling reduces the amount of custom code required significantly.

Developers who have compared it directly to alternatives tend to land in the same place. A developer who tested LangChain, LlamaIndex, and Haystack summarized the split:

Choose LangChain if you need flexible integration with multiple tools and services. LlamaIndex is great for complex data ingestion and indexing needs. Haystack is ideal for production-ready, scalable implementations.

Others in a LangChain vs. Haystack discussion echoed the same strengths, but from different angles:

Haystack is simple, easy to understand and extend with your custom functionality. It's basically a pipeline orchestrator — I would say it's on a much lower abstraction level than LangChain.

Haystack feels more production-ready for search-heavy workflows, great modularity and a clean pipeline system.

The recurring theme is that Haystack's lower abstraction level is a feature, not a limitation: you see what the pipeline is doing, you can extend any component, and search-heavy workloads map cleanly onto its primitives.

* Dify is distributed via Docker; PyPI download numbers not available

** Semantic Kernel ships across NuGet (C#), PyPI (Python), and Maven (Java); combined download numbers are not published

The comparison table gives you the data. Here are the decision variables that actually matter:

Start with language. If you're building in TypeScript, Mastra is the only real option designed for it. For C# or Java, Semantic Kernel is your anchor. Every other framework on this list assumes Python.

Single agent vs. multi-agent. For a single-agent loop without heavy orchestration overhead, Smolagents is the fastest setup. For multi-agent systems with defined roles, CrewAI requires the least boilerplate. For multi-agent systems with complex branching and error handling, LangGraph gives you the most control.

Ecosystem lock-in. The OpenAI Agents SDK integrates tightly with OpenAI's hosted tools (file search, web search, computer use) but ties you to one provider. Google ADK gives you the same tight integration for Gemini and Vertex AI. LangGraph, CrewAI, Haystack, Smolagents, and Semantic Kernel are all provider-agnostic.

Primary data source. If your agent's job is processing large document collections (internal knowledge bases, legal search, financial reports), Haystack's pipeline architecture handles chunking, embedding, and retrieval as first-class operations. For live web data, Firecrawl's /agent endpoint handles that for any framework.

Enterprise constraints. .NET teams with existing infrastructure should evaluate Semantic Kernel. Teams that need human-in-the-loop approval steps should look at LangGraph, which has the most mature support for suspend/resume workflows. Teams that need observable agents with built-in tracing should look at Mastra (native OpenTelemetry) or pair any framework with an observability layer.

Visual development. Dify is the only framework on this list with a GUI workflow builder. If your team includes non-engineers who need to build or modify agent workflows directly, that's a meaningful differentiator.

OpenAI, Anthropic, and McKinsey have each published detailed guidance on deploying agents in production. Here are 10 tangible best practices distilled from those guides, applicable to any of the frameworks above — see the agentic AI adoption landscape for broader context:

1. Select the appropriate agent type for your specific use case. Carefully evaluate whether you need copilot agents for individual productivity, workflow automation platforms, domain-specific agents, or AI virtual workers.

2. Deploy agent systems rather than isolated agents. Complex tasks benefit from specialized sub-agents working in coordination where manager agents break down workflows and assign subtasks.

3. Implement the four-step agent workflow: user task assignment, planning and work allocation, iterative output improvement, and action execution.

4. Build constructive feedback loops where agents can review and refine their work before final delivery, improving output quality.

5. Implement collaborative review processes by designing specialist "critic" agents that can review the work of "creator" agents and request iterations.

6. Prioritize accuracy verification with architectures that check for errors or hallucinations before sharing responses with users.

7. Center human values in ethical decisions, ensuring they're rooted in organizational and societal values that place humans at the center of the AI ecosystem.

8. Use agents for unpredictable situations where rule-based systems would fail, leveraging their foundation in large, unstructured data sets.

9. Set clear performance metrics to assess agent impact, such as issue resolution rates, handling time, and productivity improvements.

10. Anticipate value beyond automation by looking at broader benefits like process reimagining and IT infrastructure modernization.

If you want to go deeper on any of these practices, the original guides are worth reading in full:

1. Best practices for Claude Code
2. McKinsey & Company: What Is an AI Agent?
3. OpenAI: A Practical Guide to Building Agents

Firecrawl is the web data stack built for AI agents: one API family covering Search, Scrape, Parse, Crawl, Map, and Interact. The workflow is Find → Extract → Clean → Use. Search finds fresh sources from the live web and returns full page content, not just links. Scrape and Parse turn those sources into clean, token-efficient Markdown or structured data. Interact handles dynamic pages, clicks, logins, and forms in a real browser. Crawl and Map provide depth across entire sites. Every surface connects to any framework on this list through the Python and TypeScript SDKs.

Search is the entry point for most agentic web search workflows. One call returns full page content alongside the URL, so agents can find sources and extract them without a second round-trip:

from firecrawl import Firecrawl
 
app = Firecrawl(api_key="fc-YOUR-API-KEY")
 
# Search and scrape full page content in one call
results = app.search(
    "YC W22 consumer startups",
    limit=5,
    scrape_options={"formats": ["markdown"]},
)
for r in results.web or []:
    print(r.url)
    print(r.markdown[:400])  # clean, token-efficient Markdown

Scrape works on the real web: JS-heavy pages, SPAs, anti-bot systems, and geo-sensitive content. Parse handles PDFs and documents. Interact is the browser primitive for pages Scrape cannot reach — clicks, form fills, logins, and dynamic interactions:

# Interact: cloud browser session for dynamic pages
session = app.browser()
 
result = app.browser_execute(
    session.id,
    code='await page.goto("https://news.ycombinator.com")\ntitle = await page.title()\nprint(title)',
    language="python"
)
print(result.result)  # "Hacker News"
app.delete_browser(session.id)

Crawl extracts content from every page of a site. Map generates a full URL inventory in one call. The LLMs.txt API converts sites to clean text for LLMs.

For teams in Claude Code, Cursor, or Antigravity, the MCP server and CLI bring Search, Scrape, and Interact into agent workflows with no extra setup. No-code access is available through n8n, Make, and Zapier. See the Firecrawl documentation for the full API reference.

The ten frameworks discussed in this article represent the most capable open source solutions available in 2026, each targeting a distinct set of requirements. LangGraph handles enterprise state management, CrewAI makes multi-agent role-playing fast to set up, Smolagents minimizes overhead for single-agent loops, Semantic Kernel brings AI to .NET environments, and Haystack is purpose-built for RAG and document processing. Organizations should match their specific constraints (language, team size, data sources, and orchestration complexity) against the framework's actual strengths rather than defaulting to whichever has the most GitHub stars. The "how to choose" section and comparison table above are the fastest path to a defensible decision. Implementing the best practices outlined above will help teams maximize value while staying in control of their agent systems.

• Integrate with MCP servers for development environment enhancements
• Understand the agent harness infrastructure that keeps long-running agents from losing state mid-task
• Explore the best MCP servers for developers across Claude Code, Cursor, Figma, and E2B
• Access models like GLM-4.5 for advanced reasoning
• Explore n8n workflow templates for automation patterns
• Build visual workflows with our LangFlow tutorial
• Learn the API integration patterns for AI agents — from direct REST calls and function calling to MCP gateways and A2A protocol
• Scaffold a complete web research agent project with the open-source firecrawl-agent stack — bring your own model and deploy to your own infrastructure