HelixML
Helix Code

Give every coding agent its own computer.

Bring Claude, Codex, Goose or whichever agent your developers already use. Helix puts each one on its own GPU-accelerated desktop, runs dozens of them side by side on hardware you control, and keeps a human on every merge.

Try free for 24 hoursTalk about an enterprise pilot →
15+ agent desktops per nodeSOC 2 Type II and ISO 27001Humans merge
Control Plane

A self-hosted control plane for coding agents.

Bring the agent you already pay for — Claude Code, OpenAI Codex, Gemini CLI, Qwen Code, Goose or Zed. Helix runs it on your own infrastructure, gives every thread its own sandboxed Linux desktop, and ships with the org chart, the budget and the deploy target attached.

One spec task: the agent's reasoning and diff on the left, its live sandbox desktop on the right, Reject and Open PR at the top. This one is running Codex.
Bring Your Own Subscription

One place to manage every model.

Helix doesn't resell tokens. Connect the Claude or ChatGPT subscription you already pay for, paste API keys for the providers you use, or point it at the GPUs in your own rack — then every project, agent and spec task draws from that same configured pool. Keys are scoped per user, per organisation, or across the whole installation, so a team gets inference without an API key ever landing in a repository.

  • Connect a Claude or ChatGPT subscription for desktop agents — not only API keys
  • Groq, Cerebras, Together, Fireworks and xAI too — or any OpenAI-compatible endpoint
  • Scope providers per user, per organisation, or installation-wide
  • Switch agent or model mid-thread — chat history and uncommitted work carry over
Configure LLM providers →

Agents

  • Claude Code
  • Codex
  • Gemini CLI
  • Qwen Code
  • Goose
  • Zed Agent

Models & runtimes

  • DeepSeek
  • Kimi
  • Llama
  • Mistral
  • Ollama
  • LM Studio
  • vLLM
  • NVIDIA NIM
  • Bedrock
Sandboxed Threads

Every thread gets its own Linux box.

This is the part a desktop app can't do. Each thread boots a containerised Ubuntu desktop on your infrastructure — the Zed IDE, a terminal, a browser, your repository cloned onto its own branch. Agents install packages, run Docker and click through the app they just built, and none of it touches your laptop or another agent's filesystem. Start a dozen at once.

  • One thread, one branch, one isolated desktop — separate dockerd, separate network
  • Up to 15 agent desktops on a single machine
  • Agents get root, a browser and a GPU — not just a shell
  • Step into any running desktop and take the keyboard
How sandboxes work →
Three tasks in flight on one project — each one its own desktop, each one resumable by anyone on the team.
Full Visibility

Watch the work, not just the diff.

The sandbox desktop streams to your browser as H.264 video, so you see what the agent sees — the editor it is typing in, the tests it is running, the browser it is clicking through. Its files and terminals are one tab away. When the branch is good, one button opens the pull request; the merge still waits for a human.

  • Live desktop streamed over WebSocket — no VPN, no VNC client
  • Browse every file in the sandbox while the agent works
  • Real terminals — the same shell the agent is using
  • Reject or Open PR: the merge stays human
Review and merge →
The Files tab opens the sandbox's working tree while the agent is still in it — chat on the left, the code it is editing on the right.
And the terminals are the same shells the agent typed into, open below the workspace.
The Platform Around It

Orgs, budgets, and somewhere to put the thing.

An agent tool is not a platform until a finance team can live with it. Helix comes with the surrounding machinery: organisations and teams with role-based access, shared secrets and org-level providers, every LLM call logged with its model, tokens and cost, concurrency caps per organisation, and hosting so the thing your agents built gets a URL instead of a screenshot.

  • Organisations, teams and roles — shared secrets, shared providers, one place to revoke access
  • Usage tracking: tokens, cost and request counts per user, per project, per provider
  • Budget controls: per-org sandbox concurrency caps, credit pricing, and a hard ceiling on compute spend
  • Website hosting: every project can go live on its own domain, every session can share a preview URL
Organisations and teams →Host a project →
The problem

Your developers are already running agents. Just not where you can see them.

Walk the floor of any engineering-forward company and you will find the same thing. Developers with a Mac Mini under the desk running a single coding agent around the clock. They bought the hardware. They are paying for the API keys. And they are shipping faster than the colleagues who are not doing this.

That is the signal. The demand for autonomous agents on dedicated hardware is already here, and right now it is sitting outside your infrastructure, outside your security perimeter and outside your visibility. The question is not whether your team will run coding agents. It is whether you will give them a version of it that scales.

Spec coding → parallel agents → human review → merge.

Your Role Change

You're becoming a manager of agents

Helix gives you the control room.

The Agent Computer

A full desktop — not just a terminal.

Every agent gets a full GPU-accelerated 4K streaming desktop — browser, terminal, filesystem, GUI applications. You can see what every agent is doing, in real time. Claude Code, Codex, Gemini CLI, Qwen — swap models per task. This is what makes Helix fundamentally different from every other approach.

  • 4K hardware-encoded streaming desktop
  • Browser, terminal, filesystem, and GPU per agent
  • Code, design, research, animation, CAD — not just code
  • Watch any agent work in real time
  • Any ACP-compatible agent — swap models per task, no lock-in
  • Works beautifully on desktop, tablet, and mobile
Why agent virtualization needs a new stack →
Over-Engineered for Speed

The fastest agentic engineering stack.

3×faster Claude on Helix Cloud

Every layer is purpose-built for minimum latency. A blazing-fast IDE built in Rust with GPU-accelerated rendering — no Electron, no browser overhead. Agents on the server, close to inference over server-grade networking. Fully hardware-accelerated video end to end. Works with Claude Code, Codex, Gemini CLI, and Qwen.

  • Accelerated Claude — higher uptime, less peak-time congestion
  • IDE built in Rust — GPU-accelerated rendering, zero Electron overhead
  • Server-side agents — your connection doesn’t slow them down
  • Hardware-accelerated video — server GPU to client GPU
The full speed stack explained →
Fleet Visibility

See every agent. Step into any one.

See every running agent desktop from 30,000 feet. Zoom into any agent's live screen. Jump in with multi-cursor pair programming when one gets stuck. Back out when it doesn't need you.

  • 30,000-ft fleet dashboard
  • Zoom into any agent's live desktop
  • Multi-cursor pair programming
  • Full audit trail of every agent action
  • End-to-end trace — pinpoint exactly where things went wrong
Multiplayer

Your team in Tokyo picks up where London left off.

Every agent environment is shared. Multiple developers can watch the same agent, direct it, and interact with the running app — simultaneously or across shifts. Full chat history, spec progress, and running state persist independently of who's online. No end-of-shift summaries. No context reconstruction. Just open the task and keep going.

  • Multiple developers in the same agent environment
  • Full chat history visible to everyone with access
  • Zero-friction handoff across time zones
  • Spec-driven context — structured, not ad-hoc
  • Replace private dev boxes with shared agent computers
See follow-the-sun in action →
Density

Up to 15 agent desktops on a single machine.

This is the key innovation. High-density sandboxed isolation — dozens of fully isolated agent desktops running on one physical machine. Each agent's filesystem, credentials, and network access are completely separate.

  • Up to 15 isolated agents per node
  • Deduplicated filesystem — zero storage explosion
  • Per-agent credential and network isolation
  • No cross-contamination between agents
Project Management

Sorry, you're a manager now.

Break projects into specs. Chat with the PM agent about architecture, then let worker agents implement in their own isolated desktops. Track agents across columns: Backlog → Design review → Implementation review → Done. Specs are reviewed before code is written — not after. The board moves — you manage the flow.

  • PM agent helps break down projects into specs
  • Specs reviewed before implementation begins
  • Kanban pipeline with human review gates
  • PRs require your sign-off before merge
  • Your team and agents work the board together
Enterprise Security

Blast radius contained by design.

Ephemeral per-task git keys. Branch-scoped access. RBAC, SOC 2 Type II, ISO 27001. Every agent desktop is a sandbox — credentials are issued at task start and revoked at task end. Nothing persists.

  • Ephemeral per-task git keys
  • Branch-scoped access — no accidental writes to main
  • RBAC, SOC 2 Type II, ISO 27001
  • Token metering per project
  • Slack & Teams integration
Clone

Do it once. Clone it fifty times.

Do a task once in one repo — the spec learns from the work. Then clone that knowledge across 49 other repos and spin up background agents to do them all in parallel. Security patches, compliance updates, logging changes — done in minutes, not weeks.

  • Apply the same change across 50 repos in minutes
  • Spec compounds — learns from the first task
  • Clone group dashboard — track progress across all repos
  • Works for code, compliance rollouts, policy updates — any repeated structured task
Code Intelligence

Agents that understand your codebase.

Powered by Kodit. Code indexing, cross-repo navigation, and wiki generation, so agents find the right context instead of guessing. Every agent gets an understanding of your organisation's repositories before it writes a single line.

  • Reduce duplication by surfacing reusable code
  • Reduce tokens by providing the right context, first time
  • Reuse organisational patterns and practices
  • Improve agentic coding performance and productivity
Deep dive into Kodit →
Deep Dive

See the full workflow

From spec to merged PR — agent desktops, kanban pipeline, fleet visibility, and human review gates in action.

Join the Helix Cloud waitlistEnterprise deployment →

Cloud waitlist moving fast. Introduce yourself on Discord to skip the queue. Mac app available now.

How work flows

Specs, review gates, and a human on the merge

Helix structures work through specs rather than prompts thrown at a repository. Every stage has a gate, and a person holds the gate.

  1. 1
    A spec gets written and reviewedA planning agent breaks the project down into spec documents. Those get reviewed and approved before a line of code is written.
  2. 2
    A worker picks it up in its own desktopApproved specs move off the kanban backlog. The agent implements in an isolated desktop with ephemeral, branch-scoped git credentials issued at task start and revoked at task end.
  3. 3
    You watch, or you do notThe desktop streams live. Zoom in when you want to see how it is going, pair-program when it stalls, leave it alone when it is fine.
  4. 4
    A human reviews and merges the pull requestAgents push only to the branch they were assigned, never to main. Every PR needs human sign-off. The board runs Backlog, Design review, Implementation review, Done.
Enterprise controls

The things that decide whether this gets deployed

Single-agent tools were designed to connect one assistant to a consumer messaging app. Helix was designed to run a fleet inside a security boundary.

  • Ephemeral per-task git credentialsTokens are issued when a task starts and revoked when it ends. No long-lived keys sitting on a machine, and agents can only push to their assigned branch.
  • RBAC, SSO and audit loggingRole-based access control and single sign-on from day one, with per-project token metering so you can see LLM spend by team, project and agent.
  • SOC 2 Type II and ISO 27001Independently audited. Agents talk through Slack and Teams, not consumer messaging apps.
  • Runs where you need itKubernetes, Linux, Apple Silicon, or air-gapped with no outbound internet access. From the $299/year Mac App up to a full cluster.
Infrastructure

Is your team ready for agent fleets?

Three questions every engineering team should be able to answer before deploying autonomous agents at scale. We can help.

Can a new engineer go from zero to running code in one click?

One-click sandbox templates, checked into your repo

Can you spin up 10 identical environments programmatically?

Kubernetes-backed sandbox runner — spin up dozens via API

If an agent is compromised, what limits the blast radius?

Per-task ephemeral git keys + fully sandboxed filesystems

Try Helix for Mac — 24-hour free trialTalk to us about enterprise deployment
Private AI Stack

Not ready for agent fleets? Start where you are.

Most teams begin with private inference or RAG — and that’s fine. Helix covers the entire AI stack, from running open-source models to orchestrating dozens of agents. Everything runs fully self-hosted on your own infrastructure — Mac, Linux GPU, or enterprise Kubernetes — even air-gapped with open-source LLMs. Start with the pieces you need. Scale when you’re ready.

See the full private AI stack →

Inference · RAG · Vision RAG · Evals · Observability · Agent Fleets

Pricing

One price for the whole fleet

24-hour free trial on Mac app. Cloud and Enterprise plans available on request.

Mac App

Individual
$299per year

The full power of agent desktops on your own Mac. Run dozens of agents simultaneously, each in its own isolated desktop. Share across your LAN — your whole team gets agent desktops from one machine. Credentials and dev data stay on your hardware.

  • Multiple simultaneous agent desktops
  • LAN sharing — team access from one Mac
  • Your own API keys, no markup
  • Use your API key or Claude subscription, or go fully local with Ollama
  • Mac Mini / Mac Studio / MacBook compatible
Start 24-hour trialAlso available: Helix for Linux — $199/year

Cloud

Team
$499/mper user

Accelerated Claude — 3× faster, higher uptime, no peak-time congestion

Managed agent fleet infrastructure. Get your team running in minutes — no hardware, no Kubernetes, no setup. Helix handles the sandboxes, networking, and scaling.

  • Accelerated Claude — 3× faster, higher uptime, less congestion than the public Anthropic API
  • Agents run at server speed — your connection doesn't slow them down
  • Fully hardware-accelerated video — server GPU to client GPU, end to end
  • Everything in Mac App
  • Full streaming desktops for every agent
  • 30 concurrent agent desktops
  • 5,000 tasks per month
  • 10 projects
  • Shared fleet dashboard for the whole team
  • Zero infrastructure to manage
Start free trial

Enterprise

Pilot slots limited
From $75K8-week production pilot

Deploy agent desktops on your Kubernetes cluster. Full RBAC, SOC 2 Type II, ISO 27001. Ephemeral credentials, branch-scoped git access, token metering. Your infrastructure, your control, unlimited agents.

  • Everything in Cloud
  • Agents work at server speed — close to your inference provider or local models
  • Deploy on your Kubernetes cluster
  • RBAC and SSO
  • SOC 2 Type II & ISO 27001
  • Ephemeral per-task credentials
  • Unlimited sandbox runners
  • Token metering per project
  • Dedicated onboarding (8-week pilot)
Contact salesDeveloper license from $199/year · Install docs →

Sovereign Server

Turnkey hardware
$175Khardware + onboarding + first-year licenseBuy now →Full specs & ROI →
4U rack server with 8× NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs

A 4U rack server with 8× NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs (768 GB total VRAM), Helix preloaded, shipped to your data centre. Plug in, power on, run 50+ developers with agents in parallel — each with their own GPU-accelerated desktop — with zero cloud dependency. Frontier DeepSeek reasoning (1.1–1.7K output tok/s at 95–99% cache reuse) on hardware you own.

The maths: Real agent fleets burn through $800/developer/month or more of cloud tokens — a team of 50 is paying roughly $40K/month. A Sovereign Server supports 50+ developers and runs frontier DeepSeek models on your own GPUs — just the cost of electricity and your annual Helix licence. At that spend the $175K hardware pays for itself in about five months, then keeps working for a decade. No token metering. No surprise bills. No vendor deciding to double their API prices overnight. Learn more about digital sovereignty →

  • 8× RTX PRO 6000 Blackwell Server Edition GPUs — 768 GB VRAM
  • Helix pre-installed and configured
  • Supports 50+ developers in parallel
  • 1.1–1.7K output tok/s at 95–99% cache reuse
  • Frontier reasoning: 89% ARC-AGI-1 on DeepSeek V4 Flash
  • Hundreds of concurrent agent desktops
  • Air-gap ready — no internet required
  • Zero telemetry, zero phone-home
  • Discounted 8-week onboarding included
  • First-year enterprise license included
  • RBAC, SSO, full audit trail
  • Your jurisdiction, your hardware, your data

The teams that move first will set the pace. Everyone else scrambles to keep up.

Try free for 24 hours
Try Helix Cloud free

Waitlist moving fast. Say hi on Discord to skip the queue.

Enterprise deployment →
Getting started

Start on a Mac, or start with a pilot

The Mac App is $299/year and runs dozens of agent desktops on hardware you already own. Credentials and dev data stay on your machine. It is the fastest way to find out whether a fleet of agents is useful to your team.

Enterprise deployments start with an 8-week structured pilot on your own Kubernetes cluster, from $75K. That includes onboarding, RBAC and SSO configuration, integration with your git and CI/CD workflows, Slack or Teams, token metering dashboards and a final readout. At the end you have a production-grade agent cluster in your infrastructure and a clear picture of what org-wide looks like.

Want the whole thing on one box? The Sovereign Server is a 4U appliance with Helix preloaded.

Frequently asked questions

Which coding agents does Helix Code run?
Claude Code, Codex, Goose, Qwen Code and Zed's agent, among others. Helix sandboxes and orchestrates whichever agent you bring, and you can switch agents per task without changing your workflow.
Can you run AI coding agents on your own infrastructure?
Yes. Helix deploys on your Kubernetes cluster (with air-gapped support), on a Mac Studio, or as the $299/year Mac App. Agents run in isolated desktops inside your security perimeter with ephemeral per-task git credentials, and a full self-hosted cluster deployment keeps all code and data in your environment.
Is Helix SOC 2 or ISO 27001 certified?
Yes. Helix is SOC 2 Type II and ISO 27001 certified (independently audited). Enterprise deployments add RBAC, SSO, audit logging, and per-project token metering.
How do you keep autonomous coding agents safe on a production codebase?
Work flows through specs with human review gates: specs are reviewed before code is written, and agents' pull requests require human sign-off before merge. Agents push only to their assigned branch with short-lived, branch-scoped credentials issued at task start and revoked at task end, never to main. Each agent's desktop is streamed live so you can watch or intervene.
What does Helix Code cost?
The Mac App is $299/year. Linux and Kubernetes installs start from $199/year. Enterprise deployments start with an 8-week structured pilot on your own Kubernetes cluster from $75K.