Best open source AI agents in 2026

Searching for the best open source AI agent in 2026 gets you a list that mixes very different software. A teammate you chat with, a Telegram gateway, a control center for coding agents, and a Python framework do not replace one another. This roundup sorts the open source AI agents you can run yourself into two groups, applications and libraries, then gives each project’s real license and the job it was built for. There is no benchmark here, and nothing is sorted by GitHub stars.

Every description below was checked against the project’s public repository or documentation on October 7, 2026. Where a README has since changed, trust the README over this page.

Apps vs libraries: how this roundup is organized

Group one is software you install and then use day to day: Krypton, OpenClaw, Hermes Agent, OpenHands, and Goose. All five can be self-hosted. Unless you point them at a local model, they still send requests to a model provider.

Group two is code: LangGraph and CrewAI. There is nothing to “log in” to. You write a program on top of the library, and you host that program yourself.

Dify gets its own section. It is often listed next to agent platforms, and its license is not plain Apache-2.0, so labeling it that way would be inaccurate.

Hosted products that publish no runnable source are left out. For those, see the open source alternatives hub, which compares several of them with Krypton.

Krypton: persistent AI teammates you self-host

Krypton is an Apache-2.0 open source platform for AI teammates that stick around. You deploy it from the published Docker images or from a source checkout. One shared API serves every client: the web app plus the Electron desktop and Expo mobile apps. A hosted option, Krypton Cloud, is in beta; its plans are on the pricing page.

Every bot keeps its own conversations, memory, routines, and history. A routine is plain Markdown you can read, and it can run on a schedule. Bots get a browser, a terminal, files, and a graphical desktop. Local Docker is the default computer; E2B, Daytona, CreateOS, and Boat are optional remote ones. Model credentials are yours to supply: OpenAI, Anthropic, Google, Vercel AI Gateway, any OpenAI-compatible endpoint, or a local server such as Ollama, LM Studio, llama.cpp, or MLX. Bots can each run on a different model.

You decide where a bot must stop and ask for approval. Every action goes into an audit log on your deployment. Postgres and the bots’ files stay on the machine you operate, while prompts still travel to whichever provider you picked.

Day to day, you just chat. A fresh bot interviews you, and you manage it inside that same conversation. Connectors for Slack, WhatsApp, Telegram, iMessage via Sendblue, and Feishu/Lark are optional add-ons.

Good fit: recurring operational work where the bot, its routine, and its approvals belong in one app, and running Docker is acceptable. Poor fit: you need a library inside a service you already have, or you want the agent to exist only in Discord without any Krypton app. Installation lives on the self-hosted AI agent page. For the nearest comparisons in shape, read the OpenClaw alternative and Hermes alternative pages.

OpenClaw: a self-hosted gateway for chat apps

OpenClaw is an MIT-licensed, self-hosted gateway that links chat apps to an assistant running on your own machine. According to the project, the OpenClaw Foundation is an independent 501(c)(3). The docs state that no hosted service sits in between and that the software has no paid tier.

Setup is the project’s install script, then onboarding, then a running Gateway. You can leave that process in a terminal or install it as a background service. Its configuration sits under ~/.openclaw. Documented channels include Discord, Google Chat, iMessage, Matrix, Microsoft Teams, Signal, Slack, Telegram, WhatsApp, Zalo, and more through plugins, along with a browser Control UI and mobile nodes.

The install docs we read recommend Node 26 and support Node 24.16+ or Node 26.1+; the installer can set Node up for you. Tool execution is not sandboxed by default. Once sandboxing is switched on, the documented backends include Docker, Podman, SSH, OpenShell, and Crabbox. Either way, the Gateway process itself runs on the host.

Good fit: you want the assistant to appear in the chat apps you already use, through a single gateway on hardware you control. It is a different product from a teammate interface. Our OpenClaw vs Hermes Agent vs Krypton comparison sets that model beside Krypton and Hermes without scoring a winner.

Hermes Agent: desktop and terminal agent from Nous Research

Hermes Agent is an MIT-licensed agent from Nous Research that you can run locally. The project also lists optional Nous Portal credits and cloud hosting.

It has two install paths, and they are worth keeping apart. The desktop app for macOS, Windows, and Linux shares ~/.hermes/ with the CLI. Per the desktop guide, first-run onboarding can get you to a first message within seconds, and picking a provider later skips provider setup entirely. The app launches its own local backend, so chatting there does not need the CLI.

The CLI quickstart goes: run the installer, then hermes setup (Quick Setup, Full Setup, or Blank Slate), then hermes model. Secrets live in ~/.hermes/.env, and all other settings in ~/.hermes/config.yaml. The quickstart requires a model with a context window of at least 64,000 tokens. Messaging platforms are configured with hermes gateway setup and run through a gateway that the desktop guide treats as its own process, apart from the backend the app starts.

Good fit: one person who wants a desktop or terminal agent, with config files they can open in their home directory, adding a gateway only if chat apps are needed. It does not replace a multi-user web app backed by a Postgres audit log. For the skills and memory features Hermes describes, go to its docs; we make no claims beyond them.

OpenHands Agent Canvas: control center for coding agents

OpenHands Agent Canvas presents itself as a self-hosted control center where developers run coding agents and automations. Its README says it runs the OpenHands agent plus other ACP-compatible agents, Claude Code and Codex among them, on local, remote, and cloud backends. The root LICENSE file in the GitHub repository is MIT.

The first quickstart option is a global npm install. It needs Node.js 24 or later and uv:

npm install -g @openhands/agent-canvas
agent-canvas

The README cautions that this route runs the agent server straight on the machine you install it on, with full access to your filesystem. Docker sandbox options are documented separately. The README adds that agents can optionally run on OpenHands Cloud or OpenHands Enterprise infrastructure. We do not cover the commercial terms of those hosted offerings here: the MIT license mentioned above is the repository license we fetched, not an assessment of each hosted plan.

Good fit: software development, meaning conversations with coding agents, automations, and switching between backends. It is built to steer that work; it is not meant as an all-purpose teammate that minds an inbox or runs scheduled operations routines. Treat the warning about the unsandboxed install as a real one.

Goose: general-purpose agent with MCP extensions

The Goose README presents a native open source AI agent with a desktop app, a CLI, and an API, for coding and for other kinds of work. The repository is aaif-goose/goose, and its license file is Apache-2.0. According to the README, Goose belongs to the Agentic AI Foundation at the Linux Foundation.

That README also claims support for 15+ providers (Anthropic, OpenAI, Google, Ollama, Azure, Bedrock, and others) and connections to 70+ extensions over the Model Context Protocol. Those figures are the project’s own; we did not measure them. (For comparison, Krypton bots can use custom MCP servers on any plan, and Krypton Cloud adds a hosted one-click MCP catalog.) The Goose desktop app is documented for macOS, Linux, and Windows, and the CLI installs from a script attached to the project’s stable release.

Good fit: a general agent on your own machine, used from a desktop app or a terminal, with a broad range of MCP extensions. It is neither a gateway meant to front many chat networks at once nor a library you drop into a service you already wrote.

LangGraph and CrewAI: agent frameworks, not apps

LangGraph is a low-level orchestration framework for stateful agents. The langchain-ai/langgraph repository is MIT-licensed. You use it by writing code that defines a graph, its state, and the model calls. Its README offers no chat app to install, and we say nothing here about LangSmith or any hosted pricing.

The CrewAI README describes an open-source Python framework that pairs high-level abstractions with low-level APIs for multi-agent workflows. The repository is MIT-licensed. The same README introduces CrewAI AMP Suite, a commercial control plane offering managed deployment, observability, governance, security, and enterprise support, either on-premise or in the cloud. The framework and AMP are separate products; installing the Python package does not sign you up for AMP.

Reach for either one when the agent is a feature of a product you are building and you want control over how it runs. Skip them if what you wanted was a working application by this afternoon: persistence, authentication, and an approval UI would all be yours to write.

Dify license caveat: modified Apache-2.0

Dify, made by LangGenius, regularly shows up in roundups of open source agent platforms. Its LICENSE is not Apache-2.0 on its own. Instead it is Apache-2.0 altered by extra conditions, and two of them deserve attention before you build on Dify.

First, the license forbids using Dify’s source to run a multi-tenant environment without written authorization from Dify, and it defines one tenant as one workspace. Second, if you use the frontend, you may not remove or change the logo or copyright information in the Dify console or applications. Uses that do not touch the frontend are exempt from that second rule. The license defines the frontend as the web/ directory, or the web image when running under Docker.

This is a brief warning, not a complete legal review. If Dify is on your shortlist, read the license file yourself, and do not treat it as the same grant as the Apache-2.0 that Krypton and Goose use.

How to pick an open source AI agent

Begin with the work you need done, not with where a project sits on a list.

• Long-lived bots with readable routines, approval stops, and an audit trail, on a server you run: choose Krypton. Install with Docker, then chat.
• One assistant inside the chat apps you already have: choose OpenClaw, and read its sandboxing docs before giving tools free rein. The Gateway is the product.
• A desktop or terminal agent configured from your home directory: choose Hermes, and add the messaging gateway only if you need it. You can start from either the desktop onboarding or the CLI quickstart.
• A control center for coding agents: choose OpenHands, and take the unsandboxed npm install seriously.
• A general desktop and CLI agent with lots of MCP extensions: choose Goose, keeping in mind that the provider and extension counts come from the project itself.
• An agent built into your own service: choose LangGraph or CrewAI, and expect to run and maintain the result yourself.
• Considering Dify: read the modified license before assuming you may resell a multi-tenant copy or rebrand the console.

Whatever you pick, run two checks. Read the actual license file, not a badge in some article (this one included). And find out where your prompts are sent: self-hosting the agent is not the same as self-hosting the model, so unless you choose a local model server, the provider still receives each prompt.

None of this claims that one project produces better results than another. These are different kinds of software, and the right one is whichever matches the shape of your work. If Krypton looks like that match, compare the hosted and self-hosted options or go straight to the install guide.