KubeCon + CloudNativeCon + OpenInfra Summit + PyTorch Conference China 2026
September 7–9, 2026 · Shanghai, China.
KubeCon + CloudNativeCon + OpenInfra Summit + PyTorch Conference China 2026 brought the OpenInfra, cloud native and AI communities together in Shanghai. Co-located events ran on September 7, followed by two days of keynotes, breakouts and the Solutions Showcase on September 8–9, with practitioners, technologists and community members from across the region collaborating on Kubernetes, OpenStack, PyTorch and dozens of other open technologies.
- KubeCon + CloudNativeCon + OpenInfra Summit + PyTorch Conference China 2026
- Schedule and session slides
Speakers who shared their slides have them attached to their sessions in the schedule.
Sessions from end user organizations
The event published no end user track, so the sessions below are those whose speakers listed an organization that meets the CNCF End User definition as their company in the official schedule: an organization that uses cloud native technologies internally rather than selling or supporting them. They include the CNCF End User member Ant Group alongside adopters such as ANTA Group, China Merchants Bank, China Mobile, City Storage Systems, Horizon Robotics, INTSIG, Meta, NTT DOCOMO, Sony, Tiger Brokers, Trip.com and Viettel, plus researchers from the Beijing Academy of Artificial Intelligence, Peng Cheng Laboratory and East China Normal University.
29 sessions, presented by speakers from organizations that meet the CNCF End User definition. All times are CST (UTC+8), local to Shanghai. Some sessions overlap; talks in the same time slot run concurrently.
Source: official Sessionize API · Verified October 31, 2026. This conference has ended; the schedule below is the final record. See the official schedule for the full program. Jun Zheng, Tan Pei Xiang CMB AI assistants exhibit distinct peak and off-peak traffic patterns. During off-peak hours, the platform allocates idle GPUs to LoRA incremental training. As peak traffic arrives, KEDA scales out vLLM inference services based on request load, prompting training tasks to save progress at secure checkpoints and proactively release capacity. Once traffic subsides, training automatically resumes from the saved checkpoints. This solution prioritizes online services to meet latency targets while continuously leveraging off-peak resources for model iteration, achieving coordinated optimization between inference SLOs and training efficiency. 7F | Grand Ballroom II + III Yaya Xia AI agents create a demanding kind of workload. They generate and run code, interact with external systems, and often need an isolated execution environment for only a few minutes.
The cloud native and open infrastructure communities have spent years building the foundations this workload now needs. This keynote examines how those existing capabilities can be assembled into an agent runtime, supported by new ecosystem evidence from CNCF and OpenInfra. The idea becomes concrete through an open-source runtime stack. Kubernetes Agent Sandbox manages the sandbox lifecycle, while Kata Containers provides workload isolation, with other cloud native components supporting execution and resource delivery. Together, these existing technologies form an agent runtime designed for the needs of agentic AI. 7F | Grand Ballroom II + III Yaya Xia, Xu Wang An agent runtime has to create a working environment on demand, isolate code the platform may not trust, and release resources when the task ends. Much of this machinery already exists across cloud native and open infrastructure projects. This keynote follows one agent task through an open-source runtime stack.
Kubernetes Agent Sandbox manages its lifecycle, while Kata Containers provides a dedicated guest-kernel boundary. The rest of the chain handles container execution and efficient delivery of images and model artifacts. Seen together, these projects offer a practical foundation for secure, short-lived agent workloads and a shared path for the ecosystem to improve it. 7F | Grand Ballroom II + III Mengsi Lyu, Hongjun Zhang, Yufeng Lyu Porting large models across diverse accelerators and running them efficiently remains difficult. Developers can download LLMs and multimodal models such as Qwen, MiniMax, and DeepSeek, yet the runtime path below PyTorch, vLLM, or SGLang is still fragmented across vendor libraries, compiler stacks, communication backends, and framework patches.
This tutorial introduces how to port large models onto various AI accelerators by using the FlagOS open-source stack. we will walk through the path from PyTorch operators to training and inference with vLLM and SGLang.
Audiences will learn how Triton enables portable kernel programming, how FlagGems provide PyTorch operator coverage, how unified plugins of FlagOS for vLLM, Megatron, VeRL etc. support training and inference on different AI accelerators, and KernelGen help auto-coding for different accelerators. This tutorial shows how developers can bring open models to more hardware, with less porting effort and stronger community collaboration. 7F | Pearl Hall JIanxiang Sun, Shuangkun Tian As autonomous driving shifts to end-to-end models, Horizon Robotics faces unprecedented scale. Thousands of concurrent, sub-minute workflows pushed infrastructure to its limits, where traditional orchestration and "Informer Choke" caused severe instability and resource waste.
We re-architected our platform to handle 8 million daily tasks, saving 1,000+ CPU nodes. We will dive into:
1. Orchestration Re-engineering: Replacing per-workflow agents with a centralized Argo Workflows Agent Service. This "Agentless" approach cut infrastructure costs by 2.4M CNY/month and saved 1,000+ CPU nodes.
2. Scheduling & State Optimization: Overcoming Informer bottlenecks by refactoring metadata, reducing VolcanoJob size by 30%, and slashing sync latency from 4 minutes to <10 seconds.
3. Stability & Multi-Tenancy: Leveraging Kueue and Volcano to implement elastic quotas and resolve preemption conflicts, ensuring system stability in large-scale multi-tenant environments. 1F | Mandarin Hall I Hongcai Ren, Yiheng Ci Karmada (Kubernetes Armada) is a Kubernetes management system that enables you to run your cloud-native applications across multiple Kubernetes clusters and clouds. In this presentation, the maintainer of the Karmada project will share: - A Brief introduction to Karmada.
- New features over the last year
- Real-world case studies
- Overview of the community
- Roadmap 5F | 5B + C Fengjun Lyu, Wenbo Qi In 2025, after nearly eight years of incubation within CNCF, the Dragonfly project officially graduated. But getting there wasn't easy. Growing from an internal project at Alibaba to a full-community-driven CNCF graduated project came with its fair share of challenges. In this talk, we will discuss the inner workings of Dragonfly's journey to its current state. We’ll cover our lessons in community governance, including how we evolved from a small group of maintainers to transparent decision-making and attracted global contributors through effective open-source practices. On the technical side, the increasing popularity of LLMs has made the efficient distribution of model files at the GB or even TB scale a significant challenge. We'll dive into how Dragonfly's P2P capabilities have evolved to tackle the challenge of pulling massive model files concurrently across Kubernetes clusters, along with best practices we've developed for AI inference and training workloads. 1F | Mandarin Hall II Jiahang Xu China Merchants Bank has transitioned from AI prototypes to large-scale internal deployment of Large Language Models, AI Agents for Digital Employees. To manage the inherent unpredictability of these autonomous systems in the regulated banking sector, the bank utilizes an “In-Control” architectural pattern built on Platform Engineering principles for its internal operations.
This framework rests on three pillars:
Platform Engineering for AI: Streamlines internal deployment using standardized “AI Agent-as-a-Service” templates to empower Digital Employees.
Secure Sandboxing: Employs Kubernetes-native micro-VMs to execute agent-generated code in isolation, protecting core infrastructure.
Financial Guardrails: Implements real-time monitoring and deterministic policies to ensure compliance and budget control within the enterprise.
This structured approach allows the bank to manage internal Digital Employees in cloud environments while maintaining strict data sovereignty and auditability. 1F | Mandarin Hall I Wenbo Qi, Chenyu Zhang Dragonfly provides efficient, stable, and secure file distribution and image acceleration using P2P technology within cloud-native architectures. This talk will briefly introduce Dragonfly and highlight the features of its latest version. Key updates include enhanced security and new functionalities tailored for more efficient and robust model distribution. We will also demonstrate how Dragonfly preheats and distributes AI models (packaged as OCI Artifacts) to read-only volumes in Kubernetes, enabling faster deployments. Additionally, we will introduce P2P-based state snapshot and restore capabilities in AI agent scenarios. 5F | 5B + C Xiao Zhang, Walter Duan Intsig built CamScanner (300M downloads) and runs one of China's busiest document processing platforms. Their GPU problem is unusual: they don't juggle dozens of models — they run one thing (OCR) at absurd concurrency across ~1,000 cards. The bottleneck isn't placement, it's queue time. People waiting in line. They moved from Tencent QGPU to HAMi, the CNCF Sandbox project, and got virtualization, scheduling, and monitoring in one package. Queue times dropped. Utilization went up. This isn't just an Intsig talk. HAMi runs in production at SF Express (GPU fleet cut from 1,400 to 1,000 cards), China Merchants Bank (10,000+ GPUs, utilization 20%→80%), NIO (10x CI efficiency), and ICBC (utilization 20%→70%). We'll share patterns that work and anti-patterns that waste money — like why slicing GPUs below 1/6 backfires. A quick Chaterm demo closes the talk — Intsig's open-source AI terminal for GPU cluster ops in plain language. 7F | Grand Ballroom II + III Bertrand Souville, Muhammad Hamza How do you turn complex Telco standards into production-ready code—without months of manual design and validation? This session introduces a spec-driven development workflow using AI coding agents to accelerate the design, implementation, and testing of features in OpenStack Tacker.
We show how AI agents navigate large codebases to propose architectural solutions and generate test suites directly from specifications. Two use cases are presented: (1) Cloud-native high availability, with AI-assisted design of Kubernetes Operators enabling redundancy and fast failover toward 99.999% SLA; and (2) Massive-scale vRAN, with a Leader–Conductor style coordination model inspired by OpenStack orchestration systems coordinating thousands of VNFs/CNFs, along with automated edge-case test generation. Attendees will learn a repeatable workflow for combining AI with upstream collaboration to accelerate the delivery of carrier-grade systems while maintaining OpenInfra and Kubernetes standards. 1F | Mandarin Hall I Kaiming Cheng, Jack Khuu, Laura Wang Recently, the PyTorch team released KernelAgent, an open agentic system achieving 100% correctness across all 250 L1/L2/L3 KernelBench tasks. We extend that work by adding a hardware-guided optimization layer to the existing framework. Building on the previous correctness-focused pipeline, KernelAgent integrates GPU hardware-performance signals into a closed-loop multi-agent workflow to guide the optimization for Triton Kernels. We evaluate the kernels generated by KernelAgent on all 100 L1 KernelBench tasks. Overall, it achieved 2.02x speedup over generated kernels from earlier versions. On average, KernelAgent generated 1.56x speedup when compared to default torch.compile, outperforming 65 of 100 KernelBench L1 tasks and achieving 89% of the hardware roofline efficiency on the H100. The optimization codebase is located at KernelAgent repo with documentation to get started. We also share a selection of end-to-end KernelAgent optimization artifacts in the open-source repo. 7F | Grand Ballroom II + III Yihang Li Every AI app eventually needs memory. Most teams hit the same walls: choosing a backend locks them into a later rewrite, wiring retrieval and lifecycle bleeds into every layer, and non-Python teammates have no clean way in. PowerMem is an open-source (Apache 2.0) memory library that treats these as developer-experience problems. The talk covers the design choices: auto-loading config from .env so the first example is under ten lines of Python; one memory API across five surfaces (Python SDK, pmem CLI with shell, HTTP API with OpenAPI docs, MCP server over SSE/stdio/streamable-http, web dashboard); pluggable storage (OceanBase, PostgreSQL, SQLite) and model providers so prototype and production share one code path; schema migration and backup/restore baked into the CLI. Attendees leave with patterns for multi-surface developer experience and a practical checklist for evaluating memory libraries. 1F | Mandarin Hall I Jiamu Liu, Yanjun Chen Researchers are exploring how AI workflows can accelerate science in recent AI waves. Most existing workflows are built for AI/ML model training, and they fall short for domain-specific scientific work that demands traceable, and reproducible workflows.
To bridge this gap, China Mobile Research Institute built an AI4S system that unifies computing infrastructure and a zero-code software platform. The infrastructure uses Kubernetes to federate multiple cross-region clusters into a pool of heterogeneous resources. The platform covers the entire research lifecycle, form model training to scientific agent development, allowing researchers to build customized assistants without coding.
In collaboration with an RNA-focused biology lab, the system was applied to train a RNA structure prediction model. The resulting model achieved very well performance.
This presentation will share the system architecture, design decisions, and key lessons learned from deploying AI in real scientific research. 1F | Mandarin Hall II Liyi Huang, Tingjin Ye, Yashi Su Join us as we celebrate a decade of Cilium, now the de-facto standard CNI for Kubernetes and a cornerstone of cloud native networking and security. This session provides updates on the latest Cilium release and highlights how its unified eBPF-powered stack is transforming Kubernetes environments and beyond by replacing fragmented toolchains with seamless, secure, scalable, and simplified solutions. We’ll showcase how Anta Group used the 'Less is More' approach in their data center architecture by consolidating core networking, load balancing, and observability into Cilium and how Alibaba is using Tetragon to secure AI agents beyond just prompt guardrails. These stories will demonstrate how Cilium is streamlining operations and reshaping the cloud native stack, cementing Cilium’s role as the networking and security data plane for modern infrastructure for the next decade to come. 5F | 5B + C Dandan Liang, Weizhou Lan Driven by IoT and AI, future networks demand an architectural revolution. A CCNN is proposed that converges RAN, IP bearer and data center networks, using Kubernetes as the network OS to unify virtualization, scheduling, and management of compute, storage and network resources, thus enabling secure, cross-domain resource integration. The demo comprises: a Cybertwin-based personal agent service; the security agent function of Cybertwin that implements zero-trust; the data agent function that provides secure multi-dimensional personal data services; the communication agent function that delivers a cloud-native wireless access method for users; finally, a distributed medical collaborative inference based on the user’s personal agent, which demonstrates application-centric unified scheduling and intelligent orchestration of transmission, computing, and storage resources, laying an original, cutting-edge foundation for resource networking and intelligent scheduling in cloud-native networks. 1F | Mandarin Hall II Feng Gao In safety-critical edge scenarios like drones in flight, autonomous robots, or AGVs/AMRs, an unplanned pod restart can cause motion interruption, safety hazards, or crashes. Traditional Kubernetes assumes updates can happen anytime, but many edge applications need explicit confirmation that the device is safe (landed, parked, or idle) before upgrading.This lightning talk introduces Edge Resource Upgrade Control, a new feature in KubeEdge v1.22.0. By adding the annotation edge.kubeedge.io/hold-upgrade: "true" to Deployments, StatefulSets, DaemonSets, or Pods, the edge node intercepts the new Pod and holds it in a pending state inside edged. A new HeldUpgrade PodCondition is reported back to the cloud.On the edge, local logic decides when it is safe. Operators release the hold with:keadm ctl unhold-upgrade pod (pod-name)
keadm ctl unhold-upgrade node (node-wide) 7F | Pearl Hall Jane Xu PyTorch strives to offer tested and proven optimizers (think SGD, AdamW, Muon) and we want them to be fast, consistent, and simple to use. We want people to trust our optimizers :D This session will cover how we pushed along each of those dimensions with our latest developments on newer optimizers like Muon, adding more mixed precision (BF16 AdamW), and lifting out-of-the-box performance. We’ll share the new features and algorithms you can try out for driving down your loss curves and, if you’re curious, give insight on how we make things speedier but keep them just as sturdy. 7F | Pearl Hall Tan Pei Xiang RL (e.g., GRPO) is vital for LLM reasoning, yet current tools are either too rigid or engineering-heavy. Twinkle, co-developed by ModelScope and China Merchants Bank, offers a breakthrough via:
- Atomic Design: Orchestrate RL loops in ~150 lines. Swap modules (Reward/Loss) like Lego without touching the core.
- C-S Architecture: Decouples algorithm semantics from GPU orchestration (torchrun/Ray/HTTP).
- Serverless TaaS: Multi-tenant LoRA pools enable 8+ concurrent tasks on one base model, maximizing resource utility.
As a superset of the Tinker API, Twinkle supports FSDP2 and Megatron backends. It solves the flexibility-scale trade-off, enabling true "Training-as-a-Service." We will explore its architecture, rapid GRPO/DPO integration, and financial sector case studies, concluding with the shift toward "micro-service training" for Agent RL. 7F | Grand Ballroom II + III Jane Lyu, Fupan Li, Zesheng Zong, Hiu Yeung, Sunny Chan No single project, company, or community builds the AI stack alone. Behind the models, frameworks, cloud native technologies, and infrastructure powering AI is a global open source community working across every layer. This session brings together contributors from across the stack to share how collaboration between projects and communities turns individual technologies into an open, interoperable AI ecosystem—and why that collaboration matters even more as AI evolves. 7F | Grand Ballroom II + III Trong Vinh Nguyen We didn't buy all our GPUs/AI chips at once. Years of procurement across different budget cycles left us with a fleet spanning multiple generations-from T4s that still run fine, to L40Ss, A100s, H200s, and the newer B200s-each with different memory capacities, compute profiles, and driver requirements. Managing these as isolated, team-specific bare-metal allocations meant we were sitting on underutilized assets while other teams waited in queue. This talk is about how we unified that messy reality into a single platform by layering three open-source ecosystems: OIF at the bare-metal layer, CNCF tooling for GPU pooling and multi-tenant slicing, and PyTorch Foundation projects for serving optimization. The result is a Token-as-a-Service platform that treats every GPU in the fleet (old or new) as a productive contributor. We'll share what it took to get there, what we're still figuring out, and where we see this going as model complexity and multi-agent workloads continue to grow. 7F | Grand Ballroom II + III Trong Vinh Nguyen, Quoc Dat Le In 2018, most of IT and Telco infras of Viettel (largest telco in Vietnam) run on VMware or legacy on-premise solutions. The utilization of physical infra was low, need hundreds of people to operate all the infras, MTTR was nightmare, depends on support tickets from vendors... Recently, VMWare licenses price went high. That's why we have to migrate our infras to open source tech stacks and solutions. OpenStak, Ceph, Kubernetes, Prometheus... are our choices. By the end of 2025, over 80% of our massive infra had been migrated to open source Cloud and Cloud Native solutions.
This talk will be about how we choose the starting point, how we move from here to there, and the way we achieve the current state, how we collaborated with open source community in Vietnam and Asia. 7F | Grand Ballroom II + III Maxim Nazarenko, Nibir Bora Running stateful workloads in Kubernetes is challenging; migrating the storage beneath them is even harder. Migrating hundreds of live storage volumes without downtime might seem nearly impossible. In this session, we present a battle-tested approach for doing exactly that: migrating hundreds of Azure Disk-backed PersistentVolumes from deprecated in-tree drivers to CSI with zero downtime and minimal service disruption. By leveraging a deep understanding of Kubernetes internals, we accomplished this using only standard user-facing Kubernetes APIs without control plane forks, risky hacks, or even custom operators. We’ll break down the critical mechanics that make it possible, touching upon immutability constraints, claimRef behavior, finalizers, and StorageClass interactions. Through real-world examples from large-scale production data platforms, this talk demonstrates how advanced Kubernetes systems expertise can unlock operational capabilities that many teams assume are out of reach. 7F | Pearl Hall Tristan Rice, Amir Afzali GPU failures at scale are not exceptions — they are scheduled events. At Meta, training jobs spanning tens of thousands of GPUs encounter hardware faults daily, yet training continues without missing a step. In this talk, we discuss open-source tools that make this possible. We introduce the fault tolerance APIs in torchcomms, covering NCCL, MCCL and Gloo backends. MCCL is Meta's production fault tolerance collective communication library and we will deep dive into its design and fault tolerance capabilities. We also show how torchcomms uses NCCL's new primitives — ncclShrink, ncclGrow, and ncclCommRevoke — to gracefully shrink or grow communicator membership without deadlocking the cluster. We'll cover novel checkpointing approaches — including checkpoint-to-peer-memory and checkpoint-to-local-disk — using torchstore as one example of how fast RDMA transfers between GPU peers can replace slow distributed filesystem writes and enable live recovery. 1F | Mandarin Hall I ChongKang Tan As AI infrastructure evolves, fragmented GPU clusters and bursty AI workloads make large-scale multi-cluster operations increasingly difficult.
In this talk, we share how we built an Elastic Compute Pool that federates fragmented GPU capacity across clusters into a unified global scheduling domain.
While Kubernetes Dynamic Resource Allocation (DRA) and Kueue provide a strong foundation for AI scheduling, we found critical gaps in applying them to global-scale GPU pools—particularly around application-level topology awareness, failover-aware placement, and cross-cluster resource modeling.
We will dive into how we extended DRA to address these limitations and how we unified the orchestration of training and inference workloads across hundred-thousand-GPU-scale infrastructure.
Attendees will learn the architectural tradeoffs, scheduler and resource management extensions, and operational lessons required to make Kubernetes federation practical for AI-native compute platforms. 1F | Mandarin Hall I Dunfan Lu, Jason Ansel Helion is a Python DSL that raises kernel authoring above languages like CUDA and Triton: you describe a kernel at a high level, and a compiler and autotuner generate the device code. This talk introduces two new compiler backends. The motivation is hardware heterogeneity and performance. Accelerators are diverging, and reaching state-of-the-art performance on each one normally means hand-writing kernels in that vendor's low-level language. The new backends lower a Helion kernel through CuteDSL for recent NVIDIA GPUs and through Pallas for TPUs. The same source targets different hardware without giving up that performance or rewriting per vendor. The second half covers code generation by LLM agents. Because Helion sits above the languages it compiles to, a kernel takes fewer tokens to express and offers less surface area for mistakes, and the autotuner handles the performance tuning that agents do poorly. We cover where this holds up and where it doesn't. 5F | 5B + C Fupan Li, Xuewei Niu AI agents need more than Linux. Kata Containers 4.0 delivers a universal secure sandbox for the agent era. A new Rust-based default runtime replaces Go for superior safety and speed. Multi-hypervisor support — QEMU, Dragonball, Cloud Hypervisor, Firecracker — adapts to any infrastructure. Template-based instant startup achieves sub-100ms sandbox launch, enabling elastic agent scaling at cloud speed. Confidential Computing via Intel TDX, AMD SEV-SNP, Hygon CSV, and DCU protects sensitive workloads at hardware level. And for the first time, Kata breaks beyond Linux: Android, OSWorld, and Windows sandboxes unify under one runtime, powering diverse AI agent environments securely and instantly. The future of sandboxing is multi-world — and it starts with Kata 4.0. 7F | Pearl Hall Hongcai Ren, Zongqing Li Karmada (Kubernetes Armada) is a Kubernetes management system that enables you to run your cloud-native applications across multiple Kubernetes clusters and clouds. In this presentation, the maintainer of the Karmada project will share: - A Brief introduction to Karmada.
- New features over the last year
Application Priority Scheduling
Stateful Application Cluster Failover
Federated ResourceQuota Enforcement
Workload Affinity
AI Jobs Scheduling Enhancements
- Real-world case studies
- Overview of the community
- Roadmap
- QA 5F | 5B + C Wei Wang In 2026, PyTorch stands at the center of a rapidly expanding global AI ecosystem. Through a data-driven analysis of activity across GitHub, Hugging Face, and related open platforms, this talk reveals a clear upward trajectory in contributions from China—spanning code, models, tools, and community engagement. Yet as domestic efforts in AI frameworks and hardware accelerate, the risk of fragmentation grows. We argue that China’s homegrown AI infrastructure should actively converge with mainstream ecosystems like PyTorch, not to replace them, but to co-develop interoperable standards that benefit the entire global community. The path forward lies not in isolated stacks, but in shared foundations. 7F | Grand Ballroom II + IIITuesday, September 8
Tidal Auto-scaling for Training and Inference Based on Kubernetes + KEDA
Abstract
What AI Agents Need from Open Infrastructure
Abstract
Building an Agent Runtime with Open Infrastructure
Abstract
📚 Building Portable Large Models on Heterogeneous AI Accelerators with FlagOS
Abstract
8 Million Tasks Daily: Driving Efficiency in Multi-Tenant Data Platforms at Horizon Robotics
Abstract
Project Lightning Talk: Multi-cluster Orchestration System: Karmada Updates and Use Cases
Abstract
Dragonfly's CNCF Graduation Journey and Large-Scale AI Model Distribution in Practice
Abstract
Scaling Digital Employees at China Merchants Bank in Production: A Controlled AI Agents Approach
Abstract
Dragonfly V2.5.0 - Intro, Updates, Data Distribution in AI Infrastructure
Abstract
How Intsig Serves Billions of Document Scans: GPU Virtualization at Scale with HAMi
Abstract
Spec-Driven Evolution: How AI Agents are Rewriting the OpenStack/K8s Playbook
Abstract
KernelAgent: Hardware-Guided GPU Kernel Optimization via Multi-Agent Orchestration
Abstract
Minutes, Not Weeks: Long-Term Memory for AI Applications with PowerMem
Abstract
Building AI4S Systems for Scientific Research on Kubernetes
Abstract
10 Years of Cilium: Connecting, Securing, and Simplifying the Cloud Native Stack
Abstract
Cybertwin-based Cloud Native Network (CCNN): Network Architecture Innovation and Practice
Abstract
⚡Edge Resource Control in KubeEdge:Safely Holding and Releasing Pod Updates for Critical Edge Device
Abstract
⚡ Speedy But Sturdy PyTorch Optimizers
Abstract
Redefining LLM Training through Atomic Components and Serverless TaaS
Abstract
Wednesday, September 9
Meet the Community Behind the Open Source AI Stack
Abstract
A Cloud Native Stack from Bare Metal to Tokens for Large-Scale AI Inference
Abstract
Escaping the Vendor Trap: A Journey for Migrating Legacy Infrastructure to OpenStack and K8s
Abstract
In-Place PVC Re-Binding: Zero-Downtime Disk Migration Using Only the Kubernetes API
Abstract
Training Through Failures: How Meta Keeps 100k-GPU Jobs Alive with Open-Source Fault Tolerance
Abstract
Turning Fragmented GPU Clusters Into One Elastic Compute Pool
Abstract
Helion's New CuTe DSL and Pallas Backends and How we Built Them via Agents
Abstract
From Cloud to AI: How Kata Containers 4.0 Reinvents the Sandbox for the Agent Era
Abstract
Multi-cluster Orchestration System: Karmada Updates and Use Cases
Abstract
The State of the PyTorch Ecosystem in 2026: Global Trends and China’s Rising Role
Abstract
Event pages and schedules are maintained by the Linux Foundation.