NVIDIA Is Putting Real Skin in the Open AI Game

TL;DR — Key Takeaways

• Open AI needs more than open models: Without accessible compute, scheduling, storage, observability and security, open weights still sit inside a largely closed ecosystem.
• NVIDIA is contributing real resources: It has joined the CNCF Governing Board, moved GPU technology upstream and committed $4 million to help projects test on real GPUs.
• GPU waste is blocking production AI: Static allocation leads to idle accelerators, overprovisioning and teams competing inefficiently for scarce capacity.
• Kubernetes is becoming AI’s operating layer: Dynamic GPU allocation, community scheduling and conformance standards could make AI workloads easier to run across vendors and platforms.
• Talk is cheap. Compute is not: Companies claiming to support open AI should contribute engineering, governance, testing capacity and GPU cycles—not just code or marketing.

We spend a lot of time arguing about what qualifies as open AI.

Can you download the model weights? Can you inspect the training data? Can you modify the model? Does the license qualify as open source, open weight or merely open enough to satisfy a marketing department?

Those are important questions. We should keep asking them. But they represent only one part of what will determine whether the AI ecosystem develops in the open.

A model does not run on good intentions. It requires compute, networking, storage, scheduling, observability, security and an increasingly complicated collection of infrastructure needed to move it from an experiment into production. You can make the model weights available to the world, but if the infrastructure required to operate that model remains inaccessible, fragmented or locked inside proprietary platforms, we have not created an open AI ecosystem. We have created an open component surrounded by a closed system.

That is why a recent CNCF post from Erin Boyd, a senior director at NVIDIA and a member of the CNCF Governing Board, deserves attention. Boyd makes the case that the future of AI will be community-driven and open—and, more importantly, details what NVIDIA is doing to help make that happen.

It is easy to issue a press release about openness. NVIDIA is putting some skin in the game.

The company has joined the CNCF Governing Board. It is contributing its GPU Dynamic Resource Allocation work upstream in Kubernetes. It has placed KAI Scheduler into the CNCF Sandbox. It is participating in the Kubernetes AI Conformance Program. And it has committed $4 million over three years so CNCF projects can run continuous integration and testing on actual GPUs rather than relying on emulators.

That last commitment may be the most important.

In the AI economy, compute is currency. GPU cycles cost real money, and the shortage or expense of those cycles has become one of the greatest barriers facing researchers, startups and open source maintainers. Donating code matters. Assigning engineers to work upstream matters. Accepting community governance matters. But giving open source projects access to the expensive infrastructure they need to test their software against real-world AI environments is something more.

It is tangible. It is measurable. It costs NVIDIA something.

That is what putting skin in the game looks like.

Kubernetes Becomes the Operating Layer for AI

The cloud-native community has been preparing for this moment for more than a decade, even if it did not originally describe the destination as AI.

Kubernetes gave organizations a common way to orchestrate applications across different clouds, data centers and infrastructure environments. The CNCF ecosystem grew around it to address networking, observability, security, service discovery, policy, storage and the countless other problems involved in operating distributed systems at scale.

AI is now encountering many of those same problems.

Training models is only one part of the AI lifecycle. Organizations must also fine-tune models, serve inference, manage agents, allocate scarce accelerators, observe performance, maintain availability and support multiple teams competing for the same infrastructure. These are not simply model problems. They are distributed systems problems.

Distributed systems are where the cloud-native community lives.

According to the figures cited in Boyd’s CNCF post, 82% of container users run Kubernetes in production, while 66% of organizations hosting generative AI already use Kubernetes to manage at least some inference workloads. Yet only 7% deploy models daily, while 47% do so only intermittently.

That gap tells us something. Organizations have learned how to build and experiment with AI. They have not yet made operating AI routine.

GPUs are one reason why.

Kubernetes was not originally designed for a world in which accelerators would be the most valuable resources in the data center. Historically, Kubernetes treated GPUs as static and indivisible. That may have worked when an organization had a small number of relatively straightforward workloads. It does not work nearly as well when the same cluster must support large training jobs, latency-sensitive inference, multiple tenants and rapidly changing demand.

The predictable result is waste. Expensive accelerators remain idle. Teams overprovision because they cannot reliably obtain resources when they need them. Jobs reserve more capacity than they use. Applications behave one way in a test environment and another when introduced into a shared production cluster.

If AI is going to become an everyday production workload, GPUs must eventually become as manageable through Kubernetes as CPUs, memory and storage. They will never be identical resources, but they need the same kind of dynamic allocation, policy, visibility and automation that cloud-native practitioners now take for granted elsewhere.

The question is whether each accelerator vendor and cloud provider builds its own answer or whether the industry develops these capabilities together.

NVIDIA is supporting the community route.

Going Upstream Matters

NVIDIA’s GPU Dynamic Resource Allocation driver is being developed upstream through Kubernetes SIG-Node as a reference implementation of a vendor-neutral API.

That “vendor-neutral” description matters. So does the decision to work upstream.

The driver allows GPU resources to be allocated on demand rather than locked into static reservations when workloads are scheduled. It adds early support for sharing GPU devices through NVIDIA’s Multi-Instance GPU technology and introduces ComputeDomains, through which GPUs can share memory across nodes using Multi-Node NVLink.

The technical details will continue to evolve. The governance model is already significant.

NVIDIA could have delivered these capabilities as proprietary extensions optimized for NVIDIA products. Instead, it is helping develop a standard mechanism within Kubernetes and placing the work under community oversight.

That does not mean NVIDIA has stopped being NVIDIA. It is a commercial company, and it will benefit if Kubernetes makes GPUs easier to deploy, share and consume. Better utilization makes accelerated infrastructure more attractive. Easier operations allow more organizations to move AI into production. A larger production AI market means greater demand for the chips and systems NVIDIA sells.

Good.

We need to stop treating commercial benefit as evidence that an open source contribution is somehow impure.

The most successful open source communities have rarely depended upon altruism alone. Linux did not become the foundation of modern computing because every company involved abandoned its commercial interests. Kubernetes did not take over enterprise infrastructure because cloud providers stopped competing.

These ecosystems grew because companies recognized that collaborating on shared infrastructure could expand the market for everyone. They stopped spending all their resources rebuilding the same plumbing and competed higher in the stack, where their individual products and services could deliver greater value.

Enlightened self-interest is not the enemy of open source. It has often been one of open source’s most productive forces.

From NVIDIA Scheduler to Community Project

The KAI Scheduler contribution is another example.

AI clusters introduce scheduling demands that traditional infrastructure was not necessarily designed to handle. Large jobs may need multiple GPUs to become available simultaneously. Different business units need fair access to shared clusters. Schedulers must understand complex resource relationships and avoid moving or evicting workloads unnecessarily.

KAI Scheduler was built to address those challenges. According to NVIDIA, it has operated against clusters containing more than 10,000 GPUs. It supports gang scheduling, hierarchical queues, resource fairness and asynchronous workload binding.

NVIDIA could have kept that technology inside its own stack. Instead, KAI Scheduler was accepted into the CNCF Sandbox.

A Sandbox project is not automatically a finished standard, nor is acceptance a guarantee that the project will ultimately become widely adopted. What it does is give the community a place to participate. The roadmap is no longer dictated solely by one company’s product schedule. Maintainers, platform teams, users and other vendors can inspect the work, contribute to it and help determine what it becomes.

That is how community ownership begins.

We sometimes speak about openness as though posting source code to a public repository completes the job. It does not. A repository can be visible while its direction remains effectively closed. Genuine openness requires participation, governance and some meaningful ability for people outside the originating company to influence the project.

Moving KAI Scheduler into the CNCF is therefore about more than code availability. It is a decision about where the technology’s future will be negotiated.

Trust, but Conform

The Kubernetes AI Conformance Program completes another part of this picture.

Open APIs mean relatively little if every provider implements them differently. We saw this repeatedly in earlier waves of infrastructure. Vendors claimed compatibility while customers discovered that supposedly portable applications depended on undocumented behaviors, proprietary additions or interpretations that worked only inside one platform.

Conformance gives users something stronger than a vendor promise. It establishes shared requirements and a repeatable way to demonstrate that infrastructure behaves as expected.

The Kubernetes AI Conformance Program has reportedly grown from 18 to 31 certified platforms in only a few months. Its requirements are also expanding to address emerging operational needs, including agentic workflows and resizing inference-serving pods in place.

That is how an ecosystem matures. First comes experimentation. Then shared interfaces. Then testing and conformance that allow users to rely on those interfaces across products and providers.

This is also why the $4 million GPU commitment is so central. Conformance cannot be theoretical. CNCF projects need to test their software on the hardware that organizations actually use. An emulator may be useful for part of the development process, but it cannot reproduce every characteristic, failure mode or performance challenge of a production GPU environment.

Open source maintainers should not have to pass the hat every time they need to determine whether their project works on modern accelerated infrastructure. If the industry expects community projects to become the foundation for production AI, then the companies benefiting from that foundation must help finance the work.

NVIDIA is doing that with more than a sponsorship check. It is providing access to the compute itself.

Open AI Is an Entire Stack

None of this means NVIDIA is opening everything.

NVIDIA is not turning over its chip designs to the CNCF. CUDA remains a powerful source of differentiation and competitive advantage. NVLink, its systems architecture and its accelerator roadmap remain central to the company’s position in the market.

But openness does not require every company to surrender every crown jewel.

It requires us to decide which parts of the stack should become shared foundations and which parts remain legitimate areas of competition. It requires open interfaces where portability matters, community governance where no single vendor should control the road and conformance where users need assurance that the promises are real.

This is why defining open AI solely by the availability of model weights is too narrow.

Open AI includes models, but it must also include schedulers, runtimes, APIs, orchestration, testing, observability and governance. It needs infrastructure on which models from different sources can operate. It needs standards that allow organizations to move workloads without rebuilding their systems every time they change a model, cloud or accelerator.

The open model debate is important. The open infrastructure debate may ultimately determine how much practical freedom users have.

The Right Kind of Bet

NVIDIA believes an open, community-governed infrastructure layer will accelerate AI adoption. It is almost certainly right. It also expects to prosper from the larger market that results.

There is no contradiction in those two statements.

The test is not whether NVIDIA benefits. The test is whether the community benefits too—whether the work happens upstream, the interfaces remain vendor-neutral, governance extends beyond one company and the resources being contributed allow the ecosystem to do things it could not otherwise do.

By those measures, NVIDIA’s expanding CNCF participation represents a meaningful step.

The future of AI will not be open merely because companies publish weights or repositories. It will be open when the infrastructure needed to build and operate AI is developed through communities, governed through shared standards and supported by companies willing to put genuine resources behind it.

NVIDIA is contributing code. It is contributing engineering. It is sharing governance. And, critically, it is contributing the GPU cycles without which much of this work cannot be properly tested.

Now the rest of the AI industry should follow its lead.

Hyperscalers, model developers, accelerator companies and infrastructure vendors all benefit from the work being done across Kubernetes and the CNCF. They should contribute upstream rather than constructing proprietary side roads. They should accept community governance rather than using “open” as a distribution strategy. And they should contribute the compute, testing capacity and engineering time required to make open AI infrastructure viable.

Talk is cheap. GPU cycles are not.

NVIDIA is putting real skin in the open AI game. That is worth recognizing—and worth demanding from everyone else.

Frequently Asked Questions

Why are open model weights not enough to create an open AI ecosystem?

Models also require compute, networking, storage, orchestration, observability and security. When those layers remain proprietary or inaccessible, users still lack practical freedom.

What is NVIDIA contributing to the CNCF ecosystem?

NVIDIA is contributing GPU Dynamic Resource Allocation work to Kubernetes, placing KAI Scheduler in the CNCF Sandbox, participating in AI conformance efforts and providing $4 million in GPU testing support.

Why does AI conformance matter?

Conformance gives users evidence that supposedly portable AI infrastructure behaves consistently across vendors, rather than relying on compatibility claims that may hide proprietary differences.