KubeCon NA 2026 · VM API · NVKE

VM API and NVKE: two KubeCon releases, explained

Broadcom released a Kubernetes API for VMs. NVIDIA released a Kubernetes engine for GPU racks. Here is what each one does, plus my thoughts at the end.

Two hands on one drafting table, one arranging a row of virtual machines and the other working on a rack of GPU servers, both wired into a single control panel.
Illustration: Field Signal, created with Google Gemini.

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.

Hand-drawn sketch: vSphere, KubeVirt and Cloud boxes, each with a different-shaped plug, and the same VM definition written twice.
Every platform has its own plug, so the same VM gets written once per platform.

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.

Hand-drawn sketch: one VirtualMachine card with arrows to vSphere, marked today, and dashed KubeVirt and Cloud boxes, marked next.
One VirtualMachine, one provider per platform. vSphere is the only provider that exists today.

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:

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 vm-api/vm-api GitHub repository page showing Apache 2.0 license, 12 stars and the api, config and controller folders.
The VM API repo the week it was announced: Apache 2.0, one contributor, no releases. Screenshot: github.com/vm-api/vm-api.

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.

Hand-drawn sketch: an operator asks NVKE for a cluster, NVKE asks NICo through Cluster API for GPU machines; beside it, a node with a TPM key joins the cluster and a node with no key is rejected.
Left: how NVKE builds a cluster, through NICo and Cluster API. Right: nodes attest with their TPM before they can 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:

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

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.

Hand-drawn sketch: VM plus GPU equals a circled question mark, with the words no portable way to ask for a GPU.
The open question.

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:

References

Field notes

Keep up with Field Signal.

New engineering field notes and coverage from the automated desks, in one email list. Unsubscribe any time.

Follow Pranav on X: @Pranav_patel06 · Watch on YouTube