The open source, identity-based, secretless sandbox platform

Run isolated, reproducible sandboxes for developers, AI agents and automated workloads on your own infrastructure, with identity-based, policy-driven, secretless access to databases, SSH servers, APIs and Kubernetes clusters, without credentials ever reaching the sandbox.

  • Free and open source
  • Designed for self-hosting
  • Built on Octelium

Cordium runs every Workspace as an isolated sandbox. Above the sandboxes, the Octelium access layer connects each Workspace to the databases, SSH servers, Kubernetes clusters, HTTP APIs and LLM APIs it is authorized to reach, on a per-request basis and through its own identity, while the upstream credentials stay at the access layer and never reach the sandbox.

Why Cordium

Isolated execution is only half of the problem

Sandboxes for developers, AI agents and automated workloads need isolated, reproducible execution as well as access to real infrastructure. Existing platforms solve one side and leave the other to the user. Cordium unifies both in a single platform.

  1. 01

    Credentials inside the sandbox

    API keys, database passwords, SSH private keys and kubeconfigs end up in environment variables, files and shell history, where a leaked log or a prompt injection can exfiltrate them.

    In Cordium

    Upstream credentials stay at the Octelium identity-aware proxy and are injected at the protocol layer once a request is authorized. The Workspace never holds them.

  2. 02

    Isolation without identity

    Most sandbox platforms isolate processes but leave infrastructure access to whatever credential the sandbox holds, so the credential itself becomes the authorization boundary.

    In Cordium

    Every Workspace run gets a dedicated Octelium Session as its identity, and every request it makes is authorized against that identity with policy-as-code.

  3. 03

    One tool per workload

    Remote development environments, AI agent sandboxes and CI runners are usually separate products, each with its own identities, its own credentials and its own audit trail.

    In Cordium

    The same Workspace serves long-lived coding sessions and short-lived automated runs, through the browser, SSH, the CLI and the SDKs.

  4. 04

    Incomplete visibility

    Network and container logs rarely explain which agent ran which query against which database, or why it was allowed to.

    In Cordium

    OpenTelemetry-native, L7-aware access logs tie every request back to the Workspace Session, its owner and the Policy that decided it.

Agent: testing a repository in an Ubuntu Workspace

Cordium Workspaces used from the web portal, including the Cordium Agent, and from the cordium CLI.

Agent: testing a repository in an Ubuntu Workspace

  • Jane asks the Cordium Agent, with Claude Opus 5.5: "Run an ubuntu:24.04 Workspace, install sudo, git and zsh, clone github.com/acme/ledger and run its tests".
  • The agent creates the Workspace k3x9 in the default Space from the ubuntu:24.04 image with github.com/acme/ledger cloned in /workspace/repo.
  • It runs apt-get update -qq && apt-get install -y -qq sudo git zsh golang-go as root in k3x9, then go test ./... in /workspace/repo.
  • ? github.com/acme/ledger/cmd/ledger [no test files]
  • ok github.com/acme/ledger/api 0.903s
  • ok github.com/acme/ledger/internal/accounts 0.412s
  • ok github.com/acme/ledger/internal/fx 0.236s
  • ok github.com/acme/ledger/internal/journal 1.087s
  • All tests passed in k3x9. The 4 packages of github.com/acme/ledger passed with Go 1.22, after installing sudo, git and zsh.
  • The repository is a Go module, so I also installed golang-go. It is cloned in /workspace/repo, and you can continue there from a terminal in the portal or with cordium ssh k3x9.

Agent: benchmarking two branches in parallel Workspaces

  • Jane starts a new chat, switches the model to GPT-6.1 and asks: "Run 2 Workspaces with github.com/acme/ledger on main and dev, benchmark internal/journal in both and compare the results".
  • The agent creates the Workspaces p7m2 on the main branch and q4n8 on the dev branch in parallel, both from golang:1.26.
  • It runs go test -bench . -count 6 ./internal/journal in both Workspaces at the same time, then cd /tmp && cordium cp p7m2:/tmp/main.txt . && go run golang.org/x/perf/cmd/benchstat@latest main.txt dev.txt in q4n8.
  • p7m2:/tmp/main.txt → main.txt (2184 bytes)
  • goos: linux
  • goarch: amd64
  • pkg: github.com/acme/ledger/internal/journal
  • │ main.txt │ dev.txt │
  • │ sec/op │ sec/op vs base │
  • Post-4 41.24µ ± 2% 28.73µ ± 1% -30.33% (p=0.002 n=6)
  • Replay-4 1.842m ± 3% 1.791m ± 2% ~ (p=0.180 n=6)
  • Lookup-4 412.6n ± 1% 398.1n ± 1% -3.51% (p=0.002 n=6)
  • geomean 31.53µ 27.36µ -13.22%
  • dev is faster on the hot path of internal/journal: Post dropped from 41.2µs to 28.7µs, while Replay shows no significant change.
  • Post: 41.24µs on main, 28.73µs on dev, change −30.33%
  • Replay: 1.842ms on main, 1.791ms on dev, change ~
  • Lookup: 412.6ns on main, 398.1ns on dev, change −3.51%
  • Both benchmarks ran in parallel in p7m2 and q4n8, then q4n8 pulled the results of p7m2 with cordium cp under your identity, with no SSH keys involved.

Agent: querying a PostgreSQL Service without its password

  • Jane goes back to the conversation "Test ledger on Ubuntu 24.04" and asks: "Now query the billing-db Postgres Service from k3x9 and show me the 5 largest unpaid invoices".
  • The agent runs apt-get install -y -qq postgresql-client as root in k3x9, then psql -h billing-db -d billing -c "SELECT id, customer, total, due_date FROM invoices WHERE status = 'unpaid' ORDER BY total DESC LIMIT 5" in k3x9.
  • id | customer | total | due_date
  • -------+----------------+----------+------------
  • 10477 | Initech | 12400.00 | 2026-10-02
  • 10469 | Northwind GmbH | 8920.50 | 2026-10-14
  • 10481 | Globex Corp | 4210.00 | 2026-10-15
  • 10462 | Umbrella Ltd | 2145.90 | 2026-09-28
  • 10473 | Hooli | 980.50 | 2026-10-20
  • (5 rows)
  • These are the 5 largest unpaid invoices, $28,656.90 in total, and 2 of them are overdue: Initech and Umbrella Ltd.
  • The query ran from k3x9 as jane@acme.com through the billing-db Service. The Workspace never held the database password, which Octelium injects once the request is authorized.

Portal: launching a Workspace from the default Space

  • Jane opens the Default Space from the Spaces page and clicks New workspace.
  • In Launch a workspace, she sets the repository to https://github.com/acme/ledger and the container image to golang:1.26, keeps Start immediately on and clicks Create & start.
  • The Workspace m4t8 goes from Start requested to Initializing, Pulling image, Starting runtime, Preparing and Running, while its Logs tab streams the startup logs.
  • Trying to pull docker.io/library/golang:1.26...
  • Getting image source signatures
  • Copying blob sha256:7cf63256a31a done
  • Copying blob sha256:0bd2f6b5e4b1 done
  • Copying blob sha256:3fd8d35c5b94 done
  • Copying config sha256:1c41a7d38b3e done
  • Writing manifest to image destination
  • Cloning into '/workspace/repo'...
  • remote: Enumerating objects: 4182, done.
  • Receiving objects: 100% (4182/4182), 2.31 MiB | 18.40 MiB/s, done.
  • Resolving deltas: 100% (2507/2507), done.

Portal: running commands in the browser terminal

  • Jane opens the Terminals tab of m4t8, where Octelium Services are reachable by name without any credentials.
  • octelium@cordium:/workspace/repo$ go test ./...
  • ? github.com/acme/ledger/cmd/ledger [no test files]
  • ok github.com/acme/ledger/api 0.887s
  • ok github.com/acme/ledger/internal/accounts 0.405s
  • ok github.com/acme/ledger/internal/fx 0.241s
  • ok github.com/acme/ledger/internal/journal 1.112s
  • octelium@cordium:/workspace/repo$ curl -s http://payments-api/v1/charges?limit=2
  • {"object":"list","data":[{"id":"ch_3Q8xK2","amount":4200},{"id":"ch_3Q8xJ9","amount":1850}],"has_more":true}
  • octelium@cordium:/workspace/repo$ env | grep -ciE 'token|secret|password'
  • 0

CLI: cordium run with an image, a repository and resource limits

  • ~ ❯ cordium run --image golang:1.26 --repository https://github.com/acme/ledger --cpu 4000 --memory 8192 --storage 20000
  • octelium@cordium:~$ cd /workspace/repo && echo $CORDIUM_NAME
  • x7k2
  • octelium@cordium:/workspace/repo$ go build -o bin/ledger ./cmd/ledger && ls -lh bin
  • total 18M
  • -rwxr-xr-x 1 octelium octelium 18M Oct 11 14:02 ledger
  • octelium@cordium:/workspace/repo$ exit

CLI: cordium exec and cordium ssh for commands and IDEs

  • ~ ❯ cordium exec x7k2 -w /workspace/repo -- go vet ./...
  • ~ ❯ echo $?
  • 0
  • ~ ❯ cordium ssh x7k2 -- git -C /workspace/repo log --oneline -2
  • a41c9e2 (HEAD -> main, origin/main) journal: round half to even
  • 7d03b18 api: paginate the entries endpoint
  • ~ ❯ cordium ssh x7k2 --print-config >> ~/.ssh/config
  • ~ ❯ code --remote ssh-remote+cordium-x7k2 /workspace/repo

CLI: cordium cp between your machine and Workspaces

  • ~ ❯ cordium cp x7k2:/workspace/repo/bin/ledger ./ledger
  • x7k2:/workspace/repo/bin/ledger → ./ledger (18874368 bytes)
  • ~ ❯ cordium cp ./testdata/fixtures.sql k3x9:/tmp/fixtures.sql
  • ./testdata/fixtures.sql → /tmp/fixtures.sql (48211 bytes)
  • ~ ❯ cordium cp x7k2:/workspace/repo/bin/ledger k3x9:/tmp/ledger
  • /workspace/repo/bin/ledger → /tmp/ledger (18874368 bytes)
  • ~ ❯ cordium ssh k3x9 -- /tmp/ledger version
  • ledger v0.18.2 (a41c9e2)
Secretless access

Access infrastructure without credentials inside the sandbox

Every Workspace run gets a dedicated Octelium identity. Processes inside the Workspace reach authorized resources with standard tools, while the upstream credentials stay at the Octelium identity-aware proxy.

Read about accessing Octelium Services

Two Cordium Workspaces reach the same Octelium Service with standard tools and no credentials, while the Service picks the upstream credential from the identity of each Workspace in the PostgreSQL, Kubernetes and HTTP modes.

  • PostgreSQL: the POSTGRES Service pg-staging proxies postgres://10.0.2.8:5432. Its default config injects the Secret pg-staging-rw, while a dynamic configuration rule selects the readonly config and the Secret pg-staging-ro for the Workspaces of the claude-agent.payments.cordium Template.
  • The Workspace h2n6, created from the dev.payments.cordium Template, runs psql -h pg-staging payments, then UPDATE plans SET price = 49 WHERE id = 3; without holding any credential. No rule matches it, so the default config applies, Octelium injects the Secret pg-staging-rw and the upstream authenticates the request as app_readwrite. The terminal shows psql (17.6) Type "help" for help. payments=> UPDATE plans SET price = 49 WHERE id = 3; UPDATE 1
  • The Workspace v8q3, created from the claude-agent.payments.cordium Template, runs psql -h pg-staging payments, then UPDATE plans SET price = 49 WHERE id = 3; without holding any credential. The rule ctx.session.status.ext.cordium.templateRef.name == "claude-agent.payments.cordium" selects the readonly config, Octelium injects the Secret pg-staging-ro and the upstream authenticates the request as app_readonly. The terminal shows psql (17.6) Type "help" for help. payments=> UPDATE plans SET price = 49 WHERE id = 3; ERROR: permission denied for table plans
  • Kubernetes: the KUBERNETES Service k8s-staging proxies https://10.0.8.1:6443. Its default config injects the Secret k8s-viewer, while a dynamic configuration rule selects the deployer config and the Secret k8s-deployer for the Workspaces of the ci.payments.cordium Template.
  • The Workspace r5w2, created from the ci.payments.cordium Template, runs export KUBECONFIG=~/.kube/k8s-staging.acme.com, then kubectl rollout restart deploy/ledger -n payments without holding any credential. The rule ctx.session.status.ext.cordium.templateRef.name == "ci.payments.cordium" selects the deployer config, Octelium injects the Secret k8s-deployer and the upstream authenticates the request as sa/deployer. The terminal shows deployment.apps/ledger restarted
  • The Workspace h2n6, created from the dev.payments.cordium Template, runs export KUBECONFIG=~/.kube/k8s-staging.acme.com, then kubectl rollout status deploy/ledger -n payments without holding any credential. No rule matches it, so the default config applies, Octelium injects the Secret k8s-viewer and the upstream authenticates the request as sa/viewer. The terminal shows Waiting for deployment "ledger" rollout to finish: 1 of 2 updated replicas are available... deployment "ledger" successfully rolled out
  • HTTP: the HTTP Service github proxies https://api.github.com. Its default config injects the Secret github-token, while a dynamic configuration rule selects the agents config and the Secret github-agents for the Workspaces of the claude-agent.payments.cordium Template.
  • The Workspace v8q3, created from the claude-agent.payments.cordium Template, runs curl -s github/repos/acme/ledger/pulls -d @pr.json | jq .user.login without holding any credential. The rule ctx.session.status.ext.cordium.templateRef.name == "claude-agent.payments.cordium" selects the agents config, Octelium injects the Secret github-agents and the upstream authenticates the request as acme-agents-bot. The terminal shows "acme-agents-bot"
  • The Workspace r5w2, created from the ci.payments.cordium Template, runs curl -s github/repos/acme/ledger/releases -d @release.json | jq .author.login without holding any credential. No rule matches it, so the default config applies, Octelium injects the Secret github-token and the upstream authenticates the request as acme-bot. The terminal shows "acme-bot"
Database names and database users
An agent's Workspace reaches one database, as one database user

Database names and database users

An agent's Workspace reaches one database, as one database user

  • Policy p-agents-reporting
  • all:
  • of:
  • - match: '"agents" in ctx.user.spec.groups'
  • - match: ctx.request.postgres.connect.database == "reporting"
  • - match: ctx.request.postgres.connect.user == "readonly"
  • ALLOW: agent-07 · Workspace abc, connect database=reporting user=readonly, all three expressions match.
  • DENY: agent-07 · Workspace abc, connect database=payments user=readonly, database is outside the rule.
  • DENY: agent-07 · Workspace abc, connect database=reporting user=admin, database user is not readonly.

HTTP methods, paths and bodies

Agents read from the payments API, but never write to it

  • Policy p-agents-payments
  • - effect: DENY
  • condition:
  • match: ctx.request.http.method != "GET"
  • - effect: ALLOW
  • condition:
  • match: '"agents" in ctx.user.spec.groups'
  • ALLOW: agent-07 · Workspace abc, GET /v1/charges?limit=10, rule 2, User is in the agents Group.
  • DENY: agent-07 · Workspace abc, POST /v1/refunds, rule 1, DENY rules override ALLOW rules.
  • DENY: linus@acme.com · Workspace m3p, GET /v1/charges, no rule matched, nothing is allowed by default.

Kubernetes verbs, resources and namespaces

CI Workspaces can read production, and nothing more

  • Policy p-ci-readonly
  • all:
  • of:
  • - match: '"ci" in ctx.user.spec.groups'
  • - match: ctx.request.kubernetes.verb in ["get", "list", "watch"]
  • - match: ctx.request.kubernetes.namespace == "production"
  • ALLOW: ci-runner · Workspace ci4m, list pods in production, Group, verb and namespace all match.
  • DENY: ci-runner · Workspace ci4m, delete deployment in production, verb delete is not in the allowed set.
  • DENY: agent-07 · Workspace abc, list pods in production, User is not in the ci Group.

The same Service, different reach

People and agents use the same Workspaces, under different Policies

  • Policy p-bastion
  • all:
  • of:
  • - match: ctx.user.spec.type == "HUMAN"
  • - match: '"sre" in ctx.user.spec.groups'
  • ALLOW: jane@acme.com · Workspace x7k2, ssh bastion.prod, HUMAN User in the sre Group.
  • DENY: agent-07 · Workspace abc, ssh bastion.prod, User type is WORKLOAD.
  • DENY: linus@acme.com · Workspace m3p, ssh bastion.prod, User is not in the sre Group.
Visibility

Real-time, L7-aware visibility for every Workspace

Every request a Workspace makes to infrastructure is logged in real time with its full identity context and exported to your OpenTelemetry OTLP receivers.

Read about visibility and logs
AccessLogOTLP
ALLOWagent-07reporting.dbPOSTGRESWorkspace abc, query: select id, total from invoices limit 50
ALLOWci-runnerk8s-prodKUBERNETESWorkspace ci4m, verb=list resource=pods namespace=production
DENYagent-07paymentsHTTPWorkspace abc, POST /v1/refunds, policy=p-agents-payments
ALLOWjane@acme.combastion.prodSSHWorkspace x7k2, session recorded, upstream user=deploy
ALLOWagent-07geminiHTTPWorkspace q9w2, GET /v1beta/models 200
Programmable

A programmable sandbox platform for agents and automation

Everything the CLI and the web portal do is available over the gRPC API, with official SDKs for Go, TypeScript, Python and Rust. Create, start, drive and destroy sandboxes from a CI pipeline, a scheduler, an internal developer platform or an AI agent.

Read about the APIs and SDKs
main.gogithub.com/octelium/cordium/cordium-go

Credentials are read from the environment, including OIDC assertion files for workload identity federation, so the same code runs on a laptop, in CI and inside a Workspace.

Go SDK (github.com/octelium/cordium/cordium-go): create an ephemeral Workspace, run a command, print its output and delete the Workspace.
c, err := cordium.New(ctx)
if err != nil {
	return err
}
defer c.Close()

ws, err := c.Workspaces().Run(ctx,
	cordium.WithImage("python:3.13"),
	cordium.Ephemeral(),
)
if err != nil {
	return err
}
defer ws.Delete(context.WithoutCancel(ctx))

res, err := ws.Exec(ctx, "python -c 'print(6 * 7)'")
if err != nil {
	return err
}
fmt.Println(res.Output(), res.ExitCode) // 42 0
TypeScript SDK (@octelium/cordium): create an ephemeral Workspace, run a command, print its output and delete the Workspace.
import { Cordium, argv } from "@octelium/cordium";

const client = new Cordium();

const workspace = await client.workspaces.run({
  image: "node:22",
  ephemeral: true,
});

try {
  const result = await workspace.exec(argv("node", "-p", "6 * 7"));
  console.log(result.stdout); // 42
} finally {
  await workspace.delete();
  client.close();
}
Python SDK (cordium-sdk): create an ephemeral Workspace, run a command, print its output and delete the Workspace.
from cordium import Cordium

with Cordium() as client:
    workspace = client.workspaces.run(
        image="python:3.13",
        ephemeral=True,
    )
    try:
        result = workspace.exec(["python", "-c", "print(6 * 7)"])
        print(result.stdout)  # 42
    finally:
        workspace.stop().wait_until_stopped()
        workspace.delete()
Rust SDK (cordium): create an ephemeral Workspace, run a command, print its output and delete the Workspace.
use cordium::{Client, Command, WorkspaceOptions};

let client = Client::from_env().await?;

let workspace = client
    .workspaces()
    .run(WorkspaceOptions::new().image("python:3.13").ephemeral(true))
    .await?;

let result = workspace
    .exec(Command::argv(["python", "-c", "print(6 * 7)"]))
    .await?;
println!("{}", result.stdout_text()); // 42

workspace.delete().await?;
workspace.yaml
A WorkspaceAn image, a repository and a lifecycle task, applied with cordium run --file.
A Workspace. An image, a repository and a lifecycle task, applied with cordium run --file.
spec:
  image:
    registry:
      url: python:3.12-bookworm
  repository:
    url: https://github.com/acme/api
  runtime:
    tasks:
      - name: install
        type: ON_CREATE
        workingDir: /workspace/repo
        run: pip install -r requirements.txt
        onFailure: ON_FAILURE_ABORT
An inline Dockerfile. The image is built by the Cluster, and the limits are capped by the Space and the Cluster.
spec:
  image:
    dockerfile:
      inline: |
        FROM node:22-bookworm
        RUN apt-get update && apt-get install -y \
          podman postgresql-client
        RUN npm install -g @anthropic-ai/claude-code
  limit:
    cpu:
      millicores: 4000
    memory:
      megabytes: 8192
    storage:
      megabytes: 20480
A devcontainer. The image, features and hooks come from the repository's devcontainer spec, and port 3000 is served by the portal.
spec:
  repository:
    url: https://github.com/acme/web
  image:
    repository:
      devcontainer:
        dirPath: .devcontainer
  applications:
    - name: web
      port: 3000
      isDefault: true
A parameterized Template. One Template serves many runs. Variables are overridden per run, and the Workspace stops once its tasks complete.
spec:
  vars:
    - name: BRANCH
      value: main
    - name: TASK
      value: Fix the failing tests.
  repository:
    url: https://github.com/acme/api
    cloneOptions:
      branch: ${{ vars.BRANCH }}
  runtime:
    autoStop: true
    tasks:
      - name: run-agent
        type: POST_START
        workingDir: /workspace/repo
        run: claude "${{ vars.TASK }}"

A running Workspace yields a crash-consistent snapshot and a stopped one a clean snapshot. Both outlive their source.

Snapshots

A running Workspace yields a crash-consistent snapshot and a stopped one a clean snapshot. Both outlive their source.

  • # Snapshot a Workspace while it keeps running
  • $ cordium create snapshot before-upgrade --workspace abc
  • Started taking the WorkspaceSnapshot: before-upgrade of the Workspace: abc
  • # Restore it into a brand new Workspace
  • $ cordium run --snapshot before-upgrade
  • ✓ Workspace status: PREPARING (6s)
  • octelium@cordium:~$ git -C /workspace/repo status --short
  • M src/billing/invoice.go
  • ?? migrations/0042_add_tax_rates.sql

Volumes

Exclusive Volumes are mounted by one running Workspace at a time. Shared Volumes need a shared filesystem backend such as NFS, CephFS or EFS.

  • # Volumes have a lifecycle of their own
  • $ cordium create volume datasets --size 50000
  • Successfully created the Volume: datasets of 50000 MB
  • $ cordium create volume build-cache --size 20000 --shared
  • Successfully created the Volume: build-cache of 20000 MB
  • # Mount read-only or read-write, per Workspace
  • $ cordium run --volume datasets:/data:ro --volume build-cache:/cache
  • ✓ Workspace status: PREPARING (9s)
  • octelium@cordium:~$ ls /data
  • eval images labels train

Pre-builds

A pre-build runs a Template's initialization once and snapshots the result, so dependency-heavy Templates start in seconds.

  • # Pre-build a Template into a VolumeSnapshot
  • $ cordium build ml-env.research
  • Started a build for Template: ml-env
  • # New Workspaces restore from it instead of starting cold
  • $ cordium run --template ml-env.research
  • ✓ Workspace status: PREPARING (5s)
  • octelium@cordium:~$ python -c 'import torch; print(torch.__version__)'
  • 2.8.0
Isolation

Rootless sandboxes with egress network policies

Each Workspace runs as a rootless container inside a restricted outer container, with dropped capabilities, a custom seccomp profile and enforced resource limits. Egress network policies decide where it can connect.

Read about Workspace configuration
Public networks only, by default
With no rules, a Workspace reaches the internet but not private networks

Public networks only, by default

With no rules, a Workspace reaches the internet but not private networks

  • egress:
  • # no rules, so every destination falls
  • # back to the default action
  • defaultAction: ALLOW_PUBLIC
  • ALLOW: pip install requests to 151.101.0.223:443, public destination, default action.
  • DENY: psql -h 10.0.4.40 to 10.0.4.40:5432, private network, default action.
  • DENY: curl http://169.254.169.254 to 169.254.169.254:80, protected network, denied whatever the rules say.

Deny everything except what a job needs

A DENY default with explicit ALLOW rules by CIDR and port

  • egress:
  • defaultAction: DENY
  • rules:
  • - action: ALLOW
  • cidrs: ["140.82.112.0/20"]
  • ports: [443]
  • ALLOW: git clone https://github.com/acme/api to 140.82.112.4:443, matches the ALLOW rule.
  • DENY: pip install requests to 151.101.0.223:443, no rule matched, default action.
  • DENY: ssh -T git@github.com to 140.82.112.4:22, port 22 is outside the rule.

DENY rules always take precedence

A destination matched by a DENY rule is denied even if an ALLOW rule matches it

  • egress:
  • rules:
  • - action: ALLOW
  • cidrs: ["10.0.0.0/8"]
  • ports: [5432]
  • - action: DENY
  • cidrs: ["10.0.9.0/24"]
  • ALLOW: psql -h 10.0.4.40 to 10.0.4.40:5432, private, but allowed by a rule.
  • DENY: psql -h 10.0.9.12 to 10.0.9.12:5432, the DENY rule overrides the ALLOW rule.
  • DENY: redis-cli -h 10.0.4.7 to 10.0.4.7:6379, outside the rules, private by default.
Use cases

Use Cordium across development and automation

Start with remote development environments or AI agent sandboxes, then apply the same Workspaces, identities, Policies and audit trail to CI/CD, automation and secretless access to infrastructure.

Questions

Frequently asked

Is Cordium free and open source?
Yes. Cordium is free and open source under the Apache 2.0 license and is designed for self-hosting. There is no proprietary cloud-based control plane, no tiered feature set, and it is not a limited version of a separate paid SaaS product. Cordium is built on Octelium, whose Cluster components are licensed under AGPLv3.
How is Cordium different from other sandbox platforms?
Remote development environments such as GitHub Codespaces and Coder, and sandbox platforms such as E2B and Daytona, provide the execution environment and leave infrastructure access to whatever credentials are placed inside it. Cordium additionally gives every Workspace its own identity and provides secretless, policy-driven access to SSH servers, databases, HTTP APIs, Kubernetes clusters and mTLS services, so no upstream credential is ever exposed, distributed or managed inside the sandbox.
How are Workspaces isolated?
Each Workspace runs as a rootless container inside a restricted outer container, with all Linux capabilities dropped except a small explicit set, a custom seccomp profile, a restricted /proc and enforced CPU, memory and storage limits. It runs on standard Kubernetes with no VMs, bare-metal nodes or specialized hardware, and egress network policies decide which destinations it can reach.
Can AI agents use Cordium programmatically?
Yes. Everything the CLI and the web portal do is available over the gRPC API, with official SDKs for Go, TypeScript, Python and Rust. Agents and orchestrators authenticate as workload Users, including secretlessly through OIDC assertions issued by platforms such as GitHub Actions and Kubernetes, and every Workspace they run gets its own Session identity.
Do I need an existing Octelium Cluster?
Cordium runs on top of Octelium. The quick installer can automatically set up a complete Octelium Cluster and installs Cordium on top of it. If you already run an Octelium Cluster, Cordium can be installed on it as a package.
Do I need Kubernetes experience to run Cordium?
No. Cordium runs on Kubernetes, but the quick installer provisions a complete single-node Cluster, Kubernetes included, on any Linux machine or VM with at least 4GB of RAM and 20GB of disk storage. Production installations can run on managed or on-premises multi-node Kubernetes.
Get started

Install Cordium on your own infrastructure in minutes

One fresh Linux VM/server and a domain you own. The installer takes care of Octelium, Cordium and all of their dependencies, Kubernetes included.

$ curl -o install-cluster.sh https://octelium.com/install-cluster.sh$ chmod +x install-cluster.sh$ ./install-cluster.sh --domain <DOMAIN> --cordium