PyTorch Conference North America 2026

Registration & Badge Pick-Up

Registration · Oct 20, 2026 · 07:30–18:00 local time; timezone inferred

Keynote: Welcome to PyTorch Conference North America

Keynote · Oct 20, 2026 · 09:00–09:15 local time; timezone inferred

• Mark Collier

Keynote: PyTorch Updates

Keynote · Oct 20, 2026 · 09:15–09:30 local time; timezone inferred

• Alban Desmaison
• Edward Yang

Sponsored Keynote: Trainium’s Journey to Native PyTorch

Keynote · Oct 20, 2026 · 09:35–09:40 local time; timezone inferred

PyTorch now runs natively on Trainium with no code changes required. AWS customers are already training frontier models using standard PyTorch workflows on Trainium. In this keynote, we share how we got here: enabling eager mode and torch.compile, integrating with TorchTitan, TorchAO, and HuggingFace Transformers v5, and making our tools like Neuron Explorer work natively with PyTorch. We'll cover our upstream contributions to PyTorch and TorchTitan, and our ongoing collaboration with the PyTorch team on what comes next.

• Colin Brace

Keynote: Beyond Brute Force: The Era of Adaptive Intelligence.

Keynote · Oct 20, 2026 · 09:40–09:48 local time; timezone inferred

The next generation of truly intelligent systems won't be defined by scale. The next unlock is architectural: systems that keep learning after deployment, closing the gap between a model's frozen training distribution and the evolving world it operates in. In this talk, Sara Hooker, Co-founder of Adaption, discusses moving past static AI toward systems that are malleable by design. She'll dig into the technical foundations of continual, gradient-free learning: how models can update behavior without full retraining, without catastrophic forgetting, and without the compute cost of repeated fine-tuning cycles. Built so that AI adapts to people rather than the reverse.

• Sara Hooker

Sponsored Keynote: PyTorch at Meta - From Internal Workloads to Multi-Silicon Ecosystem

Keynote · Oct 20, 2026 · 09:50–09:55 local time; timezone inferred

Jana van Greunen shares how Meta uses PyTorch to power its frontier AI research and production workloads — and how that work feeds back into the open-source ecosystem. She'll cover Meta's latest PyTorch initiatives, including Helion (the kernel layer) and TorchTitan's expansion into reinforcement learning, as well as Meta's deepening collaboration with hardware partners to bring PyTorch-native support to the next generation of AI chips.

• Jana van Greunen

Keynote: Simon Mo, Inferact

Keynote · Oct 20, 2026 · 10:00–10:05 local time; timezone inferred

• Simon Mo

Keynote: Brian Stevens, SVP and AI CTO, Red Hat

Keynote · Oct 20, 2026 · 10:05–10:08 local time; timezone inferred

• Brian Stevens

Keynote Sessions to be Announced

Keynote · Oct 20, 2026 · 10:10–10:15 local time; timezone inferred

Keynote: PyTorch Performance for Agents on Vera Rubin

Keynote · Oct 20, 2026 · 10:15–10:25 local time; timezone inferred

In this keynote, Ujval will explore what agentic workloads need from AI systems and how the PyTorch stack can address these needs. Agentic systems introduce new bottlenecks and optimization opportunities. A single request can trigger long chains of reasoning, tool calls, code execution, data movement, and distributed inference. Training and inference serving software needs to be optimized across CPUs, GPUs, memory, and networking. Using Vera Rubin as a case study, he will show how co-design across hardware and software can improve end-to-end performance, efficiency, and developer experience for agents at scale.

• Ujval Kapasi

Coffee Break

Break · Editorial classification · Oct 20, 2026 · 10:35–11:10 local time; timezone inferred

Community Expo

Not classified · Oct 20, 2026 · 10:35–19:30 local time; timezone inferred

Contributing to PyTorch with AI agents

Birds of a feather · Oct 20, 2026 · 10:35–11:05 local time; timezone inferred

How should AI agents be used productively to contribute to PyTorch? What are good things to know? How can you get someone to review your PR? Come talk about these things. A good pre-read is this devlog: https://docs.pytorch.org/devlogs/ai-agents/2026-05-30-ai-coding-playbook/

• Edward Yang

Sponsored: Unifying Open-Source LLM Serving on Google Cloud TPUs with TorchTPU

Other · Oct 20, 2026 · 10:40–10:50 local time; timezone inferred

See how TorchTPU provides a native, high-performance compilation path for PyTorch models on Cloud TPUs. This 10-minute demo highlights how TorchTPU serves as a unified backend for leading open-source inference engines like vLLM and SGLang, enabling deployment of state-of-the-art models with minimal code modifications.

• Rob Mulla

Extending TorchInductor with FlyDSL: A New MLIR-Native Backend for High-Performance GEMMs

Breakout session · Oct 20, 2026 · 11:10–11:35 local time; timezone inferred

TorchInductor is PyTorch's primary compiler backend, generating optimized kernels through graph lowering, autotuning, and backend-specific code generation. Recent efforts have expanded TorchInductor beyond Triton, demonstrating the value of a flexible multi-backend architecture. In this talk, we present the integration of FlyDSL, AMD's Python-native and MLIR-based GPU kernel DSL, into TorchInductor's GEMM compilation pipeline. We describe how FlyDSL connects to TorchInductor's autotuning framework, covering workload analysis, candidate generation, compilation, benchmarking, caching, and runtime backend selection. We discuss the design decisions that enable FlyDSL to coexist with existing TorchInductor backends while preserving the torch.compile user experience, along with challenges in kernel specialization, compilation latency, autotuning scalability, and backend fallback. Finally, we present performance results for transformer training and inference on AMD Instinct GPUs, comparing Triton and FlyDSL implementations. Attendees will gain practical insights into FlyDSL kernel design, how new compiler backends can be integrated into the PyTorch stack.

• Liz Li

How PyTorch Powers Open Foundational Models — From Language to Vision

Breakout session · Oct 20, 2026 · 11:10–11:35 local time; timezone inferred

Training and open sourcing frontier foundational models presents unique challenges—scaling to trillions of tokens across thousands of GPUs, maintaining reproducibility, and enabling a global community to fine-tune and deploy models. In this session, we explore how PyTorch addresses key challenges in building and open sourcing foundational LLMs (Llama) and vision models (SAM). We cover three angles: 1) how PyTorch-native tools like TorchTitan power pre-training through composable parallelism, torch.compile, and Float8—applied to both LLMs and vision architectures, 2) the road to open sourcing foundational models—from internal research to community-ready releases across modalities, and 3) how this foundation enables adopters in healthcare, robotics, and autonomous systems to fine-tune Llama for domain NLP and SAM for zero-shot segmentation. We share hard-won lessons: scaling distributed training without sacrificing code clarity, designing checkpointing for interoperability, and building an open ecosystem where models train on PyTorch and millions customize them. Attendees leave with practical strategies for training, releasing, and sustaining large-scale open models with PyTorch.

• Elisa Cascardi
• Nikhila Ravi

Monarch - Single-Machine DevX at Distributed Scale

Breakout session · Oct 20, 2026 · 11:10–11:35 local time; timezone inferred

A developer’s computer is part of their identity; as unique as a fingerprint. People have their favorite tools, libraries, and agents set up for their own productivity (and happiness!). New projects that run locally are productive to work in. Unfortunately, as projects scale, we trade this development experience for more compute, using clusters with worse ergonomics. Monarch is a library for programming an entire cluster as if it were a single machine. Imperative APIs launch processes across the cluster that communicate with fast actor-based IPC and transfer data using RDMA. This fabric lets us provide services that make it feel like all processes across the cluster are on your local machine. For instance, we use Monarch to build filesystem mounts so the local filesystem is broadcast to the entire cluster, and remote logs appear locally. Iterating with Monarch takes seconds rather than minutes. Debugging is easier: the distributed process exits like a local process and its outputs are visible locally. This speeds up the development loop for humans and agents. This talk will demo the experience and show how to use Monarch primitives to build large scale post training frameworks.

• Marius Eriksen

Relay and Reuse: The Dual Engine Behind PyTorch Out-of-Tree Release Readiness

Breakout session · Oct 20, 2026 · 11:10–11:35 local time; timezone inferred

For heterogeneous accelerators, keeping pace with PyTorch's fast bi-monthly release cycle is a constant uphill battle. This session shares how we sustain high quality while shipping stable releases within a month of each upstream update. Test Refactoring & Device-Agnostic Reuse: We show how instantiate device type_tests and dynamic skipping break the tie between tests and hardware. The payoff: 580K+ community test cases become reusable out of the box, giving full API semantic parity at almost no extra cost. Cross-Repo CI Relay (CRCR) & Quality Gates: CRCR wires every PyTorch PR directly to accelerator code, co-compiling and testing both in real time. By validating upstream changes against the backend before they merge, it catches regressions at the source, easing adaptation and locking in post-release stability. Together, reuse and cross-repo CI let an out-of-tree backend ship high-quality releases within 30 days. Benefits: this blueprint lowers the barrier to hardware integration, while CRCR doubles as an early-warning system for PyTorch Core — flagging regressions before they spread, so every user gets the newest features at once, with no fragmentation.

• Jiahao Chen
• Jiahao Tan

Sponsored: What's New in Inference in October

Other · Oct 20, 2026 · 11:10–11:35 local time; timezone inferred

Keeping up with inference is a full-time job. As the field accelerates with new model architectures, inference engines, and performance techniques, it can be hard to sort out what is worth running in production. This talk provides a structured overview of the most important recent developments in inference across speculation, KV cache management, and large-scale model serving.

• Philip Kiely

Who Owns Production When the Agent Does the Fixing? Governance in AI-Assisted SRE

Breakout session · Oct 20, 2026 · 11:10–11:35 local time; timezone inferred

AI agents are no longer just suggesting fixes - they're shipping them. As autonomous remediation becomes standard in SRE workflows, the industry is quietly skipping over a critical question: when an agent misconfigures a service at 3am and takes down production, who is accountable? This talk explores the governance frameworks, guardrails, and human-in-the-loop patterns that separate safe autonomy from dangerous automation. We'll examine where AI-assisted SRE is genuinely delivering with faster MTTR, reduced toil, and smarter alerting, and where unchecked agent authority creates new classes of failure. You'll leave with a practical mental model for deciding what your agents should fix, what they should flag, and what should never leave a human's hands.

• Aditi Mewada
• Prakshal Doshi

A Developer’s Guide to Attention in vLLM

Breakout session · Oct 20, 2026 · 11:45–12:10 local time; timezone inferred

Attention is no longer just “standard attention.” As models push toward longer context windows, attention has become one of the most active areas of architecture design. New schemes, including sliding windows, sparsity, compression, and linear variants, save KV-cache memory at long contexts, and nearly all modern state-of-the-art models now use hybrid attention, mixing patterns across layers to balance quality with memory use. This talk will give developers a practical guide to how vLLM represents, serves, and optimizes this growing diversity of attention schemes. We will start by reviewing the schemes used in recent models, and then walk through the core vLLM abstractions that make them possible, including attention backends, KV-cache connectors, and the hybrid memory allocator. Together, these allow vLLM to support a wide range of attention implementations while maintaining a unified serving path, efficient batching, and high-performance memory management. Finally, we will cover the recent overhaul of vLLM’s attention abstractions: what changed, why the old assumptions no longer hold, and how the new design makes it easier and cleaner to support emerging architectures.

• Lucas Wilkinson
• Matthew Bonanni

Compute, Latency, and Safety: Architecting Stateful Guardrails for Multi-Agent Workflows

Lightning talk · Oct 20, 2026 · 11:45–11:55 local time; timezone inferred

Deploying a single LLM is a solved infrastructure problem. Deploying a multi-agent system where autonomous nodes pass state, execute external tools, and orchestrate complex workflows introduces a massive architectural bottleneck: How do you secure inter-agent handoffs without destroying real-time throughput? In production environments serving millions of users, standard security checks fail to catch "indirect orchestration exploits" (where untrusted data corrupts downstream agent privileges). But evaluating every single state change with a massive frontier model is computationally impossible and financially ruinous. This session breaks down the MLOps infrastructure required to secure multi-agent architectures at enterprise scale. Drawing from the development of open-source evaluation frameworks like SecRepoBench, we will detail how to build continuous, stateful red-teaming pipelines. Attendees will learn how to deploy specialized, low-latency Small Language Models (SLMs) as deterministic orchestration guardrails, routing cross-agent payloads through high-speed evaluation checks that catch prompt injection and operational drift without bottlenecking the entire system.

• Purva Chiniya

Helion: CuteDSL and TPU Backends for Heterogeneous Hardware, and Why It Suits Agents

Breakout session · Oct 20, 2026 · 11:45–12:10 local time; timezone inferred

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.

• Dunfan Lu
• Jason Ansel
• Oguz Ulgen

Practical GPU Programming with Triton for PyTorch Developers

Breakout session · Oct 20, 2026 · 11:45–12:10 local time; timezone inferred

If you've used PyTorch, you've already run thousands of GPU kernels, you just never had to write one. Tools like torch.compile and Triton handle that for you. But what's actually happening underneath, and what if you wanted to write a kernel yourself? This talk is a friendly introduction to GPU programming with Triton, an open-source tool for writing fast GPU code directly in Python, no CUDA, no C++ required. We'll start from the basics: what a GPU kernel is, why GPUs are fast, and how PyTorch quietly generates kernels for you behind the scenes. From there, we'll write our first Triton kernel together, starting with something simple like adding two vectors, then building up to a small matrix multiplication. Along the way you'll pick up the core ideas, how a GPU moves data around, what it means to run thousands of threads at once, and how to check whether your kernel is actually fast; all through plain, readable Python. You'll leave knowing what a GPU kernel really is, how to read the code PyTorch generates for you, and how to write a simple Triton kernel of your own. No prior GPU experience needed, just comfort with Python and PyTorch.

• JanakiRam Goteti
• Suman Debnath