Meet Mirantis at KubeCon North America Salt Lake City

Location: Hyatt Regency | Level 4 | Regency BD

Join us for a lightning-fast tour of k0s, the CNCF Sandbox distro that turns Kubernetes complexity into “one-click” magic. We’ll give a quick intro to k0s, the current state of things, latest highlights and plans for the near future. 

Location: FluxCon (AM) + OpenTofu (PM)

Kubernetes operators that expose every surface as a CRD get GitOps for free, and that includes virtual machines. KubeSwift runs VMs as pods on Cloud Hypervisor, defined entirely by CRDs, which means Flux can drive an entire VM platform; install, shared infrastructure, and running fleets, using nothing but OCIRepository, HelmRelease, and Kustomization.

But VMs aren’t containers. Image imports take minutes, root disks are stateful, and live-migration physically moves a guest to another node, which can quietly fight Flux’s drift correction. This talk walks the working three-layer model (platform → infrastructure → workloads, ordered with Flux primitives), demos scaling and rolling a VM fleet by Git commit, and then gets honest about the sharp edges: which day-2 operations belong in Git, which must stay imperative, and why knowing that boundary is what keeps Flux and your VM controllers from working against each other.

Location: Salt Palace | Level 2 | 255 EF

Agentic workloads don’t just add complexity, they change its nature. An agent that reasons, plans, and calls tools across services creates execution paths no traditional trace model was built to capture. In regulated domains like fintech, healthcare, or telco, "we don’t know what the agent did" isn’t acceptable.

The cloud-native community can solve this, because we’ve done it before: we built golden paths, guardrails, and observability stacks. Now we extend those patterns to agentic systems.

We’ll show how platform teams can build governed, observable foundations for agentic workloads: agent runtimes, context layers, tool gateways, policy/eval pipelines, and multi-agent systems over shared context. Understanding protocols like MCP, A2A and skills matter too. We’ll use OpenTelemetry to instrument reasoning chains, tool calls, and handoffs: if you can’t trace it, you can’t fix it.

Are you a platform engineer or a developer in a heavily regulated industry? This talk is for you.

Location: Kubernetes on Edge Day

Retail at scale breaks the usual operational playbook: 1,500 stores, no on-site operators, WAN links that may drop, and a hard rule that nothing is ever patched by hand. This session is a production case study in eliminating configuration drift by construction.

Every store runs a three-node NUC cluster with LibVirt and KVM, hosting a four-node k0s cluster whose nodes are Kairos-based Rocky Linux VMs. Those nodes are never upgraded in place. The operating system is built as an OCI artifact and versioned in Git; every change triggers a CI pipeline that rebuilds and pushes a fresh image, and Flux rolls it out as a full immutable rebuild. Cluster lifecycle is managed declaratively through Cluster API.

The session covers why and how each store runs a standalone control plane, the tradeoffs that choice imposes versus Hosted Control Plane, and the honest limits of an immutable-rebuild model, including how a single Git commit reaching 1,500 stores is kept from becoming a fleet-wide outage.

Location: Cloud Native AI Day Room 2

Deploying a single model well is hard. Deploying hundreds, across mixed hardware, varying parameters, and competing inference engines, is a different problem entirely  and most teams are solving 
it wrong.

Today, every production inference deployment seems to require a specialist who deeply understands the GPU, the engine (vLLM, SGLang, TensorRT-LLM, Dynamo), and the model architecture itself. 

Organizations cannot hire a performance engineer for every team that wants to serve a model.

This session reframes inference scaling as an abstraction problem, not a performance problem. We’ll explore how a small group of specialists can encode their knowledge hardware profiles, engine selection logic, autotuning, deployment topology  into reusable platform primitives that the rest of the organization simply consumes.

The result: faster time-to-production, fewer trapped configs, lower TCO, and inference expertise that compounds across the org instead of bottlenecking on individuals.