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

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 seven open-source AI agents that are real, currently maintained, and verifiable on GitHub today, what each one is actually for, where the license has strings attached, and how to think about picking one over building your own. For the framework layer underneath these tools, see our breakdown of the best open-source AI agent frameworks.

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.
• 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.
• 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.

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. 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

---

5. 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

---

6. 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

---

7. 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, browser-use, Open Interpreter, Cindy) are true open-source licenses with essentially no restrictions on commercial or hosted use. 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

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.

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. 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.

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.