Self-hosted infrastructure for a fleet of long-lived AI agents. Each agent runs in its own sandboxed container with a persistent workspace, internet access, and a pluggable driver.

Yes. Single-VM deploy on plain Docker with your own keys and data. No vendor lock-in, no per-seat SaaS tax, nothing leaves your stack.

Which agent engines (drivers) are supported?

One identical API across swappable brains: Vanilla, Opencode, Codex, and Claude Code. The driver is part of an agent's config and can be swapped anytime.

How do you keep my data and agents secure?

Every agent runs in a hardened container: read-only root filesystem, dropped capabilities, network egress filtering, and CPU/memory limits. LLM keys are stored server-side, encrypted, and never sent to the browser.

Can I watch what an agent is doing?

Yes. Every task streams over Server-Sent Events (assistant messages, tool calls, results, file changes, a live token meter), and reconnects resume where they left off.

Accounts are provisioned by admins; you self-host the stack. Use Get started, or sign in if you already have an account.

Open Source Claude Code Alternatives for Self Hosting

For most platform teams evaluating open source Claude Code alternatives, the practical shortlist is OpenCode or Aider for terminal-first work, OpenHands for governed team infrastructure, Cline for IDE-based human review, Goose for MCP-heavy workflows, and Codex CLI for OpenAI-standard shops. The harder decision is not which tool looks most like Claude Code. It is where your code, shell execution, credentials, model traffic, logs, and approvals will live.

Claude Code set the buyer's baseline: a proprietary terminal agent that runs locally, edits files, runs commands, works with repository context, supports tool workflows, and asks permission before changes or command execution. Anthropic ties access to Claude Pro, Max, Team, Enterprise, or API billing, with Pro listed at $20 monthly, Max 5x at $100 monthly, and Max 20x at $200 monthly at the time of research.

If you are replacing it for privacy, cost, control, or vendor strategy, you are choosing an agent stack, not another assistant.

For the control-plane pieces behind the shortlist, compare self-hosted coding-agent runtimes, credential proxies for AI agents, and MCP security controls.

Define self-hosted before choosing a tool

An open-source CLI that sends private repository context to a hosted frontier model is not fully self-hosted. It may still be the right choice, but call it what it is: an open-source client with cloud inference.

A more complete self-hosted coding-agent setup includes the client, execution sandbox, model gateway, model inference, secrets handling, logs, governance, and collaboration controls. That definition changes the comparison. OpenCode and Aider may solve the developer interface. OpenHands may solve more of the team platform. LiteLLM, Ollama, llama.cpp, vLLM, and Tabby may solve model routing or inference, but they are not a Claude Code replacement by themselves.

Comparison table

Option	Best fit	Self-hosting profile	Main limitation
OpenCode	Claude Code-like open-source CLI flexibility.	MIT licensed, 75+ providers, local paths through Ollama, llama.cpp, LM Studio, Atomic Chat, NVIDIA NIM, and custom base URLs.	Enterprise governance still depends on how you wrap models, logs, credentials, and execution.
Aider	Git-native terminal workflows.	Apache-2.0, repo maps, explicit file control, auto-commit support, cloud and local LLM support.	Strong for individual workflows, but not a shared governance platform alone.
OpenHands	Team-level self-hosted agent platform.	MIT open source with Enterprise docs for BYO LLM, SSO/SAML, RBAC, auditability, and containerized sandboxes.	Heavier to operate. Sandboxes, reverse proxies, deployment, and user controls become platform work.
Cline	VS Code users who want Plan and Act separation.	Apache-2.0 main project, BYOK, local runtimes, OpenAI-compatible endpoints, Ollama, LM Studio, and cloud providers.	IDE-centered rather than terminal-native. Local model performance depends on hardware.
Goose	MCP-heavy desktop, CLI, and API workflows.	Apache-2.0 under the Agentic AI Foundation, 15+ providers, 70+ MCP extensions.	Extension breadth increases the need for prompt-injection and tool-permission governance.
Codex CLI	OpenAI-standardized environments.	Apache-2.0, local CLI, works with ChatGPT plans or OpenAI API keys.	Not provider-neutral self-hosted by default. Non-OpenAI use usually needs proxies or forks.

The decision usually starts with a security question

The first request often comes from developers: they like the Claude Code workflow, but a particular repo cannot leave approved infrastructure. Security asks where prompts and command outputs go. Finance asks whether every team will bring a separate model subscription. Platform asks whether shell execution is controlled. Legal asks whether logs, source code, and credentials remain inside the company boundary.

That is the moment to split the problem into four layers.

Developer interface: terminal, IDE, desktop app, web control center, or API.
Execution control: local workspace, container, VM, remote sandbox, network policy, and write scope.
Model routing: direct vendor API, BYOK, LiteLLM gateway, private inference, or local runtime.
Governance: SSO, RBAC, audit logs, approvals, budgets, MCP allowlists, and incident records.

Open source helps with transparency and control, but it does not remove the need for those layers.

OpenCode: best for Claude-like flexibility

OpenCode is the cleanest starting point when the requirement is: give developers something close to Claude Code, but open source and model-agnostic. The project is MIT licensed, supports terminal, IDE, and desktop-oriented use, claims 75+ model providers, and supports local-provider paths through Ollama, llama.cpp, LM Studio, Atomic Chat, NVIDIA NIM, and custom base URLs.

The strategic advantage is optionality. You can try local models, provider APIs, existing subscriptions, and custom routing without making a single vendor decision on day one. Hacker News discussion around OpenCode repeatedly cites model switching and existing subscriptions as reasons developers look beyond Claude Code.

The governance gap is predictable. OpenCode does not automatically give you central policy for credentials, logs, shell execution, team access, or budget. For a platform team, the tool is one layer, not the whole operating model.

Aider: best when git is the control plane

Aider is a strong fit for terminal-heavy developers who already treat git as the unit of accountability. It is Apache-2.0 licensed, maps the repository, works with explicit file control, can auto-commit AI changes, and supports Anthropic, OpenAI, Gemini, Azure, Bedrock, Vertex AI, OpenRouter, GitHub Copilot, LM Studio, Ollama, and OpenAI-compatible APIs.

Aider's appeal is not flash. It makes agent work look like normal engineering work: files, diffs, commits, review. That is useful for teams that want AI assistance without creating a new shared platform immediately.

The limitation is scale governance. Aider plus a model gateway can work well, but Aider alone is not SSO, RBAC, sandbox orchestration, enterprise audit, or centralized policy.

OpenHands: best for shared infrastructure

OpenHands is less of a drop-in Claude Code clone and more of a self-hosted agent platform candidate. Its current direction emphasizes Agent Canvas, a developer control center that can run OpenHands, Claude Code, Codex, Gemini, or ACP-compatible agents across local, remote, and cloud backends.

The Enterprise story is the important part for platform leaders: self-hosted or private-cloud deployment, BYO LLM, SSO/SAML, RBAC, auditability, and containerized sandboxes. OpenHands also documents Docker sandboxing and caveats around reverse proxies and concurrent sandboxes.

That trade-off is honest. You get stronger central control, but you inherit platform responsibilities: deployment, sandbox capacity, networking, identity, updates, audit retention, and user support.

Cline and Goose: useful where workflow shape matters

Cline fits teams whose developers live in VS Code and want a clear checkpoint before execution. Its Plan mode can read, search, and discuss without modifying files or executing commands. Act mode can then modify files and run commands after plan context carries over. That is a good human-in-the-loop pattern for teams that are not ready to give an agent broad execution authority.

Cline also supports BYOK, local runtimes, OpenAI-compatible endpoints, Ollama, LM Studio, and cloud providers. Its local-model docs list rough expectations from 16 to 32GB RAM for smaller or quantized models to 64GB+ for larger models and context.

Goose is useful when extension breadth is the strategy. It is Apache-2.0 open source under the Agentic AI Foundation at the Linux Foundation, offers desktop, CLI, and API surfaces, supports 15+ providers, and connects to 70+ MCP extensions. That breadth should come with a strict extension allowlist, sandbox policy, and prompt-injection review.

Codex CLI and the model infrastructure layer

OpenAI Codex CLI is Apache-2.0 licensed, runs locally, installs through shell, npm, Homebrew, or binaries, and works with ChatGPT plans or an OpenAI API key. It is a natural option for OpenAI-standardized teams. It is less compelling as a provider-neutral self-hosting answer unless you are comfortable with OpenAI-compatible proxies or forks.

LiteLLM, Ollama, llama.cpp, vLLM, and Tabby belong in the comparison, but in a different column. LiteLLM is a gateway for 100+ providers with virtual keys, spend tracking, guardrails, load balancing, and a dashboard. Ollama, llama.cpp, and vLLM are inference layers. Tabby is closer to a self-hosted completion assistant and on-prem GitHub Copilot alternative than a Claude Code-style autonomous terminal agent.

Decision guide

Choose OpenCode if your main requirement is a Claude Code-like open-source workflow with broad provider flexibility.
Choose Aider if your developers are terminal-first and want AI changes to move through normal git review.
Choose OpenHands if the agent is becoming shared infrastructure with SSO, RBAC, sandboxes, and audit needs.
Choose Cline if work should stay in VS Code and Plan-to-Act checkpoints are important.
Choose Goose if MCP extension breadth is central to the workflow.
Choose Codex CLI if your model strategy is already OpenAI-centered.
Choose LiteLLM plus local inference if model control is the problem and you already know which agent client you want.

Governance checklist

Before approving any open-source coding agent, answer these questions:

Which repositories may the agent open?
Which models may receive source context?
Where are prompts, logs, command outputs, and diffs stored?
Can the agent run shell commands, install packages, use the network, or call MCP tools?
How are secrets exposed, scoped, rotated, and audited?
Who pays for model usage, and where are budgets enforced?
What internal tasks prove the agent improves delivery without raising defect or incident risk?

Anthropic published vendor-controlled research based on about 400,000 interactive Claude Code sessions from about 235,000 people between October 2025 and April 2026. That is useful market signal. It is not a substitute for your own evaluation on private repos, local workflows, review defects, and cost per accepted change.

The strategic mistake is treating open source as equivalent to self-hosted. For platform leaders, the real comparison is local convenience versus governed infrastructure, cloud model performance versus private inference, and developer velocity versus the controls required to let agents touch production code safely.