Best open-source AI agents in 2026 (that actually work)

Short answer: the best open-source AI agents in 2026 are OpenCode and goose for coding with any model, Cline for an approval-gated coding agent in your editor, OpenHands for running several coding agents from one control center, Hermes Agent for an always-on personal agent you reach from chat apps, browser-use for web browsing, and Buzz for agents that work inside your team chat. Eleven of the 12 below ship under MIT or Apache 2.0. Suna is source-available, not open source.

Open-source AI agents stopped being a research curiosity somewhere around mid-2026. Jack Dorsey's Block shipped a workspace where agents sit in the same channel as your team. A two-person research team's browser agent passed 100,000 GitHub stars. And a wave of self-hosted coding agents now do the job that used to require a subscription and an API key you didn't control.

The catch: "open source" gets stretched to cover a lot of things this year, from a fully MIT-licensed project you can fork and ship, to a "source-available" release with a license that quietly blocks you from competing with the vendor's own hosted product. If you're deciding what to actually run, that distinction matters more than the star count.

This guide covers twelve AI agents that are real, currently maintained, and verifiable on GitHub today. Eleven ship under an OSI-approved open-source license (MIT or Apache 2.0). One, Suna, is source-available, and we say so in its entry. For each we cover what it is actually for, where the license has strings attached, and how to think about picking one over building your own. This post is about finished agents you install and run. For the framework layer underneath them, see our breakdown of the best open-source AI agent frameworks, and for coordinating several agents in code, the best multi-agent frameworks.

How we picked and checked these agents

Every entry had to pass three checks. We opened the LICENSE file in its GitHub repository and named the license exactly, calling it open source only when the license is OSI-approved. The project had to ship a release in September 2026. And it had to be a finished agent you install and run, not a framework you build on. The order is editorial, not a star ranking: agents that cover a distinct job (team coordination, multi-agent control, a general assistant) come before agents that repeat an earlier entry's job with less adoption, which is why high-star vendor CLIs such as Codex CLI and Gemini CLI sit lower. Licenses, stars and release dates were checked on 2026-09-26. Evidence tier: maker docs, READMEs and LICENSE files. No hands-on testing is claimed.

Best open-source AI agents: a brief overview

• Buzz: Best for making AI agents real members of your team chat and codebase, not just a bot you ping.
• goose: Best for a self-hosted coding agent that works with any model, including local ones.
• OpenHands: Best for running several coding agents from one self-hosted control center.
• OpenCode: Best for a terminal coding agent that works with 75+ model providers.
• Hermes Agent: Best for an always-on personal agent you reach from Telegram, Slack or Discord.
• Suna (Kortix): Best for a generalist agent that browses, writes files, and runs commands from plain instructions, source-available rather than fully open source.
• browser-use: Best for giving any agent the ability to actually operate a web browser.
• Open Interpreter: Best for a lightweight agent harness tuned to get strong results out of cheap models.
• Cline: Best for an approval-gated coding agent inside VS Code, the terminal, or a desktop app.
• Codex CLI: Best for running OpenAI's coding agent locally on a ChatGPT plan you already pay for.
• Gemini CLI: Best for a free-tier terminal agent built around Gemini models.
• Cindy: Best for one local agent that carries your existing Claude Code or Codex subscription across every app on your machine.

1. Buzz, best for making AI agents real team members

Buzz is Block's open-source answer to a problem every team running agents eventually hits: your agents live in a different system than your humans do. Chat is in Slack, code review is in GitHub, and the agent's output shows up as a pull request nobody in the channel actually saw get built. Buzz collapses all three into one workspace built on the Nostr protocol, where every message, commit, and workflow step is a signed event in a single log, and every participant, human or agent, has its own cryptographic identity and permission set.

Because agents show up as members rather than as a bolted-on integration, you can watch one work in real time, in the same channel your team already uses, with an audit trail that shows exactly which identity did what. It's early: mobile apps and approval gates are still in development, and the desktop client is the primary way in today. For teams that are past the "one developer with an agent on their laptop" stage and into "several agents touching shared systems," Buzz is worth a serious look before you improvise your own version of this with webhooks and a spreadsheet. See our guide to using Buzz for setup and how agents actually join a channel.

Key features

• Every human and agent gets its own cryptographic identity and permission scope
• Chat, code review, and Git events live in one signed, auditable log
• Self-hostable Nostr relay, written in Rust, or use the free desktop app
• Agents participate as channel members, not as a separate bot integration

Best for

• Teams already running more than one agent that need a shared, auditable workspace
• Engineering teams tired of losing context at the handoff between chat, code, and CI
• Organizations that want a permission model for agents instead of one shared API key

Pricing

• Free and open-source under Apache 2.0
• Self-hosted: your own infrastructure costs only
• Desktop app free for macOS, Windows, and Linux

Pros

• Solves a real coordination problem instead of adding another chat integration
• Cryptographic identity per agent makes accountability and permissioning concrete
• Backed by Block, with active development and a real roadmap

Cons

• Genuinely early: mobile apps, richer approval gates, and voice features are still coming
• Self-hosting the relay is the most capable path, and that means running your own infrastructure
• The ecosystem of pre-built agent integrations is still forming

---

2. goose, best for a self-hosted coding agent that works with any model

goose started at Block and was donated to the Linux Foundation's Agentic AI Foundation in 2026, and it has grown into one of the most widely used open-source coding agents on GitHub. The design goal is straightforward: an agent that goes beyond code suggestions and actually installs dependencies, edits files, runs tests, and debugs failures, without locking you into one model vendor.

That model independence is the reason teams reach for goose over a closed alternative. It supports 15+ LLM providers, including local models through Ollama, so you can run an entirely offline setup with no API key and no data leaving your machine if that's a requirement. Extensions ship through the Model Context Protocol, and with 70+ available, most tools a coding agent needs to touch (databases, browsers, ticketing systems) already have one. It runs as a CLI, a desktop GUI, or an API, so it fits into a terminal-first workflow or a more structured internal tool.

Key features

• Works with 15+ LLM providers, including fully local models via Ollama
• 70+ Model Context Protocol extensions for tools and data sources
• CLI, desktop app, and API, all built in Rust
• Can install, execute, edit, and test code autonomously, not just suggest it

Best for

• Engineering teams that want a coding agent without committing to one model vendor
• Developers who need a fully offline option for sensitive codebases
• Teams building AI agent development workflows on infrastructure they already control

Pricing

• Free and open-source under Apache 2.0
• No usage fees when self-hosted; you pay only for whichever model provider you connect

Pros

• Provider flexibility means you are not rebuilding your agent stack when a model vendor changes pricing
• Large, active community: 50,000+ stars and daily development activity
• Local-model support makes a genuinely offline agent workflow realistic

Cons

• Rust-based extension development has a steeper learning curve than a pure-Python stack
• Desktop GUI is newer than the CLI and less battle-tested for complex workflows
• No built-in multi-agent orchestration; that's a separate layer you add yourself

---

3. OpenHands, best for running multiple coding agents from one control center

OpenHands takes a different angle than a single-agent tool: it's a self-hosted control center for running coding agents, including OpenHands' own agent, Claude Code, Codex, Gemini, or anything that speaks the Agent Client Protocol, across local, remote, and cloud backends. Instead of picking one agent and living inside its interface, you get a layer that manages several at once and wires them into the tools your team already uses.

That control-center framing is what makes OpenHands useful past the individual-developer stage. It supports automations tied to Slack, GitHub, and Notion, so an agent run can be triggered by an actual event in your existing stack rather than a manual prompt. For a team standardizing how multiple engineers use multiple agents, that's a materially different problem than "does this one agent write good code," and it's the one OpenHands is built to solve.

Key features

• Runs multiple agent types (its own agent, Claude Code, Codex, Gemini, ACP-compatible agents) from one interface
• Automations that connect to Slack, GitHub, and Notion
• Works across local, remote, and cloud backends
• Self-hosted developer control center rather than a single-agent tool

Best for

• Teams standardizing agent usage across multiple engineers and multiple agent types
• Organizations that need agent runs triggered by real events, not manual prompts
• Teams evaluating custom workflow automation before building an internal agent platform from scratch

Pricing

• Free and open-source under MIT license
• Self-hosted with no usage fees beyond your own infrastructure and model costs

Pros

• One of the largest open-source agent communities on GitHub, with 80,000+ stars
• Genuinely multi-agent and multi-backend rather than tied to a single model or vendor
• Built-in automation hooks reduce the custom glue code most teams end up writing anyway

Cons

• More moving parts to configure than a single-agent CLI tool
• Self-hosting a control center is a bigger operational commitment than running one agent locally
• Best suited to coding and engineering workflows, not general business task automation

---

4. OpenCode, best for a terminal coding agent that works with 75+ model providers

OpenCode calls itself "the open source AI coding agent", and on GitHub it backs that up: 210,209 stars when we checked on 2026-09-26, MIT license, and a release on 2026-09-21. The repository now lives at anomalyco/opencode. It is a terminal-first agent with a full text interface, plus a desktop app that the project itself still labels beta.

The detail that sets it apart from most terminal agents is the built-in split between two agents you switch with the Tab key. The "build" agent has full access for development work. The "plan" agent is read-only: it denies file edits by default and asks before running bash commands, which makes it a safe way to explore an unfamiliar codebase before you let anything change. Its docs say it uses the AI SDK and Models.dev to support 75+ LLM providers, and it can run local models through Ollama, LM Studio or llama.cpp.

Key features

• Two built-in agents: full-access "build" and read-only "plan", switched with Tab
• A "general" subagent for complex searches and multistep tasks, called with @general
• 75+ LLM providers per its docs, including local models through Ollama and LM Studio
• Installs through npm, Homebrew, Scoop, Chocolatey, pacman, mise or Nix

Best for

• Terminal-first developers who want to swap model providers without swapping tools
• Teams that want a read-only planning pass before an agent touches files
• Anyone standardizing on an MIT-licensed coding agent they can fork

Pricing

• Free and open-source under the MIT license
• You pay only for the model provider you connect, or nothing for local models

Pros

• The largest coding-agent community on this list by GitHub stars
• Read-only plan mode gives you a safer default for exploration
• Wide provider support keeps you out of single-vendor lock-in

Cons

• The desktop app is marked beta in the project's own README, so the terminal is the mature path
• A terminal interface is a harder sell for teammates who live in an IDE
• Skip it if you want agents coordinating across a team; OpenHands or Buzz fit that better

---

5. Hermes Agent, best for an always-on personal agent you reach from chat apps

Hermes Agent comes from Nous Research and is the most-starred repository on this list: 249,199 stars on 2026-09-26, MIT license, with release v2026.9.24 two days before we checked. It is a general agent, not a coding tool. Nous describes it as "the self-improving AI agent": it writes skills from completed tasks, improves them during use, keeps agent-curated memory, and searches its own past conversations.

The practical difference is where it lives. One gateway process connects it to Telegram, Discord, Slack, WhatsApp, Signal and the CLI, so you can message it from your phone while it works on a cloud machine. A built-in cron scheduler runs natural-language jobs such as daily reports unattended. It supports seven terminal backends (local, Docker, SSH, Singularity, Modal, Daytona and Vercel Sandbox), and you can point it at Nous Portal, OpenRouter, OpenAI or your own endpoint, switching with hermes model.

Key features

• Agent-curated memory, skill creation after complex tasks, and search across past sessions
• One gateway for Telegram, Discord, Slack, WhatsApp, Signal and the CLI
• Built-in cron scheduler that delivers results to any connected platform
• Seven terminal backends, including serverless ones that hibernate when idle

Best for

• Individuals who want a personal agent that runs on a server and answers in their chat apps
• Teams automating recurring reports or audits on a schedule
• Builders who want a self-hosted general agent under a permissive license

Pricing

• Free and open-source under the MIT license
• Model costs depend on the provider you connect; hosting can be a small VPS per the README

Pros

• Broad reach: chat apps, scheduling and subagents in one self-hosted process
• Model-agnostic, with provider switching that needs no code changes
• Date-based release tags (v2026.9.24) make it easy to see how current your install is

Cons

• The README warns that Windows antivirus tools can quarantine its bundled uv.exe as a false positive, which adds setup friction on Windows
• Connecting an agent to your messaging accounts and a shell is a wide permission scope to secure
• Skip it if your job is focused coding work in a repository; OpenCode, goose or Cline fit that better

---

6. Suna (Kortix), best for a generalist agent that handles real tasks end to end

Suna, built by Kortix, is a generalist agent rather than a coding-focused one: point it at a task described in plain language and it can research a topic, browse the web, manage files, run commands, and deploy a website, chaining those actions together instead of stopping at a single answer. That breadth is the appeal for teams that want one agent handling research, data pulls, and operational busywork rather than stitching together several narrow tools.

One thing worth being precise about: Kortix describes Suna as "fully open source," and the repository does ship a LICENSE file, but it's the Elastic License 2.0, not an OSI-approved open-source license. Elastic 2.0 lets you use, modify, and self-host the code freely, but it specifically restricts offering it as a competing hosted service. That's a meaningfully different deal than Apache 2.0 or MIT, and it's worth reading before you build a product on top of it, not after.

Key features

• Handles browsing, file management, command-line execution, and website deployment from natural-language instructions
• Chains multiple actions together to complete a task rather than answering once and stopping
• Self-hostable with a setup wizard, or run on Kortix Cloud as a managed option
• Integrates with external APIs and services for broader task automation

Best for

• Operations teams that want one generalist agent instead of five narrow ones
• Teams comfortable self-hosting who want full control over a broad-task agent
• Anyone evaluating Kortix Cloud who first wants to confirm what "open source" covers in this specific license

Pricing

• Source-available under the Elastic License 2.0; free to self-host and modify
• Kortix Cloud: managed hosting available, pricing on kortix.com
• Restriction: the license blocks offering Suna itself as a competing hosted service

Pros

• Genuinely broad task coverage in a single agent, not just a coding tool
• Setup wizard lowers the bar for self-hosting compared to a bare repository
• Active project: 20,000+ stars and commits as recent as this week

Cons

• Elastic License 2.0 is source-available, not open source in the OSI sense; check it against your use case
• Smaller community than goose or OpenHands, so fewer third-party integrations
• Broad task coverage means more surface area to sandbox and monitor safely in production

---

7. browser-use, best for giving any agent the ability to actually use the web

browser-use is not a standalone agent you chat with, it's the layer that lets an agent operate a browser the way a person would: opening pages, clicking, typing into forms, and reading what's on screen, driven by natural-language instructions rather than brittle scraping code. Built originally by two researchers out of ETH Zurich, it has become one of the fastest-growing open-source AI projects on GitHub, passing 100,000 stars.

The reason it matters for this list: most of the other agents here are strong at writing code or managing files, but weak at the huge share of business software that only exposes a web UI with no API. browser-use is what plugs that gap. Pair it with goose, OpenHands, or a custom agent built on any framework, and you get an agent that can log into a portal, pull a report, or fill out a form the same way a person on your team would.

Key features

• Lets any LLM control a real browser: navigate, click, type, and read page content
• Works from natural-language task descriptions rather than hardcoded scraping selectors
• Python library designed to plug into other agents and frameworks
• Actively maintained with frequent releases

Best for

• Teams automating tasks against internal tools or vendor portals that have no API
• Developers building a custom agent who need reliable browser control as one component
• Anyone extending goose, OpenHands, or a framework-based agent with real web access

Pricing

• Free and open-source under MIT license
• No hosted version; you run it as part of your own agent stack

Pros

• MIT license with no restrictions on commercial or hosted use
• One of the most-starred open-source AI projects released in the last two years
• Solves the specific, common problem of software with a UI but no API

Cons

• It's a component, not a full agent product; you still need something to drive it
• Web UIs change, and selector-adjacent automation still needs occasional maintenance
• Running it reliably at scale means managing real browser sessions, which is heavier than an API call

---

8. Open Interpreter, best for strong results from low-cost models

Open Interpreter has repositioned itself as an agent harness built specifically to close the performance gap between expensive frontier models and cheaper ones: it's a fork of OpenAI's Codex agent, tuned to emulate the harness structure that gets the best results out of low-cost models rather than requiring a top-tier one. For teams where model spend is the constraint, that framing matters more than another general-purpose agent would.

It runs commands in native sandboxing across macOS, Linux, and Windows, works as an Agent Client Protocol agent so it plugs into editors that support ACP, and supports the Codex exec protocol for compatibility with existing SDKs. It also respects shared conventions like AGENTS.md files and .agents/skills directories, so it can slot into a workflow you've already built around another agent instead of requiring you to start over.

Key features

• Purpose-built harness aimed at getting strong output from low-cost models specifically
• Native sandboxed command execution on macOS, Linux, and Windows
• Works as an Agent Client Protocol agent for editor integration
• Compatible with AGENTS.md and .agents/skills conventions from other agent ecosystems

Best for

• Teams optimizing for model cost without giving up agent capability
• Developers who want portability across agent ecosystems instead of vendor lock-in
• Editor-integrated workflows that support the Agent Client Protocol

Pricing

• Free and open-source under Apache 2.0
• No usage fees when self-hosted; costs are whatever model provider you connect

Pros

• Genuinely differentiated angle: performance-per-dollar rather than raw capability
• Cross-platform native sandboxing without extra configuration
• Standards compatibility (ACP, AGENTS.md) avoids locking you into one agent's ecosystem

Cons

• Its usefulness is tied directly to how much you care about low-cost-model performance specifically
• Younger in its current form than its reputation suggests, since the harness was substantially reworked
• Smaller extension ecosystem than goose or OpenHands today

---

9. Cline, best for an approval-gated coding agent in your editor, terminal or desktop

Cline has been around since mid-2024 and now ships as a VS Code extension, a CLI, a desktop app for macOS and Windows, and a Node.js SDK, all from one Apache 2.0 repository with 69,387 stars on 2026-09-26. The license note matters here: the README states that the JetBrains plugin is not being open-sourced, so the JetBrains client is the one piece you cannot fork.

Its working style is built around human approval. In Plan mode it explores the codebase, asks clarifying questions and proposes a strategy. In Act mode it executes, and every file edit and terminal command needs your approval unless you switch on auto-approve. In VS Code and JetBrains each edit shows as a diff, and checkpoints let you undo the agent's work. It works with Anthropic, OpenAI, Google, OpenRouter, AWS Bedrock, Azure, Vertex, Ollama, LM Studio and any OpenAI-compatible endpoint.

Key features

• Plan and Act modes, with per-step approval or opt-in auto-approve
• Diffs and checkpoints for every edit in VS Code and JetBrains
• Project rules in .clinerules files, picked up by the CLI, VS Code and JetBrains clients
• Headless CLI mode for CI/CD, plus an SDK for building your own agents on the same engine

Best for

• Developers who want an agent inside the editor with a review step on every change
• Teams that need the same agent in the IDE, the terminal and CI
• Anyone who wants provider choice including local models through Ollama or LM Studio

Pricing

• Free and open-source under Apache 2.0 (the JetBrains plugin excluded)
• You pay your chosen model provider, or nothing for local models

Pros

• Approval on every edit and command by default keeps a human in the loop
• One engine across IDE, CLI, desktop and SDK
• Broad provider list, including self-hosted endpoints

Cons

• The JetBrains plugin is not open source, per the project's own README
• Approving every step is slow for long tasks, and auto-approve removes the safety it offers
• Skip it if you want an agent that runs unattended on a server; Hermes Agent or OpenHands fit that better

---

10. Codex CLI, best for running OpenAI's coding agent locally on your ChatGPT plan

Codex CLI is OpenAI's coding agent that runs on your own computer. The repository is Apache 2.0, had 126,599 stars on 2026-09-26, and shipped release rust-v0.157.1 that same day. It is also the base that Open Interpreter (entry 8) forked, so if you like Open Interpreter's approach, this is the upstream.

Its strongest point for teams is the sandbox. OpenAI's docs say it uses Seatbelt on macOS, bwrap plus seccomp on Linux, and WSL2 or a native sandbox on Windows, and that "by default, the agent runs with network access turned off." Approval policies range from "on-request" (escalations need approval) to "never". The README recommends signing in with a ChatGPT Plus, Pro, Business, Edu or Enterprise plan, so many teams can use it without a separate API bill.

Key features

• OS-level sandboxing on macOS, Linux and Windows, with network access off by default
• Configurable approval policies, from on-request to never
• Runs in the terminal, in IDEs such as VS Code, Cursor and Windsurf, or as a desktop app
• Installs through a script, npm or Homebrew, or as a standalone binary from GitHub Releases

Best for

• Teams already paying for ChatGPT plans that include Codex
• Security-conscious teams that want sandboxing and no network by default
• Developers comparing it with Claude Code before standardizing on one

Pricing

• The CLI is free and open-source under Apache 2.0
• Usage runs through your ChatGPT plan, or through an OpenAI API key with extra setup

Pros

• Strong default isolation, documented per operating system
• Very fast release cadence, with a new release on the day we checked
• Uses a subscription many teams already have

Cons

• The README steers you to a ChatGPT sign-in; using an API key needs additional setup
• Network off by default means tasks that fetch dependencies need explicit configuration
• Skip it if model choice is your priority; goose, OpenCode and Cline are built around provider choice

See our explainer on what Codex CLI is and the head-to-head Codex vs Claude Code comparison.

---

11. Gemini CLI, best for a free-tier terminal agent built around Gemini

Gemini CLI is Google's open-source terminal agent. It is Apache 2.0, had 107,163 stars on 2026-09-26, and released v0.61.0 on 2026-09-23. The README frames it as "the most direct path from your prompt to our model", which tells you who it is for: people who want Gemini specifically.

The main draw is cost of entry. With a personal Google account the README lists a free tier of 60 requests per minute and 1,000 requests per day. Built-in tools cover Google Search grounding, file operations, shell commands and web fetching, and MCP servers add more. It can run non-interactively in scripts, and releases come on three channels: nightly, a weekly preview, and a weekly stable promotion.

Key features

• Free tier of 60 requests per minute and 1,000 per day with a personal Google account
• Built-in Google Search grounding, file operations, shell commands and web fetch
• MCP support for custom integrations
• Non-interactive mode for scripts and workflow automation

Best for

• Developers who want to try a terminal agent without a paid plan
• Teams already committed to Gemini models
• Scripted automation that benefits from live Google Search grounding

Pricing

• Free and open-source under Apache 2.0
• Free tier with a personal Google account, per the README

Pros

• A free tier stated in the README, with no paid plan needed to start
• Search grounding built in rather than added as an extension
• Clear release channels, so you can choose stability or new features

Cons

• Built around Gemini; if you want to switch model vendors, a provider-agnostic agent is a better base
• Preview releases are published before full vetting and may contain regressions, per the README
• Skip it if you need team-level coordination or an IDE-first workflow

---

12. Cindy, best for one local agent across every app on your machine

Cindy is built around a different unit of work than the other tools here: instead of one agent tied to one interface, it's a single local agent that carries your workspace, memory, and tools across whatever you're doing on your machine, using harnesses you may already pay for. The first supported harnesses are Claude Code and Codex, with more in development, and they can switch mid-task without losing context.

The practical pitch is subscription reuse: if you already pay for Claude Code or a Codex plan, Cindy can authorize against that existing subscription rather than billing you again for the same usage. It runs locally using your real files and logged-in apps, and can drive your browser, computer, and phone, plus pick up work handed to it from messaging apps and schedules. A local mode requires no sign-in at all, though some server-backed features are unavailable in that mode.

Key features

• Single agent whose memory, skills, and tools persist across apps and mid-task model switches
• Authorizes against an existing Claude Code or Codex subscription instead of a duplicate bill
• Drives your browser, computer, and phone directly, using files and apps you're already logged into
• Local mode available with no account required, alongside a hosted service option

Best for

• Individuals or small teams who already pay for Claude Code or Codex and want one agent that works across every app, not just the terminal
• Users who want a local-first agent with an optional hosted layer, not a cloud-only product
• Anyone who wants a single continuous agent context instead of restarting one per app

Pricing

• Open-source client under Apache 2.0
• Local mode: free, no sign-in required, bring your own API keys or local models
• Hosted service: usage billed transparently through cindy.app, with existing Claude Code / Codex subscriptions authorized rather than double-billed

Pros

• Genuinely novel unit of work: one persistent agent across apps rather than one agent per tool
• Reuses subscriptions you likely already have instead of adding a new one
• Local mode with no account requirement keeps a real free, self-hosted path available

Cons

• Newest and smallest project on this list by star count, so expect rougher edges
• Native harness (beyond Claude Code and Codex) is still in development
• Full capability (browser, computer, and phone control) is a wide permission surface to reason about carefully before granting it

---

How to choose an open-source AI agent

1) Check what "open source" actually means for this specific project

This year's wave makes the label do a lot of work. Apache 2.0 and MIT (Buzz, goose, OpenHands, OpenCode, Hermes Agent, browser-use, Open Interpreter, Cline, Codex CLI, Gemini CLI, Cindy) are true open-source licenses with essentially no restrictions on commercial or hosted use. Two footnotes from the repositories themselves: Cline's JetBrains plugin is not open-sourced, and for Codex CLI and Gemini CLI the license covers the agent you run, not the OpenAI or Google models it calls. Elastic License 2.0 (Suna/Kortix) is source-available: free to self-host and modify, but it blocks offering the project itself as a competing hosted service. Read the actual LICENSE file in the repository before you build a product on top of any of them, not the marketing page.

2) Match the tool to the job, not the star count

• If you need agents coordinating with your team in one shared, auditable workspace: Buzz
• If you need a coding agent that isn't tied to one model vendor: goose
• If you're running several coding agents across a team: OpenHands
• If you need one agent handling broad operational tasks end to end: Suna
• If your agent needs to operate a web UI with no API: browser-use
• If model cost per task is your binding constraint: Open Interpreter
• If you want one continuous local agent across every app, reusing a subscription you already pay for: Cindy
• If you want a terminal coding agent with a read-only planning mode and 75+ providers: OpenCode
• If you want a personal agent that runs on a server and answers in Telegram or Slack: Hermes Agent
• If you want to approve every edit and command from inside VS Code: Cline
• If your team already pays for ChatGPT plans and wants strong sandbox defaults: Codex CLI
• If you want to start free and are happy on Gemini models: Gemini CLI

3) Decide how much infrastructure you're willing to run

Self-hosting every tool on this list is possible, and for several (Buzz's relay, OpenHands' control center) it's the way you get the full feature set. That buys you data control and no per-seat fees, at the cost of running and maintaining real infrastructure. Where a managed option exists (Kortix Cloud, Cindy's hosted service), it trades some of that control for less operational overhead. Codex CLI and Gemini CLI run on your machine, but the models they call are hosted by OpenAI and Google, so with their default setup your prompts and code context go to those providers.

4) Watch for the difference between a genuinely open model and an open-weight one

Not every headline "open" release this year is the same kind of open. Moonshot's Kimi K3 shipped its full weights on Hugging Face, which is a real and significant release, but Moonshot itself never calls it open source, and the license it ships under is explicit about that distinction. That's not a knock on the model, it's a reminder to check the actual license on anything you're evaluating, model or agent, rather than the framing in the announcement.

5) Plan for the operational layer before you pick a tool

An open-source agent gets you the primitives: tool-calling, memory, browser or code execution, sometimes coordination between multiple agents. It does not get you permission scoping for your actual systems, evaluation of whether the agent is doing the right thing, or monitoring once it's live. That's the part that takes real engineering time regardless of which tool you start from, and it's where a team that has built this before can save you months. If you want a production-grade agent wired into your actual CRM, codebase, or operations instead of a demo, our AI agent development team builds and maintains exactly that, and our AI automation agency work covers the wider automation layer around it. Book a free discovery call if you want a second opinion on which of these fits your stack before you commit engineering time to one.

FAQ

What is an open-source AI agent?

An open-source AI agent is a publicly available codebase that lets an AI model take actions, write code, browse the web, run commands, or coordinate with other agents, rather than only answering questions. "Open source" specifically means the license lets you inspect, modify, and self-host the code; tools like goose, OpenHands, and browser-use ship under permissive licenses like Apache 2.0 or MIT that place essentially no restrictions on that use.

Is Suna by Kortix actually open source?

Partially. The Suna repository is publicly available and you can self-host and modify it freely, but it ships under the Elastic License 2.0, not an OSI-approved open-source license. Elastic 2.0 specifically restricts offering the software itself as a competing managed service, which is a real limitation that Apache 2.0 or MIT projects on this list do not have. Read the license before building a product on top of it.

What is the difference between goose and OpenHands?

goose is a single coding agent you run as a CLI, desktop app, or API, built to work with any of 15+ model providers including local models. OpenHands is a control center that runs multiple agents, including its own, Claude Code, Codex, or Gemini, across local, remote, and cloud backends, and adds automations tied to tools like Slack and GitHub. Start with goose if you want one flexible coding agent; use OpenHands if you're standardizing agent usage across a team running several agent types.

Can these agents use local models instead of a cloud API?

Yes, for several of them. goose supports local models through Ollama, giving you a fully offline setup with no API key and no data leaving your machine. OpenCode documents Ollama, LM Studio and llama.cpp setups, and Cline lists Ollama and LM Studio among its providers. Cindy's local mode also requires no sign-in and can run against local models. browser-use and Open Interpreter both work with whatever model you connect, including local ones, since they don't lock you into a specific provider.

Is Buzz by Block a replacement for Slack and GitHub?

Buzz is positioned as an alternative to both, combining team chat and Git-style code events with AI agents as first-class members, all logged as signed events on the Nostr protocol. It's genuinely usable today via the free desktop app, but Block itself describes it as early-stage: mobile apps, richer approval workflows, and some integrations are still in development, so most teams are running it alongside their existing tools rather than as a full replacement yet.

What is the fastest way to give an existing agent web-browsing ability?

browser-use is built specifically for this: it's a library, not a standalone chat agent, that lets any LLM control a real browser, navigating pages, clicking, and filling forms from natural-language instructions. Pair it with a coding agent like goose or a control center like OpenHands when the task requires reaching a system that only exposes a web UI, not an API.

Should I self-host an open-source agent or use a managed cloud version?

It depends on how much infrastructure your team wants to run. Self-hosting gives you full data control and no per-seat costs, but you own the uptime, updates, and security of that infrastructure. Managed options like Kortix Cloud or Cindy's hosted service trade some of that control for less operational burden. For regulated data or highly custom permission requirements, self-hosting is usually the safer default; for a team without spare DevOps capacity, the managed option gets you running faster.

How do I know if an "open source" AI release actually is one?

Check the LICENSE file in the repository, not the announcement or marketing copy. Apache 2.0 and MIT are true open-source licenses with almost no restrictions. Source-available licenses like Elastic 2.0 let you see and modify the code but add specific commercial restrictions, most commonly blocking you from offering it as a competing hosted service. Some 2026 model releases add a further wrinkle: Moonshot calls Kimi K3 "open-weight" and deliberately avoids the term "open source" for its own model license, which is a useful example of a vendor being precise about the distinction.

Which open-source AI agent has the most GitHub stars?

On 2026-09-26, Hermes Agent by Nous Research led this list with 249,199 stars, followed by OpenCode with 210,209 and Codex CLI with 126,599. Stars measure attention, not fitness for your job. Suna had 20,237 and Cindy 2,814, and both still earn a place: Suna as a generalist task agent, Cindy as one agent that follows you across apps.

Are Codex CLI and Gemini CLI really open source?

The agents are. Both repositories ship the Apache 2.0 license, so you can read, fork and modify the CLI code. The models behind them are not open. Codex CLI's README steers you to a ChatGPT plan sign-in, and Gemini CLI is built for Gemini, with a free tier of 1,000 requests a day on a personal Google account.

What is the difference between OpenCode and Cline?

OpenCode (MIT) and Cline (Apache 2.0) are both coding agents that work with many model providers, including local ones. OpenCode is terminal-first, with a read-only "plan" agent and a full-access "build" agent you switch with Tab. Cline centers on the editor, where every edit shows as a diff and waits for your approval unless you turn on auto-approve.

Can an open-source agent run on a schedule or take tasks from chat apps?

Yes, several on this list can. Hermes Agent has a built-in cron scheduler and a gateway for Telegram, Discord, Slack, WhatsApp and Signal. Cline's desktop app schedules routines, Cindy takes work from messaging apps and schedules, and OpenHands triggers runs from Slack, GitHub and Notion. Unattended runs need tighter permissions than a supervised session, so scope them first.

Do I need a team of engineers to run any of these in production?

You can get a demo running with any of these tools in an afternoon. Getting one into production, safely scoped to your real systems, evaluated for whether it's actually doing the right thing, and monitored once it's live, is a separate and larger effort that most teams underestimate. If you'd rather have that operational layer built and maintained by a team that has done it before, AI agent development work is exactly that gap, from picking the right open-source foundation to running it safely against your actual data.