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.
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.
- 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 CordiumUpstream 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.
- 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 CordiumEvery Workspace run gets a dedicated Octelium Session as its identity, and every request it makes is authorized against that identity with policy-as-code.
- 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 CordiumThe same Workspace serves long-lived coding sessions and short-lived automated runs, through the browser, SSH, the CLI and the SDKs.
- 04
Incomplete visibility
Network and container logs rarely explain which agent ran which query against which database, or why it was allowed to.
In CordiumOpenTelemetry-native, L7-aware access logs tie every request back to the Workspace Session, its owner and the Policy that decided it.
One sandbox platform for developers, AI agents and automation
A Workspace is an isolated, rootless container sandbox on standard Kubernetes. The same Workspace serves as a remote development environment for engineers and as an execution sandbox for AI agents, CI/CD jobs and automated scripts.
- Access Workspaces through the browser-based terminal, the cordium CLI, standard SSH for VS Code, Zed and JetBrains, or programmatically through the gRPC API and SDKs.
- Persistent Workspaces preserve their filesystem across restarts, while ephemeral Workspaces start clean every time and can stop on their own once their tasks complete.
- Full root capability inside the sandbox to install packages, run services and run nested containers, with no VMs, bare-metal nodes or specialized hardware.
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)
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.
- Covers HTTP API keys and access tokens, SSH passwords and private keys, PostgreSQL and MySQL passwords, kubeconfigs and mTLS client certificates.
- psql, ssh, curl and kubectl work unmodified, with no SDK, no credential injection and no secrets in environment variables.
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"
Identity-based access control on every request
Access from a Workspace is authorized on a per-request basis against the identity behind it, the context around it and the content of the request itself, with policy-as-code using CEL and OPA.
- Application-layer access control on HTTP methods, paths and bodies, database names and users, Kubernetes verbs, resources and namespaces, and MCP and LLM operations.
- Humans authenticate through OIDC and SAML 2.0 identity providers, GitHub OAuth2 and passkeys, while agents and workloads use OAuth2 or federated OIDC assertions.
- Zero standing privileges. There is no admin or superuser User, and all access must be granted by a Policy that can be revoked on the next request.
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.
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.
- Application-layer detail in every entry: HTTP methods and paths, database queries, Kubernetes operations, recorded SSH sessions, and MCP and LLM calls with token usage.
- Every entry correlates back to the Workspace Session and its owner, which is what post-incident analysis of an agent run actually needs.
- OpenTelemetry-native visibility. Logs go to the log management and SIEM tools your organization already operates.
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.
- Run commands and stream their output, move files, attach to persistent terminals, follow initialization logs and watch Workspace state changes.
- Manage Templates and pre-builds, snapshots, Volumes, Spaces, Secrets and Memberships through the same clients.
- Authenticate workloads secretlessly with OIDC assertions from platforms such as GitHub Actions and Kubernetes, or with OAuth2 and access tokens.
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.
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 0import { 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();
}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()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?;Declarative, reproducible environments
Workspace environments are defined in YAML specs covering the container image, repository cloning, lifecycle tasks, environment variables, resource limits, variable substitution and application ports.
- Build Workspace filesystems from OCI images, Dockerfiles, git repositories and devcontainers, with multi-repository cloning including private repositories.
- Templates reuse one configuration across many Workspaces, and variables let a single Template serve many different tasks.
- Spaces group Workspaces, Templates, Secrets and Volumes, with resource limits resolved across the Workspace, Space and Cluster levels.
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_ABORTspec:
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: 20480spec:
repository:
url: https://github.com/acme/web
image:
repository:
devcontainer:
dirPath: .devcontainer
applications:
- name: web
port: 3000
isDefault: truespec:
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 }}"Kubernetes-native storage, snapshots and Volumes
Workspace storage is backed by Kubernetes persistent volumes on any CSI driver, including Longhorn, Ceph, OpenEBS, AWS EBS, GCP Persistent Disk and Azure Disk.
- Snapshots capture a Workspace's storage while it keeps running, so it can be cloned into new Workspaces or restored after a risky change.
- Volumes outlive the Workspaces that mount them, mounted by one Workspace at a time or shared by several, read-only or read-write per mount.
- Template prebuilds that reduce cold startup for heavy Workspaces from minutes to near instant.
- Storage classes and snapshot classes are selected through CEL rules, routing different Workspaces to different storage backends.
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
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.
- Egress rules allow or deny destinations by CIDR and port. By default public networks are reachable and private ones are not, and DENY rules always take precedence.
- Read-only root filesystems and per-Workspace Linux capabilities, merged with the Space and Cluster configuration.
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 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.
Development
04- Remote development environmentsPersistent Workspaces for VS Code, Zed and JetBrains over standard SSH, or a full terminal in the browser.
- Reproducible project environmentsTemplates, devcontainers and pre-builds, so every engineer starts from the same initialized filesystem.
- Nested containersRun Podman inside a Workspace, including databases and services for integration tests.
- Secretless infrastructure accessReach databases, SSH servers, Kubernetes clusters and internal APIs from a Workspace without distributing credentials.
AI agents and automation
06- Claude Code sandboxesRun Claude Code in an isolated Workspace with policy-controlled, secretless access to the infrastructure it works on.
- Codex sandboxesRun OpenAI Codex against real APIs, databases and clusters, with no raw credentials inside the Workspace.
- OpenCode sandboxesLet OpenCode plan, modify repositories and run tests inside an isolated, auditable execution environment.
- CI/CD executionEphemeral, auto-stopping Workspaces that build, test and deploy with secretless access to clusters and registries.
- Sandboxes from codeCreate, drive and destroy Workspaces from Go, TypeScript, Python and Rust in any orchestration system.
- Identities for AI agentsAgents act under their own identities and Policies, rather than holding long-lived, over-privileged credentials.
The same capabilities ship with every installation, from a single VM to a multi-node production cluster.
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.
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