Whether Claude Code is open source is worth settling before you build a workflow around it, because the license decides what you can inspect, self-host, and control. If you run a platform team standardizing an agent layer, or a regulated team that can't let code touch a third-party cloud, that answer decides whether the tool clears a security review at all.

The short answer is that Claude Code is not open source, and the answer you actually need is what you run instead when auditability, self-hosting, or model freedom is the requirement. This guide covers what Claude Code's license means for the code it writes, the four best open-source alternatives, and where OpenHands fits as an open workspace and control layer for teams that want to keep using agents like Claude Code while adding automation, deployment flexibility, and governance.

Is Claude Code open source?

No. Claude Code is proprietary software, with no MIT, Apache, or General Public License attached. The license file on the official Anthropic repository reads "© Anthropic PBC. All rights reserved," and your use of it falls under Anthropic's legal agreements rather than any Open Source Initiative (OSI) approved permissions. You can install and run it on a paid plan, but you can't inspect, fork, or self-host the agent itself.

The part that usually surprises your reviewer is how Claude Code compares to its peers. OpenAI's Codex command-line interface (CLI) ships its client under an Apache 2.0 license, though the backing service stays proprietary, and the open-source terminal agents further down this guide put their whole agent layer under a permissive license. Claude Code keeps the entire thing closed, which is exactly what fails a source-review gate.

What Claude Code's license means for your code

The license on the agent and the rights to the code it writes are two separate questions, and the output is generally yours either way. Anthropic's Commercial Terms, covering application programming interface (API) keys, the Claude Console, and Team and Enterprise plans, assign output ownership to you and add copyright indemnity for authorized use. Anthropic says its commercial products, including the Anthropic API and Claude for Work, are not used to train its models by default, while its consumer privacy center describes separate data handling for Free, Pro, and Max plans, so confirm the terms that apply to your plan.

Being open source is also a narrower claim than "you can read the code." The OSI Open Source Definition requires free redistribution and bars restrictions on business use, a source-available license lets you view code you still can't freely reuse, and Claude Code is neither. Even if source code or implementation details are discussed publicly, that does not create open-source rights. The license file and governing terms are what determine what legal rights you have to inspect, modify, redistribute, or self-host the tool.

The 4 best open-source Claude Code alternatives

The four tools below all carry OSI-approved licenses, and each one lets you use Claude models through an Anthropic API key under bring-your-own-key (BYOK). We compare them on six dimensions, which are license, primary interface, model flexibility, self-hosting, whether the tool runs Claude Code through the Agent Client Protocol (ACP), and enterprise controls.

1. OpenHands

OpenHands is the open-source platform for building and running AI coding agents. It gives teams a path from a single local agent session to repeatable workflows, automations, shared backends, and enterprise controls.

The starting point is Agent Canvas, OpenHands’ local-first workspace for running agent sessions, inspecting conversations, managing files and terminal output, and turning useful patterns into automations. Developers can start locally on a laptop, then move workflows to a remote VM, OpenHands Cloud, or a self-hosted backend when they need more persistence, isolation, or team access.

OpenHands can also connect to external ACP-compatible agents, including Claude Code, Codex, and Gemini CLI, through the Agent Client Protocol. In that setup, the external agent manages its own model, tools, and execution, while Agent Canvas provides a workspace for working with agent conversations and workflows.

Key features:

• Open-source agent platform: The OpenHands core is MIT-licensed, so teams can inspect, extend, and self-host the platform.

• Agent Canvas: A local-first workspace for running agents, inspecting activity, and turning useful patterns into workflows.

• ACP Support: Agent Canvas can drive external ACP-compatible agents such as Claude Code, Codex, and Gemini CLI.

• Model-agnostic: Teams can use supported model providers, private models, or local models depending on their infrastructure and policy requirements.

• Path to enterprise controls: OpenHands Enterprise adds controls for teams that need SSO, RBAC, auditability, cost visibility, and governed deployment.

Pros:

• Runs the agent you already pay for: It's the only tool here that connects to Claude Code itself through ACP, a different path from standard BYOK model access, so Agent Canvas can drive Claude Code through ACP while Claude Code continues to use its own supported authentication and runtime behavior.

• Outer-loop automation with a control plane: Agents run on a schedule or on events, and RBAC, SSO, and audit logs come from the Agent Control Plane.

• Supports a path from local experimentation to cloud, self-hosted, or enterprise deployment.

Cons:

• Workflow focus: The biggest value appears when teams are running repeated workflows or multiple agents, not just one-off local sessions.

• Infrastructure ownership: Self-hosting an enterprise deployment requires infrastructure ownership.

• Governed by original licenses: External agents such as Claude Code remain governed by their own licenses, terms, and runtime behavior.

Best for: Platform and security teams that want an open, self-hostable foundation for agent workflows while allowing developers to keep using familiar coding agents.

2. OpenCode

If you want the closest open-source peer in this list, OpenCode is it, terminal-first and provider-neutral with an MIT license that puts the entire agent in the open. You run it as a terminal user interface, and it comes with a companion desktop app and an IDE extension.

Key features:

• 75+ model providers via Models.dev: Connections cover Anthropic, OpenAI, Google Gemini, AWS Bedrock, and local models, with GitHub Copilot and ChatGPT login supported directly.

• BYOK with MCP support: You bring your own key and attach local or remote Model Context Protocol (MCP) servers, and the agent runs client-side, though inference still goes to whichever model provider you point your key at.

Pros:

• Provider neutrality is a first-class design goal. Swapping models mid-session is a normal move, and the whole agent is MIT-licensed with no backend to gate a security review.

• The interface meets you where you work. Your terminal, desktop, and editor surfaces all share one agent.

Cons:

• No org-wide control plane: Access control, audit, and cost governance across teams come from your own stack, not the tool.

• It's a single-agent terminal tool at heart: Running many agents across repositories on a schedule is outside its scope.

Best for: An individual developer or small team that wants a fast, open terminal agent with the widest model choice.

3. Aider

Aider is a terminal pair programmer written in Python, installed from the Python Package Index (PyPI), and licensed under Apache 2.0. It runs against your local Git repository, which is where its strengths really show up.

Key features:

• Repository-wide code map with architect pairing: It maps the codebase to reason about files it has not opened, and a strong reasoning model plans each change so a faster model can write the diff.

• Automatic Git commits: Each change lands as a discrete commit with a conventional message, and a lint, test, and repair loop runs across many languages.

Pros:

• Git-native with a small footprint: Every edit is a commit that makes review and rollback natural, and it's a plain Python install with no proprietary backend and no code leaving for anything but the model you configure.

• Model choice is wide: Support covers Anthropic Claude, OpenAI, Google Gemini, and local models through Ollama, and you switch with a /model command.

Cons:

• The surface is the terminal: You get no graphical workspace, only an experimental browser mode.

• It's a single local agent with no governance layer: Scheduled runs across a fleet, access control, and audit aren't part of the tool.

Best for: A developer who lives in the terminal and Git, and who wants precise, commit-level control over an open-source agent.

4. Cline

Cline lives mostly in your editor sidebar as a VS Code extension, with a preview CLI for macOS and Linux, and it runs client-side on a BYOK model under an Apache 2.0 license.

Key features:

• Plan and Act modes with an embeddable SDK: You review the plan before the agent touches files, and a software development kit (SDK) lets you run the agent runtime inside your own tools.

• Model-agnostic BYOK: Support spans Anthropic, OpenAI, Google, AWS Bedrock, LiteLLM, and local models through Ollama.

Pros:

• It sits inside the editor with an embeddable runtime: Developers already in VS Code get an agent without leaving the workspace, and the SDK opens the door to custom internal tooling.

• An enterprise tier exists: SSO, RBAC, and audit logs are available for teams that need them.

Cons:

• The core is editor-bound: The strongest experience is inside VS Code, with the CLI still in preview.

• Org-wide governance lives behind the enterprise tier: The open-source build runs one agent at a time and does not include central control across repositories.

Best for: A VS Code team that wants an open agent in the editor with a clear path to SSO and RBAC when the rollout grows.

How to choose an open-source Claude Code alternative

The right pick comes down to which of the six dimensions is your hard constraint, so sort the tools by the requirement that gates your rollout rather than by feature count. Match yours to one of the buckets below:

• If you want the widest model choice with no lock-in: OpenCode leads on raw provider count, and Aider and Cline are close behind on BYOK breadth.

• If you want commit-level control in the terminal: Aider's Git-native workflow fits a developer who wants every change as a reviewable commit.

• If you want an agent inside your editor with a path to team governance: Cline covers the VS Code case and adds an enterprise tier for SSO and RBAC later.

• If you want to keep Claude Code, run agents across repositories, and self-host with audit: OpenHands is the platform layer around the others, running your existing agent while adding automation and an enterprise agent control plane.

None of these picks locks you in the way a closed platform would, since every tool here runs on an open license and your own keys, so a wrong first choice costs you an afternoon rather than a migration. OpenHands keeps that flexibility even at the platform level, because Agent Canvas connects to Claude Code through ACP and any model through LiteLLM, so consolidating on it later doesn't mean abandoning whatever you picked first.

How OpenHands works with Claude Code on an open platform

OpenHands lets you keep Claude Code while moving the workspace and workflow layer around it to an open source platform. Agent Canvas connects to Claude Code through the Agent Client Protocol, the same protocol it can use to work with Codex, Gemini CLI, and other ACP-compatible agents.

That does not make Claude Code open source. The Claude Code agent still manages its own model, tools, authentication, and execution. What OpenHands adds is the surrounding platform: a local-first workspace, workflow automation, backend flexibility, and a path to enterprise controls.

For teams with stricter deployment requirements, OpenHands can be self-hosted so the agent runtime and execution environment stay under their control. Full data containment still depends on the model path. If a workflow calls a hosted model provider, prompts and code context may leave the environment. Teams that need inference to stay private should pair OpenHands with approved private, local, or self-hosted models.

Getting past the security review with an open agent

Open-source agents give teams more leverage in a security review because they can inspect the agent layer, run it under their own controls, and choose model providers that fit cost, performance, and policy. This turns "can we see the source" from a blocker into a checkbox. The exact privacy boundary still depends on how the tool is deployed, where inference runs, and which external services the workflow calls.

For repeated outer-loop work such as dependency updates, PR review, and vulnerability fixing, pick an agent you can audit, self-host, and automate, and keep the model choice flexible so teams can route work based on cost, performance, availability, and policy. If you want to see how the layer runs before you commit to it, start with the open agent community.

Frequently asked questions about Claude Code and open source

Is Claude Code open source?

Claude Code is proprietary software under Anthropic's legal agreements, and its license file reads "© Anthropic PBC. All rights reserved." It carries no MIT, Apache, or GPL license, and it isn't OSI-approved. If open source is a hard requirement for you, OpenHands gives teams an MIT-licensed platform for agent workflows. Agent Canvas can connect to Claude Code through ACP, but Claude Code itself remains proprietary and governed by Anthropic’s terms.

Can I see or modify Claude Code's source code?

Is there an open-source alternative that works with Claude models?

Yes, and you have four good ones to pick from. OpenHands, OpenCode, Aider, and Cline all carry OSI-approved licenses and run Claude models through BYOK, so you keep the model you like. OpenHands goes further by connecting Claude Code through ACP, so teams can keep a familiar agent while adding automations, shared workflows, deployment flexibility, and enterprise controls around it.

How much does an open-source agent cost to run?

The agent code is free, and your spend is the model tokens plus whatever infrastructure you self-host on. That's the practical draw of BYOK, since you pay the provider directly and switch to a cheaper model when a plan limit hits. The OpenHands pricing page lays out the open-source local install, the free-with-usage-limits cloud tier, and the self-hosted enterprise option.

About OpenHands

OpenHands is the open-source platform for building and running AI coding agents, with the interface, automations, and control layer needed to go from a single local agent to a system running across an entire organization. The mission is to make agent-based software development accessible, transparent, and controllable by default. That starts in the open. The core framework is open source, giving developers and platform teams full visibility into how agents execute work and interact with their systems. The project has over 80,000 GitHub stars, 9 million downloads, and contributions from hundreds of developers. OpenHands is used by engineers at large enterprises and fast-growing startups to build, run, and scale AI coding agents across real software engineering workflows. The long-term vision is to become the full stack AI coding agent platform for software engineering. Not just helping developers write code, but running meaningful parts of the software lifecycle.