Helix — a private agent fleet with spec-driven coding
👥 Discord
Run a fleet of coding agents on your own infrastructure. Each agent gets its own GPU-accelerated desktop; you organize the work on a spec-driven Kanban board and review the pull requests.
It's about running agents on the server, not on every developer's laptop. You already run Claude Code (or Codex, or Gemini) locally: one agent, one terminal, tied to your machine and your attention. You wouldn't hire a team of developers and sit them all at one laptop — so why make your agents share one? Helix gives each agent its own computer.
Helix runs those agents as a fleet — many in parallel, each in its own isolated sandbox with a full desktop (browser, terminal, filesystem, GUI apps), on your own infrastructure, shared with your team. You describe an outcome as a spec task, an agent plans it, you approve the plan, and it implements the change and opens a pull request. Instead of one person babysitting one agent in one terminal, you and your team collaboratively dispatch, steer, and review many from a shared Kanban board.
It runs with the agent harnesses you already use (Claude Code, Codex, Gemini CLI, Qwen Code, or any ACP-compatible agent) against the LLM providers you already use — including self-hosted models on your own GPUs. Self-hostable end to end, including air-gapped.
Projects & the Kanban board
Work lives in projects. Each project connects one or more git repositories and has a Kanban board where spec tasks move left to right:
Backlog → Planning → Spec Review → In Progress → Pull Request → Merged
- Backlog — Create a task with a one-paragraph description of the outcome you want (what should be true when done, not how to do it).
- Planning — Click Start Planning. A planning agent reads the repo and writes a spec (requirements, design, task breakdown) to a
helix-specs branch.
- Spec Review — Read the plan. Highlight text to request changes and the agent re-plans, or Approve to commit to it.
- In Progress — An implementation agent codes in its own isolated desktop sandbox. Watch it live, type into the task thread to steer it, or switch to a different agent mid-session — the new one picks up where the last left off.
- Pull Request — When it's done, a PR is opened in your repo. The PR is the real review gate.
- Merged — The task closes when the PR merges.
Tasks run in parallel — each in its own sandbox — so you're not waiting for one to finish before starting the next. Per-column WIP limits keep the board honest. See Manage your backlog on the Kanban board.
Why Helix is different
- A full desktop per agent — not just a terminal. Every agent gets a GPU-accelerated streaming desktop with a browser, terminal, filesystem, and GUI apps. You can watch any agent work in real time.
- Fleet visibility. See every running agent from a dashboard, zoom into any one's live screen, and jump in with pair programming when it gets stuck.
- Multiplayer. Agent environments are shared. Teammates across time zones open the same task and keep going — full chat history and running state persist, no handoff summaries.
- High-density isolation. Many fully isolated agent desktops run on a single machine, with a deduplicated filesystem and per-agent credential and network isolation.
- No lock-in, and cheaper runs. Swap agent harnesses per task and point Helix at whatever models you run. Because context carries across the switch, you can start a task on a cheap local model and escalate to an expensive one only when it's actually needed — instead of paying frontier prices for the whole run.
Works with your stack (no lock-in)
Agent harnesses — use any of these per task, and swap between them mid-task:
- Claude Code
- OpenAI Codex
- Gemini CLI
- Qwen Code
- Goose
- Zed Agent
- Anything that speaks ACP (Agent Client Protocol)
Source control — connect your repositories and Helix opens pull requests where your code already lives:
- GitHub
- GitLab
- Azure DevOps
LLM providers — hosted or self-hosted:
- Major hosted providers (OpenAI, Anthropic, …)
- Anthropic via Helix's proxy, including Anthropic on Google Vertex AI and Anthropic on AWS Bedrock
- Self-hosted models — attach any OpenAI-compatible endpoint as an external provider. This includes vLLM: point Helix at your vLLM server's OpenAI-compatible URL and run open models on your own GPUs, on Kubernetes or bare metal, air-gapped if you need to.
Also included
Helix is a full private GenAI stack, so the pieces you'd expect are here too:
- Knowledge / RAG — document ingestion (PDF, Word, text), a web scraper, multiple RAG backends (Kodit, LlamaIndex), PGVector embeddings, and vision RAG.
- Skills & tools — REST/OpenAPI integrations, MCP server compatibility, GPTScript, OAuth token management, and a custom-tool SDK.
- Tracing & observability — every agent step, requests/responses to LLMs, APIs, and MCP servers, token usage, and cost analysis.
- Multi-tenancy & auth — organizations, teams, and role-based access control, with OIDC single sign-on.
- Billing & metering — track token usage and spend per user and per team, so you can see where the budget goes.
- Automation — scheduled/cron tasks and webhook triggers.
- Notifications — Slack, Discord, and email.
🚀 Quick Start
Install on Docker
Use our quickstart installer:
curl -sL -O https://get.helixml.tech/install.sh
chmod +x install.sh
sudo ./install.sh
The installer will prompt you before making changes to your system. By default, the dashboard will be available on http://localhost:8080.
For setting up a deployment with a DNS name, see ./install.sh --help or read the detailed docs. We've documented easy TLS termination for you.
Next steps:
Install on Kubernetes
Use our Helm charts for production deployments:
🔧 Configuration
All server configuration is done via environment variables. You can find the complete list of configuration options in api/pkg/config/config.go.
Key environment variables:
OPENAI_API_KEY - OpenAI API credentialsANTHROPIC_API_KEY - Anthropic API credentialsPOSTGRES_* - Database connection settingsSERVER_URL - Public URL for the deploymentRUNNER_* - GPU runner configuration
See the configuration documentation for detailed setup instructions.
👨💻 Development
For local development, refer to the Helix local development guide.
Prerequisites:
- Docker Desktop (or Docker + Docker Compose)
- Go 1.24.0+
- Node.js 18+
- Make
Quick development setup:
# Clone the repository
git clone https://github.com/helixml/helix.git
cd helix
# Start supporting services
docker-compose up -d postgres
# Run the backend
cd api
go run . serve
# Run the frontend (in a new terminal)
cd frontend
npm install
npm run dev
See local-development.md for comprehensive setup instructions.
📖 Documentation
🤝 Contributing
We welcome contributions! Please see our Contributing Guide for details.
By contributing, you confirm that:
- Your changes will fall under the same license
- Your changes will be owned by HelixML, Inc.
📄 License
Helix is licensed under a similar license to Docker Desktop. You can run the source code (in this repo) for free for:
- Personal Use: Individuals or people personally experimenting
- Educational Use: Schools and universities
- Small Business Use: Companies with under $10M annual revenue and less than 250 employees
If you fall outside of these terms, please use the Launchpad to purchase a license for large commercial use. Trial licenses are available for experimentation.
You are not allowed to use our code to build a product that competes with us.
Why these license clauses?
- We generate revenue to support the development of Helix. We are an independent software company.
- We don't want cloud providers to take our open source code and build a rebranded service on top of it.
If you would like to use some part of this code under a more permissive license, please get in touch.
🆘 Support
🌟 Star History
If you find Helix useful, please consider giving us a star on GitHub!
Built with ❤️ by HelixML, Inc.
