The Cloud Native Computing Foundation, or CNCF, is a nonprofit that hosts and governs cloud-native open-source projects under the Linux Foundation. It launched on 21 June 2015 with Kubernetes as its seed project. By giving these projects vendor-neutral homes, it lets rival companies build on shared infrastructure without any one of them owning the result.

A dark server room corridor lined with red-lit equipment racks receding into the distance. The image evokes the large clusters of machines that cloud-native software runs across, the kind Kubernetes and other CNCF projects coordinate.
The CNCF governs the software that turns rows of servers like these into one elastic, self-healing platform.

What it was

By 2015, containers had changed how software shipped. Docker, released in 2013, let developers package an application with everything it needed into one portable unit. But running thousands of containers across many machines was hard. Something had to decide where each container ran, restart failed ones, and route traffic to them.

Google had solved this internally with a system called Borg. It rebuilt the ideas as an open-source project named Kubernetes and released it in 2014. The risk was clear. A single company controlling such a foundational tool would scare off competitors. So Google donated Kubernetes to a new neutral body, and the CNCF was born.

The CNCF does not write most of the code itself. It holds the trademarks, funds shared services, and provides governance. Projects move through tiers as they mature: sandbox for early work, incubation for growing adoption, and graduated for proven, widely used software. Maintainers come from many companies, and decisions follow community process, not one vendor’s roadmap.

Think of it as a conservation trust for shared land. Many farms border one forest. Rather than let the biggest farm fence it off, they place the forest in a trust. Everyone keeps using it, rules are public, and no single owner can lock the gate.

Step 1SandboxA new project joins for early experiments, gaining a neutral home and basic support.
→
Step 2IncubationThe project shows real production users and a healthy community of contributors.
→
Step 3GraduatedIt passes a security audit and proves broad adoption, becoming a trusted standard.

Why it mattered

The CNCF gave the cloud-native ecosystem a center of gravity. Before it, every cloud vendor had an incentive to push its own proprietary orchestration. That would have split the market and locked customers in. Neutral stewardship of Kubernetes meant Amazon, Google, Microsoft, and others could all support the same platform.

That shared base accelerated everything. Kubernetes became the standard way to run containers within a few years. Around it grew a stack of complementary projects that each filled a gap.

Orchestration
KubernetesSchedules and heals containers across a cluster
Networking
EnvoyCoreDNSRoutes and resolves traffic between services
Observability
PrometheusOpenTelemetryCollects metrics and traces from running systems
Packaging
HelmcontainerdPackages apps and runs container images

The foundation also built trust through process. Graduated projects pass independent security audits. Public governance documents spell out how maintainers are chosen. KubeCon conferences, held across several regions each year, gave the community a place to meet and grow. Certification exams gave engineers a recognized credential.

How it connects to AI today

Modern AI runs on cloud-native infrastructure, and the CNCF stack is its backbone. When you call a large language model API, your request often hits a service running inside a Kubernetes cluster. The model server is a container. Kubernetes places it on a machine with the right GPU, scales the number of replicas as traffic rises, and restarts it if it crashes.

The match is not accidental. AI inference is bursty and expensive. Demand spikes when users arrive and falls when they leave. Kubernetes was built for exactly this elastic, failure-prone world, so AI teams adopted it rather than reinventing it.

Several CNCF projects now target AI work directly. Kubernetes added device plugins so it can schedule GPUs and other accelerators. Projects like Kubeflow, KServe, and Ray run on Kubernetes to serve models and manage training pipelines. The Open Container Initiative image format, closely tied to this ecosystem, is how model-serving images ship.

A builder meets the CNCF stack constantly. If you deploy an AI app to Amazon EKS, Google GKE, or Azure AKS, you are running managed Kubernetes. If you watch a dashboard of request latency, that is often Prometheus and Grafana. If you trace a slow inference call across services, OpenTelemetry likely captured it. The vendor neutrality the CNCF protects is why the same skills carry across all three big clouds.

Still in use today

The CNCF is active and growing, not a historical artifact. It is one of the largest open-source foundations in the world, hosting well over a hundred projects across many maturity tiers. Nothing has replaced it, because its neutral-governance model is the reason it works. A competing vendor-owned body would defeat the purpose.

Kubernetes remains the flagship and the de facto standard for container orchestration. Its core is mature and stable, so attention has shifted to the layers around it: security, cost control, developer experience, and AI workloads. New projects keep entering the sandbox, and KubeCon and CloudNativeCon events continue to draw large crowds. The certifications it created are now common requirements in cloud job listings. The CNCF persists because shared, trusted infrastructure benefits everyone who builds on the cloud.

Further reading