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:

ReleaseDateCEL-native milestone
v1.11.02023-11-10validate.cel sub-rule; native ValidatingAdmissionPolicy generation
v1.14.02025-04-25ValidatingPolicy (vpol) and ImageValidatingPolicy (ivpol) shipped; CEL PolicyException; extended CEL libraries
v1.15.02025-07-31MutatingPolicy (mpol), GeneratingPolicy (gpol), DeletingPolicy; image() operator renamed parseImageReference
v1.16.02025-11-10Namespaced variants; v1beta1 for all five CEL types; fine-grained CEL exceptions; CEL libraries in matchConditions
v1.17.02026-02-02NamespacedMutatingPolicy and NamespacedGeneratingPolicy complete the namespaced matrix
v1.18.02026-04-29CLI parity: apply/test over all new types; excludes and mutateExisting in mpol
v1.19.02026-08-20Declared full feature parity; official deprecation of the legacy types
v1.20.02026-11-12Legacy 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)ScopeWhat 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
CreateDenied, with a message naming the policies.kyverno.io replacement
Update, spec changedDenied
Update, spec unchanged (GitOps/Helm no-op reconcile, metadata-only)Allowed, silently
Delete / status subresourceAllowed
Read, list, exportAllowed — but nothing enforces them
Enforcement of existing stored policiesNone. Marked NotReady; startup signals and a gauge report them; violating workloads are admitted.
CLI apply/test on legacy manifestsHard error, no escape hatch — use a pre-1.20 CLI
Helm install/upgrade with legacy resources presentBlocked 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 policiesAllocations beforeAllocations afterEngine time beforeEngine time after
12,3278540.31 ms0.10 ms
1637,0552,7184.91 ms0.16 ms
64148,1318,67220.01 ms0.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 NotReady status, the kyverno_legacy_policies_total gauge (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's disableHooks, and global.templating.enabled all 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 marked NotReady with warnings.
  • Legacy generate-labels are a cleanup trap. Legacy generate rules wrote both generate.kyverno.io/policy-name and generate.kyverno.io/rule-name labels; the CEL GeneratingPolicy writes only policy-name. A cleanup command that omits the rule-name existence 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, and kyverno_policy_changes_total are 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 CEL expression field, 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 watch and */status permissions 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.cel and 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 ValidatingPolicy and ImageValidatingPolicy under policies.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-errors CI 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 oci policy 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.