Introduction: Why Self-Hosting Keeps Coming Up

Self-hosting AI coding agents is usually not about ideology. It comes up when teams need tighter control over where code runs, which credentials an agent can use, and what systems it can reach.

That matters most when the agent is doing more than editing files in a terminal. Once the workflow includes internal APIs, private repositories, staging databases, telemetry systems, or incident tooling, the execution boundary becomes part of the product decision.

Proliferate is built for that boundary. It is an open-source, self-hostable IDE for running coding agents with their native harnesses, locally or in cloud sandboxes. Instead of forcing every workflow through one hosted product shell, it lets teams run Claude Code, Codex, Cursor, OpenCode, and similar tools inside environments they control.

The practical question is not whether self-hosting sounds attractive. It is whether your team needs agents that can operate against real internal systems without handing that control plane to a third party.

Why Developers Are Moving to Self-Hosting

The first driver is usually compliance or data handling. Some teams simply cannot route source code, credentials, or internal context through a third-party SaaS product boundary and call it done.

The second driver is workflow depth. A local coding assistant is one thing. A workflow that reacts to a Sentry issue, opens a worktree, investigates a failure, runs tests, and prepares a pull request is another. Once agents start touching real systems, teams care a lot more about where those agents execute and how isolation works.

Cost and flexibility matter too. Hosted tools often bundle model access, execution infrastructure, and collaboration features into one subscription model. Self-hosting breaks those apart. Teams can keep the models and credentials they already use, choose where workloads run, and move between providers without rewriting the rest of their setup.

That is the gap Proliferate is trying to close. It supports existing agent ecosystems without asking teams to give up infrastructure control or adopt another vendor-managed runtime.

What Self-Hosting Actually Requires

Running AI coding agents on private infrastructure requires more than starting a container. At minimum, teams need clarity on three things: where code executes, how isolation works, and how credentials are handled.

Proliferate addresses the execution problem by supporting two main paths. Code can run locally in a git worktree that Proliferate manages, which is useful when a developer wants full access to the local repository and fast iteration. Or it can run in an isolated cloud sandbox when the team wants longer-lived execution, cleaner separation from the workstation, or a more standardized environment.

Isolation matters because agent-generated code is not trustworthy by default. Proliferate uses sandboxed execution so agents can work against repositories and internal tools without sharing a host process with everything else on the machine. The point is not theoretical purity. The point is reducing the blast radius when an agent runs commands, edits files, or reaches into connected systems.

Credential handling is the third piece. Proliferate is designed to work with the credentials teams already have, including Claude Code login, Codex login, and provider API keys. That means self-hosting does not require inventing a separate identity layer just to get started.

The Self-Hosted AI Coding Agent Ecosystem

Different tools sit at different layers of the stack.

Claude Code is a terminal-native coding agent. It is strong when a developer wants to stay in one attended session and drive the work directly. It is not trying to be a broader orchestration system.

OpenCode also centers the developer workflow, with its own terminal and client surfaces. It gives teams another agent product choice, but it still leaves open the question of where execution should happen and how to coordinate more than one agent workflow at a time.

Proliferate sits above that layer. It is less about replacing the agent and more about providing the runtime around the agent: managed worktrees, sandboxed execution, shared workspaces, review flows, and the ability to run locally or in cloud environments without changing the underlying code workflow.

That distinction matters. If your team only needs a single attended coding session, the harness itself may be enough. If your team needs repeatable execution, controlled environments, and workflows that span more than one agent run, the surrounding runtime starts to matter more than the model picker.

Getting Started: A Practical Path to Self-Hosting

The easiest way to start is to keep the workflow small.

In Proliferate, that usually means connecting the agent credentials your team already has, opening a repository, and choosing whether the run should happen locally or in a cloud sandbox. Local execution is useful when the work is tightly coupled to a developer workstation. Cloud execution is useful when the task needs a cleaner environment or should keep running after the laptop closes.

From there, keep the first workflow narrow. A good example is routine bug triage. Let an agent investigate a failure in its own worktree, gather context, propose a fix, and run verification before handing the result back for review. That is enough to validate whether your isolation, credentials, and environment setup are doing the right thing.

Another concrete path is a plan/code/review loop. One agent drafts a plan, another implements the change in an isolated worktree, and a review step checks the diff before anything is merged. That is a more honest test of self-hosting than a toy prompt because it exercises the actual control points that matter in production.

The common thread is that everything stays git-backed. Whether code runs locally or remotely, the work still lands in a repository with branches, diffs, and rollback paths that engineers already understand.

Security and Sandboxing: Protecting Your Infrastructure

Security is where self-hosting either becomes real or falls apart.

Proliferate runs agents inside isolated environments rather than directly against the host. In practice, that means the agent can edit code, run commands, and interact with connected systems inside a bounded workspace instead of sharing unrestricted access with the rest of the machine.

That boundary matters most when workflows become operational. A useful example is Sentry triage. An incoming issue can trigger a run, the agent can inspect the relevant code and logs, prepare a candidate fix in its own worktree, run tests, and open a pull request for review. That is much closer to a real engineering workflow than a chatbot answering questions about a repository.

The same logic applies to internal tools. If an agent needs to read telemetry, inspect build output, or call an internal API, teams want that behavior happening in an environment they can reason about. Self-hosting does not remove risk, but it gives teams more control over where the risk sits and how much access the agent actually gets.

For enterprise deployments, that extends to custom controls, private runners, and tighter infrastructure boundaries. The technical point is simple: if agents are going to touch real systems, sandboxing and environment control are not optional details.

Conclusion: Taking Control of Your AI Coding Stack

Self-hosting is worth the effort when your team needs more than a convenient coding assistant. It starts to make sense when agents need access to private repositories, internal systems, repeatable environments, or automation paths that should not depend on a third-party runtime boundary.

Proliferate is designed for that use case. It gives teams a way to run existing coding agents inside managed worktrees or cloud sandboxes, keep the workflow git-backed, and build real execution patterns such as Sentry triage, plan/code/review, and isolated parallel runs.

That is the practical value of self-hosting: not abstract control, but a workflow that stays closer to the infrastructure, permissions, and review process your team already trusts.