Webinar · Took place online on Thursday 10 September 2026

Build the GPU cloud you've been renting

About 50 minutes with Andrei Kvapil, the creator of Cozystack: turn the GPUs you already own into a multi-tenant platform teams can use — or customers can buy — from bare metal to a metered inference endpoint, assembled entirely from open source.

  • Took place on 10 September 2026
  • 50 minutes, with a live Q&A
  • Recording not published yet
Timur Tukaev — workshop host

The GPUs are already racked. Now make them earn

Every team wants AI infrastructure, and the market sells it as a product you buy whole. In reality a GPU platform is a stack of layers — sharing, tenancy, inference, metering — and each one already has a mature open-source project waiting. The gap is not the hardware. It is the assembly, and that is exactly what this session walks through.

Where this usually starts

Expensive cards run at twenty or thirty per cent while one team waits on another, because there is no sharing, no quotas and no self-service. Or the budget bleeds into hyperscaler GPU instances for work that could run on hardware in your own racks, with the data staying home. Or the platform team is asked to "hand the GPUs out" and discovers there is no clean way to do it.

None of these calls for new hardware. They call for a way to turn the cards you already own into a platform teams can use — or customers can buy.

What turns cards into a platform

Cozystack is an open-source cloud platform and CNCF Sandbox project that turns a node with GPUs into GPU-ready tenant clusters, managed databases, S3-compatible storage and inference — each one a Kubernetes resource behind one API. Teams get their own cluster, not a namespace, with the cards visible inside.

On top of it, Ænix modules turn the platform into a business: GPU usage measured per tenant, tenant quotas, a self-service panel, and integrations that pass consumption to your billing system (WHMCS or your own), where charging happens.

Open-source foundation
  • GPU-ready tenant clusters
  • GPU sharing · passthrough, vGPU, fractional (HAMi)
  • Managed inference · vLLM, NVIDIA Dynamo
  • Managed databases & S3-compatible storage
+ Ænix modules
  • Per-tenant GPU usage for your billing
  • Self-service panel & quotas
  • Custom integrations over the API
4 ways
to allocate one card — passthrough, vGPU, MIG partitions, time-sliced sharing (HAMi)
1 GPU → many tenants
vGPU and fractional sharing on supported cards
€0
per-core hypervisor licensing — Apache 2.0, CNCF Sandbox project

Providers already running GPU on this

Not pilots. Production platforms serving real users, built on the same foundation the session walks through.

01
5× cheaper GPU
~11,000 active users moved with no downtime

A European academic-computing platform moved off a public hyperscaler onto owned bare metal, with fractional GPU sharing across jobs and a single Cluster API spanning bare metal, a hyperscaler and a sovereign Swiss cloud — bursting to rented GPUs only when demand spikes.

02
GPU in the catalog
Switzerland · sold under the provider's own brand

A Swiss cloud provider sells GPU beside virtual machines, managed Kubernetes and databases from one platform — whole-card and shared, metered and billed with its own panel. Its own engineers became Cozystack maintainers.

Both are anonymised at the customer's request. Andrei walks through what each of them actually did with GPUs — and what he would do differently on your stack.

What the session covered

Live demos, not slides — then your questions.

  1. 01

    From bare metal to a GPU-ready tenant. A node with GPUs joins the cluster, drivers roll out, and a team gets its own cluster — not a namespace — with the cards visible inside.

  2. 02

    Ways to allocate a GPU. One whole card (passthrough) or a share of it — vGPU and fractional (HAMi) — side by side, with the utilization graph that turns idle silicon into money.

  3. 03

    From a model to an endpoint. vLLM in a tenant, then NVIDIA Dynamo — disaggregated prefill/decode and KV-cache-aware routing — with before/after latency under concurrent load on the same hardware.

  4. 04

    Three doors to one API. Order a GPU cluster from a UI, from the CLI, or with a Git commit — the same resource every time, no portal on top of a portal.

  5. 05

    Charging for GPU use. The session discussed GPU-hours for renting capacity and input/output tokens for selling inference as pricing patterns. In the platform, GPU usage is measured per tenant and charging happens in your billing system (WHMCS or your own).

  6. 06

    When your service isn't in the catalog. Package it once and deploy it with a button — plus where queues (Kueue, Volcano, KAI) fit for distributed training.

The session ended with a live Q&A with the speaker.

What you take away

01

A layer-by-layer map of a GPU platform — and the open-source project that fills each one.

02

A one-page decision matrix for sharing GPUs: passthrough vs vGPU vs fractional, and when each wins.

03

A clear-eyed view of metering — per GPU-hour and per token — and where the honest limits are.

04

A reference runbook for the whole path, so your team can reproduce it on your own cluster.

Who it was for

Enterprise teams handed a pile of GPUs and told to make them useful, and cloud, telecom and GPU providers building a sovereign AI offering. If you're weighing an open-source build against Run:ai, OpenShift AI, or simply renting from a hyperscaler, the session was built around your situation.

  • Platform & infrastructure teams
  • Cloud & GPU providers
  • Data centre operators
  • Telecom companies
  • AI & research platforms

Especially the people who own the GPUs and the decision:

  • Platform engineers
  • Architects
  • CTOs
  • Infrastructure leaders
Andrei Kvapil

Your speaker

Andrei Kvapil
Creator of Cozystack · Co-founder and CEO of Ænix

Andrei created Cozystack, the open-source cloud platform and CNCF Sandbox project, after more than fifteen years of building clouds and high-load infrastructure. He contributes to Kubernetes, KubeVirt, Cilium and LINSTOR, and speaks at KubeCon and other industry events. At Ænix, he helps teams turn their GPUs and hardware into commercial cloud services.

The webinar has taken place

It ran online on Thursday 10 September 2026. The recording is not published yet.

The team can go through a GPU platform for your own setup. For hands-on sessions coming up, see the workshops.

About the webinar

This was a free live webinar, held on 10 September 2026, for enterprise platform teams and for cloud, telecom and GPU providers building a sovereign AI offering. Andrei Kvapil — the creator of Cozystack, an open-source cloud platform and CNCF Sandbox project — showed the whole path from bare metal to a metered inference endpoint: turning a node with GPUs into GPU-ready tenant clusters, the ways to allocate a single card, serving inference with vLLM and NVIDIA Dynamo, and metering it by GPU-hour or by token — all assembled from open source. The internal AI platform and the commercial GPU cloud turn out to be the same stack. The recording is not published yet.

Quick facts

  • Format A live online webinar, about 50 minutes: a practical walkthrough with live demos, followed by a live Q&A with the speaker
  • Date Took place on Thursday 10 September 2026, 16:00 CEST (14:00 UTC), online
  • Price Free; the recording is not published yet
  • Language English
  • Who it's for Platform engineers, architects, CTOs and infrastructure leaders who own the GPUs — and providers building an AI cloud
  • Host Andrei Kvapil — creator and maintainer of Cozystack (CNCF Sandbox project), co-founder and CEO of Ænix
  • After the webinar A clear map of a GPU platform and a decision matrix for sharing GPUs you can adapt to your own cluster

Frequently asked questions

Is this about training models or running infrastructure?

Infrastructure. The session covered the platform under your AI workloads — GPU sharing, tenancy, inference serving and metering — not model training, MLOps pipelines or model quality.

We only want an internal platform, not a commercial cloud. Is it still useful?

Yes. An internal GPU platform is the same stack as a commercial AI cloud, minus the second meter. Everything on sharing, tenancy and inference applies directly to an internal build.

Do we need NVIDIA GPUs?

The live demos ran on NVIDIA — the GPU Operator, vGPU and Dynamo. MIG partitioning is available too: in tenant Kubernetes clusters the GPU Operator exposes MIG partitions on cards that support it. The state of AMD and other accelerators was covered in the Q&A.

Can you really meter inference per token on an open stack?

Yes, and the session showed it live: an AI gateway in front of the model issues API keys, counts input and output tokens, and returns a 429 (over quota) when a budget runs out. Andrei named the open components used.

Do you cover multi-node training and the GPU interconnect?

Briefly, yes. The session showed where the fabric matters — NVLink within a node, GPUDirect RDMA over InfiniBand or RoCE across nodes — and the honest limit: tightly coupled multi-node training doesn’t survive WAN latency, so it lives inside one site.

How does this compare to Run:ai or OpenShift AI?

The session compared approaches — buying a platform, renting capacity, or assembling open source — across licensing, GPU sharing, tenant isolation, inference and metering, including the honest trade-offs.

Where is the platform behind this session described?

For the platform behind this session, see GPU as a service for GPU clouds and data centres and the Ænix AI Platform.

Is there a recording?

The webinar took place on 10 September 2026; the recording is not published yet. To go through a GPU platform for your own setup, talk to the team.

Webinar · Took place online on Thursday 10 September 2026

Bring your GPUs to a conversation

The webinar took place on 10 September 2026, and the recording is not published yet. Talk to the team about a GPU platform for your own setup.