# HelixML > AI agent orchestration platform. Build AI agents with skills, knowledge, sandboxes, and integrations. ## Docs - [Getting Started](https://helix.ml/docs): Documentation for HelixML. - [Projects & Spec Tasks](https://helix.ml/docs/projects): Projects and spec tasks are the core of HelixML. This is how work is planned and executed. - [Agents](https://helix.ml/docs/agents): Build AI agents with skills, knowledge, and integrations. - [Sandboxes](https://helix.ml/docs/sandboxes): Isolated desktop environments for AI coding agents. - [Code Intelligence](https://helix.ml/docs/code-intelligence): Deep code understanding powered by Kodit. Semantic search, codebase navigation, and context-aware agent workflows. - [Mac App](https://helix.ml/docs/macos): Run dozens of AI agent desktops on your own Mac — fully local, GPU-accelerated, nothing leaves your machine. - [Helix Cloud](https://helix.ml/docs/helix-cloud): Managed Helix service with sandboxes, authentication, and infrastructure handled for you. - [Linux & Kubernetes](https://helix.ml/docs/linux-kubernetes): Install Helix on a Linux server or Kubernetes cluster. - [Sovereign Server](https://helix.ml/docs/sovereign-server): A 4U rack server with 8× NVIDIA RTX 6000 Pro GPUs and 768 GB VRAM, Helix preloaded. Ship it to your data centre, power it on, run hundreds of concurrent AI agents with zero cloud dependency. --- ## What is HelixML? Helix is a batteries-included platform for building, running and managing AI agents. It can do everything from working as a simple self-hosted ChatGPT alternative to working as a controlplane for your fleet of agents. ![Helix Code](/images/helix-code.svg) ## Features - Kanban style board to manage your project backlog, automatically picking up new work - Agent sandboxes with full desktop - Integration with all major LLM providers (Anthropic, OpenAI, Google, etc.) - Integration with all majors source control providers (GitHub, GitLab, Bitbucket) - Full planning -> implementation -> review -> pull request -> merge workflow ## Use cases - Accelerate development of any project - Internal knowledge base for your team - Automated customer support - Closed self-improvement loop through support -> tickets -> spec tasks -> fixes --- ## Projects Projects are spec-driven project management boards that organize how work gets planned and executed by AI agents. Each project acts as a workspace where you define what needs to be built, track progress across tasks, and review the results — all through a structured, approval-based workflow. ![Projects board showing spec tasks organized by status](/images/projects.png) Project provide: - Ability to collaborate with your team - Manage spec tasks - Setup Optimus, a Helix agent to help you plan and manage your project - Setup recurring tasks such as reviewing your GitHub issues and preparing new spec tasks to work on ## Spec Tasks A spec task is a discrete unit of work within a project. You describe what needs to happen — a feature to build, a bug to fix, a change to make — and an agent prepares an execution plan. Once you approve the plan, the agent carries out the work inside an isolated sandbox environment, producing a pull request for human review. Spec tasks move through a clear lifecycle: - **Define**: Write a spec describing the desired outcome - **Plan**: An agent analyzes the codebase and proposes an execution plan - **Approve** Review the plan and approve it before any work begins - **Implementation**: The agent works inside a sandbox desktop with full access to browser, terminal, and file system - **Review**: A pull request is created for human review and merge ![Spec task detail view showing the execution plan and status](/images/spec_tasks.png) This human-in-the-loop approach keeps you in control. Agents never push code or merge changes without your explicit approval. You set the direction, agents handle the execution, and you review the output. ## Jump in at any step You can always participate in the process at any step. You can review the plan, approve it, or even edit the spec to make changes. You can also review the implementation and make changes to the spec based on the implementation. ![Collaborate on the spec task](/images/spec_task_detail.png) Interact with this desktop view directly, use the browser, IDE and terminals inside the sandbox. --- Helix agents combine language models with skills, knowledge bases, and external integrations. An agent receives a user message, decides which tools to use, executes them, and synthesizes a response. ## How Agents Work When a user sends a message, the agent: 1. Loads the assistant configuration (model, system prompt, skills) 2. Queries relevant knowledge bases for context 3. Calls the LLM with available tools exposed as OpenAI function calls 4. Executes any tools the LLM decides to use (in parallel if multiple) 5. Adds results to the conversation and repeats until done Agents iterate up to a configurable maximum (default 10) before stopping to prevent runaway loops. ## Skills Skills are capabilities you attach to an agent. Each skill exposes one or more tools the LLM can invoke. ### Built-in Skills | Skill | Description | |-------|-------------| | **Web Search** | Search the internet and browse results | | **Browser** | Open URLs and extract content as markdown | | **Knowledge** | Query RAG sources for document retrieval | | **API Calling** | Execute REST APIs defined with OpenAPI schemas | | **Calculator** | Perform mathematical operations | | **Memory** | Persist information across sessions | | **MCP** | Connect to Model Context Protocol servers | ### Enabling Skills Skills are enabled in the assistant configuration: ```yaml assistants: - name: Research Assistant model: qwen3:8b system_prompt: You help users research topics. web_search: enabled: true max_results: 10 browser: enabled: true markdown_post_processing: true calculator: enabled: true ``` ## Knowledge Knowledge bases provide RAG (retrieval augmented generation) for your agents. When attached to an assistant, knowledge becomes a tool the agent can query. ```yaml assistants: - model: qwen3:8b knowledge: - name: product-docs description: Product documentation and API reference source: web: urls: - https://docs.example.com/ crawler: enabled: true rag_settings: results_count: 8 chunk_size: 2048 ``` Knowledge sources can be: - **Web URLs** with optional crawling - **Uploaded files** (PDF, DOCX, PPTX) - **Inline content** (text directly in config) - **S3 buckets** - **Google Drive** Knowledge can refresh on a schedule: ```yaml knowledge: - name: news-feed refresh_enabled: true refresh_schedule: "0 */6 * * *" # Every 6 hours source: web: urls: - https://news.example.com/feed ``` ## API Integrations Connect agents to REST APIs using OpenAPI schemas. The agent can call endpoints based on user requests. ```yaml assistants: - model: qwen3:8b apis: - name: Weather API description: Get current weather and forecasts url: https://api.weather.example.com schema: | openapi: 3.0.0 info: title: Weather API version: 1.0.0 paths: /current: get: summary: Get current weather parameters: - name: city in: query required: true schema: type: string ``` For APIs requiring authentication, use OAuth providers: ```yaml apis: - name: GitHub url: https://api.github.com schema: ./github-openapi.yaml oauth_provider: github oauth_scopes: - repo - read:user ``` ## MCP Servers Model Context Protocol (MCP) lets agents connect to external tool servers. Any MCP-compatible server exposes its tools to your agent. ```yaml assistants: - model: qwen3:8b mcps: - name: Database Tools description: Query and manage database records url: https://mcp.example.com/tools headers: Authorization: Bearer ${MCP_API_KEY} ``` MCP servers can also use OAuth for authentication: ```yaml mcps: - name: Salesforce url: https://mcp.salesforce.example.com oauth_provider: salesforce oauth_scopes: - api - refresh_token ``` ## Triggers Agents can be triggered from various sources beyond the chat UI: ### Discord ```yaml triggers: - discord: server_name: My Server channel_names: - support - general ``` ### Slack ```yaml triggers: - slack: bot_token: ${SLACK_BOT_TOKEN} channels: - C01234567 ``` ### Scheduled (Cron) ```yaml triggers: - cron: schedule: "0 9 * * 1-5" # 9am weekdays input: Generate the daily report ``` ### Webhooks Agents expose webhook endpoints that can be called by external systems to trigger conversations. ## Secrets Store sensitive values as secrets rather than hardcoding them: ```yaml assistants: - model: qwen3:8b apis: - name: Internal API url: https://api.internal.example.com headers: X-API-Key: ${INTERNAL_API_KEY} ``` Secrets are configured in the Helix UI under the app settings, or via the `secrets` field in the app configuration. ## Agent Types Helix supports different agent execution modes: | Type | Description | |------|-------------| | **helix_basic** | Simple chat assistant without tool calling | | **helix_agent** | Standard agent with skills and tool calling | | **zed_external** | Runs in isolated desktop environment with Zed IDE (Helix Code) | Set the agent type in the assistant configuration: ```yaml assistants: - model: qwen3:8b agent_type: helix_agent max_iterations: 20 ``` For Helix Code sandboxes, use `zed_external`: ```yaml assistants: - model: claude-sonnet-4-20250514 agent_type: zed_external generation_model_provider: anthropic ``` ## Example: Full Agent Configuration ```yaml name: Customer Support Agent description: Handles customer inquiries with access to docs and CRM assistants: - name: Support model: qwen3:8b system_prompt: | You are a helpful customer support agent. Use the knowledge base to answer product questions and the CRM API to look up customer information when needed. temperature: 0.3 max_iterations: 15 knowledge: - name: help-docs description: Product documentation and FAQs source: web: urls: - https://help.example.com/ crawler: enabled: true max_depth: 3 apis: - name: CRM description: Look up customer records and order history url: https://crm.example.com/api schema: ./crm-openapi.yaml oauth_provider: internal-sso web_search: enabled: true triggers: - slack: bot_token: ${SLACK_BOT_TOKEN} channels: - support-requests - cron: schedule: "0 8 * * 1" input: Generate weekly support summary ``` --- Helix Code provides isolated desktop environments where AI coding agents work autonomously. Each agent runs in its own containerized Linux desktop with a full IDE, and you watch their progress via real-time video streaming in your browser. See also the [Coding Agents overview](/docs/agents) for how sandboxes fit into the broader agent workflow. ## How It Works Each agent session receives its own containerized environment with: - **Isolated Linux desktop** running on Wayland (Sway) or X11 (GNOME) - **Zed IDE** - a Rust-based editor with native GPU rendering - **AI agent** - powered by Claude, Qwen, or other LLMs via the Helix proxy - **WebSocket streaming** - H.264 video streamed to your browser over standard HTTPS The Helix control plane manages orchestration, knowledge sources, and conversation history through the UI. ## Architecture Helix Code uses a three-tier isolation model for security and multi-tenancy: ``` +--------------------------------------------+ | HOST MACHINE | | +--------------------------------------+ | | | Helix Control Plane | | | | (API Server, Frontend, Postgres) | | | +-----------------+--------------------+ | | | | | +-----------------v--------------------+ | | | HELIX-SANDBOX CONTAINER | | | | (Docker-in-Docker) | | | | +--------------------------------+ | | | | | HYDRA | | | | | | (Multi-Tenant Isolation) | | | | | | Isolated dockerd + network | | | | | +-------+----------------+-------+ | | | | | | | | | | +-----v----+ +-----v----+ | | | | | Ubuntu | | Ubuntu | | | | | | Session | | Session | ... | | | | | with AI | | with AI | | | | | +----------+ +----------+ | | | +--------------------------------------+ | | | | | WebSocket Video Stream | | (H.264 over HTTPS) | | v | | Browser | +--------------------------------------------+ ``` **Hydra** manages multi-tenant isolation within the sandbox. Each concurrent session gets its own Docker daemon with isolated networking (separate bridge networks with non-overlapping subnets). Sessions cannot see each other's containers or network traffic. ## Features ### AI Agent Integration Agents connect to Zed IDE via WebSocket and can use any LLM provider configured in Helix: - Anthropic Claude (Sonnet, Opus) - OpenAI GPT-4 - Local models via Helix runners (Qwen, Llama) - Any OpenAI-compatible API ### Contextual Awareness Integrate external knowledge sources into agent environments: - PDFs and documents - Jira and Confluence - MCP (Model Context Protocol) servers - Custom knowledge bases ### Knowledge Aggregation Conversation histories across all coding sessions are searchable via RAG, enabling knowledge sharing across your team. ### Spec-Driven Workflows Use Kanban boards to manage agent task specifications before implementation, ensuring agents work on well-defined tasks. ## Installation ### Requirements - Linux x86_64 (Ubuntu 22.04+ recommended) - Docker - (Optional) NVIDIA GPU for hardware video encoding macOS and Windows are not supported for running sandboxes. The sandbox requires Linux with Docker. ### Quick Start Run the Helix installer: ```bash curl -sL -O https://get.helixml.tech/install.sh chmod +x install.sh sudo ./install.sh ``` The installer will detect your hardware and configure the sandbox automatically. On systems with NVIDIA GPUs, hardware H.264 encoding provides 60 FPS streaming with minimal CPU overhead. ### Configure Inference Providers After installation, configure AI providers through **Account** → **AI Providers**: - Anthropic (Claude) - OpenAI - Together AI - Any OpenAI-compatible API Or connect a Helix runner with local models for complete data privacy. ## Desktop Environments Three desktop options are available: | Environment | Display Server | Best For | |-------------|----------------|----------| | **Sway** | Native Wayland | Lightweight, fast startup, lowest resource usage | | **Ubuntu** | GNOME (Xwayland) | Full desktop experience, broader app compatibility | | **Zorin** | GNOME (Xwayland) | User-friendly interface | Each desktop includes: - Zed IDE with AI agent integration - Firefox browser - Docker CLI - Git ## Use Cases ### Autonomous Development Agents work asynchronously on tasks while you focus on other work. Review results when ready rather than waiting for completions. ### Fleet Management Manage multiple concurrent agent tasks across your team. Track progress, review outputs, and coordinate work through the Kanban board. ### Cloud Development Environments Persistent development environments that survive disconnections. Pick up where you left off from any device with a browser. ### Security Each agent runs in its own isolated container with: - Separate filesystem (no access to host) - Isolated network (no cross-session traffic) - Dedicated Docker daemon (via Hydra) Code execution is contained within the session. Even if an agent runs malicious commands, the blast radius is limited to that session's container. ## Getting Started 1. Install Helix with the installer script 2. Access the Helix UI at your deployment URL 3. Go to **Helix Code** and create a new session 4. Send a message to start the agent working 5. Watch the agent's desktop in real-time via the video stream --- Helix Code Intelligence, powered by our open source library Kodit, is a global code index. It gives both users and coding assistants an appreciation of external codebases. Agents can navigate enterprise architectures like experienced developers. ## Why It Matters Agents working without code intelligence waste tokens re-reading files, miss relevant context, and make changes that break downstream consumers. Kodit eliminates this by giving every agent the structural understanding it needs upfront. Coding assistants repeatedly rewrite functionality that already exists in organizational libraries and even the same codebase. Code intelligence reduces duplication by surfacing reusable code. In our experiments, code intelligence improves agentic coding performance on the SWE-bench benchmark by 20%. ## How It Works Helix Code Intelligence uses Kodit to build a structured representation of internal and external repositories. When an agent needs to write code, instead of guessing, it can search for relevant snippets, read API documentation and understand architecture. Kodit provides precise, context-aware responses to adopt and unify organisational patterns and prevent duplication. It prevents coding assistants reimplementing functionality that exists elsewhere in the codebase or the organisation. Kodit is also useful for humans. Helix Code Intelligence provides a dynamic wiki, built from the underlying code, to give you greater understanding of a repository if you need to learn more. Helix Code Intelligence has full integration with Helix and indexes your Projects and Repositories out-of-the-box. ## Key Capabilities - **Semantic and keyword code search** - find code by intent and keywords - **Global bash-like tools** - org-wide ls and grep functionality - **Cross-language support** - indexing pipelines that work with your code and your documentation - **External MCP access** - give local IDEs the power of code intelligence - **Automated wiki generation** - unify repository documentation _and_ keep it up to date - **Internal & external** - works with private or public repositories --- Don't have Apple Silicon? Try [Helix Cloud](https://app.helix.ml) or see [Linux & Kubernetes docs](/docs/linux-kubernetes). ## Overview Run the entire Helix platform locally on your Mac. The Mac app gives you a private, offline-capable AI agent stack powered by Apple Silicon — no cloud dependency required. ## Download ## Supported Hardware Helix runs on **any Apple Silicon Mac** (M1 and later) with **16 GB+ unified memory** — MacBook Air, MacBook Pro, Mac Mini, Mac Studio, Mac Pro. More unified memory = more agent desktops running simultaneously. 32 GB+ recommended for heavier workloads. ## What You Get - Up to 15 isolated agent desktop environments running simultaneously - GPU-accelerated 4K streaming via Apple Silicon - LAN sharing — give your team access without exposing anything to the internet - Full Helix controlplane running locally - Local LLM inference on Apple Silicon GPUs - All data stays on your machine ## Requirements - macOS 14 (Sonoma) or later - Apple Silicon (M1 or newer) - Minimum 16 GB unified memory (32 GB+ recommended) ## Licensing The Mac App requires a license at **$299/year**. You can purchase one from your [Account page](/account/licenses). A license includes: - Unlimited agent desktops (hardware permitting) - All updates for the license period - Email support --- ## Overview Helix Cloud is the fastest way to get started. We manage the infrastructure, sandboxes, authentication, and scaling — you focus on building with AI agents. ## Getting Started 1. Sign up at [app.helix.ml](https://app.helix.ml) 2. Create your first project 3. Define spec tasks and let agents do the work No installation, no infrastructure, no maintenance. ## What's Included - **Managed Sandboxes** — isolated desktop environments provisioned on demand - **Authentication** — built-in user management and team access controls - **Automatic Scaling** — infrastructure scales with your workload - **All LLM Providers** — access to Anthropic, OpenAI, Google, and more out of the box - **Source Control Integration** — connect GitHub, GitLab, or Bitbucket in one click ## Plans Helix Cloud is available on **Pro** and **Business** plans. Both include a 14-day free trial. See [Pricing](/pricing) for details. --- Install Helix on a Linux server or Kubernetes cluster. Developer license $199/year — no sales call required. ## Licensing A license is required to run Helix on Linux or Kubernetes. - **Developer license — $199/year**: For individuals, testing, and businesses with less than $10M annual revenue or fewer than 250 employees. [Buy a developer license →](/account/licenses) - **Enterprise license**: For larger organizations with full RBAC, SSO, SOC 2 Type II, and dedicated onboarding. [Enterprise licensing →](/account/enterprise) Helix runs on any Kubernetes cluster — whether that's on your own bare metal, a European cloud provider like [Hetzner](https://www.hetzner.com/) or [OVH](https://www.ovhcloud.com/), or a major cloud platform like AWS (EKS), Google Cloud (GKE), or Azure (AKS). If you can run containers, you can run Helix. For organisations focused on [digital sovereignty](/use-cases/digital-sovereignty), we also offer a [turnkey Sovereign Server](/docs/sovereign-server) — a 4U rack server with Helix pre-installed, shipped to your data centre. ## Local Setup To install Helix on your own Linux server with Nvidia/AMD GPU support, run the following command: ```bash curl -sL -O https://get.helixml.tech/install.sh && bash install.sh ``` ## Kubernetes Setup To install Helix as a chart in your Kubernetes cluster you will first need to create secrets with the following contents: ``` # Create namespace and secrets kubectl create namespace helix kubectl config set-context --current --namespace=helix # Create secrets with generated secure values kubectl create secret generic postgresql-auth-secret \ --from-literal=postgres-password="zuriOfPBBpOaUUDff32FGSAz" \ --from-literal=username="helix" \ --from-literal=password="" \ --from-literal=database="helix" kubectl create secret generic pgvector-auth-secret \ --from-literal=username="postgres" \ --from-literal=password="" \ --from-literal=database="postgres" kubectl create secret generic helix-pgvector-creds \ --from-literal=dsn="postgresql://postgres:@my-helix-controlplane-pgvector:5432/postgres" kubectl create secret generic helix-license \ --from-literal=license-key="eyJkYXRhIjoie1wiaWRcIjpcImxpY18zNlpBNllzRGRjZlVDRlVCRzdadDU4TEF5TTVcIixcIm9yZ2FuaXphdGlvblwiOlwicXF3ZXFcIixcInZhbGlkXCI6dHJ1ZSxcImlzc3VlZFwiOlwiMjAyNS0xMi0wOFQxNDoxOTowNC4wMjM5MzQ0ODJaXCIsXCJ2YWxpZF91bnRpbFwiOlwiMjAyNi0xMi0wOFQxNDoxOTowNC4wMjM3OTA4NDRaXCIsXCJmZWF0dXJlc1wiOntcInVzZXJzXCI6dHJ1ZX0sXCJsaW1pdHNcIjp7XCJ1c2Vyc1wiOjAsXCJtYWNoaW5lc1wiOjB9fSIsInNpZ25hdHVyZSI6IkFtamZqR0EzL2p5d1N5bEpDa0trM0x4eDRDWG5malpjTFVjcFBiTGdXZ2l1d0JKRTU2M2JrUC9Ea21pL1VIZEtNckdmb25OT2R1V2hrOHJ5TmNZR1RBPT0ifQ==" kubectl create secret generic helix-runner-secrets \ --from-literal=api-token="CHANGE-ME" ``` Now, save this as values.yaml for the chart: ```yaml # Production-ready configuration for helix-controlplane # For more information: https://docs.helixml.tech/helix/private-deployment/manual-install/kubernetes/ global: serverUrl: http://localhost:8080 image: tag: "" searxng: enabled: true chrome: enabled: true pgvector: enabled: true auth: existingSecret: "pgvector-auth-secret" usernameKey: "username" passwordKey: "password" databaseKey: "database" persistence: enabled: true size: 50Gi storageClass: "" annotations: {} accessModes: - ReadWriteOnce controlplane: licenseKeyExistingSecret: "helix-license" licenseKeyExistingSecretKey: "license-key" runnerTokenExistingSecret: "helix-runner-secrets" runnerTokenExistingSecretKey: "api-token" admin: userSource: "env" userIds: "all" haystack: enabled: true existingSecret: "helix-pgvector-creds" existingSecretDsnKey: "dsn" embeddingsModel: "MrLight/dse-qwen2-2b-mrl-v1" embeddingsDim: "1536" chunkSize: "1000" chunkOverlap: "50" chunkUnit: "word" rag: defaultProvider: "haystack" embeddingsProvider: "helix" inference: defaultProvider: "helix" fineTuning: defaultProvider: "helix" persistence: enabled: true size: 100Gi storageClass: "" accessModes: - ReadWriteOnce volumes: - name: data postgresql: enabled: true auth: existingSecret: "postgresql-auth-secret" postgresPasswordKey: "postgres-password" usernameKey: "username" passwordKey: "password" databaseKey: "database" architecture: standalone tika: enabled: false typesense: enabled: false ``` Now we are ready to deploy controlplane: ```bash # Add Helix Helm repository helm repo add helix https://charts.helixml.tech helm repo update # Install Control Plane with your generated values.yaml and secrets export HELIX_VERSION="latest" helm upgrade --install my-helix-controlplane helix/helix-controlplane \ -f values.yaml \ --set image.tag="${HELIX_VERSION}" ``` Now install the runner: ```bash # Install Runner (after control plane is running and secrets are created) export HELIX_VERSION="latest" helm upgrade --install my-helix-runner helix/helix-runner \ --set runner.host="http://my-helix-controlplane:8080" \ --set runner.tokenExistingSecret="helix-runner-secrets" \ --set runner.tokenExistingSecretKey="api-token" \ --set replicaCount=1 \ --set image.tag="${HELIX_VERSION}-small" ``` And to access it you can use the following command: ```bash kubectl port-forward svc/helix-helix-controlplane 8080:80 ``` --- ## Overview We ship a fully configured 4U rack server to your data centre with Helix pre-installed and ready to run. Plug it in, power it on, and your team has a private AI agent fleet — hundreds of concurrent agents, each with their own GPU-accelerated desktop — with zero cloud dependency. No API keys, no token metering, no data leaving your building. It's the fastest path to owning your AI stack. No Kubernetes expertise required. No cloud accounts. No configuration. Just hardware, software, and onboarding — in one package. [Learn why digital sovereignty matters →](/use-cases/digital-sovereignty) --- ## The hardware The Sovereign Server is built on the [Gigabyte G494-SB4](https://www.gigabyte.com/Enterprise/GPU-Server/G494-SB4-rev-AAP2) — a 4U GPU-optimised server platform designed for AI workloads. **Base configuration:** | Component | Specification | |---|---| | **GPUs** | 8× NVIDIA RTX 6000 Pro (Blackwell generation, 96 GB GDDR7 each — 768 GB total VRAM) | | **CPU** | Dual Intel Xeon 6 Series processors | | **Memory** | 256 GB+ DDR5 ECC Registered | | **Storage** | NVMe SSD (configured to workload) | | **Network** | Dual 10GbE onboard | | **Power** | Quad 3000W redundant (80+ Titanium) | | **Form factor** | 4U rackmount, standard 19″ | Configurations are customisable. We work with you during onboarding to spec the server to your workload — more memory, more storage, different networking — whatever your environment needs. --- ## What's included **Hardware** — The server itself, fully assembled, tested, and burned in before shipping. **Software** — Helix pre-installed and configured. The entire stack — inference, RAG, agents, agent desktops, fleet orchestration, observability — ready to go on first boot. **Onboarding** — A discounted 8-week structured onboarding programme with the Helix team. We help you integrate with your existing git workflows, CI/CD pipelines, SSO provider, and communication tools (Slack/Teams). Weekly check-ins and a final readout. **First-year license** — Your first year of the Helix enterprise license is included in the price. After year one, you renew annually. **Warranty** — 3-year return-to-base hardware warranty included. On-site support upgrades available. --- ## The economics Cloud AI is expensive and getting more expensive. We're hearing from teams spending $3,000 per developer per month on tools like Claude Code and Cursor — and that number keeps climbing. Per-seat and per-token pricing means your costs scale linearly with adoption — exactly when you want your team leaning into AI the hardest. The Sovereign Server flips that. **One-time hardware cost, predictable annual licence.** No token metering. No per-API-call billing. No surprise invoices. No vendor deciding to double their prices overnight. A single Sovereign Server comfortably supports 20–30+ developers and can run hundreds of concurrent AI agents, each with their own GPU-accelerated desktop. 768 GB of VRAM and hardware video encoding — this box has real density. At typical enterprise AI spend: | Scenario | Cloud AI (per year) | Sovereign Server (per year) | |---|---|---| | **10 developers, $3,000/month each** | $360,000 | Electricity + licence | | **20 developers, $3,000/month each** | $720,000 | Electricity + licence | | **30 developers, $3,000/month each** | $1,080,000 | Electricity + licence | At $3,000/developer/month, **a team of 20 is spending $720,000 per year on cloud AI.** The Sovereign Server pays for itself in under three months — and then keeps running for a decade. Even at more modest usage of $1,000/developer/month, a 20-person team recoups the hardware cost within the first year. After the hardware cost is recovered, your ongoing costs are predictable: an annual Helix licence with per-seat pricing you negotiate up front — not per-token billing that spikes every time your team leans harder into AI. Want to go all-in? Talk to us about an org-wide unlimited licence. Either way, the compute is already paid for, and you know what you're paying before the year starts. That's without factoring in the cost of a data breach, a compliance failure, or a vendor pulling the rug on your API access. --- ## Sovereignty by default The Sovereign Server isn't just cheaper. It's a different architecture. **Your infrastructure, your jurisdiction.** The server sits in your data centre, in your country, under your legal framework. Not "your region" of someone else's cloud. **No external API calls.** Every prompt, every response, every document stays on your network. Nothing leaves. **Open-weight models that rival the best.** Llama, Qwen, Mistral, DeepSeek, Kimi — the latest open-weight models now match or exceed Claude and OpenAI on most benchmarks. You choose which to run. Swap models without asking permission, and verify you're running exactly what you think you're running. No proprietary black boxes — and no reason to settle for less capable models just because you're running locally. **Works offline, air-gap ready.** Helix is designed to run fully disconnected. There's an optional version-update check, but no mandatory telemetry, no usage data collection, no licence heartbeat. Disconnect the network cable and it keeps running. **No vendor kill switch.** We can't revoke your access, force a model update, or shut you down because your use case violates an acceptable use policy. The server is yours. **Full auditability.** Every interaction logged locally. Prompts, responses, user identity, timestamps, model version. Your compliance team gets full visibility. Cloud AI providers can't offer any of this. Their business model depends on you not having it. [Read the full digital sovereignty case →](/use-cases/digital-sovereignty) --- ## What you can run The Sovereign Server runs the full Helix stack. Everything you'd get on Helix Cloud or a self-managed Kubernetes deployment — but on dedicated hardware with no shared tenancy. - **Private inference** — Run state-of-the-art open-weight LLMs locally with vLLM and Ollama backends. The latest models from Meta, Alibaba, Mistral, and DeepSeek are competitive with Claude and OpenAI on coding, reasoning, and language tasks — and you can run them on your own hardware. OpenAI-compatible API, so your existing integrations work without changes. - **RAG pipelines** — Text and vision RAG over your internal documents, PDFs, wikis. - **AI agents** — Autonomous agents with web search, browser, API calling, MCP integration. - **Agent desktops** — Full GPU-accelerated streaming desktops for every agent. Watch them work, pair-program when they need help. - **Fleet orchestration** — Spec coding, kanban pipeline, human-in-the-loop review gates. Manage dozens of agents from a single dashboard. - **Observability & evals** — Full visibility into what your agents are doing and how well they're doing it. With 8× RTX 6000 Pro GPUs and 768 GB of total VRAM, you can run large models (70B+ parameter) at production throughput while simultaneously running hundreds of concurrent agent desktops. Hardware video encoding means each desktop streams at 60fps with minimal CPU overhead. **Continuous updates, latest models.** Helix is actively developed — you can upgrade the software at any time to pick up support for new models as they're released. New open-weight models are landing every few weeks, and your server keeps pace. No waiting for a vendor to decide to "support" something. If it runs on your hardware, you can run it. --- ## Easily expandable The Sovereign Server is a single machine, but it's not a dead end. Helix is designed to scale horizontally. Need more compute? Just add more servers. Helix's architecture separates the control plane from GPU runners and agent sandboxes — so you can connect additional GPU servers to a single Helix control plane without replacing anything. Your second server doubles your capacity. Your third triples it. Each one slots in alongside the first. For larger deployments, we recommend moving the Helix control plane onto Kubernetes, which lets you manage a cluster of GPU servers as a single fleet. We can help you configure this — whether that's a handful of rack servers in your data centre or a larger distributed deployment across multiple sites. Start with one box. Scale when you need to. No rip-and-replace. --- ## Who it's for **Regulated industries** — Finance, healthcare, legal, defence, government. If you're subject to GDPR, NIS2, DORA, or the EU AI Act, the Sovereign Server gives you compliance by architecture rather than by contract. **Organisations leaving the cloud** — If you've done the maths on cloud AI spend and decided to bring it in-house, the Sovereign Server is the fastest path. No Kubernetes expertise required. **Air-gapped environments** — Classified and high-security environments where no outbound network access is permitted. The Sovereign Server runs fully disconnected after initial setup. **Teams scaling AI adoption** — If your developers are already running AI agents on personal machines and you need to bring that inside your security perimeter with proper controls, this is the enterprise answer. --- ## Pricing **~$175,000** — broken out: ~$100,000 for the hardware (CyberServe appliance, yours to keep) + $75,000 for the 8-week onboarding pilot and first-year enterprise licence. Helix pre-installed and configured. Annual licence renewal after year one with per-seat pricing. For larger organisations, ask us about org-wide unlimited licences. [Contact us](/contact) for licence pricing. Custom configurations available. If you need different GPU specs, more memory, or a multi-server deployment, we'll work with you to spec the right setup. --- ## Get started Ready to take control of your AI infrastructure? [Talk to us about a Sovereign Server →](/contact) Already have your own hardware? You can also deploy Helix on any Linux server or Kubernetes cluster. [See Linux & Kubernetes docs →](/docs/linux-kubernetes)