Agenda

Not every architecture leap is created equal. Learn what makes NVIDIA Vera Rubin NVL72 genuinely different—from its underlying architecture and the workloads it’s optimized for, to the performance gains it delivers over prior generations. Hear directly from CoreWeave’s product and engineering teams on what it actually takes to run AI workloads on Vera Rubin, so you can make an informed call on whether it’s the right next step for your organization.

In a constrained GPU market, the teams that win are the ones who know how to find available capacity and make smart decisions about how to use it. Learn how to evaluate spot, flex, and reserved models based on your workload needs. Use real-time usage dashboards to monitor spending and keep your team accountable. And apply the same cost management patterns that have helped CoreWeave customers meaningfully improve their infrastructure economics.

Security gaps don’t announce themselves—they just get exploited. Learn how to design security into your AI infrastructure from day zero, covering identity and access management, workload isolation, secure sandbox environments, and encryption. Through real customer examples spanning multiple industries, you’ll see where organizations most commonly expose risk and what it takes to close those gaps before they become problems.

Multi-cloud shouldn’t mean multiplying your operational overhead. Learn how to manage AI workloads across clouds and environments without the complexity that typically comes with it—from deploying Cross-Cloud LOTA and SUNK across providers to bridging cloud and on-premises infrastructure. You’ll leave with concrete, proven patterns for simplifying multi-environment operations, grounded in real customer examples.

Token throughput isn’t just a model problem—it’s an infrastructure problem. Learn how decisions at the rack level,from cooling and rack design to orchestration and control planes, directly affect output at scale. You’ll learn how to benchmark throughput across configurations, understand the tradeoffs that matter when you’re operating at scale, and apply patterns that help your team push more tokens without sacrificing reliability or efficiency.

Getting more out of your existing compute doesn’t require more hardware—it requires better practices. Learn how to run training and inference workloads more efficiently, from infrastructure optimizations that reduce time-to-train to serving strategies that lower latency and cost at inference time. You’ll leave with actionable techniques you can apply immediately to raise MFU, improve goodput, and get measurably more from the infrastructure you already have.

Pre-training at hyperscale breaks in predictable ways if you know where to look. Learn how to run pre-training at scale with end-to-end observability across your models and clusters, and how pioneering teams are eliminating the infrastructure overhead that typically slows the first model run. We’ll walk through a real production setup: what the configuration looks like, what breaks, and what you need to have in place before you scale. You’ll leave with a clear picture of what production-ready hyperscale training actually requires.

Published benchmark numbers are only useful if you know how to interrogate them. Learn how CoreWeave’s MLPerf and NVIDIA Exemplar results for training and inference were produced, what the NVIDIA partnership enables at the hardware layer, and how to map those published numbers to your own model size and workloads. You’ll leave with a practical framework for cutting through infrastructure claims before they cost you a contract—and a clearer sense of what performance at scale actually looks like when the methodology is transparent.

Slow iteration doesn’t just feel painful—it compounds directly into time to market. Learn two concrete patterns fortightening the development loop: how to run experiment tracking at production scale without the overhead that typically slows the cycle, and how connecting your data pipeline to serving under a unified infrastructure layer eliminates the handoff delays that consume the second half of your roadmap. Both patterns are designed to give you actionable insights you can take away and apply immediately.

When the standard fine-tuning recipe doesn’t fit your domain, the gap between general practice and what your workload actually requires gets expensive fast. Learn what fine-tuning at scale truly demands, with a focused look at two verticals—robotics and creative/biotech—where the tuning approach, data format, and hardware configuration diverge sharply from general practice. You’ll leave with a concrete model for designing your fine-tuning workflow around your domain’s actual constraints, rather than forcing your workload into a stack that wasn’t built for it.

RL has different infrastructure failure modes than supervised fine-tuning, and most teams hit them mid-run. Learn where the pipeline actually breaks—environment isolation, compute scaling at reward-model inference, the gap between a research RL setup and a production one—and which infrastructure pattern fits your current stage. We’ll cover the full range: infrastructure-scale training RL for teams running serious workloads, and serverless approaches for teams that want the capability without managing persistent compute. You’ll leave knowing how to build a production RL pipeline that doesn’t surprise you at the worst moment.

Getting a model to production is an infrastructure decision as much as a model decision—and the wrong call costs you in ops overhead, latency, or both. Learn how to evaluate the deployment models that balance infrastructure abstraction, customization, and SLA requirements for production workloads. Through two real production deployments, you’ll walk away with a clear decision framework for choosing the right approach for your workload, yourteam, and the performance bar your users actually expect.

The gap between a demo agent and a production one comes down to architecture. Learn how modern agent systems are designed to reason, plan, remember, and collaborate—and the decisions that determine whether they hold up when complexity scales. We’ll explore context management, memory systems, planning loops, and multi-agent coordination, with an honest look atthe tradeoffs between simplicity and autonomy. You’ll leave with practical patterns for decomposing complex tasks and building agents that stay effective as workflows, tools, and user expectations grow more demanding.

The agent ecosystem is maturing fast, and knowing which abstractions to reach for makes the difference between a system that scales and one that becomes a maintenance burden. Learn how to navigate the emerging landscape of agent frameworks, SDKs, and protocols—how to choose the right abstractions for your use case, instrument agents for real visibility, and leverage standards that let agents, tools, and services work together without brittle custom glue. You’ll leave with practical approaches to building development workflows that accelerate iteration without compounding operational complexity.

Demos don’t predict production performance—rigorous evaluation does. Learn how leading teams measure agent performance, detect regressions, and build genuine confidence in increasingly autonomous systems. We’ll cover evaluation methodologies from offline benchmarks to production-derived test suites, how to construct high-quality evaluation datasets from real-world traces, and which metrics actually correlate with user outcomes. You’ll leave with the tools to move beyond anecdotal results toward repeatable, trustworthy agent performance at scale.

You can’t operate what you can’t see. Learn how to monitor, troubleshoot, and run fleets of agents in production—using tracing, observability, and telemetry to surface what agents are actually doing, why they fail, and where performance bottlenecks emerge. We’ll cover operational best practices for managing reliability, controlling costs, and debugging complex multi-step workflows. You’ll leave with practical techniques for turning opaque agent behavior into clear, actionable operational insight.

Agent workloads don’t behave like standard inference—and infrastructure designed for one will underperform on the other. Learn how the unique demands of agentic workloads are reshaping inference systems design, from tool calling and context management to model routing and workflow orchestration. We’ll work through the real tradeoffs between latency, cost, and capability, and examine how infrastructure choices ripple through agent performance. You’ll leave knowing how to optimize systems built for complex, iterative reasoning at scale.

The fastest-improving agent systems aren’t just running tasks—they’re learning from their own outputs. Learn how autonomous research systems are transforming the way organizations discover insights, improve models, and accelerate experimentation. We’ll cover how evaluation-driven development makes these systems trustworthy in practice, from turning production traces into benchmarks to building quality gates that determine which behaviors get promoted to production. You’ll leave with a concrete approach to building agents that automate research tasks and get measurably better overtime.