Cordium documentation · Latest

Introduction

On this page +

What Is Cordium?

Cordium is a free and open source, self-hosted, identity-based, horizontally scalable sandbox platform built on Kubernetes and Octelium. It provides isolated, reproducible sandboxes for humans, AI agents, and automated workloads.

Cordium is designed around two tightly integrated purposes that most platforms treat as separate concerns:

  • General-purpose sandboxed execution: a platform for running both long-lived workloads (remote development environments, persistent coding sessions, running servers) and short-lived tasks (AI agent runs, CI/CD jobs, automated scripts) inside isolated, reproducible sandboxes accessible via a web browser, SSH, the cordium CLI, or gRPC-based SDKs.

  • Identity-based zero-trust secretless remote access: a platform that leverages Octelium ZTNA capabilities to provide secretless, policy-driven access to infrastructure resources (SSH servers, databases, internal HTTP APIs, LLM providers, Kubernetes clusters, mTLS services) from within Workspaces, without exposing, distributing, or managing upstream application-layer credentials (e.g. API keys and access tokens, SSH private keys, database passwords, etc.). This works for both human Users opening a browser-based terminal and AI agents executing programmatically inside a Workspace.

Cordium is 100% free and open source. It is designed for single-tenant self-hosting and built on standard Kubernetes infrastructure with no proprietary cloud control plane and no vendor lock-in.

note

Want to see Cordium in practice? The live demo lets you explore the Cordium web portal right from your browser, without installing anything. The first steps guide walks through running your first Workspace, executing commands in it, defining a Template, accessing an Octelium Service without any credentials, and taking a snapshot.

Main Features

  • Unified platform for humans and AI agents. The same Workspace (synonymous with a sandbox) can be accessed interactively through a browser-based terminal, via SSH, through the CLI, or programmatically via gRPC-based SDKs for Go, Python, Rust and TypeScript. This makes Cordium equally suitable as a remote development environment for engineers (comparable to GitHub Codespaces) and as an execution sandbox for AI agents and automated workloads (comparable to E2B or Daytona). Workspaces support both long-lived runs (remote development, persistent servers) and short-lived runs (AI agent tasks, build jobs, scripted automation).

  • Highly customizable sandbox environments with declarative management Workspace filesystems can be built from OCI/Docker images, Dockerfiles, git repositories, and devcontainers. Multi-repository cloning, including private repositories with authentication. Workspace configurations are fully declarative via YAML files and can be instantiated through the cordium CLI or managed programmatically via the gRPC API. Each running Workspace supports full root access within the sandbox, allowing Users to run containers, install system packages, and run privileged services. Templates support pre-building for fast Workspace instantiation. Spaces provide namespacing and team collaboration for Workspaces, Templates, Secrets, Volumes and GitProviders. Secrets can be referenced in environment variables and repository authentication configurations. Resource limits (memory, CPU, and storage) can be defined at the Workspace, Template, Space, and Cluster level.

  • Persistent, ephemeral and forkable storage. Workspace storage can be persistent or ephemeral. WorkspaceSnapshots checkpoint the storage of a running Workspace so that it can later be restored into brand new Workspaces (e.g. to roll back a risky change or to fork the same state into several parallel AI agent runs). Volumes provide persistent storage with a lifecycle of its own that can be mounted, exclusively or simultaneously, by several Workspaces (e.g. datasets, build caches and artifacts shared between Workspaces).

  • Network and process-level isolation Workspaces can define egress network rules (i.e. allowed and denied CIDRs and ports) with a default-deny posture, read-only root filesystems and custom Linux capabilities, which makes them suitable for running untrusted, AI-generated code.

  • Rootless container-based sandboxing on standard Kubernetes. No bare-metal nodes or specialized hardware are needed. Workspaces run efficiently on any Kubernetes cluster, from a single-node cluster on a cheap VM to managed production-grade installations.

  • A built-in AI assistant Chat with the Cordium Agent from the web portal. The agent runs inside the User's own Workspace with the User's own identity, and it can create and manage Workspaces, run commands and test suites inside them, copy files between them and access the Octelium Services that the User is authorized to access (read more here).

  • Zero-trust platform on Octelium. Cordium is built on Octelium, inheriting its zero-trust infrastructure as a foundational layer to provide the following capabilities:

    • Dynamic secretless access. Octelium's layer-7 awareness enables Users to seamlessly access resources protected by application-layer credentials without exposing, managing, or distributing such secrets (read more here). This works for HTTP APIs and LLM providers without sharing API keys and access tokens, SSH servers without sharing passwords and private keys, Kubernetes clusters, PostgreSQL/MySQL databases, and any L7 protocol protected by mTLS.

    • Modern, dynamic, fine-grained access control. Octelium provides a centralized, scalable, fine-grained, dynamic, context-aware, layer-7-aware, attribute-based access control system (ABAC) evaluated on a per-request basis (read more here) with policy-as-code using CEL and OPA (Open Policy Agent). Octelium has no notion of an "admin" User, enforcing zero standing privileges by default.

    • Continuous strong authentication. A unified authentication system for both human and workload Users, supporting any web identity provider (IdP) that uses OpenID Connect or SAML 2.0, as well as GitHub OAuth2 (read more here). It also supports secretless authentication for workloads via OIDC-based assertions (read more here). Built-in support for MFA, re-authentication, and login via FIDO2/WebAuthn/Passkey, TOTP, and TPM 2.0 Authenticators.

    • OpenTelemetry-native auditing and visibility. Real-time, identity-based, L7-aware visibility and access logging. Every request is logged and exported to your OpenTelemetry OTLP receivers for integration with log management and SIEM providers.

  • Kubernetes-native pluggable storage. Cordium leverages Kubernetes-native storage for Workspace persistence and integrates with any Kubernetes CSI driver and VolumeSnapshot provider. This includes Longhorn, AWS EBS, GCP Persistent Disk, Azure Disk, Ceph/Rook, OpenEBS, and any other CSI-compliant storage solution. Storage class and volume snapshot class selection is policy-driven via CEL expressions, allowing operators to route different Workspace types to different storage backends.

  • Open source and designed for self-hosting. Cordium, like Octelium itself, is fully open source and designed for single-tenant self-hosting. There is no proprietary cloud-based control plane, and this is not a limited open source version of a separate fully functional paid SaaS product. Cordium can be deployed on a single-node Kubernetes cluster running on a low-cost cloud VM/VPS, or on production-grade multi-node Kubernetes installations, cloud-based or on-premises, with no vendor lock-in.

The Problem Cordium Solves

Workloads inside sandboxed environments usually need access to infrastructure: databases, internal APIs, LLM providers, source code repositories, SSH targets. Managing that access (distributing credentials, rotating secrets, scoping permissions) is operationally expensive and a persistent source of security incidents. Existing sandbox platforms and runtime environments solve the execution environment problem but leave credential management entirely to the User. Most sandbox platforms for AI agents focus primarily on execution isolation and SDK ergonomics, while infrastructure access and credential governance are usually handled separately. Modern identity-aware proxy-based zero trust access platforms solve the credential problem but are not designed as execution environments.

Cordium unifies these. A Workspace is simultaneously an isolated execution environment and a first-class identity in the Octelium Cluster. Processes running inside a Workspace can access any authorized Octelium-managed resource (e.g. a PostgreSQL/MySQL database, an SSH server, an internal HTTP API, an LLM provider, a generic TCP/UDP workload, etc...) through their Workspace Octelium identity alone, with no credential injection, no static API keys, and no secrets in environment variables. The Workspace's access scope is determined based on identity and context on a per-request basis via policy-as-code using CEL and OPA expressions.

Use Cases

AI agents:

  • Sandboxes for coding agents: Run Claude Code, Codex, OpenCode or your own agents unattended in ephemeral Workspaces that fix bugs, build features and open pull requests. See examples for Claude Code and Codex.

  • Secretless access to LLM providers: Agents use Anthropic, OpenAI or any other LLM provider through an Octelium LLM gateway without a single API key inside the sandbox. See an example here.

  • Parallel agents: Fan the same task out to several Workspaces, restored from the same snapshot, and compare the results. See an example here.

Development:

  • Remote development environments: Persistent, reproducible Workspaces from images, Dockerfiles and devcontainers, accessible from the browser, VS Code, Zed, JetBrains and any SSH client. See examples for full-stack development and devcontainers.

  • Secretless access to infrastructure: Reach staging databases, Kubernetes clusters, internal APIs and SSH servers from within Workspaces without kubeconfigs, passwords or SSH keys. See an example here.

Automation:

  • CI/CD and ephemeral jobs: Run builds, test suites and container image builds in auto-stopping ephemeral Workspaces that start in seconds from pre-built Templates. See an example here.

  • Untrusted code execution: Run AI-generated or third-party code with a default-deny egress policy, a read-only root filesystem and dropped capabilities. See an example here.

Where to Go Next

  • Install a Cluster in minutes: The quick installation guide installs a full single-node Octelium Cluster with Cordium on any cheap VM/VPS using your own domain.

  • Learn the building blocks: The concepts page covers Workspaces, Templates, Spaces, Volumes, WorkspaceSnapshots and the rest of Cordium's resources.

  • Understand the architecture: How Cordium Works walks through the isolation model, the Workspace lifecycle and how every Workspace becomes an Octelium identity.

  • Run AI agents: The AI agents page explains why Cordium treats agents as first-class identities and links to ready-to-use agent configurations.