The 9 best open-source AI agents in 2026

How I picked these, and the four jobs they actually do

I went straight to primary sources for every tool here: the GitHub repo (for the real license and star count), the official docs, the pricing page, and community threads on Hacker News where people talk about what actually broke. No aggregator "top 10" lists, because those are the same recycled paragraphs the AI you are already using would give you.

The thing most roundups miss is that these tools are not competitors in one race. They are answers to four different questions, and the fastest way to waste a quarter is to pick a multi-agent research framework when what you needed was a visual RAG builder. Here is the map I keep in my head.

A few criteria I weighed on every item:

• License, read literally. "Open source" gets stretched a lot. Some of these are true MIT or Apache-2.0; others are source-available with commercial conditions. I flag which is which, because it changes what you are allowed to ship.
• Who is actually behind it, and whether it is still actively developed. One famous name on this list is now in maintenance mode.
• The real cost model. Free license, yes, but what does running it in production actually cost you.
• Who it is for, in one honest line. Not everything is for everyone.

The best open-source AI agents in 2026 at a glance

Not sure which row is yours? This little picker walks the same four questions I use.

1. LangGraph, best for developers who want low-level control

LangGraph is the framework I reach for when I want to see and control everything the agent does. Built by LangChain, it models an agent as a graph: you define nodes (steps), edges (control flow), and a shared state object that moves between them. Instead of a black-box "agent" abstraction, you get primitives, which is exactly what you want when an agent has to behave predictably.

The standout features are the ones that matter in production: durable execution that resumes after failures, human-in-the-loop interrupts so you can inspect and approve mid-run, and a real persistence layer for short and long-term memory. It is used in production by Klarna, Replit, and Elastic, which is about as strong a signal as a framework gets.

• License: MIT, genuinely free. The framework carries no cost; only the optional hosted platform (LangSmith Deployment) is paid.
• Real cost: your LLM tokens, plus either self-hosting effort or a LangSmith bill for managed deployment.
• Watch-out: it is a framework, not a product. There is no helpdesk, no ticket UI, no knowledge-base wizard. You write Python or JS.

Our take: LangGraph is the pick for engineering teams that want maximum control and are happy to own the build. If you are a developer building something bespoke, start here. If you are a support lead who wanted "an AI that answers tickets," this is the deep end of the pool.

2. CrewAI, best for role-based multi-agent teams

CrewAI clicked for me the moment I stopped thinking about "an agent" and started thinking about a team. Its two primitives are Crews (role-based agents that delegate to each other, like a researcher plus a writer plus a critic) and Flows (event-driven, controlled workflows). Founded by João Moura, it has grown fast: ~55.8k GitHub stars and 100,000+ developers through its community courses.

Beyond the open-source core there is a commercial AMP / Enterprise control plane that adds tracing, RBAC, audit trails, and human-in-the-loop gates, plus a no-code Studio you can export to Python. CrewAI claims it is used by 63% of the Fortune 500, which I would take as a marketing figure rather than a verified one, but the traction is real either way.

• License: MIT for the framework; AMP / Enterprise is a separate paid layer.
• Real cost: free to build with, LLM tokens on top, and the Enterprise plane is quote-based.
• Watch-out: multi-agent setups can get chatty and expensive, and like every framework here, there is no ticketing or support UI out of the box.

Our take: CrewAI is the best fit if your problem genuinely decomposes into roles that hand work to each other. If your "team of agents" is really just one bot answering FAQs, you are over-engineering it.

3. Microsoft AutoGen, best for multi-agent research (but read the status note)

AutoGen from Microsoft Research is the framework that popularized the "conversable agent" pattern, where you define agents that talk to each other to solve a task. It brought us group chat orchestration, the no-code AutoGen Studio, and the Magentic-One generalist system. At ~59.9k stars, it was one of the most influential agent frameworks of the last two years.

Here is the part every other listicle forgets to tell you: AutoGen is now in maintenance mode. The README carries a banner (added April 2026) saying it will get no new features, and Microsoft now points new projects at the Microsoft Agent Framework, which merges AutoGen and Semantic Kernel into one production-ready successor with an official migration guide. One Hacker News commenter summed up the era well:

"Autogen from ms was an early attempt at this, and it was fun to play with it, but too early (the models themselves kinda crapped out after a few convos). This would work much better today with how long agents can stay on track."

NitpickLawyer, Hacker News

• License: MIT for the code; free and self-hosted, you pay only for the LLM.
• Real cost: LLM tokens (multi-agent chatter burns them fast), plus an eventual migration to the Agent Framework.
• Watch-out: building fresh on AutoGen in 2026 means adopting a frozen framework.

Our take: learn from AutoGen's patterns, but for a new build, start on the Microsoft Agent Framework instead. This entry is here because it shaped the whole category, not because I would greenfield on it today.

4. AutoGPT, best for no-code autonomous task automation

AutoGPT was the viral "autonomous GPT" of 2023, and it has since been rebuilt into a full platform with a very approachable idea: describe an outcome in plain English, and its AutoPilot interface builds, runs, and debugs the agent for you. With 186k GitHub stars, it is one of the most-starred AI repos anywhere.

There is also a visual block builder, an agents dashboard that tracks spend per run, a marketplace of community agents, and 45+ integrations including Gmail, Slack, Notion, and HubSpot. The README lists customer support ("draft replies, collect context, flag escalations") as one example use case, though it is one thing you could build, not the product's purpose.

• License: split. The modern Platform is Polyform Shield (free for internal use, not resellable as a competing service); classic AutoGPT is MIT.
• Real cost: self-hosting is free with your own model keys; the hosted platform is paid.
• Watch-out: it is a general automation builder. Support is a thing you could wire up, not a shipped helpdesk.

Our take: AutoGPT is the friendliest on-ramp to autonomous agents for non-developers. If you want to automate a grab-bag of internal tasks, it is a genuinely fun place to start.

5. OpenHands, best for autonomous coding tasks

OpenHands (formerly OpenDevin) is the open-source autonomous coding agent, built by All Hands AI. It writes code, runs shell commands, browses the web, and fixes bugs end-to-end inside a sandbox, and it can even drive other agents (Claude Code, Codex, Gemini) through a common protocol. At 81.4k stars it is one of the most active coding-agent projects going.

On the benchmark that matters for coding agents, All Hands' own OpenHands LM 32B model resolves 37.4% of SWE-bench Verified; pair it with a frontier model and the reported numbers climb well past that (though those figures vary by harness, so treat them as directional). The founder is refreshingly honest about the limits of autonomy:

"We quickly switched strategies--every PR is owned by a human being. You can still see which commits were done by OpenHands, but your face is on the PR, so you're responsible for it."

Robert Brennan, co-founder, Hacker News

• License: MIT for the core; the enterprise directory is source-available.
• Real cost: free to self-host with your own LLM key; OpenHands Cloud has a free tier plus an optional $20/month Pro subscription for managed compute.
• Watch-out: self-hosting means Docker sandboxing and security hardening, and high-autonomy runs on frontier models burn tokens quickly.

Our take: if your problem is code (resolving GitHub issues, fixing bugs, decomposing tickets), OpenHands is the best open-source agent on this list. That founder quote is also the single healthiest attitude toward AI autonomy I have seen: the agent drafts, a human owns it.

6. Dify, best for building a support or RAG bot visually

Dify is where this list starts touching customer support directly. It is an LLM app platform with a visual workflow canvas, a proper RAG / knowledge pipeline, and agent capabilities, and its docs explicitly name "customer support chatbots" grounded in your product docs as a top use case. It is one of the most-starred AI repos on GitHub at ~149.5k stars, with enterprise logos like Maersk, Adobe, and PayPal.

One thing to get right: Dify is not plain Apache-2.0. It ships under the Dify Open Source License, a modified Apache-2.0 with a multi-tenant restriction (you cannot resell it as your own multi-tenant SaaS without a commercial license) and a logo restriction. For internal use as a backend or dev platform, that is fine; for reselling, it is not.

• License: source-available (Apache-2.0 plus multi-tenant and logo conditions).
• Real cost: free to self-host via Docker, or paid Dify Cloud, plus your model spend.
• Watch-out: you are still assembling and hosting the bot yourself. There is no native Zendesk or Freshdesk helpdesk integration, no out-of-the-box ticket deflection or historical-ticket simulation.

Our take: Dify is the best open-source starting point if you specifically want to build a support or knowledge chatbot and have the team to run it. If you want that same outcome without the assembly, that is exactly the gap a managed AI support agent fills.

7. Flowise, best for low-code drag-and-drop agents

Flowise is the visual builder for people who want the LangChain power without writing the LangChain code. You wire nodes (models, tools, memory, retrievers) on a canvas across three modes: Assistant (beginner), Chatflow (single-agent), and Agentflow v2 (multi-agent orchestration). It is Apache-2.0, truly open source, with 54.8k stars and 100+ integrations including MCP support.

The notable 2025 news: Workday acquired Flowise in August. The core repo stays open source, but the standalone project's long-term direction is now a fair question to ask before you bet on it. Its community has always been a strength:

"Flowise currently has the largest active community (based on GitHub data)"

sdesol, Hacker News

• License: Apache-2.0, free to self-host, including air-gapped.
• Real cost: self-host free; Flowise Cloud is paid, but its pricing page sits behind a sign-in wall, so budget carefully and expect model costs on top.
• Watch-out: the visual canvas gets complex fast for large multi-agent flows, and it still assumes real RAG/LLM understanding despite the "low-code" label.

Our take: Flowise is the friendliest way to prototype an agent visually and self-host it for free. If you value a truly permissive license, it edges out Dify here.

8. n8n, best for wiring agents into your stack

n8n is a workflow automation platform with serious AI agent chops, and its edge is that it lives where all your other apps already are: 500+ integrations, plus the ability to drop into real JavaScript or Python anywhere in a flow. At ~196.6k stars and 4.7/5 on G2, it is one of the most popular automation tools period.

The value stories are concrete: Vodafone reports saving £2.2 million on security workflows, and Huel saved 1,000 hours of manual work. Pricing is unusual and worth understanding: n8n bills on full workflow executions, not per step or per user. Cloud plans run from Starter at $20/month (2.5k executions) to Business at $800/month, and the Community Edition is free to self-host.

• License: fair-code (Sustainable Use License), source-available rather than OSI open source. Self-hosting the Community Edition is free.
• Real cost: Cloud execution tiers or free self-host, plus your LLM spend for the AI nodes.
• Watch-out: it is an automation platform first, agents second. Great for connecting an agent to 500 apps; not a purpose-built conversational support product.

Our take: if your agent's real job is to touch a lot of other systems (CRM, email, databases), n8n is the pick. It is the connective tissue, not the brain.

9. Rasa, best for enterprise, on-prem conversational AI

Rasa is the veteran here, and the one built specifically for conversational agents in regulated, high-trust environments. Its CALM architecture puts your business logic (not a raw LLM) in control of what the agent does, which is why banks, insurers, and telcos, named customers include BNP Paribas Fortis, N26, and Swisscom, run it on-prem or air-gapped with full data control.

Get the license story right, because Rasa's reputation runs ahead of its current model. The classic RasaHQ/rasa SDK is Apache-2.0 (21.3k stars) but effectively legacy. The current product, Rasa Pro with CALM plus Rasa Studio, is a commercial, source-available platform. The free Developer Edition is capped at one bot and 1,000 external conversations per month, which makes it a prototype tier, not a free production tier, and everything above it is quote-gated.

• License: Apache-2.0 for the legacy SDK; Rasa Pro / Studio are commercial / source-available.
• Real cost: free Developer Edition for prototyping; Pro and Enterprise are sales-only, no public figures.
• Watch-out: heavier engineering lift than a hosted LLM agent, and the "open source" story has narrowed a lot.

Our take: if you are in a regulated industry and need on-prem or air-gapped conversational AI with source-level control, Rasa is still the serious answer. For everyone else, the engineering lift is hard to justify versus a hosted agent.

The real cost of "free"

Every tool above is "free," and every one of them still costs money to run. This is the trap I watch teams walk into: they see a $0 license and budget $0, then a quarter later they are paying for LLM tokens, cloud infrastructure, and, most of all, the engineering weeks it took to build and the ongoing time it takes to keep it working.

None of that makes open source a bad choice. It makes it a build choice. If you have engineers who want to own the whole stack, the total cost is worth the control you get. But if you are a support or ops team whose actual goal is "resolve more tickets, faster," you are signing up to build and maintain a product on the side, and the token bill from chatty multi-agent runs is a real line item nobody warns you about.

Try eesel for customer support

Here is the honest fork, because I would rather you pick the right tool than the one I work on.

If you want control and have the engineering appetite, build on one of the frameworks above. If your actual goal is "resolve customer tickets without standing up and babysitting an agent platform," that is what eesel AI is for. It is a managed AI support agent you brief in plain language, connect to your existing knowledge (past tickets, docs, help center), and plug into Zendesk, Freshdesk, or Slack in minutes, not months.

The one differentiator I would flag, because it is the thing every framework above leaves to you: before eesel answers a single live customer, it simulates the agent against your historical tickets so you can see the real resolution rate and cost before going live. That is how Gridwise reached 73% tier-1 resolution in month one. Pricing is pay-as-you-go per task, with no per-seat fees, so you are not paying for a platform you have to build first. It is free to try. Want a support agent live this week instead of next quarter? That is the whole idea.