Helix Private Coding Fleet
Run parallel coding agents on your infrastructure, from reviewed specs to pull requests.
- Source repo
- helixml/helix
- Stars
- ★ 829
- Last updated
- 2d ago
- License
- NOASSERTION
- Primary language
- Go
- FA score
- 51/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformCodex · Claude Code · OpenAI API · Claude API
- Cost
- Free tier plus a paid hosted plan
- Setup effort
- High · needs real infrastructure
- You'll need
- Typical use
- An engineering team with several independent features or bug fixes that wants to dispatch coding work in parallel while retaining a shared board and PR review.
- Not a fit if
- Companies over $10M revenue or 250 employees need a paid license
- Individuals without GPU or Kubernetes infrastructure wanting one local agent
- Teams planning to build a competing product from this code
- Source review
- 51/100 · Major gaps
What does this agent do, and when should you use it?
Helix is a private coding-agent fleet platform organized around projects, connected Git repositories, and Kanban-based spec tasks. A task progresses through Backlog, Planning, Spec Review, In Progress, Pull Request, and Merged: a planning agent writes a specification to a helix-specs branch, then an approved implementation agent changes code and opens a PR. Each active agent runs in an isolated, GPU-accelerated desktop environment with a browser, terminal, filesystem, and GUI applications. Teams can observe work live, steer it through the task thread, and switch agent harnesses during a task. Helix supports Claude Code, OpenAI Codex, Gemini CLI, Qwen Code, Goose, Zed Agent, and ACP-compatible agents, with GitHub, GitLab, and Azure DevOps source-control connections. It offers Docker installation plus Kubernetes Helm charts for the control plane and GPU runners, including an end-to-end self-hosted and air-gapped deployment path.
A user connects one or more Git repositories to a project and creates a spec task on the Kanban board. Selecting Start Planning causes a planning agent to read the repository and write requirements, design, and task breakdown to a helix-specs branch; the user can request changes by highlighting text or approve the specification. In In Progress, an implementation agent runs in its own desktop sandbox using the selected agent harness, with access to a browser, terminal, filesystem, and GUI apps; users can watch live, steer through the task thread, or switch agents mid-session. When the work is complete, Helix opens a Pull Request in the connected source-control system, and the task closes after the PR merges. The platform also ingests PDF, Word, text, and scraped web content for knowledge/RAG, integrates tools through REST/OpenAPI, MCP, GPTScript, and a custom-tool SDK, and traces LLM, API, and MCP requests alongside token usage and cost.
- An engineering team with several independent features or bug fixes that wants to dispatch coding work in parallel while retaining a shared board and PR review.
- An enterprise running self-hosted models in a controlled or isolated network that needs coding agents and GPU runners on its own infrastructure.
- A project lead using GitHub, GitLab, or Azure DevOps who wants to approve an agent-produced specification before implementation and keep the PR as the final review gate.
- A development team that needs to choose or switch among Claude Code, OpenAI Codex, Gemini CLI, Qwen Code, or an ACP-compatible agent for individual tasks.
- An internal engineering group that wants agents to work with PDF, Word, text, or scraped-web knowledge through the documented RAG capabilities.
How do you install or deploy this agent?
For the Docker quick start:
curl -sL -O https://get.helixml.tech/install.sh
chmod +x install.sh
sudo ./install.shThe installer prompts before changing the system, and the dashboard defaults to http://localhost:8080. Production deployment is documented through Control Plane and Runner Helm charts. Server configuration uses environment variables: configure OPENAI_API_KEY or ANTHROPIC_API_KEY for the chosen hosted provider, POSTGRES_* for database connectivity, SERVER_URL for the public deployment URL, and RUNNER_* for GPU runner configuration. Local development requires Docker Desktop, or Docker with Docker Compose, plus Go 1.24.0+, Node.js 18+, and Make.
How do you use this agent?
Open http://localhost:8080 after installation, create a project, and connect one or more Git repositories. Create a spec task in Backlog that states the desired outcome, then select Start Planning; the planning agent writes the specification to the helix-specs branch. Review it in Spec Review, highlighting text to request changes or selecting Approve. In In Progress, choose an available agent harness and steer the agent through the task thread; switch agents if needed. The completed agent opens a PR in the connected source-control system, and merging that PR moves the task to Merged.
What are this agent's strengths and limitations?
- It makes specification review and pull requests explicit gates: plans are written to a helix-specs branch and implementation returns through the existing code-hosting workflow.
- Each agent receives an isolated, GPU-accelerated desktop with a browser, terminal, filesystem, and GUI apps rather than only a shared terminal session.
- Tasks can select or switch among Claude Code, Codex, Gemini CLI, Qwen Code, Goose, Zed Agent, and ACP-compatible agents, while also supporting OpenAI-compatible endpoints.
- It provides both a Docker quick start and Kubernetes control-plane and runner Helm charts, with documented self-hosted and air-gapped operation.
- RAG, OpenAPI/MCP tool connectivity, OIDC, RBAC, and usage/cost tracing are included for teams centralizing agent operations.
- Local development explicitly requires Docker, Docker Compose, Go 1.24.0+, Node.js 18+, and Make; production also requires planning for a control plane and GPU runners.
- Hosted-model usage requires the relevant OPENAI_API_KEY or ANTHROPIC_API_KEY, while self-hosted use requires a reachable OpenAI-compatible endpoint and customer-managed GPU capacity.
- The spec, approval, and PR workflow suits collaborative delivery but may be heavier than a one-off, local terminal-assistance workflow.
- Large commercial use is subject to license terms: companies with more than $10M in annual revenue or 250 employees must purchase a license through Launchpad.
- The README does not specify per-host agent density, GPU sizing, resource-scheduling behavior, or feature differences between supported agent harnesses, so capacity planning needs independent validation.
How does this agent compare with similar options?
Helix runs agents server-side in separate desktop environments and manages them through a shared Kanban board. Its stated contrast is the local-terminal pattern of running one Claude Code, Codex, or Gemini agent on a developer’s laptop; Helix uses those harnesses as selectable task executors rather than replacing them.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Helix Private Coding Fleet This agent | 51 · Major gaps | Self-hosted serviceFreemium | ★ 829 | 2d ago | Go | Codex · Claude Code · OpenAI API · Claude API |
| Symphony | Insufficient evidence | CLIFree + model costs | ★ 28k | 1mo ago | Elixir | Codex |
| OSpec | 69 · Some gaps | CLIFree + model costs | ★ 390 | 2mo ago | JavaScript | Codex · Claude Code |
| fx Coding Agent | 65 · Some gaps | CLIFree + model costs | ★ 3.8k | today | Zig | ChatGPT · Codex · OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
The README describes private infrastructure, isolated sandboxes, credential and network isolation, and user approval of plans; the installer is said to prompt before changing the system. The sample does not show implementation details for those safeguards. The CLI skill requires an API key and exposes session and bot operations, while the Drone MCP uses a bearer token and writes logs under a temporary directory; finer-grained credential protection, log cleanup, and authorization controls are not evidenced. Contributor instructions exist, but publisher identity and a verifiable user-facing update path are not established.
The sampled workflow has clear task stages, and the scripts include failure checks; the Drone tool returns errors and the sandbox test sample covers synchronization failures. Deductions reflect the limited sample, which cannot establish consistency across the whole product, and the large dependency set has no supplied evidence of availability guarantees, integrity review, or dependency security assessment.
The README identifies teams running coding agents on their own infrastructure and describes collaborative Kanban tasks, agent switching, source-control integrations, model providers, and GPU runners. It lists harnesses, ACP, deployment modes, and some boundaries. The broad product scope is not accompanied here by detailed component limits or precise trigger conditions, and Docker, local development, and Kubernetes setup still rely on external documentation.
The README is organized around product capabilities, quick start, configuration, development, documentation, contribution, and licensing, with Docker and Helm entry points and CLI/MCP examples. Production details and limitations largely point to documentation not included in the packet. Licensing is complex: README terms for free use and the subscription-service agreement in LICENSE.md require reconciliation by readers. The sample does not provide a clear release changelog or a verifiable maintenance owner and update commitment.
The Kanban flow, per-agent desktops, parallel work, and pull-request review provide a concrete path from task description to code review; the Drone MCP formats build, step, and log information for use. The claimed productivity and cost advantages remain product assertions in this sample. There is no quantification of deployment effort, GPU resources, operations, or savings to support an ordinary user's cost-benefit judgment.
Some README claims are consistent with the sampled CLI skill, MCP server, Go dependencies, Helm test template, and sandbox scripts, and the documentation distinguishes several capabilities and setup steps. Most product claims lack independent corroboration in the sample, and promotional benefits are not systematically separated from verifiable facts. This is a static review only; no execution or independent validation is claimed.
- Deployment involves GPU runners, repositories, model-provider credentials, and external integrations; verify actual permission boundaries, data flows, log retention, and backup recovery before production use.
- The README's free-use description and the subscription agreement in the license file are not straightforward to reconcile; review the complete terms that apply to the intended deployment.
- Include GPU, storage, cluster, and operational costs in evaluation; the sample provides no verifiable cost or performance measurements.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/helixml-helix)<a href="https://followagents.com/en/agents/helixml-helix"><img src="https://followagents.com/badge/helixml-helix.svg" alt="FARS review"></a>Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
What's Changed * fix(frontend): clear first embed message draft by @chocobar in https://github.com/helixml/helix/pull/3521 * Recover org bots after transient provider outages by @chocobar in https://github.com/helixml/helix/pull/3522 Full Changelog: https://github.com/helixml/helix/compare/2.12.50...2.12.51View on GitHub ↗ -
Release notes excerpt
What's Changed * fix(api): stop reflecting upstream errors on git connection validation (TST-01-271) by @chocobar in https://github.com/helixml/helix/pull/3518 * fix(api): restrict /debug/pprof to admins (TST-01-050) by @chocobar in https://github.com/helixml/helix/pull/3517 * fix(api): block SSRF via git browse-remote base_url (TST-01-272) by @chocobar in https://github.com/helixml/helix/pull/3516 * fix(api): block SSRF via provider endpoint base_url (TST-01-270) by @chocobar in https://github.com/helixml/helix/pull/3514 …View on GitHub ↗ -
Release notes excerpt
What's Changed * chore(zed): bump Zed to stop per-event websocket log lines by @nessie993 in https://github.com/helixml/helix/pull/3503 * chore(deploy): rotate container logs by @nessie993 in https://github.com/helixml/helix/pull/3501 * fix(settings-sync): log a persistent poll error once, not every 30s by @nessie993 in https://github.com/helixml/helix/pull/3502 * fix(hydra): stop tracked-but-stopped desktops pinning GC; harden orphan reaper by @nessie993 in https://github.com/helixml/helix/pull/3504 …View on GitHub ↗
FAQ
Is Helix tied to one model provider?
Do agents run on each developer’s machine?
How does code reach the main branch?
Can it operate without internet access?
What are the commercial-use limits?
Thanks — we use this to improve the page.