Kubernetes Isn’t Replacing Your VMs. It’s Learning to Manage Them.
At KubeCon + CloudNativeCon North America 2026, Broadcom contributed VM API to the CNCF Sandbox, introduced a more open operating model for virtual machines, and expanded the ecosystem around VMware vSphere Kubernetes Service. The headline is bigger than Kubernetes supporting another resource type: it is about giving platform teams a common, declarative way to request VMs without abandoning the hypervisor and operational practices that already run the business.
What happens when the developers who live in GitOps and Kubernetes need a virtual machine—not a container? Until recently, many enterprises sent that request down a separate path: a vCenter request, a PowerCLI script, an infrastructure-as-code pipeline, or a ticket. The workload ultimately lands on vSphere, but the developer experience, approvals and operational inventory may span disconnected systems. At KubeCon in Salt Lake City, November 9–12, 2026, Broadcom highlighted a different approach: VM API, an emerging provider-neutral Kubernetes API for VMs, and KubeVM Service, VMware’s vSphere implementation of declarative VM management.
The news is meaningful, but three distinctions matter before anyone rewrites a production platform: CNCF Sandbox acceptance is not graduation or a guarantee of cross-provider compatibility; VM API is not the same component as KubeVM Service; and a VM controlled through Kubernetes is still a native VM on the underlying hypervisor, not a VM magically converted into a container. Those distinctions help turn an exciting announcement into an architecture decision you can actually defend.
The announcement: What happened at KubeCon?
On November 9, 2026, Broadcom announced that VM API was accepted into the Cloud Native Computing Foundation (CNCF) Sandbox. The company also said it would co-chair the new Kubernetes Workload Conformance Working Group and disclosed more than 20 newly validated partner solutions for VMware vSphere Kubernetes Service (VKS). Broadcom followed with a November 10 technical explanation of the VM API–KubeVM architecture. These are separate developments: an open-source governance milestone, a proposed path for broader workload conformance, and a concrete expansion of a supported Kubernetes ecosystem.
For API authors, versioning matters. The emerging project publishes a vm-api.io/v1alpha1 API and a Kubernetes VirtualMachine custom resource. Its longer-term model also describes deployment/replica-style VM controllers akin to VirtualMachineSet and VirtualMachineDeployment; do not assume every proposed primitive is currently a stable, installed CRD. Check the active repository and release manifests before writing production automation. Alpha status means the API contract can change.
VM API did not arise in a vacuum. Broadcom describes it as an evolution of the earlier VM Operator, developed over more than six years to express vSphere VMs as Kubernetes-managed resources. KubeVM Service was introduced in October 2026 as an approach to native ESX VM lifecycle management through Kubernetes. The KubeCon contribution is about moving toward a provider-neutral API contract, not claiming that all VMs in every cloud already support an identical, production-ready feature set.
That caution is especially important because the technical article illustrates providers such as KubeVirt, Proxmox, AWS and Google Cloud as architectural possibilities. Its own note warns that the diagram is not a list of currently available providers. Before a proof of concept, check the upstream VM API project for supported implementations, versions and release maturity.
VM API, KubeVM Service and VM Operator: Three names, different jobs
| Layer | Primary role | What it does not guarantee |
|---|---|---|
| VM API | Common Kubernetes custom resources and controllers expressing VM intent; provider-neutral project accepted into CNCF Sandbox. | That every provider implements every feature, device, migration operation or network mode identically. |
| Provider / KubeVM Service | VMware commercial vSphere integration that translates the API’s desired state into native ESX VM operations within VCF. | That Kubernetes has replaced vCenter, VCF Operations, storage policies or hypervisor operations. |
| VM Operator lineage | The existing vSphere-specific experience and technical foundation on which the newer VM API approach builds. | That older VM Operator manifests are automatically identical to the newer project’s portable contract. |
| VKS | CNCF-certified Kubernetes runtime delivered with supported VMware Cloud Foundation releases and governed by its own lifecycle. | That VKS itself is the VM hypervisor or that partner add-ons are automatically licensed. |
The simplest architecture diagram can be written in a single line: Git / developer portal → Kubernetes API and VM API custom resources → provider controller / KubeVM Service → vCenter and native ESX VMs. The Kubernetes control plane stores intended state and drives reconciliation; the hypervisor remains responsible for running the guest. The same VM can still appear in vCenter, be observed through VCF Operations, and use applicable vSphere capabilities such as HA, vMotion, DRS and enterprise backup integrations subject to configuration and edition.
Why this matters even if you never plan to containerize a database
The strongest enterprise use case is selective modernization. Production application servers, databases, appliances and long-lived VMs may be well served by traditional vSphere administration. But platform teams providing development sandboxes, ephemeral test environments, CI runners, AI workstations and isolated execution environments increasingly want to request compute through one self-service API. Under a declarative model, the request can enter a Git pull request, be checked against admission and policy guardrails, and be reconciled by a controller instead of living solely inside a one-time provisioning script.
This is not a promise that every GitOps change is safe or that reconciliation resolves all operational drift. A hypervisor administrator can still change the VM directly in vCenter; the controller may later attempt to reconcile a field it owns. Platform teams therefore need an explicit source-of-truth and field-ownership policy distinguishing declaratively managed VMs from those administered through established VI procedures. If that boundary is left implicit, the new control plane can create a new class of operational conflict rather than eliminate one.
There is economic and organizational context here as well. A Linux Foundation survey cited in Broadcom’s November 9 announcement surveyed 492 practitioners and reported that VMs accounted for an average 53% of production applications. The company also reported that 61% of respondents described VM administrators and container teams as collaborative or integrated, and that AI/agentic workloads were cited by 34% of organizations expanding their VM footprints. These are survey findings, not universal measurements; they nevertheless challenge the simplistic assumption that Kubernetes adoption makes VMs irrelevant.
Cloud economics: More useful than a dramatic overprovisioning statistic
Unifying a Kubernetes-facing request layer for VMs and containers can make the infrastructure more measurable: operators can compare actual CPU, memory, storage and GPU demand; enforce quotas and right-sized VM classes; scale test environments down when idle; and avoid standing up a dedicated island of hardware for every team. Broadcom’s VKS 3.8 positioning emphasizes placing control-plane workloads away from costly GPU resources and using node-pool placement to meet business constraints.
That is a legitimate cost argument, but it is not proof of an across-the-board utilization saving. Published overprovisioning ratios vary by workload and measurement method, and internal field estimates are not a substitute for a citable benchmark. Before claiming dramatic consolidation, measure requests versus observed usage, reserve resources for HA/upgrade headroom, consider licensing and storage constraints, and model failure domains. The objective is to share a supportable fabric across appropriately isolated workloads—not to claim that all VMs and containers will fit on fewer hosts just because they share an API.
Bring your own Kubernetes: OpenShift and other distributions still matter
For most large enterprises, the platform choice is heterogeneous. VKS does not automatically displace existing Red Hat OpenShift, Rancher-managed clusters or other supported Kubernetes distributions. For example, Red Hat’s public OpenShift 4.20 vSphere installation guide explicitly lists supported vSphere 8, VVF 9 and VCF 9 infrastructure options, with detailed requirements for virtual hardware, vCenter, CSI integration and networking. Whether OpenShift is managed by IBM, Red Hat or a customer’s own platform team, its application lifecycle remains a distinct support question.
The portability promise of VM API applies to the declarative VM request contract where a compatible provider exists; it does not mean a KubeVM Service provider can administer every resource in an OpenShift cluster, or that VM API converts all Kubernetes distributions into one supported runtime. Evaluate whether the VM API control plane should live beside existing clusters, how those clusters obtain VM capacity, and how shared vSphere infrastructure, storage policies, NSX security and ownership boundaries are enforced.
Our earlier VKS on VCF versus OpenShift performance analysis and Architect’s Edge Live VKS/OpenShift webinar recap explored the practical debate around performance, bare metal and platform choice. VM API adds a new dimension to that discussion: the possible convergence of how teams request compute, even when Kubernetes runtimes and application operations remain heterogeneous.
KubeCon was bigger than VM API: The surrounding VKS developments
The Kubernetes story this week is not a single open-source repository. On November 9, Broadcom published a partner validation update for VKS spanning observability, security, ingress, storage, AI and application platforms. Newly validated examples include Splunk, Datadog, Dynatrace, Grafana Labs and New Relic for observability; CrowdStrike Falcon, Vault, Sysdig, Wiz and Tigera for security; and Commvault, PowerProtect Data Manager, HPE Alletra and Scality RING for data protection and storage. These are reported validations, not blanket statements that every version, integration path or subscription is supported. Read each partner’s exact matrix before procurement or deployment.
Just before the conference, VKS 3.8 added a meaningful Day-2 operations package. Its chained upgrade feature supports a validated transition of up to three Kubernetes minor versions in one operation (N+3), with workers cordoned and drained once across the chain rather than at every intermediate hop. That reduces disruption; it does not remove release, add-on, ClusterClass or disruption-budget compatibility checks. The release also adds granular node placement to protect expensive GPU or geographically constrained resources, disables SSH access on control-plane and worker nodes as part of its hardened node model, and adds file-integrity monitoring through AIDE. The VKS 3.8 release documentation also describes an Immutable Photon OS node option; architects should verify which OS image and management mode their clusters use, and move SSH-dependent troubleshooting or configuration scripts to supported alternatives before adopting immutable nodes. See the VKS 3.8 release notes for version-specific prerequisites and exceptions.
Air-gapped operations deserve their own validation. VKS 3.8 extends its add-on lifecycle with Helm/OCI-based options and local depot capabilities, but an isolated site’s registry credentials, embedded Fleet Depot availability, image mirroring and legacy Carvel bundle relocation must be tested for the exact VKS service definition and add-on set. Do not assume that enabling one internal registry makes every Helm and Carvel add-on offline-ready. In addition, independent Supervisor upgrades have been available since VCF 9.0, so this is an existing platform lifecycle improvement—not a feature merely promised for the next release. A Kubernetes runtime upgrade, Supervisor update and VM API provider upgrade remain separate support and compatibility questions.
The ecosystem also includes Solo.io, listed in the November 9 VKS partner validation announcement for agentgateway, kagent and enterprise Istio. Broadcom’s November 9 Breakroom Chat episode gives a public example of the agentic and service-mesh discussion; validation is not a claim that every integration version is supported or automatically entitled.
Another timely example is Broadcom’s November 10 Agent Substrate demonstration on VKS. The example packages an emerging AI-agent runtime as an add-on, showing snapshot, hibernation and resumption workflows. Its authors specifically say the provided add-on artifacts and configurations are demonstration-only and not officially supported production configurations. Future exploration of hardware-isolated workers and vSphere Pods is a direction of investigation, not a shipped guarantee. This illustrates what a growing Kubernetes ecosystem makes possible while keeping product readiness honest.
The Kubernetes Workload Conformance Working Group was announced October 27, 2026, before KubeCon, with SIG Architecture and SIG Apps as sponsors. The public charter focuses on objectively testable workload behavior at runtime: disruption tolerance, security posture, resource usage, networking, storage, API usage and observability. It specifically excludes application business logic, mandating Helm or other packaging formats, and retesting Kubernetes cluster conformance. Its deliverables are a version-specific specification, a testing methodology and upstream tooling—not an already-established portability certification. That nuance matters: Broadcom’s involvement is news, but the working group’s October launch and long-term test development must not be presented as a finished November standard.
For architects: Eight questions before your first KubeVM proof of concept
- Pick one bounded use case. Start with disposable developer or test VMs, not a critical production database.
- Confirm exact software support. Document the VCF, Supervisor, VKS, KubeVM Service and VM API versions—and what is supported versus experimental.
- Define ownership. Decide which VM properties GitOps owns and which remain subject to infrastructure operations and change control.
- Govern identities and tenancy. Test namespace RBAC, service accounts, VM classes, resource quotas, admission policy and separation of duties.
- Design networking and storage first. Validate address allocation, approved networks, service connectivity, storage policies, image sources and guest bootstrap handling. For NSX-backed designs, explicitly test Distributed Firewall (DFW) policy, security groups/tags and microsegmentation for VMs created declaratively; a Kubernetes namespace or GitOps manifest does not automatically impose the intended NSX policy. Check where the enforcement point actually sits.
- Prove day-two workflows. Provision, resize where supported, power-cycle, recover from failure, apply guest patches, capture logs and delete cleanly; test controller reconciliation after out-of-band changes. In disconnected environments, verify image and add-on sourcing, private registries, DNS/proxy isolation and upgrade-path dependencies before introducing a deployment pipeline.
- Keep recovery in the design. Confirm backup/restore behavior, consistency, ownership of VM and Kubernetes metadata, and DR runbooks. The underlying VM being visible to vCenter does not prove the application is recoverable.
- Measure the benefit. Track approval latency, time-to-provision, policy violations, inventory accuracy and cleanup of temporary VMs; don’t deploy another control plane without a measurable problem to solve.
Our existing VCF Operations Orchestrator guide addresses the complementary question of turning monitored events into approved, verified operational workflows. The cyber-defense blueprint shows why observation, enforcement and verification must remain distinct. For guest integration lifecycle considerations, see our VMware Tools and virtual hardware analysis.
What’s available, what’s emerging—and what should not be assumed
Each evidence entry links directly to the announcement, technical article, release material or upstream project behind the claim. These sources help distinguish new releases from early-stage projects and demonstration-only work.
| Item | Evidence and primary sources (reviewed November 15, 2026) | Editorial caution |
|---|---|---|
| VM API | Broadcom: CNCF Sandbox acceptance announced Nov. 9; upstream VM API source repository. | Sandbox is an early governance stage, not an interoperability certification. |
| KubeVM Service | Broadcom: KubeVM Service introduction, Oct. 22; VM API and provider architecture, Nov. 10. | Confirm supported versions, entitlements and exact provider capabilities. |
| VKS 3.8 | VKS 3.8 features, Nov. 2; new partner validations, Nov. 9. | Validate compatibility at partner-product and cluster-release level. |
| Agent Substrate on VKS | Broadcom: implementation walkthrough and demonstration, Nov. 10, including sample add-on artifacts. | The article expressly identifies its example artifacts as demonstration-only and not production-supported. |
| Workload conformance | Kubernetes: working group announced Oct. 27; official working group charter. | Runtime behavior specifications and tests are still being developed; this is not an existing certification. |
Architect’s Edge: Keep the VM. Modernize the interface.
The important architectural idea is not that Kubernetes has defeated virtualization. It is that virtual machines and containers increasingly need to participate in the same governed developer experience. A common declarative API could reduce unnecessary tooling differences, but it cannot eliminate the importance of provider support, network segmentation, backup design, patching, ownership and security controls. The VM still has a guest operating system, and someone still owns its lifecycle.
For now, the strongest project is a controlled proof of concept around KubeVM Service on an explicitly supported VCF environment, with a parallel track observing VM API’s upstream evolution. That permits teams to capture immediate platform-engineering value while helping shape—not prematurely depending on—an emerging open standard. The better question is not whether all of your VMs belong in Kubernetes. It is which VM workflows become simpler, safer and more repeatable when the request enters Kubernetes and the execution remains on vSphere?
Official sources and technical follow-up
- Broadcom — VM API CNCF Sandbox announcement, Nov. 9, 2026
- Broadcom — How VM API and KubeVM Service Deliver Open Standards and Enterprise Execution, Nov. 10
- VM API — upstream open-source repository and active project documentation
- Broadcom — Introducing KubeVM Service, Oct. 22
- Broadcom — Open collaboration, workload conformance and Velero, Nov. 9
- Broadcom — New VKS partner validations, Nov. 9
- Broadcom — VMware vSphere Kubernetes Service 3.8, Nov. 2
- Broadcom — Running Agent Substrate on VKS, Nov. 10; demonstration support caveat
- CNCF — KubeCon 2026 project milestones, Nov. 10
- Kubernetes — Workload Conformance WG announcement, October 27, 2026 and charter and defined exclusions
- Broadcom TechDocs — VKS 3.8 release notes and upgrade prerequisites
- Broadcom — Independent Supervisor upgrades introduced with VCF 9.0
- Red Hat — OpenShift Container Platform 4.20 on VMware vSphere
- Broadcom — VKS and Solo.io partner architecture discussion
Research cut-off: November 15, 2026. This article distinguishes shipped features, partner validations, CNCF Sandbox status, and demonstration-only artifacts. It does not assert that potential providers are supported or that future capabilities are generally available. Verify release matrices and commercial rights before deploying.
Discover more from PKGuild
Subscribe to get the latest posts sent to your email.