Chaos engineering — deliberately injecting failure into a system to see how it responds — has moved from Netflix curiosity to standard SRE practice. In 2026, the three names engineering teams compare most are Gremlin, Chaos Mesh, and LitmusChaos. They are not quite peers: Gremlin is a commercial platform with custom, quote-based pricing, while Chaos Mesh and LitmusChaos are both free, Apache-licensed, CNCF-hosted open-source projects built specifically for Kubernetes. This guide compares what each actually does and who it fits.
At a Glance
| Tool | Price | Open Source | Governance | Best For |
|---|---|---|---|---|
| Gremlin | Custom quote; 30-day free trial, no credit card | No | Commercial company (Gremlin Inc.) | Enterprises wanting a managed platform with reliability scoring, dependency discovery, and reporting |
| Chaos Mesh | Free | Yes (Apache 2.0) | CNCF Incubating project | Kubernetes-native teams wanting broad fault coverage (network, I/O, kernel, cloud) with CRD-based control |
| LitmusChaos | Free (core); Enterprise option referenced but unpriced on the project site | Yes (Apache 2.0) | CNCF Incubating project | Kubernetes teams wanting a shared ChaosHub of reusable experiments and GitOps-friendly workflows |
Short Verdict
If your team runs on Kubernetes and wants to start chaos testing without a procurement cycle, Chaos Mesh and LitmusChaos are both genuinely free and CNCF-governed, so the choice between them comes down to workflow style: Chaos Mesh favors fine-grained CRDs per fault type with a strong namespace/RBAC-based blast-radius model, while LitmusChaos favors a community ChaosHub of pre-built, shareable experiments plus steady-state “probes.” Gremlin is the choice when you need a managed product with cross-team reliability scoring, dependency mapping, and executive-level reporting — but you’ll need to talk to sales, since no self-serve price list is published.
What Each Tool Is
Gremlin is a commercial chaos engineering and reliability platform. Beyond raw fault injection, it packages dependency discovery, reliability scoring across an organization, disaster-recovery testing, continuous risk detection (like configuration drift), and an early-access “Foresight AI” layer that recommends and re-verifies fixes. Gremlin.com doesn’t publish list prices anywhere; the Gremlin Platform is “priced per service” and Foresight AI is “priced per team,” both behind a sales conversation, with a 30-day no-credit-card trial as the only self-serve option.
Chaos Mesh is a CNCF Incubating open-source project, licensed Apache 2.0, that runs as Kubernetes-native Custom Resource Definitions. Experiments — PodChaos, NetworkChaos, StressChaos, and others — are just Kubernetes objects you apply with kubectl or manage through its bundled dashboard. It deploys to any cluster, including local ones like minikube or kind.
LitmusChaos is also a CNCF-hosted, Apache 2.0 open-source platform, installed via Helm, built around declarative, schedulable “Chaos Experiments” (renamed “Chaos Faults” as of version 3.0) that can be chained in sequence or parallel. Its distinguishing feature is ChaosHub, a public (and in paid Enterprise setups, private) catalog of pre-built, reusable experiments, plus steady-state “probes” that verify a hypothesis before and after a fault runs.
Pricing Breakdown
| Plan | Price | What You Get |
|---|---|---|
| Gremlin – Free trial | $0 for 30 days | Full access to fault injection experiments, reliability testing/scoring, observability integrations, and implementation support; no credit card required, no auto-conversion to paid. |
| Gremlin Platform | Custom, “priced per service” | Dependency discovery, fault injection and scenarios, reliability scores, disaster-recovery testing, risk detection, org-wide benchmarking and reporting. |
| Gremlin Foresight AI | Custom, “priced per team” (early access) | Adds AI-driven resilience recommendations and closed-loop remediation verification on top of an existing platform license. |
| Chaos Mesh | $0 | Full fault-injection catalog (pod, network, DNS, HTTP, I/O, time, stress, kernel, block device, JVM, physical-machine, and cloud faults on AWS/Azure/GCP), dashboard, Workflow and Schedule orchestration — no license cost since it’s self-hosted on your own cluster. |
| LitmusChaos core | $0 | ChaosHub experiments, Helm-based install, scheduling, chaining, probes, Prometheus metrics export, litmus-lite for lightweight local testing. |
| LitmusChaos Enterprise | Not published; contact via litmuschaos.io | The project site references an Enterprise offering alongside the open-source core, but gives no pricing detail — treat this as a separate commercial conversation, not part of the free project. |
Because Gremlin and LitmusChaos Enterprise are both quote-based with nothing published, we aren’t estimating numbers for either — any figure you see elsewhere online for “Gremlin pricing” is almost certainly a third-party estimate, not an official rate card.
Key Feature Comparison
- Fault injection breadth: Gremlin groups attacks into Resource (CPU, memory, GPU, I/O, disk, process exhaustion), State (shutdown, time travel, process killer), and Network (blackhole, latency, packet loss, DNS blocking, certificate-expiry checks). Chaos Mesh covers pod, network, DNS, HTTP, I/O, time, stress, kernel, block-device, JVM, physical-machine, and public-cloud (AWS/Azure/GCP) faults. LitmusChaos ships fault definitions through ChaosHub rather than a fixed built-in list, so coverage depends on which hub experiments you pull in.
- Kubernetes-native support: Chaos Mesh and LitmusChaos are both built Kubernetes-first — CRDs and Helm charts respectively. Gremlin supports Kubernetes by targeting Deployments, ReplicaSets, StatefulSets, DaemonSets, and Pods directly, alongside its broader bare-metal, multi-cloud, and serverless coverage.
- Blast-radius control: Gremlin advertises explicit “blast radius controls and automatic halt conditions” as a safety feature. Chaos Mesh scopes experiments with label/annotation selectors and a namespace allowlist, with RBAC enabled by default. LitmusChaos scopes experiments through its declarative ChaosEngine/ChaosExperiment resources and probes that can gate or report on steady-state health.
- Experiment scheduling / GameDay-style workflows: Chaos Mesh has a dedicated Workflow feature (serial or parallel steps, suspend nodes, status checks) plus a Schedule resource for recurring runs. LitmusChaos experiments are described as “declarative, schedulable, and browsable” and can be chained into scenarios. Gremlin’s own marketing pages describe “recommended scenarios” for common failure modes, though neither of the pages we reviewed used the specific term “GameDay” — check Gremlin’s documentation directly if that exact workflow label matters to your evaluation.
Pros and Cons
Gremlin
- Pros: Explicit blast-radius and halt-condition safety controls; dependency discovery and org-wide reliability scoring go beyond raw fault injection; covers bare metal, multi-cloud, serverless, and Kubernetes from one product; 30-day no-card trial.
- Cons: No published pricing at all — every tier requires a sales conversation; not open source, so you can’t audit or self-host the control plane; overkill for a small team that just wants to kill a pod and watch what happens.
Chaos Mesh
- Pros: Completely free and Apache-licensed; very broad fault catalog including kernel- and JVM-level faults most tools skip; CRD-based design fits naturally into existing GitOps/Kubernetes workflows; RBAC on by default.
- Cons: Kubernetes-only in practice — no native support for bare-metal or non-Kubernetes infrastructure; you own the operational burden of running and upgrading it yourself; still an Incubating (not Graduated) CNCF project, so governance maturity is a notch below a Graduated project.
LitmusChaos
- Pros: Free and Apache-licensed; ChaosHub gives teams a head start with pre-built, shareable experiments instead of writing fault definitions from scratch; probes make it straightforward to assert steady-state before/after a fault; exports Prometheus metrics for existing dashboards.
- Cons: The project’s own documentation is thinner on specifics (exact fault catalog, scheduling mechanics) than Chaos Mesh’s; also Incubating-stage CNCF governance; the Enterprise tier is mentioned but entirely unpriced, so budgeting for anything beyond the free core requires a direct inquiry.
Who It’s a Good Fit For
- Kubernetes-native platform teams on a budget: Chaos Mesh or LitmusChaos — both are free, CNCF-governed, and designed specifically for your environment.
- Teams wanting pre-built, shareable experiment libraries: LitmusChaos, via ChaosHub.
- Teams needing kernel, JVM, or cloud-provider-level fault injection on Kubernetes: Chaos Mesh, for its broader built-in catalog.
- Enterprises needing org-wide reliability scoring, dependency mapping, and executive reporting across mixed infrastructure (not just Kubernetes): Gremlin, accepting the custom-quote process.
Who Should Look Elsewhere
- Teams without any internal platform engineering capacity to self-host and maintain an open-source chaos tool may find Gremlin’s managed model a better operational fit, despite the opaque pricing.
- Teams running mostly bare-metal or non-Kubernetes infrastructure get limited value from Chaos Mesh or LitmusChaos, both of which are Kubernetes-first by design.
- Teams that need firm, published pricing to get budget approval quickly may be frustrated by both Gremlin’s and LitmusChaos Enterprise’s quote-only models — the open-source cores of Chaos Mesh and LitmusChaos remain the only genuinely zero-cost path.
The Bottom Line
Chaos Mesh and LitmusChaos cover the same ground — free, CNCF-governed, Kubernetes-native chaos engineering — and the choice between them is really a matter of workflow preference: Chaos Mesh’s CRD-per-fault-type model versus LitmusChaos’s ChaosHub-and-probes model. Gremlin sits in a different category entirely: a commercial, broader-than-Kubernetes reliability platform with safety controls and organizational reporting baked in, priced only through direct sales contact. Pair whichever chaos tool you choose with an observability stack that can actually show you what broke — our comparison of Datadog, Grafana Cloud, and New Relic is a reasonable place to start if you don’t already have one in place.
FAQ
Is Gremlin open source?
No. Gremlin is a commercial product built by Gremlin Inc. It offers a 30-day free trial with no credit card required, but there is no ongoing free or open-source tier.
Are Chaos Mesh and LitmusChaos really free?
Yes, for their core open-source projects. Both are licensed under Apache 2.0 and hosted as CNCF Incubating projects, meaning the software itself carries no license fee — you only pay for the infrastructure you run it on. LitmusChaos’s site also references a separate paid Enterprise offering, but that’s distinct from the free core project.
Do I need Kubernetes to use Chaos Mesh or LitmusChaos?
Effectively, yes. Both are built around Kubernetes primitives — Chaos Mesh via Custom Resource Definitions, LitmusChaos via Helm charts and ChaosEngine resources — and are designed to run inside a Kubernetes cluster.
How much does Gremlin actually cost?
Gremlin doesn’t publish prices. Its site describes the Gremlin Platform as “priced per service” and Foresight AI as “priced per team,” both requiring a quote request. Any specific dollar figure you see quoted elsewhere is a third-party estimate, not an official number.
What’s the difference between a CNCF “Incubating” and “Graduated” project, and does it matter here?
CNCF projects move through Sandbox, Incubating, and Graduated maturity stages as adoption and governance mature. As of this writing, both Chaos Mesh and LitmusChaos are CNCF Incubating projects per their own sites — neither has reached Graduated status yet, which is worth factoring into a long-term tooling bet even though both are already widely used in production.
Sources
- gremlin.com/pricing — Gremlin Platform and Foresight AI pricing model, free trial terms
- gremlin.com/docs/fault-injection/experiments — Gremlin fault injection types and Kubernetes targeting
- gremlin.com — Gremlin platform features, blast radius and halt conditions
- chaos-mesh.org — Chaos Mesh overview, fault types, CNCF status
- github.com/chaos-mesh/chaos-mesh — Apache 2.0 license confirmation and fault categories
- litmuschaos.io — LitmusChaos overview, CNCF status, ChaosHub, and Enterprise reference
- docs.litmuschaos.io/docs/introduction/features — LitmusChaos feature history by version
- github.com/litmuschaos/litmus — Apache 2.0 license confirmation
