I work at Broadcom on VCF and VKS adoption. This post uses only public material: the repos, the docs and the launch posts linked at the bottom. The opinions at the end are my own.
Two Kubernetes releases came out of KubeCon North America this week.
Broadcom put VM API into the CNCF Sandbox. It gives Kubernetes a standard way to manage virtual machines, whatever hypervisor they run on.
NVIDIA put NVKE, the NVIDIA Kubernetes Engine, into public preview. It turns racks of bare-metal GPU machines into managed Kubernetes clusters.
This post explains what each one is, how it works and where it stands today. My own thoughts are at the end.
VM API: what it is
Kubernetes is very good at one thing: you write down what you want in a YAML file, and controllers keep making it true. It does that for containers everywhere. It has never had a standard way to do it for VMs. vSphere has its own VM resource. KubeVirt has another. Every cloud has its own API. If you run VMs in two places, you write everything twice.

VM API is one shared format for that. It's open source (Apache 2.0) at github.com/vm-api/vm-api and is now a CNCF Sandbox project. It grew out of VM Operator, which has run VM Service on vSphere for about six years and creates the VMs behind VKS clusters.
VM API: how it works
You describe a VM once:
apiVersion: vm-api.io/v1alpha1
kind: VirtualMachine
metadata:
name: web-01
spec:
powerState: PoweredOn
instanceType:
name: standard-4 # CPU and memory from a named profile
bootDisk:
source:
image:
apiGroup: vm-api.io
kind: VirtualMachineImage
name: ubuntu-2204
sizeGiB: 50
storageClassName: fast # the StorageClass you already use
bootstrap:
cloudInit:
userData:
name: web-01-userdata
key: user-data
# The only platform-specific part:
infrastructureRef:
apiGroup: infrastructure.vsphere.vm-api.io
kind: VSphereVirtualMachine
name: web-01
Everything above the last block is meant to be portable. The infrastructureRef at the bottom points at a provider: a plug-in that knows how to build the VM on one specific platform. A generic controller watches the VM and reads the provider's status through a fixed contract (provider ID, power state, addresses, and two readiness conditions). It never imports the provider's code.

This is the Cluster API pattern, and Broadcom says so. Cluster API split "a Kubernetes cluster" from "how AWS or vSphere builds one." VM API does the same split for a single VM. The commercial vSphere provider is called KubeVM Service. It builds a native ESX VM, so vSphere HA, DRS and vMotion keep working underneath.
Three things VM API is not:
- Not a hypervisor. It never runs a VM itself.
- Not a migration tool. The roadmap says it does not move running VMs or disks between providers.
- Not KubeVirt. KubeVirt runs VMs inside the cluster, as pods on KVM. VM API leaves the VM where it lives and gives Kubernetes the remote control.
VM API: where it stands
It's very early. The repo was created on October 30. It has the API types, the generic controller, a provider guide and a smoke test. One contributor, no releases. vSphere is the only provider that exists. Installing the CRD on its own, as the README says, "does not provision a VM."

The roadmap lists what comes next: image catalogs, a portable way to request accelerators like GPUs, more providers (vSphere, KubeVirt and cloud VMs are named), a conformance suite, and VM-level versions of ReplicaSets and Deployments.
One naming note so you don't get confused clicking around. Broadcom's CNCF sandbox application, filed in September, calls the project KubeVM with a kube-vm.io API group. The repo today says vm-api.io/v1alpha1. Trust the repo.
NVKE: what it is
NVKE solves a different problem. Say you run a GPU cloud, an "AI factory." Your customers want their own Kubernetes clusters on your GPUs, each isolated, upgraded and patched for them. Building that management layer yourself is a lot of work. NVKE is NVIDIA's open-source version of it: Apache 2.0, at dsx-ai-factory/nvke.
NVKE: how it works
The operator asks NVKE for a cluster. NVKE provisions bare-metal GPU machines through NVIDIA's NICo infrastructure controller, using a Cluster API provider called CAPNICo. Then it forms the cluster and handles scaling, upgrades, node replacement and certificates.
Each node proves its identity with SPIFFE/SPIRE and its TPM before it's allowed to join.

NVIDIA is careful to say NVKE is "not a Kubernetes distribution and not a Cluster API flavour," even though it drives Cluster API underneath.
Two more pieces shipped with it:
- NVKR (NVIDIA Kubernetes Recipes) is the build system that makes the signed node images NVKE deploys.
- NVIDIA Snapshot restores inference replicas from a checkpoint instead of reloading the model. Crusoe reported a GLM-5.3 replica going from about 8 minutes to 31 seconds.
NVKE: where it stands
NVKE and NVKR are in public preview, and the docs say plainly that NVKE is not recommended for production yet. Mirantis, Rafay, Spectro Cloud, vCluster, OpenNebula, Netris, Firmus and SK Telecom said they'll build on it. It is bare-metal Kubernetes from start to finish. There are no VMs in it.
Side by side
- What Kubernetes manages. VM API: VMs on a hypervisor you already run. NVKE: bare-metal GPU machines.
- Who it's for. VM API: platform teams with an existing VM estate. NVKE: GPU clouds and AI factory operators.
- How it's built. Both use the Cluster API pattern: a generic core, with a provider doing the platform-specific work.
- What it leaves alone. VM API leaves HA, placement and live migration to the hypervisor. NVKE leaves the hardware lifecycle to NICo.
- Status. VM API: CNCF Sandbox, v1alpha1, no releases. NVKE: public preview, not for production.
Try them
VM API's smoke test installs the CRD on a throwaway kind cluster and creates a VirtualMachine object. It won't boot a VM, but it shows you the API in about a minute:
git clone https://github.com/vm-api/vm-api
cd vm-api
make test-smoke # needs Docker and kind
NVKE has a local quickstart against a mock NICo, so you can see the management plane without any GPU hardware.
My thoughts
Everything above is what shipped. This part is opinion.
They're the same move. Neither one makes Kubernetes the hypervisor or the hardware manager. Both make Kubernetes the API and let the system that already owns the resource do the hard parts. One is pointed at the VMs a company already has. The other is pointed at the GPU racks it's buying.
The open question is how a VM asks for a GPU. In VM API today you can't ask for one directly. You pick a sizing profile that happens to include a GPU. NVKE doesn't have the question at all, because it has no VMs.

The pieces mostly exist. Kubernetes has Dynamic Resource Allocation (DRA) for requesting devices, and KubeVirt can already attach a GPU to a VM through DRA. What's missing is a VM API field that means "one GPU" on any platform. I'd like to be able to write something like this:
spec:
instanceType:
name: standard-8
accelerators: # does not exist yet
- name: gpu0
deviceClassName: gpu.nvidia.com
count: 1
This matters to more teams than it sounds. A Linux Foundation survey of 492 practitioners found the average organization still runs 53% of its production apps on VMs. Of the teams adding VM capacity, 34% name AI and agentic workloads as a reason. The teams I talk to have years of VMs running the business and a GPU footprint growing fast.
Agents will force the issue. Both companies also showed up around Agent Substrate, a CNCF Sandbox project for running agent sandboxes on Kubernetes. NVIDIA is adding GPU support. Broadcom demoed it on VKS and floated VM-level isolation. A sandbox that sometimes needs a GPU and sometimes needs a VM is the workload neither release covers alone.
Three things I'm watching:
- A second VM API provider. KubeVirt is the obvious one, since it runs on a laptop with no cloud account. Until a second provider exists, portability is a claim and not a fact.
- The accelerator field in VM API. Whoever shapes it decides how VMs and GPUs meet in Kubernetes.
- Conformance. Broadcom is co-chairing the new Kubernetes Workload Conformance working group. If it produces real tests, that may matter more to platform teams than either launch.
References
- VM API repository
- CNCF Sandbox application: vm-api and vSphere provider
- Broadcom: VM API contributed to CNCF (press release)
- VMware blog: How VM API and KubeVM Service deliver open standards
- VMware blog: Advancing the cloud-native ecosystem through open collaboration
- VMware blog: Running Agent Substrate on VKS
- NVKE documentation
- NVKE repository
- Cloud Native Now: NVIDIA adds NVKE, NVKR and Snapshot
- NVIDIA: Agent Substrate, advancing Kubernetes for agents at scale
- KubeVirt: GPU assignment with DRA
- NVIDIA GPU Operator with KubeVirt and DRA
- Linux Foundation: Cloud native workloads 2026 survey
