Enterprise orchestration.
No Kubernetes required.
Odysseus is a fully managed container orchestration platform. Sign up, connect your nodes with a one-liner, and get autoscaling, canary deployments, AI-powered operations, and CVE scanning — without the Kubernetes complexity.
Fully managed control plane · One-liner node setup · No dedicated platform team
Stuck between too simple
and too complex?
Managing 50 or 100 containers shouldn't require a dedicated platform team. But it shouldn't be held together with shell scripts either.
Docker Compose hits its limits
No autoscaling, no high availability, no rolling deploys. One bad push can take down your entire service — and manual recovery takes the team away from shipping.
Kubernetes is overkill
A documented 2 GB minimum per machine, months of ramp-up, 1–2 dedicated engineers to maintain it. At this size you're paying an enterprise tax for features you'll never fully use.
Every deployment is a risk
No canary releases means bugs reach 100% of your users instantly. No audit trail means you can't answer "what changed and when?" for compliance reviews or post-mortems.
- 30–60 minutes of manual deployment steps
- A bad deploy takes down 100% of users
- Scale manually when traffic spikes hit
- No audit trail — "who changed that?" is unanswerable
- Secrets live in environment variables or bash scripts
- Recovery from failure takes 15–30 minutes
- 2–3 minute automated deployments, every time
- Canary releases expose bugs to 10% before full rollout
- Prometheus-driven autoscaling, no manual intervention
- Complete audit trail with actor, timestamp, and outcome
- Vault-backed secrets on tmpfs — never in env vars
- Instant automated rollback on health check failure
Sign up, connect, deploy
Odysseus is fully managed. Sign up, run a one-liner to connect your nodes, and start deploying — the control plane is on us.
Everything you need.
Nothing you don't.
Built for teams that have outgrown Docker Compose but don't want to build a platform team just to run their containers.
Docker Compose syntax you already know
Extend your existing docker-compose.yml files with an x-odysseus block. No new DSL to learn — your team ships on day one.
Multi-network container attachment
Attach containers to multiple Docker networks simultaneously — a key limitation of Nomad and many other orchestrators that Odysseus solves natively.
Four-tier RBAC
Admin, Operator, Developer, and Read-only roles out of the box. Control exactly who can deploy, scale, or just observe — with JWT + mTLS authentication.
Lightweight agent, zero overhead
The Odysseus agent is a single Go binary that runs on your nodes — about 28 MB of resident memory, measured on live production and development nodes. Installs in seconds, auto-upgrades with health-check-gated rollback.
Automated incident response
Odysseus detects container crashes, OOM kills, restart loops, and health check failures in real time — then executes remediation automatically. Self-healing infrastructure without on-call fatigue.
Built-in CVE scanning
Dual-backend vulnerability scanning with Trivy and Grype. Define policies to block deployments with critical CVEs automatically. Get patch recommendations with severity-based prioritization.
Meet Athena — your AI ops assistant
Deploy, troubleshoot, and manage infrastructure through natural language. Athena connects to 61 orchestration tools with RBAC-scoped access and safety guardrails.
SRE Orchestrator — self-healing infrastructure
Detect container crashes, OOM kills, health check failures, and performance anomalies in real time. An integrated LLM diagnoses root causes and executes safe remediations — with graduated rollout and human approval guardrails.
LLM-powered analysis
Multi-turn AI analysis with configurable timeouts, token limits, and custom system prompts. The LLM investigates, diagnoses, and proposes commands — each tagged with a risk level.
Configurable guardrails
Set max commands per incident, cooldown periods, dangerous command patterns, and per-service blacklists. Control which severities and risk levels can auto-execute.
Full incident lifecycle
Incidents progress through open, in progress, awaiting approval, resolved, failed, or escalated — with deduplication, correlation, and resolution tracking (fixed, dismissed, external, no action needed).
The right tool at 50–100 containers per node — and up from there
Odysseus is purpose-built for the point where Docker Compose breaks down and Kubernetes is more machinery than the job needs — and it keeps going from there.
| Capability | Docker Compose | Odysseus | Kubernetes |
|---|---|---|---|
| Autoscaling | ✗ | ✓ Prometheus-driven | ✓ Complex setup |
| Zero-downtime deployments | ✗ | ✓ | ✓ |
| Canary deployments | ✗ | ✓ Auto-promote + rollback | Via Istio/Argo |
| Instant rollback | ✗ | ✓ | ✓ |
| RBAC | ✗ | ✓ 4 built-in roles | ✓ Complex RBAC |
| Audit trail | ✗ | ✓ Built-in | Via add-on |
| Vault secret injection | ✗ | ✓ tmpfs-mounted | Via sidecar |
| Geographic data residency | ✗ | ✓ Placement filter, by ISO country or region[1] | Via node affinity on custom labels |
| Multi-network containers | Limited | ✓ Native | Via CNI plugin |
| Control plane RAM | None — CLI only | 47–65 MB measured | 2 GB minimum per machine[2] |
| Per-node agent RAM | None — CLI only | ~28 MB measured | 275 MB measured on K3s; 574 MB – 1.9 GB reserved by managed providers[3] |
| Learning curve | Hours | Days | Months |
| AI operations assistant | ✗ | ✓ Athena (61 tools) | ✗ |
| CVE scanning | ✗ | ✓ Trivy + Grype | Via add-on |
| Auto-incident response | ✗ | ✓ AI-powered SRE | Via add-on |
| Dedicated platform staff | 0 | 0 | 1–2 engineers |
| Containers per node | 1–20 containers | 50–100+ containers[4] — 82 measured; the platform total scales with the number of nodes | 110 pods per node[4] — a pod holds one or more containers |
How these numbers and claims were arrived at
-
Geographic data residency is a placement filter, and it ships switched off.
A deployment carries
odysseus.io/data-residency-country— an ISO 3166-1 alpha-2 code such asCAorDE— orodysseus.io/data-residency-region, which names an operator-defined set of those codes, orodysseus.io/blocked-countries. The scheduler compares each against the node’s own country and region labels before it places anything, and a node that does not satisfy the requirement is dropped from the candidate set — so the deployment cannot land outside its permitted geography, rather than being found there afterwards. It is switched on per installation in the control plane’s configuration and is off by default; the regions are the operator’s own definitions, not ours. Kubernetes can express the same constraint: it shipstopology.kubernetes.io/regionandtopology.kubernetes.io/zoneas well-known node labels, and node affinity to select on them, but no country or residency label of its own — so residency there is assembled from custom labels and affinity rules — kubernetes.io. The difference is where the concept lives, not whether it can be done. -
Odysseus memory figures are measured, not modelled. Both are resident
memory (RSS) of the running process, sampled over a 14-minute window on 20 August 2026
across two live installations: production (control plane 47–51 MB over 19 samples, node
agent 26–28 MB) and development (control plane 49–64 MB over 18 samples, node agent
26–28 MB). The control plane runs
once per installation; the agent runs once per node. The control plane publishes the
figure itself as
process_resident_memory_byteson its Prometheus/metricsendpoint, so it can be checked directly rather than taken on trust. We quote RSS rather thandocker statsbecause the latter includes reclaimable page cache, which on a freshly started container reads several times higher without any of it belonging to the orchestrator. The Kubernetes figure is the documented minimum in the upstream kubeadm install guide: “2 GB or more of RAM per machine” — kubernetes.io. -
Per-node comparison. Upstream Kubernetes publishes no default reserve
for its node agents —
kubeReservedandsystemReservedboth ship empty — so there is no single official number to quote. The profiled figure is SUSE’s published K3s resource profiling, which puts the Kubernetes components on an agent (worker) node — its words, “the kubelet and k3s agent” — at 275 MB on an Intel 8375C, from 95th-percentile readings at steady state — docs.k3s.io. K3s is a single merged binary with its own embedded runtime, so this is a floor for upstream Kubernetes running the same components as separate processes, not an equivalent. The reserved figures are capacity that managed providers withhold from every worker node before any application container is scheduled, computed from their own published formulas: AWS EKS reserves(11 × max-pods) + 255MiB (574 MiB on an m5.large, which supports 29 pods) — docs.aws.amazon.com; Google GKE reserves 25% of the first 4 GiB and 20% of the next 4 GiB plus 100 MiB (≈1.9 GiB on an 8 GiB node) — cloud.google.com. Reserved capacity is an allowance the scheduler withholds, not measured consumption; we label it as such because the two are not the same thing. -
Container counts are per node, and ours is a statement of fit, not a cap.
Odysseus is built for the range where Docker Compose runs out of road and Kubernetes is
more machinery than the job needs. The largest figure we have actually run is 82
containers across two tenants on a single node, in our own development installation,
counted with
docker ps --filter label=odysseus.managed=trueon the date above; our production platform node carries 4, which is a small node rather than a limit. A platform total is that per-node figure across however many nodes a control plane manages — an architectural consequence, not something we have measured at fleet scale, so we publish the per-node number we have demonstrated and no fleet number we have not. The Kubernetes figure is that project’s own documented ceiling for a supported cluster: “No more than 110 pods per node”, stated alongside “No more than 5,000 nodes” and “No more than 300,000 total containers” — kubernetes.io. The two columns do not count the same unit — Kubernetes limits pods, a pod holds one or more containers, and we count containers — so read them as adjacent rather than interchangeable. We do not convert between them, because the ratio depends on how the pods are built. Managed distributions cap lower again: AWS EKS derives the per-node pod cap from the machine’s network interfaces rather than from that documented figure, and its own worked example is 29 pods on a two-vCPU machine — the document cited in note 3.
Simple, transparent pricing
Base fee + per-node pricing that scales with you. Start free, upgrade as you grow.
For indie developers, home labs, and evaluation use.
- Up to 3 nodes
- 1 user
- Full Docker Compose compatibility
- WireGuard VPN mesh
- Basic Prometheus metrics
- 2-tier RBAC
- Community support
- No Athena AI
- No CVE scanning
For solo developers and tiny teams running small production workloads.
- Up to 5 nodes
- Up to 3 users
- Athena AI (100 queries/mo)
- Weekly CVE scanning
- Canary deployments
- Vault secret injection
- Basic SRE automation
- 30-day audit trail
- Email support (48h SLA)
For SMB production workloads. The core commercial tier.
- Up to 50 nodes
- Unlimited users
- Unlimited Athena AI
- Continuous CVE scanning + policy gating
- Full canary auto-promote/rollback
- Prometheus autoscaling
- Full SRE automation (8 incident types)
- Full 4-tier RBAC
- 90-day audit trail
- Priority support (4h SLA)
For multi-site organizations with compliance and custom SLA needs.
- Unlimited nodes
- Everything in Pro
- Multi-datacenter federation
- SSO / SAML / LDAP / OIDC
- 1-year audit trail
- SOC 2 & ITSG-33 compliance
- Volume discounts (50+ nodes)
- Dedicated account manager
- 1h SLA + 24/7 on-call support
Start orchestrating
in under 10 minutes.
Sign up, connect your first node, and deploy — all in under 10 minutes. No Kubernetes expertise, no dedicated platform team.