In June 2019, Nirmata co-founder Jim Bugwadia published a blog post introducing a policy engine whose
distinguishing feature was an absence: Kyverno policies were plain Kubernetes resources, validated by
pattern matching, and — in the words the project would repeat for years — they
did not require learning a new language. That bet is the reason Kyverno exists. It is the reason
it was donated to the CNCF in November 2020 with 574 GitHub stars, incubated by July 2022, and graduated
on March 16, 2026 with Bloomberg, Coinbase, LinkedIn, and Spotify running it in production. And on
November 12, 2026, that same project shipped v1.20.0 — a release whose defining act is the deletion of
the pattern-matching engine that carried all of that history, replaced by a stack built on the
Common Expression Language: a policy language. The irony is not subtle, but the
engineering is serious, and the archaeology matters more than the irony. The removal was planned in
public as a soft cutover, re-planned twelve days later as a hard one, executed as a four-part surgical
sequence against a live ecosystem, and shipped with an upgrade gate whose Helm value name —
acknowledgeLegacyPoliciesNotEnforced — tells you exactly what happens if you
skip the migration. This is the tale of how the most successful anti-language policy engine in the
Kubernetes ecosystem decided its founding abstraction was a liability, and what it cost to remove.
The Ancestor: Patterns Over Languages (2019–2020)
A policy engine whose identity was an absence
The repository was created on February 4, 2019 under the Nirmata organization — the v1.0.0 README's
Travis badge still points at nirmata/kyverno — and Jim Bugwadia's
introduction post on June 3, 2019 framed the project as the application of telecommunications-grade
policy management to Kubernetes: "My co-founder and I both came from the telecommunications industry
where managing critical infrastructure at scale relied on implementing IT policies." The core
design decision was visible in the first release: where OPA had spent 2015–2019 making the case for
Rego as a general-purpose policy language, Kyverno went the other way. The v1.0.0 release (December 5,
2019) described validation as "overlay style syntax, with support for pattern matching" — a
Kyverno rule was a partial Kubernetes object, and the engine checked whether incoming resources
matched it.
The canonical example, straight from the v1.0.0 README, has aged into a museum piece — this is what Kubernetes policy looked like when "no new language" was the whole pitch:
apiVersion: kyverno.io/v1
kind: Policy
metadata:
name: check-cpu-memory
spec:
rules:
- name: check-pod-resources
match:
resources:
kinds:
- Pod
validate:
message: "CPU and memory resource requests and limits are required"
pattern:
spec:
containers:
# 'name: *' selects all containers in the pod
- name: "*"
resources:
limits:
# '?' requires 1 alphanumeric character and '*' means
# 0 or more. Together '?*' requires at least one char.
memory: "?*"
cpu: "?*"
requests:
memory: "?*"
cpu: "?*"
That is the whole grammar: a fragment of the object you want, with wildcards. No expressions, no
query language, no negation beyond deny conditions that arrived later. The
bet behind it was argued explicitly in Nirmata's October 2020 post, the same month the project joined
the CNCF sandbox: "While other general purpose policy solutions were retrofitted to Kubernetes,
the Nirmata team designed Kyverno for Kubernetes… Kyverno policies are simply Kubernetes resources,
and do not require learning a new language." Kyverno means to govern in Greek — the
same root as Kubernetes — and for the first two years of its life that name stood for a specific
claim: governing Kubernetes should require nothing but Kubernetes' own idioms. The CNCF accepted the
project into its sandbox on November 10, 2020, at which point it carried 574 stars. The foundation's
incubation announcement two years later would repeat the pitch almost verbatim — policies that
"do not require learning a new language" — while crediting the project with 856% committer
growth, 5X star growth, and a hundred-plus releases.
The Language That Crept in the Back Door (2020–2022)
Variable substitution, and everything that followed it
The problem with a pattern is that it can only state what it can see. Real policy needs to reference things that are not in the object being validated — labels from the Namespace, values from ConfigMaps, fields of related resources. Kyverno v1.1.0 (January 11, 2020) shipped the fix: "Support variable substitution" (PR #549), where variables are JMESPath expressions evaluated against the request and substituted into the policy before matching. JMESPath is a query language for JSON. The first release of Kyverno's second year quietly contained the seed of the thing the project was defined by not having.
What followed was six years of scope creep expressed as a rule syntax. Each new capability
sharpened the engine and widened the language surface at the same time: preconditions
gained JMESPath conditions; deny rules arrived as an escape hatch where patterns
could not express negation; foreach arrived because patterns could not iterate
lists; a growing library of custom JMESPath functions — string, time, base64, regex, label-matching
helpers — accumulated because plain JMESPath could not do Kubernetes things; and the
context block gained apiCall and variable stores so
JMESPath could reach other objects. None of these decisions was wrong in isolation. The composite
was a domain-specific language with pattern matching embedded in it, documented across a dozen
interlocking fields — while the marketing sentence at the top of every overview page never changed:
no new language required.
The operational consequence was not theoretical. To give the engine deterministic rule isolation — so one rule's context could not leak into the next — the 1.17.0 release (February 2026) started copying the entire evaluation context at every checkpoint. The Kyverno team later reproduced and measured the result: "between 12% and 23% depending on load" admission-throughput regression versus 1.16.4, caught by outside benchmarks. A shallow-snapshot, copy-on-write fix landed in 1.19.2 — and with it the sentence that explains the entire pivot: "The legacy engine is on its way out, so the effort belongs in the engine replacing it."
The CEL Beachhead: validate.cel and the VAP Alignment (2023–2024)
Riding the API server's new policy language
Common Expression Language arrived in Kubernetes the same way JMESPath had arrived in Kyverno:
as a small answer to a small problem, which grew. CEL was introduced to the API server for CRD
validation rules (the x-kubernetes-validations extensions), then selected as
the expression language for ValidatingAdmissionPolicy — the in-process, no-webhook
admission policy type that Kubernetes 1.26 shipped in alpha in December 2022. That decision mattered
to Kyverno more than to anyone else: ValidatingAdmissionPolicies were CEL evaluated inside the API
server, and they were the Kubernetes project's official answer to the problem Kyverno's entire
product addressed. Kyverno 1.10 (May 2023) added early ValidatingAdmissionPolicy support; 1.11
(November 10, 2023) — five months of development, eight pre-releases, and more than 500 merged pull
requests — landed the beachhead: a new validate.cel sub-rule that put CEL
expressions inside ordinary Kyverno policies, plus the ability to auto-generate a native
ValidatingAdmissionPolicy and its binding from a compatible rule.
The framing in the 1.11 announcement is worth reading carefully, because it already contained the project's future: Kyverno was positioning itself as the management layer over the API server's own policy engine — applying policies via CLI, producing PolicyReports, handling the lifecycle. The engine beneath could be replaced, and the release notes for the following two years read as the slow execution of that insight.
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: check-deployment-replicas
spec:
validationFailureAction: Enforce
background: false
rules:
- name: check-deployment-replicas
match:
any:
- resources:
kinds:
- Deployment
validate:
cel:
expressions:
- expression: 'object.spec.replicas < 4'
message: 'Deployment spec.replicas must be less than 4.'
Five months later, on April 24, 2024, Kubernetes 1.30 graduated ValidatingAdmissionPolicy to GA.
From that point the industry's direction was written: CEL is the policy language of the Kubernetes
API plane — in CRD rules, in admission policies, in matchConditions on
webhooks. A Kubernetes policy engine whose expression layer was a bespoke JMESPath fork was now
definitionally out of alignment with the platform it governed.
The Second API Surface: Discrete CEL-Native Types (2025–2026)
From one rule-list to five purpose-built CRDs
The transition that Kyverno's own 1.19 announcement dates to v1.14 (April 25, 2025) began as a
parallel construction site. Instead of converting the legacy engine in place, the project built a
second, CEL-native API surface alongside it — discrete policy types under a new
policies.kyverno.io group, each dedicated to one action, each mirroring the
shape of the corresponding native Kubernetes policy API. The release cadence that followed is the
clearest record of the strategy:
| Release | Date | CEL-native milestone |
|---|---|---|
| v1.11.0 | 2023-11-10 | validate.cel sub-rule; native ValidatingAdmissionPolicy generation |
| v1.14.0 | 2025-04-25 | ValidatingPolicy (vpol) and ImageValidatingPolicy (ivpol) shipped; CEL PolicyException; extended CEL libraries |
| v1.15.0 | 2025-07-31 | MutatingPolicy (mpol), GeneratingPolicy (gpol), DeletingPolicy; image() operator renamed parseImageReference |
| v1.16.0 | 2025-11-10 | Namespaced variants; v1beta1 for all five CEL types; fine-grained CEL exceptions; CEL libraries in matchConditions |
| v1.17.0 | 2026-02-02 | NamespacedMutatingPolicy and NamespacedGeneratingPolicy complete the namespaced matrix |
| v1.18.0 | 2026-04-29 | CLI parity: apply/test over all new types; excludes and mutateExisting in mpol |
| v1.19.0 | 2026-08-20 | Declared full feature parity; official deprecation of the legacy types |
| v1.20.0 | 2026-11-12 | Legacy engine deleted; CEL-based types are the only engine |
Note what that table does not show: the cost. From April 2025 to August 2026,
every feature Kyverno shipped had to be built twice — once for the legacy rule engine that carried
the installed base, once for the CEL types that were the future. Feature-parity tracking issue #16302
(opened June 23, 2026 by maintainer Shuting Zhao) exists because parity was a managed deliverable
with its own checklist, mapping ClusterPolicy/Policy
to ValidatingPolicy/NamespacedValidatingPolicy,
CleanupPolicy to DeletingPolicy, and so on. The
1.19.0 release closed the last gaps; the 1.19 announcement marked the moment the project was willing
to say so publicly: "everything you can do with a ClusterPolicy — validation, mutation, generation,
image verification, and cleanup — can now be done with the dedicated CEL-based policy types."
The graduation ceremony happened in the middle of that convergence. On March 16, 2026 the CNCF TOC voted 9–0 (with two members not voting) to graduate Kyverno — announced March 24 at KubeCon EU in Amsterdam, with the foundation counting growth from 574 stars at contribution to more than 9,000, adopters from Bloomberg and Coinbase to Deutsche Telekom, LinkedIn, Spotify, Vodafone, and Wayfair, a third-party security audit and TAG Security assessment behind it, and TOC sponsor Karena Angell's verdict: "Kyverno met that bar through its technical maturity, security posture and the growing number of organizations relying on it." The same announcement contained a sentence that would have been unthinkable in the 2019 pitch: "With its latest release, Kyverno has fully adopted Common Expression Language (CEL), aligning with the future direction of Kubernetes admission controls." The foundation's graduation press release — the document that defines a project for the historical record — describes Kyverno's defining technical fact as the adoption of a policy language.
Loud Deprecation: The 1.19 Warning Campaign
Kyverno 1.19.0 (August 20, 2026) was engineered to make ignoring the deprecation impossible. The
release wired deprecation notices into every surface a user touches: a new
pkg/deprecations package made the policy admission webhooks return
Kubernetes API warnings whenever a ClusterPolicy,
Policy, CleanupPolicy, or legacy
PolicyException was processed; the Helm chart printed a matching notice in
its install output; the CLI gained a --warnings-as-errors flag so CI could
turn the warnings into build failures; and a new metric,
kyverno_deprecated_api_requests_total, counted every legacy API request by
group, version, kind, and field — the go/no-go signal for the removal phase. The message users saw
on every legacy policy apply was precise about the destination:
Warning: ClusterPolicy (kyverno.io) is deprecated and will be removed in a
future release; migrate to ValidatingPolicy, MutatingPolicy, GeneratingPolicy
or ImageValidatingPolicy (policies.kyverno.io), see
https://kyverno.io/docs/guides/migration-to-cel/
clusterpolicy.kyverno.io/require-labels created
One change in the 1.19 wave deserves more attention than it got: the
kyverno-policies chart — the one that ships the Pod Security Standards
baseline — flipped its default policyType from
ClusterPolicy to ValidatingPolicy. The rendered
policy sets were verified identical between the two modes (11 baseline policies, 17 restricted),
which means the project's own default installation became CEL-native in 1.19, quietly, for everyone
who did not override the value. A kyverno migrate CLI command appeared to
rewrite stored objects, the migration guide published field-by-field mappings, and the docs version
selector gained a v1.20 entry. By September 2026 the only thing left between the CEL world and the
removal of the legacy one was the removal plan itself — which is where this tale stops going
forward in a straight line.
The Removal Plan That Changed Shape Mid-Cycle
September 2026: the soft cutover
The plan published on August 18, 2026 — tracking issue #17214, phase 2 of the removal roadmap —
was a conservative one. All legacy CRDs and versions would stay fully served in 1.20; the admission
webhooks would hard-deny new writes; and crucially, existing stored policies would
keep being enforced until a later release. The issue's own risk analysis is the most
instructive document in this story, because it explains why the obvious shortcut was never taken:
deleting the CRDs outright would have triggered Kubernetes' built-in
CustomResourceCleanup finalizer, which garbage-collects every custom
resource of that type before removing the CRD — "permanently wipe every user's stored policies
from etcd during the upgrade — irreversible, with no confirmation step." Worse, Kyverno's CRDs
live in regular chart templates rather than Helm's hook-gated crds/
directory, so Helm 3's prune-on-upgrade would have deleted the live CRD — and with it every
ClusterPolicy in the cluster — automatically. The rejected alternative is a design document about
failure modes that would have made national incident-review headlines.
On September 10, 2026 the soft cutover shipped into the 1.20 branch. PR #17535 implemented the
deny: creates and spec-changing updates of the five legacy kinds rejected with a migration message,
while no-op GitOps reconciles passed through untouched — the diff compares typed specs with
Kubernetes' Semantic.DeepEqual, which by construction ignores
metadata and status, so Argo CD, Flux, and Helm
re-applying an unchanged policy never trip the gate. A temporary toggle,
features.blockLegacyPolicyAPIs.enabled, was the operator escape hatch.
PR #17534 added the Helm-side gate: a render-time lookup check plus a
pre-install/pre-upgrade hook Job running a hidden
kyverno check-legacy-policies command, both blocking installs while legacy
resources exist. PR #17553 brought the same hard-error to kyverno apply and
kyverno test — and then removed its own escape-hatch flag on maintainer
review: the CLI has no opt-out; if you still need to validate legacy manifests during the migration
window, you run a pre-1.20 CLI.
September 22, 2026: the amendment
Twelve days later, on September 22, 2026, Jim Bugwadia — the author of the original no new language pitch — opened issue #17701 with a decision that replaced the plan's core requirement: "This replaces this epic's earlier requirement to retain legacy Go API packages in v1.20. Kubernetes CRD serving does not require Kyverno's Go types or generated clients. v1.20 removes legacy execution AND corresponding Go API types." The enforcement half of the soft cutover was gone. Existing policies would not keep enforcing; they would keep existing — readable, exportable, deletable, and pointedly inert. The five sub-issues (#17708 write protection, #17710 server execution, #17711 CLI branches, #17713 Go APIs, #17707 verification) split the deletion into independently shippable halves, with an explicit invariant: "The epic forbids any merged state where execution is removed while writes are still accepted."
October 21–25: the four-part surgery
Execution ran as a four-PR sequence against the 1.20 branch, each one cutting execution from a different binary so the tree compiled at every step:
| PR (merged) | Scope | What it actually removed |
|---|---|---|
| #18164 (Oct 21) | admission binaries | Legacy admission path in pkg/webhooks/resource, the legacy policy cache, ClusterPolicy-driven webhook rule building, VAP generation from ClusterPolicy specs, and the blockLegacyPolicyAPIs escape hatch — 82 Go files, +757/−13,316 lines, plus 16 conformance suites deleted whole (−96,244 lines) |
| #18187 (Oct 22) | background controller | Legacy generate/mutate dispatch; in-flight legacy UpdateRequests are deleted, not parked — parked URs would have sat Pending forever, still counted by the work gauge |
| #18195 (Oct 23) | reports controller | Legacy background-scan evaluation; reports whose results were all legacy are deleted; a one-shot startup sweep prunes stale legacy results when legacy policies remain |
| #18265 (Oct 25) | the engine itself | pkg/engine legacy arms, pkg/autogen, typed legacy informers (replaced by metadata-only lists on a 30-second refresher), write RBAC on legacy kinds, and three policy metrics |
The follow-through PRs finished the anatomy: #18282 deleted the legacy Go API packages and regenerated the clients; #18231 froze the legacy CRD schemas and extracted shared types; #18047 deleted the CLI's legacy execution and authoring branches. On October 23, PR #18228 flipped the migration E2E suite to match the amended reality — the script's scenario A4 had asserted "ClusterPolicy enforcement still active post-upgrade"; it now asserts the opposite: a pod that violates a surviving legacy policy is admitted. That one-line test change is the entire story of this release compressed into CI: Kyverno 1.20 deliberately lets violating workloads in when the policy guarding them was never migrated.
The PR record of this cycle also captures something rare: an AI code-review catch on the way out the door. #18265's deletion of the legacy exception-event path almost took CEL PolicyException events with it — the guarding predicate was type-agnostic — and the PR credits Copilot with catching it in review, fixed and pinned by tests that fail on the old code.
What v1.20.0 Actually Does (and What It Refuses to Do)
Shipped November 12, 2026, the release leaves the legacy API surface physically intact — every CRD stays served, schemas frozen, objects readable — while making every path that could act on them a dead end. The matrix, assembled from the upgrade documentation and the deletion PRs:
| Operation on a legacy policy (ClusterPolicy, Policy, CleanupPolicy, ClusterCleanupPolicy, legacy PolicyException) | v1.20.0 behavior |
|---|---|
| Create | Denied, with a message naming the policies.kyverno.io replacement |
| Update, spec changed | Denied |
| Update, spec unchanged (GitOps/Helm no-op reconcile, metadata-only) | Allowed, silently |
| Delete / status subresource | Allowed |
| Read, list, export | Allowed — but nothing enforces them |
| Enforcement of existing stored policies | None. Marked NotReady; startup signals and a gauge report them; violating workloads are admitted. |
CLI apply/test on legacy manifests | Hard error, no escape hatch — use a pre-1.20 CLI |
| Helm install/upgrade with legacy resources present | Blocked by default (render-time check + hook Job) until acknowledged |
graph TD
W["kubectl apply: legacy kyverno.io policy write"] --> WB["Admission webhook: ShouldBlock gate"]
WB -->|"create / spec changed"| DENY["DENIED with migration message
pointing at policies.kyverno.io"]
WB -->|"spec unchanged reconcile"| PASS["allowed silently"]
WB -->|"delete / status"| PASS2["allowed"]
STORE["Existing stored ClusterPolicy
(stays in etcd, CRDs still served)"] --> NR["Marked NotReady
kyverno_legacy_policies_total gauge
startup signal + kyvernopre warnings"]
NR -.->|"NOT enforced"| ADMIT["violating workloads admitted"]
CEL["policies.kyverno.io write
(vpol / mpol / gpol / ivpol / dpol)"] --> ENF["CEL engine: compiled programs,
per-request activation, cost-bounded
evaluation, reports, exceptions"]
UP["helm install/upgrade"] --> GATE{"Legacy policy CRs
still on cluster?"}
GATE -->|"yes"| BLOCK["Blocked: render-time lookup check
+ legacyPolicyCheck hook Job
(kyverno check-legacy-policies)"]
GATE -->|"no"| GO["proceed"]
BLOCK --> ACK["acknowledgeLegacyPoliciesNotEnforced=true
acknowledges, does NOT restore enforcement"]
The Helm values at the release tag document the gate with unusual candor — this is the shipped
charts/kyverno/values.yaml at v1.20.0:
upgrade:
# -- Installing or upgrading is blocked by default when legacy kyverno.io policy
# resources (ClusterPolicy, Policy, CleanupPolicy, ClusterCleanupPolicy,
# PolicyException) are found on the cluster. As of 1.20, Kyverno no longer
# executes these legacy policy types even though their APIs remain available
# for read, list, export, and delete: setting this to true does not restore
# enforcement, it only acknowledges that legacy policies found on this cluster
# are not enforced. Migrate them to the policies.kyverno.io policy types, or
# set this to true to bypass the check. This disables both the render-time
# check and the legacyPolicyCheck hook Job.
acknowledgeLegacyPoliciesNotEnforced: false
legacyPolicyCheck:
# -- Enable the pre-install/pre-upgrade hook Job that checks for legacy
# kyverno.io policy resources on the cluster. A second, server-side check
# for GitOps tools that honor Helm hooks...
enabled: true
The migration itself is mechanical in the simple cases and re-architectural in the hard ones. A label-validation ClusterPolicy becomes a ValidatingPolicy — the migration guide's canonical side-by-side:
# BEFORE — the legacy pattern (kyverno.io/v1)
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: require-labels
spec:
validationFailureAction: Enforce
rules:
- name: check-labels
match:
any:
- resources:
kinds:
- Pod
validate:
message: 'Required labels missing'
pattern:
metadata:
labels:
app: '?*'
version: '?*'
# AFTER — the CEL expression (policies.kyverno.io/v1)
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
name: require-app-version-labels
spec:
matchConstraints:
resourceRules:
- apiGroups: ['']
apiVersions: ['v1']
operations: ['CREATE', 'UPDATE']
resources: ['pods']
validationActions: ['Deny']
validations:
- expression: >
['app', 'version'].all(label,
object.metadata.?labels[label].orValue('') != '')
message: 'Required labels missing'
Field-level translation is documented per-rule: spec.admission becomes
spec.evaluation.admission.enabled,
spec.background becomes
spec.evaluation.background.enabled,
validationFailureAction becomes
validationActions, and applyRules has no
equivalent — a multi-rule ClusterPolicy that validated, mutated, and generated in one object splits
into three separate policies of three different types. That last mapping is the real cost of the
migration for large estates: the unit of policy composition changed. Existing
kyverno test suites are reusable against migrated policies, the CLI can
resolve namespaces and subresources, and the storage version of the
policies.kyverno.io types moved from v1beta1 to v1 in this release — but
nobody should quote "mechanical" at a 400-policy platform team without showing them the
applyRules row.
Why CEL Won: The Production Mechanics
The numbers the pivot was riding on
The public evidence for the CEL engine's superiority arrived on October 19, 2026 — three weeks
before the release that made it the only engine — in a post-mortem by Raunak Madan titled
"Optimizing Kubernetes Admission Control: Where Kyverno's CEL admission cost actually goes."
Its opening is as close to a confession as a graduated CNCF project publishes: a public benchmark
had put Kyverno behind its alternatives, those benchmarks measured the legacy ClusterPolicy engine,
and "that answer was right but incomplete: we had not checked what the CEL engine itself was
spending its time on." What the heap profile showed was not what anyone expected:
86.8% of everything the engine allocated went to
ConvertObjectToUnstructured — converting the admitted object into
the map form CEL reads — while actual policy evaluation "barely registered." The
conversion ran inside the loop over matched policies: with the Pod Security Standards installed,
roughly 16 policies match a Pod creation, so Kyverno parsed the same Pod 16 times per admission.
The cost was O(policies) where it should have been O(1).
The fix — convert once per request, splice the object back in, keep every engine's existing
request.object contract identical — shipped in 1.19.2 and turned the
profile inside down: conversion fell from 86.8% of allocations to 2.9%, and the largest frame
became evaluateWithData, the code that actually runs the user's policy.
The measured curve, for a ~50 KB Pod, engine-only:
| Matched policies | Allocations before | Allocations after | Engine time before | Engine time after |
|---|---|---|---|---|
| 1 | 2,327 | 854 | 0.31 ms | 0.10 ms |
| 16 | 37,055 | 2,718 | 4.91 ms | 0.16 ms |
| 64 | 148,131 | 8,672 | 20.01 ms | 0.36 ms |
The MutatingPolicy engine improved on the same curve: 258,943 to 52,689 allocations and 10.59 ms to 2.97 ms at 64 policies. Before the fix, allocations grew ~63× from one to 64 policies; after, ~10× — and that residual is the actual CEL evaluation, the work the policies exist to do. The post also answered the question the CEL pivot was really about — how a webhook-based engine compares to the API server's own in-process ValidatingAdmissionPolicy. Running the same 16 Pod Security Standards policies through both: at one policy native wins (9.2 ms vs 12.8 ms); at the full 16-policy set Kyverno wins (~20 ms vs ~29 ms), and the CPU comparison is more lopsided still — 3.2 cores for Kyverno's engine against 8.2 for the API server dispatching the native policies, 67% of which is dispatch machinery while the CEL bytecode itself is 5.5%. Native VAP cost lands on the control plane, which cannot be scaled horizontally the way a Kyverno deployment can. And the legacy engine? The same post reproduced its regression — 12–23% between 1.16.4 and 1.17.0, caused by the full-context copy on every checkpoint — and fixed it with a shallow copy-on-write snapshot in 1.19.2, with the closing sentence that is this whole tale in miniature: "The legacy engine is on its way out, so the effort belongs in the engine replacing it."
1.20 then hardened the CEL stack the way the API server hardens its own: PR #17988 found that
policy expressions were compiled with no cost limit — cel-go's own cost limit was
useless against Kyverno's dyn-typed variables, which resolve no overload
and get billed a flat 1 per call. The fix prices calls by function name, adds a per-program limit,
an interrupt frequency, a per-request budget, and pre-execution guards. The PR's verification is a
production story on its own: before, a single ConfigMap-sized expression could drive the admission
controller to OOMKilled and take unrelated writes down with it; after, the
same input is denied with "per-program cost limit exceeded" and the controller survives
repeated attempts. The 1.20 release notes carry the matching performance work —
perf(cel) PRs that build the request activation once per admission
(#17572, #17585) and reuse compiled ImageValidatingPolicy programs across admissions (#17599) — and
an allocation-regression CI gate (#17573) to keep it that way.
The Operational Toil Nobody Warns You About
Read the v1.20 upgrade notes as an operator, not an archaeologist, and the release is a checklist of ways to silently lose enforcement:
- The enforcement cliff is silent. The E2E suite now asserts that a pod
violating a surviving legacy policy is admitted. If you upgrade with unmigrated policies and
acknowledge past the Helm gate, your guardrails do not log an error per violating workload — they
simply stop existing. The only traces are the
NotReadystatus, thekyverno_legacy_policies_totalgauge (metadata-only, refreshed every 30 seconds), and startup log lines. - The Helm gate has documented bypass routes. The chart README lists them
itself:
--no-hooks, Argo CD's Skip Hooks directive, Flux'sdisableHooks, andglobal.templating.enabledall sidestep the hook Job — which is exactly why the render-time lookup gate exists as the second layer, and why YAML-manifest installs get no gate at all: they are merely markedNotReadywith warnings. - Legacy generate-labels are a cleanup trap. Legacy generate rules wrote both
generate.kyverno.io/policy-nameandgenerate.kyverno.io/rule-namelabels; the CEL GeneratingPolicy writes onlypolicy-name. A cleanup command that omits therule-nameexistence term will delete resources a live CEL policy is managing. And if a same-named CEL GeneratingPolicy adopts the orphaned resources before you clean up, the adopted resources keep carrying the stale legacy label. - Report history has a deletion window. Export before upgrading —
kubectl get polr,cpolr -A -o yaml— because the 1.20 reports controller deletes reports whose results were all legacy, and delete legacy policies only after the 1.20 reports controller has started once, or the one-shot startup sweep never runs and stale results linger. - Monitoring breaks.
kyverno_policy_results_total,kyverno_policy_execution_duration_seconds, andkyverno_policy_changes_totalare no longer registered in 1.20, and the chart's Grafana panels for them are removed. Dashboards and alerts pinned to those series go quietly dark on upgrade. - JMESPath has one foot in the grave. GlobalContextEntry projections still
accept
jmesPath— and 1.20 deprecates it, adds a CELexpressionfield, and ships usage telemetry to count who still depends on it. The query language that crept in the back door in 2020 is being walked out the front in 2026. - The upgrade window itself has a race. During rollout, pods still running
1.19 temporarily lose
watchand*/statuspermissions on legacy kinds — transient, but real if your upgrade strategy is slow.
None of this is hidden — every item is in a PR description or the upgrade guide, stated plainly. The aggregate effect, though, is that v1.20 is a release where the safe upgrade path is longer than the release notes, and the unsafe paths are all one flag wide.
Community Engine & Corporate Influence: Who Actually Built It
The deletion was executed almost entirely by one company's employees — but the company is not
the owner; it never was after 2020. Kyverno was created inside Nirmata, donated to the CNCF sandbox
on November 10, 2020, and has been foundation-governed since. The 1.20 cycle's named actors tell
the story: Shuting Zhao (realshuting) opened the parity tracker and
authored the deprecation plumbing; Raunak Madan (raunak-nirmata) wrote
the four deletion PRs and the admission-cost post; Jim Bugwadia — Nirmata's founder, the author of
the 2019 introduction post and of the CEL-alignment era's largest cleanup PRs — opened the
amendment that replaced the project's own plan. The founder who wrote "do not require learning
a new language" in 2020 signed off on deleting the language's engine in 2026, twice, in public
writing both times. That continuity is either the healthiest or the most ironic thing in this
tale, and it is both.
The graduation review formalized the project's independence posture: a third-party security
audit and TAG Security assessment, a formal governance review, contributor guidelines for the
responsible use of AI-assisted development (the repository gained an AGENTS.md
hierarchy in the same cycle), and a 9–0 TOC vote sponsored by Karena Angell. The installed base the
foundation certified is the same one the v1.20 gate now protects: Bloomberg, Coinbase, Deutsche
Telekom, Groww, LinkedIn, Spotify, Vodafone, Wayfair — and the repo stands at 8,356 stars and
1,742 forks as of this tale, its description rewritten once more from
"Kubernetes Native Policy Management" to "Unified Policy as Code."
KYVERNO 1.19 (dual engine) KYVERNO 1.20 (CEL only)
AdmissionRequest AdmissionRequest
| |
[ Webhook: block legacy WRITES ] [ Webhook: block legacy WRITES ]
| |
+----+----+ (execution gone: nothing
| | acts on legacy objects)
v v
LEGACY CEL vpol/ivpol |
ENGINE ENGINE v
(pattern, (compiled CEL vpol / mpol / gpol
JMESPath, programs, / ivpol / dpol engines
foreach, cost model) (compiled programs, once-
deny...) per-request activation,
| | bounded evaluation cost)
v v |
Reports Reports Reports + PolicyReports
(legacy (CEL (CEL + native VAP/MAP results;
scan sources) legacy results swept once)
sources)
|
Background: legacy generate/mutate Background: gpol/mpol only;
via UpdateRequests legacy URs deleted, not parked
Current Trajectory: The Verdict
The roadmap past 1.20 is already written: issue #17493 tracks Kyverno 1.21's stop-serving step — Go types, CRD templates (~10k+ lines per CRD), the upgrade gate's opt-out replaced by an explicit orphan-acknowledgement value, and tombstone webhook rules that always deny writes to the removed kinds with a "removed in 1.21; migrate to policies.kyverno.io" error, safe to register even where the CRDs are absent, dropped again in 1.22. The direction past that is in the graduation announcement: policy enforcement for AI and Model Context Protocol gateways, the same declarative machinery aimed at the next surface that needs governing. If the pattern engine's history teaches anything, it is that Kyverno's durable asset was never the pattern syntax — it was the admission-path infrastructure (matching, reports, exceptions, autogen, image verification) that any expression language can ride on.
Verdict: v1.20 is the most disciplined major-version deprecation this writer has covered in the Kubernetes ecosystem — phased in public, gated at the Helm layer, byte-for-byte storage-preserving, tested in both directions (upgrade and rollback), and honest in its own values file about what the opt-out does not do. The performance case for the CEL engine is real and published with its limitations. The cost is equally real: a seven-year policy syntax is dead, every Kyverno tutorial written before 2025 now targets a deprecated API, and the migration for mixed validate/mutate/generate policies is re-architecture, not translation.
Who should skip this upgrade: teams with large unmigrated
ClusterPolicy estates and a hard upgrade deadline — the acknowledge flag
buys you silence, not enforcement, so stay on 1.19.x and migrate first; YAML-manifest installations,
which get warnings and NotReady markers but none of the Helm gate's
protection; and anyone whose alerting rides the three removed metrics — rebuild the dashboards
before the rollout, not after. Who it is for: CEL-first platform teams on modern
clusters, anyone already standardizing on ValidatingAdmissionPolicy semantics, teams that need
policy over JSON payloads outside Kubernetes, and multi-tenant platforms that need cost-bounded
expressions (the #17988 hardening makes namespaced policy authors safe to host). For the
side-by-side with the other engine that bet on a language — and lost its founding company instead
— read our
Kyverno vs. OPA Gatekeeper guide, our
OPA tale covers the Rego side of the same industry-wide drift,
and our SBOM enforcement guide shows the
verify-images path that v1.20's ImageValidatingPolicy now carries alone.
Timeline: Pattern to CEL, Seven Years
- 2019-02-04 — The repository is created under the Nirmata organization; Jim Bugwadia introduces it publicly on June 3, 2019 as Kubernetes native policy management.
- 2019-12-05 — v1.0.0: policies as Kubernetes resources, validation by overlay patterns (
?*wildcards), mutation by overlay or JSON Patch. The pitch: no new language to learn. - 2020-01-11 — v1.1.0 ships variable substitution (PR #549): JMESPath expressions enter the policy format through the back door, along with pod-controller autogen (#518).
- 2020-11-10 — Kyverno is accepted into the CNCF sandbox with 574 stars; the October Nirmata post repeats the pitch: "policies are simply Kubernetes resources, and do not require learning a new language."
- 2022-07-13 — CNCF incubation, credited with 856% committer growth and 5X star growth. The rule syntax is now patterns + JMESPath preconditions + deny + foreach + apiCall contexts.
- 2023-11-10 — Kyverno 1.11 lands
validate.celand native ValidatingAdmissionPolicy generation: five months, eight pre-releases, 500+ PRs. CEL becomes a second expression layer inside the legacy format. - 2024-04-24 — Kubernetes 1.30 graduates ValidatingAdmissionPolicy to GA: CEL is now the API server's own policy language, and the alignment argument is settled from outside the project.
- 2025-04-25 — Kyverno 1.14 introduces
ValidatingPolicyandImageValidatingPolicyunderpolicies.kyverno.io: discrete, CEL-native, VAP-shaped policy types. The dual-engine era begins. - 2025-07-31 / 2025-11-10 — 1.15 adds MutatingPolicy, GeneratingPolicy, DeletingPolicy; 1.16 adds namespaced variants and v1beta1 for all five CEL types. Every feature now ships twice.
- 2026-03-16 — CNCF Graduation (announced March 24 at KubeCon EU, Amsterdam; TOC vote 9–0). The press release names the project's defining technical fact: it "has fully adopted Common Expression Language."
- 2026-08-20 — Kyverno 1.19 declares full feature parity and officially deprecates
ClusterPolicy,Policy, the cleanup policies, and the legacy PolicyException — warnings, metrics, a--warnings-as-errorsCI flag, and a PSS chart that defaults to CEL policies. - 2026-09-22 — Issue #17701 amends the 1.20 plan twelve days after the soft cutover shipped: remove legacy execution and the Go APIs entirely. Existing policies will stop enforcing in 1.20, not 1.21.
- 2026-10-21 → 2026-10-25 — The four-part surgery: #18164, #18187, #18195, #18265 delete legacy execution from the admission binaries, background controller, reports controller, and the engine core — +757/−13,316 Go lines in part 1 alone, −96,244 conformance lines, three policy metrics and the escape hatch removed.
- 2026-11-12 — v1.20.0: CEL-based policy types are the only engine. Legacy CRDs stay served and stored policies stay readable, but nothing enforces them; the Helm chart blocks upgrades with
upgrade.acknowledgeLegacyPoliciesNotEnforced;kyverno ocipolicy bundles, explainable decisions, and MutatingPolicy JSON mode ship in the same release. - Planned: 1.21 / 1.22 — Issue #17493 (open as of this tale): stop serving the legacy kinds, delete ~10k+ lines of CRD templates per kind, register tombstone webhooks that deny with a "removed in 1.21" message — and drop the tombstones again in 1.22.