cordium

module
v0.18.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 2, 2026 License: Apache-2.0

README

Cordium

License Discord Slack

Cordium is a free and open source, self-hosted, identity-based, horizontally scalable sandbox platform built on Kubernetes and Octelium for humans and AI agents.

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.

Documentation · Quick Installation Guide · Examples

Tours

Web Portal Tour CLI Tour
Create and manage Workspaces, open terminals and chat with the Cordium AI assistant. Run Workspaces, execute commands, copy files and access infrastructure without credentials.

Main Features

  • Unified platform for humans and AI agents. Workspaces are isolated, rootless container sandboxes running on standard Kubernetes. The same Workspace can be used for long-lived coding sessions and short-lived automated workloads, through a web browser, SSH and editors (e.g. VS Code, Zed and JetBrains), the CLI or the SDKs.

  • Declarative, reproducible environments. Define images, Dockerfiles, devcontainers, repositories, lifecycle tasks, environment variables and resource limits in YAML. Workspaces support root access inside the sandbox for installing system packages and running nested containers. Reusable Templates support pre-builds that capture a fully initialized filesystem for fast startup.

  • Persistent, ephemeral and forkable storage. Persistent Workspaces preserve their filesystem across stops and restarts, while ephemeral ones start fresh on every run. WorkspaceSnapshots checkpoint storage and restore it into new Workspaces for rollback or parallel runs. Volumes outlive individual Workspaces and provide persistent or shared storage for datasets, caches and artifacts.

  • Network isolation and egress control. Restrict outbound traffic by CIDR and port, including a default-deny posture, with network policies enforced outside the sandbox. Read-only root filesystems and configurable Linux capabilities provide further controls for untrusted and AI-generated code.

  • A built-in AI agent. Chat with the Cordium Agent from the web portal to create and manage Workspaces, run commands and test suites, copy files and use authorized Octelium Services. The agent runs inside your own Workspace with your own identity, with configurable approvals for sensitive operations.

  • Secretless access to infrastructure. Standard tools (e.g. psql, ssh, curl and kubectl) access authorized Octelium Services without holding upstream API keys, database passwords, SSH private keys or kubeconfigs. Credentials remain at Octelium's identity-aware proxy and are applied at the protocol layer.

  • Identity-based access control. Octelium provides per-request, L7-aware attribute-based access control (ABAC), with policy-as-code using CEL and OPA and zero standing privileges by default. Authentication supports OIDC and SAML 2.0 identity providers, GitHub OAuth2, passkeys and workload identity federation.

  • OpenTelemetry-native auditing and visibility. Infrastructure requests through Octelium are authorized and logged with the Workspace's identity. Export L7-aware access logs to your OpenTelemetry OTLP receivers for integration with log management and SIEM providers.

  • APIs and SDKs. The complete gRPC API used by the CLI and web portal is available through official SDKs for Go, Python, Rust and TypeScript/JavaScript. Create and manage sandboxes, execute commands, transfer files and manage snapshots and Volumes from your applications, AI agents and CI pipelines.

  • Open source and designed for self-hosting. Run Cordium on a single-node VM or a production multi-node Kubernetes cluster, cloud-based or on-premises. There is no proprietary control plane, no tiered feature set and no vendor lock-in. Spaces organize Workspaces, Templates, Secrets and Volumes for individuals and teams.

Getting Started

  1. Install a Cluster. Follow the quick installation guide for a single-node Linux VM/VPS, or the Cluster installation guide for an existing Octelium Cluster or a multi-node Kubernetes installation.
  2. Install the CLIs. Follow the CLI installation guide for Linux, macOS and Windows.
  3. Run your first Workspace. Follow the first steps guide to run a Workspace, create a Template, access infrastructure without credentials and take a snapshot. You can also use the web portal at https://cordium.<DOMAIN>.

CLI Usage

Set your Cluster domain, log in and create a Workspace from your default Template with an interactive terminal:

export OCTELIUM_DOMAIN=example.com
octelium login
cordium run

Create a disposable Workspace from an image, or use your own YAML configuration:

cordium run --image python:3.13-slim --ephemeral --rm
cordium run --file workspace.yaml

For an existing Workspace named abc, open a terminal (starting it first if stopped), run a test suite or follow its startup logs:

cordium run abc
cordium exec abc -w /workspace/repo -- make test
cordium logs abc

Read the CLI guide for Templates, Volumes, snapshots, file transfers and automation, and the SSH and IDE guide for editor integration and port forwarding.

Workspace Configuration

Workspaces and Templates share the same declarative spec structure. For example, the following workspace.yaml clones a Python project and installs its dependencies on the first run. Replace the repository URL with your own project:

spec:
  image:
    registry:
      url: python:3.13-slim
  repository:
    url: https://github.com/myorg/my-project
  runtime:
    tasks:
      - name: install
        type: ON_CREATE
        workingDir: /workspace/repo
        run: pip install -r requirements.txt
        onFailure: ON_FAILURE_ABORT

Run it via cordium run --file workspace.yaml, or save it as a reusable Template via cordium create template python-dev --file workspace.yaml.

Read the configuration guide for spec inheritance, repository configuration and variables, and the dedicated guides for images and devcontainers, environment and tasks, resources and timeouts and secretless access.

FAQ

How does Cordium differ from sandbox platforms such as Daytona and E2B?

Cordium combines sandboxed execution with Octelium's identity-based access to infrastructure. Every Workspace has its own Session identity, and the upstream credentials used to access an Octelium Service remain outside the sandbox. Access can be scoped to the Workspace, its Template or its Space and is evaluated per request using identity and context. This applies to developers and AI agents alike, including access to private resources behind NAT and public APIs such as LLM providers. Read more about the architecture here.

How are Workspaces sandboxed?

Each Workspace runs inside a Kubernetes pod, which bootstraps a hardened supervisor, that in turns launches the actuall sandbox as a rootless container. The sandbox has its own filesystem, processes and network, and its root user maps to an unprivileged user outside it. This lets you install system packages and run containers inside the Workspace without granting it root access to the Kubernetes node.

The supervisor enforces resource limits and network egress policies outside the sandbox. Cordium runs on standard Kubernetes nodes without requiring a separate VM per Workspace or specialized hardware. Read more about the isolation model here.

What storage is needed for snapshots and shared Volumes?

Template pre-builds and WorkspaceSnapshots require a Kubernetes CSI storage backend with volume snapshot support. Shared Volumes require a multi-writer filesystem backend (e.g. NFS, CephFS or EFS). Persistent Workspaces and exclusive Volumes can use regular single-writer storage. Read the storage guide for configuration.

License

Cordium-owned source code is licensed under the Apache License 2.0.

Cordium is built on top of Octelium. Some Cordium components or complete deployments may include Octelium Cluster components, which are publicly licensed under AGPLv3. Octelium Labs, LLC owns the relevant copyrights for both projects.

Copyright © Octelium Labs, LLC. All rights reserved.

Directories

Path Synopsis
client
cordium module
cluster
apiserver module
common module
e2e module
genesis module
mockapiserver module
nocturne module
portal module
rscserver module
supervisor module
vigil module
workspace module
cordium-go module
pkg module
unsorted
licenser command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL