0.5 devconf-us-2026 2026-09-24 2026-09-25 2 00:05 https://pretalx.devconf.info https://pretalx.devconf.info/media/devconf-us-2026/img/devconf-logo-us-reverse_1u6k6QQ.svg US/Eastern Ladd Room (Capacity 170) Talk 2026-09-24T09:00:00-04:00 09:00 00:15 Join us for the conference opening with the organizers! devconf-us-2026-3263-welcome General Urvashi MohnaniSally O'Malley en false https://pretalx.devconf.info/devconf-us-2026/talk/LELFUT/ https://pretalx.devconf.info/devconf-us-2026/talk/LELFUT/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T09:15:00-04:00 09:15 00:35 Keynote TBD devconf-us-2026-3264-keynote-tbd General en false https://pretalx.devconf.info/devconf-us-2026/talk/DRNWGB/ https://pretalx.devconf.info/devconf-us-2026/talk/DRNWGB/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T10:00:00-04:00 10:00 00:35 Reinforcement learning for LLMs still looks like something only big labs can afford: expensive GPUs, complex training stacks, fragile recipes, and weeks of trial and error. But the ecosystem has quietly changed. With LoRA-based training, TRL, Unsloth, and adapter-aware serving in systems like vLLM and llama.cpp, it is now realistic for ordinary engineers to run useful GRPO experiments and serve multiple task-specific adapters on shared infrastructure. This talk is for engineers who want to move beyond prompting and try practical RL post-training without building a research lab. We’ll walk through a small GRPO training recipe using LoRA, explain the 5–6 hyperparameters that matter most, and show how those choices affect training behavior in practice. Attendees will leave with a runnable notebook, a mental model for configuring GRPO runs, and a practical path from “trained LoRA adapter” to “servable model variant” on existing inference infrastructure. devconf-us-2026-3217-the-practical-engineer-s-guide-to-rl-post-training Artificial Intelligence and Data Science Rohan Awhad en false https://pretalx.devconf.info/devconf-us-2026/talk/7CPYUJ/ https://pretalx.devconf.info/devconf-us-2026/talk/7CPYUJ/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T10:40:00-04:00 10:40 00:35 Performance engineers at Red Hat analyze vLLM inference benchmarks across Nvidia, AMD and TPU accelerators every release cycle. The data lives everywhere: benchmark CSVs, GPU metrics in Grafana, PyTorch profiler traces, vLLM source code on GitHub, and server logs with engine configuration details. Answering "why did throughput regress by 12% between vLLM-0.16.0 and vLLM-0.18.0 for model X?" used to mean hours of manual cross-referencing. We built an AI agent to unify it all and do it in minutes. The AI Performance Agent is a LangGraph ReAct agent powered by Google Gemini, connected to a FastMCP server exposing 30 specialized tools for benchmark querying, kernel-level profiler analysis, source code diffing, GPU metrics, energy computation, cost analysis and more, all through natural language. This talk covers the MCP architecture that makes the tools reusable across any client, the prompt engineering that teaches the model when to use which tool and when to stop and ask for clarification , the Langfuse v3 observability stack, and deploying the full system on OpenShift. Live demo included. What attendees will take away: - A reusable architecture pattern for building MCP-based AI agents that integrate with enterprise data sources - Practical prompt engineering patterns for multi-tool agents that need to be rigorous, not just fluent - A deployment blueprint for running LangGraph agents with full observability on OpenShift - The open-source tool stack: LangGraph, FastMCP, Langfuse, Streamlit, all community projects devconf-us-2026-3056-1-agent-30-tools-what-we-learned-building-an-mcp-powered-performance-detective Artificial Intelligence and Data Science Harshith Umesh en false https://pretalx.devconf.info/devconf-us-2026/talk/V8WPUW/ https://pretalx.devconf.info/devconf-us-2026/talk/V8WPUW/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T11:20:00-04:00 11:20 00:35 What if your backlog could shrink while your team focuses on high-impact features? On the HyperShift team at Red Hat, we built an AI-powered workflow using Claude Code that autonomously picks up Jira tickets, implements solutions, opens PRs, and even responds to peer review feedback — all without a developer lifting a finger. In this talk, we'll walk through the key automations we built as Claude Code skills, orchestrated through OpenShift CI periodic jobs: jira:solve — A four-phase pipeline triggered weekly by a periodic CI job. Given a Jira issue, it fetches the ticket details, analyzes the codebase, generates an implementation plan, writes the code and tests, and runs verification (linting, builds, unit tests). Then an AI peer review evaluates the changes for code quality issues. A third phase automatically addresses the review findings and pushes fixes. Only after this internal review cycle completes does the final phase open a PR. address-reviews — A separate periodic job that runs every three hours. It queries GitHub for agent-created PRs with pending review comments from humans or AI reviewers, categorizes them by priority (blocking, change requests, questions, suggestions), makes the requested code changes, amends the relevant commits, and posts concise replies — closing the feedback loop without context-switching a developer. It can also be triggered on-demand for any PR via a Prow comment. Together, these create a pipeline where low-priority backlog items flow from Jira to review-ready PRs with minimal human intervention. Developers review the AI's work rather than doing it themselves, acting as supervisors instead of implementers for routine fixes. We'll cover: Architecture: How we built a system of Claude Code skills that encode our team's standards — code formatting conventions, Gherkin-style test patterns, effective Go idioms, conventional commit formatting, PR templates, and a project-specific AI review profile — so the AI produces output that meets the same bar as a human contributor. The solve pipeline: Jira ticket parsing → codebase analysis → plan generation → implementation → verification → AI peer review → review fixes → PR creation The review loop: How the address-reviews job triages human and AI feedback, makes surgical code changes, amends commits, and replies to reviewers Guardrails: Comment deduplication, authorization checks, token refresh across long-running phases, and why human review remains essential Results and lessons learned: What works, what doesn't, and where human judgment is still irreplaceable Whether you're a platform engineer, SRE, or developer tired of your backlog growing faster than you can triage it, this talk will give you a practical blueprint for putting AI to work on the tasks your team doesn't want to do and the lower-priority ones it doesn't have time to do. devconf-us-2026-2932-ai-powered-backlog-burndown-how-we-taught-claude-code-to-solve-jira-tickets-and-address-code-reviews Artificial Intelligence and Data Science Bryan CoxAlberto Garcia Lamela en false https://pretalx.devconf.info/devconf-us-2026/talk/7TZHJF/ https://pretalx.devconf.info/devconf-us-2026/talk/7TZHJF/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T13:00:00-04:00 13:00 00:35 Migrating legacy documentation often reveals a critical bottleneck for enterprise operations: trapped, unstructured data. Red Hat’s Procurement team recently faced this challenge when migrating over 32,000 legacy vendor contracts to a new Contract Lifecycle Manager (CLM). The new system required specific metadata - such as creation dates, expiration dates, and signatories - extracted from a complex mix of generated and scanned PDFs. These documents spanned multiple languages and featured non-standard layouts and tabular data. Completing this extraction manually was projected to take over a year, consuming approximately 14,000 hours and $700,000 in operational costs. This session details how Red Hat engineered a reusable, AI-driven automation pipeline to solve this challenge in a fraction of the time. Hosted on Red Hat OpenShift AI, the solution utilizes Docling to convert highly unstructured PDFs into Markdown. From there, the text is processed through a Qwen2.5 32B LLM to intelligently extract and format the required metadata into structured JSON. By transitioning to an automated, unstructured-to-structured ETL approach, the team completed the migration in just 3 months. The project required only 1,700 hours of development and review, ultimately saving 75% in FTE hours and achieving $600,000 in cost savings. devconf-us-2026-2921-unstructured-to-structured-etl-automating-contract-metadata-extraction-with-docling-and-genai Artificial Intelligence and Data Science Taylor Agarwal en false https://pretalx.devconf.info/devconf-us-2026/talk/DE7B7X/ https://pretalx.devconf.info/devconf-us-2026/talk/DE7B7X/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T13:40:00-04:00 13:40 00:35 Most conversations about agentic AI start with the wrong question: which model should we use? Models commoditize on a six-month cycle. The team that picked the right model last quarter is one release away from being wrong, and the next release after that. What actually differentiates a production agentic system isn't the model, it's the operational layer around it: tool routing, conversation state, cost controls, guardrails, observability, audit trails. That layer is where the engineering compounds. This talk is for engineers building agentic systems on real backends, not framework demos, not greenfield AI startups, but the boring middle where most production work lives: a service, an ORM, a queue, a model API. We'll separate durable patterns that survive a model swap from disposable ones you'll delete in six months as models improve, and look at how to design the boundary between them so your stack absorbs capability gains rather than breaking. The talk has three parts. First, the wrong question, "which model?" dominates the conversation, and what the right question looks like. Second, the durable layer-six patterns shown in framework-free Python, each in roughly 30 lines: tool routing, the agentic loop with bounded rounds, conversation compaction that doesn't corrupt tool-call structure, race-free cost tracking, audit-driven observability, and content moderation as fail-open infrastructure. Third, the disposable layer, retry logic, certain guardrails, aggressive compaction; code that's load-bearing today and will be dead weight in two model generations. We'll cover how to detect that a layer has aged out, and how to keep the boundary clean so removal is a deletion, not a rewrite. What you'll leave with: a working vocabulary for what's durable vs. disposable in your own stack (more useful, in practice, than the SDK / framework/harness distinction); a public gist of framework-free reference patterns to take home; and a diagnostic for spotting the parts of your current system that are about to age out. What this talk deliberately avoids: framework recommendations or comparisons (this talk is about the layer frameworks abstracted over), live model demos (capability differences across frontier models are not the point), and product case studies. Patterns are presented stack-agnostically; production grounding is implicit, not the spine. Audience: backend and platform engineers shipping agentic features in production; technical leads making architecture decisions about whether to adopt agent frameworks. Prerequisites: comfort reading Python and basic familiarity with calling an LLM API. No prior agent framework experience required; this talk works equally well for engineers who've never used LangChain and for engineers ripping it out. devconf-us-2026-3215-the-model-is-a-commodity-the-harness-is-the-product Artificial Intelligence and Data Science Shubhank Saxena en false https://pretalx.devconf.info/devconf-us-2026/talk/HGAM8H/ https://pretalx.devconf.info/devconf-us-2026/talk/HGAM8H/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T14:20:00-04:00 14:20 00:35 Multimodal large language models introduce a class of inference problem that standard vLLM profiling playbooks were not designed for. While LLM inference is well-understood, Multimodal MoE models introduce a chaotic new variable: image resolution. In a real-world product catalog, 20x variance in image size disrupts standard batch formation, drives preemption spikes. This talk presents the profiling methodology and optimization path we followed to achieve the top result among all B200 submissions on the MLPerf Inference benchmark for Qwen3-VL-235B-A22B-Instruct, a 235-billion-parameter mixture-of-experts vision-language model with 22 billion active parameters. The workload is the MLPerf Shopify product catalog: 48,289 real e-commerce images paired with text, classified into structured JSON output. We submitted results on both 8xB200 and 8xH200 nodes running RHEL with CentML-optimized vLLM. Results Configuration Throughput Context 8×B200 — Server 67.86 samples/sec #1 among all B200 submissions; 50% faster than top B300 submission 8×B200 — Offline 79.04 samples/sec #1 B200 result; on par with top B300 submission 8×H200 — Offline 18.22 samples/sec Only H200 submission for this model 8×H200 — Server 11.05 samples/sec Only H200 submission for this model We will present the profiling work that drove these results and how we identified the ViT encoder as the primary throughput constraint, why Shortest Job First scheduling outperformed continuous batching defaults on variable-image workloads, how FP8 multimodal attention was validated without compromising benchmark accuracy, and what the FlashInfer MoE kernel traces revealed about active-parameter utilization under the MLPerf traffic pattern. devconf-us-2026-3219-profiling-and-optimizing-vllm-for-large-multimodal-moe-inference Artificial Intelligence and Data Science HARIKA POTHINANaveen Miriyalu en false https://pretalx.devconf.info/devconf-us-2026/talk/JQK7PL/ https://pretalx.devconf.info/devconf-us-2026/talk/JQK7PL/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T15:20:00-04:00 15:20 00:35 Agentic AI systems are transforming how developers approach the Software Development Lifecycle, enabling a shift from "coder of every line" to "architect of outcomes." These autonomous agents understand context, reason about complex problems, and execute multi-step workflows across the entire SDLC. We will demonstrate how agentic AI tools accelerate open source development while maintaining code quality and security. ### The session will include: - Overview of agentic AI capabilities: multi-file refactoring, legacy modernization, security-first development, and knowledge transfer. - Architectural patterns for AI integration: Model Context Protocol (MCP) for connecting to external systems and Agent Skills for domain-specific guidance. - Demonstrations of context management, spec-driven development, MCP-based integrations, and agent skill implementation. - Best practices for balancing automation with human oversight in open source projects. Attendees will leave with practical understanding of how to leverage agentic AI to accelerate development, while simultaneously maintaining control using intent-based specifications in their open source projects. ### Target Audience Open source maintainers, software architects, DevOps engineers, and developers interested in AI-assisted development devconf-us-2026-3245-agentic-ai-in-open-source-development-from-autopilot-to-co-pilot Artificial Intelligence and Data Science James BuscheRafael Vasquez en false https://pretalx.devconf.info/devconf-us-2026/talk/RHC8JN/ https://pretalx.devconf.info/devconf-us-2026/talk/RHC8JN/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T16:00:00-04:00 16:00 00:35 In many enterprise change management processes, risk assessment is still performed manually, while recurring low-risk change patterns may be pre-authorized or assigned default classifications. This paper presents an automated, quantitative risk assessment framework for software change requests that combines large language model (LLM) evaluations of change artifacts with rule-based operational risk scoring. With this system, risk is divided into two orthogonal dimensions: change risk, which evaluates plaintext change plans, test plans, rollback plans, based on a combination of LLM inference and timing and blast radius heuristics; and asset risk, which uses operational metrics such as code coverage, availability, incident history, and open defects to assess the operational health of the target software asset. These scores are adjusted by configurable multipliers for environment type, asset business criticality, and peak event periods. Deployed within a large financial technology organization and integrated with an ITSM platform, a messaging platform, and operational metrics databases, the framework has evaluated tens of thousands of change requests in production. This paper describes the system architecture, the scoring algorithms, the LLM integration strategy, and discusses design decisions that allow the framework to operate reliably at enterprise scale while remaining interpretable and auditable. devconf-us-2026-3157-a-hybrid-llm-and-rule-based-risk-assessment-framework-for-enterprise-software-change-management Artificial Intelligence and Data Science James Gilmore en false https://pretalx.devconf.info/devconf-us-2026/talk/PVT7YE/ https://pretalx.devconf.info/devconf-us-2026/talk/PVT7YE/feedback/ Ladd Room (Capacity 170) Talk 2026-09-24T16:40:00-04:00 16:40 00:35 Large Language Models are increasingly constrained by inference architecture rather than training. As workloads diversify, traditional monolithic serving stacks struggle with mixed latency targets, long context prompts, GPU memory pressure, and inefficient batching. This talk presents two emerging patterns treating LLM inference as a distributed systems challenge. **Dynamic Prefill Decode (PD)** separates the compute-intensive prefill phase from the memory-bound decode phase, scaling each across specialized GPU pools to improve utilization and reduce tail latency. **Semantic Routing** replaces static load balancing with inference-aware decisions, selecting the right model and infrastructure tier per request. We explore tools like vLLM, Ray Serve, KServe, and TensorRT-LLM. The session includes a live demo showing semantic routing, model selection, latency differences, and cost tradeoffs across multiple models. devconf-us-2026-3069-emerging-llm-serving-architectures-dynamic-pd-disaggregation-semantic-routing Artificial Intelligence and Data Science Ayushi Tiwari en false https://pretalx.devconf.info/devconf-us-2026/talk/EXRZ3P/ https://pretalx.devconf.info/devconf-us-2026/talk/EXRZ3P/feedback/ 106 (Capacity 45) Talk 2026-09-24T10:00:00-04:00 10:00 00:35 Unprecedented breakthroughs in quantum computers and algorithms have shortened estimates of when classical asymmetric encryption will be officially broken (called Q-day) to 2030 or sooner, requiring migration to post-quantum cryptography on a tighter timeline. How legitimate is this threat? And will open source software be ready when Q-day happens? We'll talk facts: busting the myth that Q-day is "always 10 years away" by putting emerging academic research into context and discussing which developments alter threat models (and which do not). High-level information will be deliberately project-agnostic and accessible to laypersons. Then, we conduct a survey of critical open source infrastructure and their PQC readiness, from language libraries to popular Linux Foundation projects, covering topics including confidential computing, observability, AI applications and more. The audience will walk away with suggested action items, prioritized blockers, and opportunities to collaborate. devconf-us-2026-3029-6-100-qubits-and-counting-is-open-source-ready Security and Compliance Arthur Savage en false https://pretalx.devconf.info/devconf-us-2026/talk/TQSLRY/ https://pretalx.devconf.info/devconf-us-2026/talk/TQSLRY/feedback/ 106 (Capacity 45) Talk 2026-09-24T10:40:00-04:00 10:40 00:35 With many build systems now generating SBOMs, SLSA provenance, vulnerability reports, etc, we’ve never had more evidence about what goes into our software. But if there's nothing acting on the evidence gathered, our pipelines can still produce non-compliant artifacts. Collecting evidence is important of course, but looking at the evidence, assessing its correctness, and evaluating compliance with business and security policies for each artifact produced, is what really helps make our build systems more secure, and lets us claim SLSA build levels, and satisfy NIST and EU regulations. In this session, we highlight the gap between generating build metadata, and actually using it to block non-compliant artifacts. We’ll walk through a realistic pipeline scenario where everything looks compliant on paper — valid SBOM, signed provenance, clean scans — and still it shouldn’t be deployed. From there, we introduce a different model: treating policies as active, blocking gates that evaluate each artifact against organizational trust requirements and managed policies. Using Conforma, an open-source Policy-as-Code engine, we will demonstrate how to: * Transform passive evidence (SPDX SBOMs, SLSA provenance) into enforceable decisions * Define and apply policies such as trusted builders, CVE thresholds, and license compliance * Integrate policy evaluation directly into CI/CD pipelines as promotion and deployment gates * Move toward a Zero-Trust model where every artifact must prove itself before advancing You’ll leave with a clear understanding of why having the data isn’t the same as being secure, and how to turn your supply chain metadata into an enforced line of defense. We’ll demonstrate this using a policy-as-code approach with Conforma. devconf-us-2026-3085-closing-the-gap-between-build-evidence-and-compliance-enforcement Security and Compliance Simon BairdCuiping Huo en false https://pretalx.devconf.info/devconf-us-2026/talk/YRCUPB/ https://pretalx.devconf.info/devconf-us-2026/talk/YRCUPB/feedback/ 106 (Capacity 45) Talk 2026-09-24T11:20:00-04:00 11:20 00:35 Confidential Containers bring hardware-backed Trusted Execution Environments (TEE) into the Kubernetes ecosystem, enabling workloads to run with stronger isolation and encrypted memory while preserving cloud-native workflows. As platform teams move toward zero-trust architectures, protecting data in use becomes essential for multi-tenant clusters, AI pipelines, and regulated environments. This talk explores the architecture behind Confidential Containers, including attestation flows, runtime integration, and scheduling considerations in Kubernetes platforms. We will discuss real-world design patterns, trade-offs, and operational impacts when introducing confidential computing into hybrid and multi-cloud environments. Attendees will leave with a practical understanding of how to enhance workload security without breaking existing DevOps practices or developer experience. devconf-us-2026-2970-confidential-containers-the-next-era-of-cloud-data-security Security and Compliance Andrea Bozzoni en false https://pretalx.devconf.info/devconf-us-2026/talk/9W8U7D/ https://pretalx.devconf.info/devconf-us-2026/talk/9W8U7D/feedback/ 106 (Capacity 45) Talk 2026-09-24T13:00:00-04:00 13:00 00:35 LLM-powered agents are rapidly moving from passive assistants to systems that can execute real commands modifying infrastructure, querying systems, and even remediating failures. This introduces a critical risk: how do we safely execute AI-generated actions without exposing the host system to prompt injection, hallucinations, or malicious inputs? This talk presents a production-ready architecture that uses microVM-based sandboxing to isolate LLM tool execution. By leveraging lightweight virtualization such as Firecracker and Kata Containers, each AI-generated command is executed inside an ephemeral, disposable virtual environment, ensuring strong isolation with minimal overhead. We demonstrate how LLM served via vLLM or running locally with llama.cpp can safely interact with system tools through a controlled execution pipeline. The session includes a live demo where prompt injection attempts are neutralized by sandbox policies, proving that AI can act autonomously without compromising security. devconf-us-2026-3214-trust-but-isolate-securing-llm-tool-execution-with-microvm-sandboxing Security and Compliance Rajesh DulhaniDipayan Dutta en false https://pretalx.devconf.info/devconf-us-2026/talk/WMLEHG/ https://pretalx.devconf.info/devconf-us-2026/talk/WMLEHG/feedback/ 106 (Capacity 45) Talk 2026-09-24T13:40:00-04:00 13:40 00:35 Security patches are supposed to reduce risk but in complex systems, they can quietly introduce new ones. It’s not uncommon for a fix to pass CI pipelines, unit tests, and even staging environments, only to trigger subtle failures under real production workloads. These “silent breakages” are especially dangerous: no immediate crashes, no obvious errors just degraded behavior, performance regressions, or incorrect results. In this talk, we explore why traditional validation pipelines fail to catch these issues, particularly in containerized and dependency-heavy environments. Drawing from real-world scenarios, we will examine how changes in low-level components such as system libraries, cryptographic modules, and runtimes can propagate unexpected side effects into higher-level applications. Through a live demonstration, we will apply a security patch that successfully passes CI checks, then observe how it introduces a non-obvious regression in a running service under realistic conditions. We will then walk through a structured debugging approach to identify the root cause and discuss strategies to design more reliable validation pipelines. Attendees will gain practical insights into detecting and preventing silent failures bridging the gap between “it passed CI” and “it actually works in production.” devconf-us-2026-3221-silent-breakages-when-security-fixes-pass-ci-but-fail-in-production Security and Compliance Satish Mane en false https://pretalx.devconf.info/devconf-us-2026/talk/NQVUEE/ https://pretalx.devconf.info/devconf-us-2026/talk/NQVUEE/feedback/ 106 (Capacity 45) Talk 2026-09-24T14:20:00-04:00 14:20 00:35 In March 2026, the LiteLLM package was compromised on PyPI through a hijacked CI/CD pipeline, silently exfiltrating credentials and secrets. Months earlier, fake DeepSeek packages targeted ML engineers with infostealers. Standard Python tooling resolves and builds packages individually with no unified view of the full dependency tree, making it hard to audit what was built, from where, and in what order. Fromager solves this by capturing the entire dependency tree as data. A bootstrap step recursively resolves all dependencies and outputs the full graph and build order as plain JSON artifacts you can review, diff, and version-control before any compilation happens. From that plan, every package is rebuilt from source in the correct order, optionally with network isolation to constrain what build scripts can reach. The result is a fully visible, reproducible supply chain. Fromager builds packages as collections, the full dependency tree is compiled together, so packages linked against each other stay ABI-compatible. This matters for stacks like PyTorch and vLLM where mismatches between CUDA or ROCm binaries cause silent failures. A plugin and override system lets you customize each build stage (download, unpack, patch, build) per package. One upstream recipe can produce builds for different hardware targets while keeping the rest of the configuration shared. We'll cover what we've learned building 1000+ packages for production AI workloads: dependency patterns specific to AI stacks, where source builds break at scale, and why building as collections is necessary for ABI correctness across accelerators. This talk is for engineers who build, deploy, or audit Python environments for production AI workloads, especially those dealing with hardware-specific builds, reproducibility requirements, or supply chain compliance. Attendees will leave with an understanding of how to evaluate their own Python supply chains and the tools to start building from source themselves devconf-us-2026-3074-from-source-to-production-securing-python-ai-stacks-against-supply-chain-attacks Security and Compliance Rohan DevasthaleLalatendu Mohanty en false https://pretalx.devconf.info/devconf-us-2026/talk/KYRBPB/ https://pretalx.devconf.info/devconf-us-2026/talk/KYRBPB/feedback/ 106 (Capacity 45) Talk 2026-09-24T15:20:00-04:00 15:20 00:35 Over the past few years Linux based bootc images such as Bazzite have exploded in the most unlikely of places. Built with bootc and Fedora and with over 80,000 concurrent weekly users, users are now the ones redefining the category and driving the requirements. Gaming handhelds? What does cloud native technology have to do with consumer facing technology? Where are all these gamers coming from, and why are all the cloud people smiling all the time? In this talk I will discuss the initial donation of bootc to the CNCF, it's adoption by a community that didn't exist, and how we got here today. We will discuss the lessons learned by the Universal Blue community over five years of production bootc usage. Then we're going to talk about where you fit in. There will be dinosaurs in this talk. devconf-us-2026-3160-dinosaurs-and-hummingbirds-how-bootc-changes-linux-forever Open Track Jorge Castro en false https://pretalx.devconf.info/devconf-us-2026/talk/NZ9ANN/ https://pretalx.devconf.info/devconf-us-2026/talk/NZ9ANN/feedback/ 106 (Capacity 45) Talk 2026-09-24T16:00:00-04:00 16:00 00:35 Intern Talk TBD devconf-us-2026-3272-intern-1-tbd General en false https://pretalx.devconf.info/devconf-us-2026/talk/3PJSFA/ https://pretalx.devconf.info/devconf-us-2026/talk/3PJSFA/feedback/ 106 (Capacity 45) Talk 2026-09-24T16:40:00-04:00 16:40 00:35 Intern Talk TBD devconf-us-2026-3273-intern-2-tbd General en false https://pretalx.devconf.info/devconf-us-2026/talk/UXTKQ3/ https://pretalx.devconf.info/devconf-us-2026/talk/UXTKQ3/feedback/ 101 (Capacity 48) Talk 2026-09-24T10:00:00-04:00 10:00 00:35 Migrating hundreds of virtual machines from vSphere to OpenShift Virtualization is not just a lift-and-shift exercise -- it demands repeatable, auditable, multi-cluster infrastructure that can be stood up and torn down with confidence. In this talk, we present a reference implementation of a GitOps-driven "migration factory" that provisions bare-metal OpenShift clusters, installs 25+ day-2 operators, and orchestrates VM migrations -- all from a single Git repository. We will walk through how a hub-and-spoke architecture is fully declared in Git and reconciled by ArgoCD using an app-of-apps pattern with sync waves to enforce ordering across operators, instances, and configurations. You will see how Advanced Cluster Management (ACM) provisions spoke clusters via Assisted Installer, how an ACM policy bootstraps GitOps on each new spoke, and how a custom ArgoCD management plugin (CMP) performs environment-variable substitution so that a single set of reusable Kustomize components can target any cluster. Through a live demo, we will stand up the full stack -- from an empty hypervisor to a running hub with two spoke clusters ready to accept migrated VMs -- and show the end-to-end automation pipeline that ties it all together. We will also share the hard lessons learned around sync-wave ordering, secret management across cluster boundaries, bare-metal networking with MetalLB and NMState, and keeping drift-free state across multiple ArgoCD instances. Attendees will walk away with a concrete, open-source blueprint they can fork and adapt to their own virtualization migration efforts, along with patterns for scaling GitOps beyond a single cluster. devconf-us-2026-2717-gitops-at-scale-building-a-virtualization-migration-factory-on-openshift DevOps and Automation Vikas MulajeRaffaele Spazzoli en false https://pretalx.devconf.info/devconf-us-2026/talk/FWNCFB/ https://pretalx.devconf.info/devconf-us-2026/talk/FWNCFB/feedback/ 101 (Capacity 48) Talk 2026-09-24T10:40:00-04:00 10:40 00:35 AI has been fastly integrating into all aspects of the IT industry in the past two years. The reliability and accuracy of AI agents has forced the companies to adpot AI for tasks ranging from writing code, code analysis, vulnerability assemsments and much more. This adoption has spanned from limited advisory role to humans performing the task to a fully-fledged human-replacement approach. This session presents the current "state-of-the-union" of AI agent adoption the cloud realm. It provides real examples on where the adoption has already and is forseen to take place and the associated risks. The session then deep-dives into the technology stacks that allow this adoption to happen covering AI agents, LLM serving and LLM training frameworks in both the commercial and open-source realms. The session ends with a real-life example of deploying an Agentic Cloud Engineer that takes on tasks, executes them and reports the results. devconf-us-2026-2976-the-agent-is-out-for-your-job-a-cloud-engineer-s-guide-to-working-with-the-agent DevOps and Automation Mohamed Elsakhawy en false https://pretalx.devconf.info/devconf-us-2026/talk/LX9ATP/ https://pretalx.devconf.info/devconf-us-2026/talk/LX9ATP/feedback/ 101 (Capacity 48) Talk 2026-09-24T11:20:00-04:00 11:20 00:35 Your alert fires at 3am. An SRE investigates, finds the root cause, applies a known fix, and goes back to sleep. Next week, the same alert fires again. Same investigation. Same fix. Same person woken up. **What if the cluster could do this itself** — investigate the alert, reason about the root cause, select the right remediation, execute it, and produce an audit trail that proves it made the right call? This talk explores the engineering challenges of building closed-loop Kubernetes self-healing with Agents as the reasoning layer. We'll dig into the hard problems: - **Trust boundaries**: How do you let an Agent investigate a production cluster without exposing secrets? How do you scope RBAC so the AI agent can read what it needs and nothing more? - **Auditability**: How do you make "AI decided to scale your HPA" auditable enough for SOC2? What does an immutable, tamper-evident audit trail look like for autonomous remediation? - **Governance**: How do you keep a human in the loop without turning it into another page? When should the AI just fix it, and when should it ask? - **Fleet-scale credentials**: How do you architect ephemeral, zero-trust credentials when the same pipeline needs to remediate across a fleet of clusters using ACM and AAP? ### Live demo We'll trigger a real alert on a Kind cluster and watch the full pipeline execute without human intervention: 1. **Signal** → AlertManager fires 2. **Investigation** → an AI Agent queries the Kubernetes API, reads logs, describes pods, builds a root cause analysis 3. **Decision** → an AI Agent selects the right remediation workflow based on the RCA 4. **Execution** → K8s Jobs/Tekton/Ansible applies the fix 5. **Audit** → Immutable event records what happened and why No slides-only theory. Bring your skepticism. devconf-us-2026-2995-when-your-kubernetes-cluster-fixes-itself-at-3am-and-you-can-prove-it-did-the-right-thing DevOps and Automation Jordi GilRaghuram Banda en false https://pretalx.devconf.info/devconf-us-2026/talk/FQWK8Y/ https://pretalx.devconf.info/devconf-us-2026/talk/FQWK8Y/feedback/ 101 (Capacity 48) Talk 2026-09-24T13:00:00-04:00 13:00 00:35 Your application works. Your users depend on it. But maintaining legacy infrastructure or even running applications on Kubernetes without fully leveraging its capabilities can be a constant source of toil. The sunk cost fallacy often keeps people from investing time and effort into improving architectures. But how do you modernize without disrupting existing users? In this session, we'll walk through a real-world modernization journey: from statically-allocated VM workers to a fully Kubernetes-native architecture without downtime. You'll see how we used queue-based routing as a migration lever, letting us move users one at a time from legacy infrastructure to auto-scaling container pods. You'll learn why we stopped building images inside our workers and instead delegated to platform-native CI/CD pipelines. That one decision eliminated the need for privileged containers entirely. Walk away with a template for modernizing a service into a cloud-native architecture, without rewriting from scratch and asking your users to take a leap of faith. devconf-us-2026-3271-from-vms-to-kubernetes-a-practical-guide-to-modernizing-without-breaking-things DevOps and Automation Yashvardhan Nanavati en false https://pretalx.devconf.info/devconf-us-2026/talk/YZJCKK/ https://pretalx.devconf.info/devconf-us-2026/talk/YZJCKK/feedback/ 101 (Capacity 48) Talk 2026-09-24T13:40:00-04:00 13:40 00:35 Shipping a solution made of several Helm-based products (platform add-ons, operators, integrations) usually means bespoke glue code, fragile ordering, and configs that fall apart between a demo cluster and production. Helmet is a reusable Kubernetes installer framework that treats dependency topology, integration wiring, and configuration as first-class concerns so teams can focus on their charts—not one-off installers. This session introduces Helmet’s core ideas: chart annotations that drive install order and namespace placement, integration secrets coupled to products via declarative rules, embedded installer bundles, and CLI/MCP workflows that stay consistent from first deploy onward. We will walk through how the same artifact and patterns support a quick demo, a PoC on a shared cluster, and a production rollout—where the main differences are configuration depth and operational gates, not a rewrite of your installer. You will leave with a mental model of when Helmet fits, how multi-product composition works in practice, and what to plan for as you harden from demo to production (validation, topology inspection, integration lifecycle). Audience / level: Platform engineers, Kubernetes admins, and teams shipping internal platforms or ISV-style installers; intermediate Kubernetes + Helm familiarity assumed. Takeaways: - How Helmet resolves deployment order and integration dependencies from chart metadata. - How one installer can evolve from demo → PoC → production through config and process, not new code each time. - Where extensions (integrations, templating, automation/MCP) fit in the lifecycle. - How you can end up with a production ready gitops repo for day two operation. devconf-us-2026-3229-helmet-composing-multi-product-kubernetes-installers-without-losing-your-mind DevOps and Automation David PerazaRomain Arnaud en false https://pretalx.devconf.info/devconf-us-2026/talk/3DBTDH/ https://pretalx.devconf.info/devconf-us-2026/talk/3DBTDH/feedback/ 101 (Capacity 48) Talk 2026-09-24T14:20:00-04:00 14:20 00:35 Kernel validation on real hardware is still a highly **manual and iterative process**. Engineers must repeatedly select system images, provision hardware boards, flash devices, configure test environments, and execute tests to reproduce issues and validate fixes. In this talk, I present an ongoing effort to **automate this validation loop using AI agents**. Instead of automating isolated steps, we treat kernel validation as a **continuous feedback system** and design agents to orchestrate the entire workflow. We will cover: - **Decomposing the kernel validation loop** into automatable stages - Designing **agent-driven workflows** for image selection, hardware provisioning, flashing, and test execution - Integrating with existing tools such as **tmt and hardware lab infrastructure** - Supporting **iterative debugging workflows** for reproducing issues and validating fixes - Lessons learned from applying this approach in **ARM-based kernel validation environments** This talk focuses on real-world engineering challenges, including **hardware constraints**, **non-deterministic failures**, and **flaky tests**. It demonstrates how AI can coordinate complex workflows while keeping **humans in the loop for critical decisions**. devconf-us-2026-3206-closing-the-loop-using-ai-agents-to-automate-kernel-validation-on-real-hardware DevOps and Automation Charles Shi en false https://pretalx.devconf.info/devconf-us-2026/talk/UQYVAJ/ https://pretalx.devconf.info/devconf-us-2026/talk/UQYVAJ/feedback/ 101 (Capacity 48) Talk 2026-09-24T15:20:00-04:00 15:20 00:35 GitOps has become the golden standard for cloud native deployments. Tools like Argo CD allow for this pattern to be followed in Kubernetes clusters. Scaling your GitOps deployments across multiple clusters using Argo CD can introduce significant challenges in security, network connectivity, and control plane performance. Should you go with multi-instance? What about cluster sharding? This session will introduce the challenges of scaling your Argo CD deployments across multiple clusters and introduce Argo CD Agent, a project which flips the script on multi-cluster Argo CD set ups by having workload clusters report back to the control plane, enabling a “pull model” instead of the traditional “push model.” This set up enables multiple benefits not present in the other multi-cluster strategies. A live demonstration will be provided to showcase it in action. devconf-us-2026-2980-argo-cd-agent-redefining-multi-cluster-gitops DevOps and Automation Christopher Coco en false https://pretalx.devconf.info/devconf-us-2026/talk/3TWRJS/ https://pretalx.devconf.info/devconf-us-2026/talk/3TWRJS/feedback/ 101 (Capacity 48) Talk 2026-09-24T16:00:00-04:00 16:00 00:35 Financial institutions are under constant pressure to increase delivery speed while proving that controls remain intact. This talk demonstrates how DevOps automation can turn compliance from a last-minute review exercise into a continuously enforced engineering capability. We will explore practical patterns for policy-as-code, environment validation, evidence collection, change traceability, automated recovery workflows, and operational drift detection. The goal is not to automate for automation’s sake, but to build systems where every change can be explained, tested, approved, and recovered with confidence. Special attention will be given to banking use cases such as fraud platform updates, critical API releases, and controlled infrastructure changes in open source environments. By the end, attendees will see how automation becomes the connective tissue between engineering, audit, risk, and operations. devconf-us-2026-3118-compliance-as-code-for-finance-automating-controls-audit-trails-and-recovery DevOps and Automation Francisco Zompa en false https://pretalx.devconf.info/devconf-us-2026/talk/ZW3VDG/ https://pretalx.devconf.info/devconf-us-2026/talk/ZW3VDG/feedback/ 101 (Capacity 48) Talk 2026-09-24T16:40:00-04:00 16:40 00:35 In the world of GitOps, a successful sync doesn't always mean a healthy application. Standard static analysis tools like kube-linter or kubeconform are excellent at catching syntax errors, but they often produce fragmented, noisy data that leaves developers guessing at the "why" and "how to fix". This session introduces LLM-powered skills. Skills provide focused context and real-time retrieval without external dependencies, making them ideal for secure, offline infrastructure environments. Using a Manifest-Validator plugin, we demonstrate how to equip ArgoCD with specialized, modular abilities that go beyond simple text generation. We will deep-dive into: 1) The Sidecar Architecture: How we consolidated linter outputs and model configurations into app-specific ConfigMaps to create a self-contained validation engine 2) Actionable Remediation: How the generated diagnostic reports can help provide developers with root cause analysis 3) The Live Audit: How the AI skills inspects live cluster resources to suggest security hardening and cost optimization opportunities based on production best practices Attendees will leave with a blueprint for building agentic DevOps tools that don't just find problems, but possess the specialized expertise to solve them. devconf-us-2026-3002-infusing-gitops-pipelines-with-llm-powered-manifest-intelligence DevOps and Automation Hema VeeradhiRichard Mitchell en false https://pretalx.devconf.info/devconf-us-2026/talk/XBSLDF/ https://pretalx.devconf.info/devconf-us-2026/talk/XBSLDF/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T10:00:00-04:00 10:00 00:15 Every agent framework ships its own UI. Every team builds their own chat interface, tightly coupled to whatever backend they chose. AG-UI is an open protocol that breaks that lock-in, a standard event stream that lets any agent backend plug into any compatible frontend. Swap your backend without touching your UI. This talk walks through what AG-UI is, why it matters for anyone building agentic applications, and what I learned building and merging the Claude Agent SDK integration into the protocol, including the tricky bits around session persistence, stateful tool handling, and human in the loop. devconf-us-2026-3101-pluggable-agents-introducing-the-ag-ui-protocol Application and Services Development Gage Krumbach en false https://pretalx.devconf.info/devconf-us-2026/talk/ZEDQQE/ https://pretalx.devconf.info/devconf-us-2026/talk/ZEDQQE/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T10:20:00-04:00 10:20 00:15 The **Backend-for-Frontend (BFF)** pattern is often introduced as a way to simplify systems, offering cleaner APIs, faster frontend development, and improved separation of concerns. On the surface, it works well. But in real-world systems, BFFs rarely remain simple for long. Over time, they begin to absorb business logic, replicate backend complexity, and grow increasingly dependent on multiple downstream services. What starts as a lightweight orchestration layer gradually shifts into a critical dependency that is harder to evolve than it was meant to be. In this talk, we’ll examine how BFFs unintentionally evolve into “mini-monoliths” through a series of small, pragmatic decisions, handling edge cases, bridging backend gaps, and centralizing logic for convenience. Drawing from real-world scenarios, we’ll explore the subtle tipping points where architectural boundaries begin to blur, and why these issues often remain invisible until they start impacting scalability, maintainability, and team velocity. devconf-us-2026-3218-the-backend-for-frontend-pattern-when-it-breaks-down Application and Services Development Khushi Kothari en false https://pretalx.devconf.info/devconf-us-2026/talk/FDLPDY/ https://pretalx.devconf.info/devconf-us-2026/talk/FDLPDY/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T10:40:00-04:00 10:40 00:15 While transforming a big idea into actual code can feel daunting for emerging developers, adopting a professional application development approach helps turn those ideas into realistic, achievable steps. By using Agentic AI as a partner, students can mirror the way professional teams work—ensuring their planning is practical and organized rather than just a "to-do" list. In this lightning talk, we will explore how to use AI to turn project visions into structured Jira backlogs with clear tasks and milestones. I’ll demonstrate how integrating AI into your project board creates a "proactive feedback loop" for application monitoring, helping you catch scope creep in real-time and move from "just code" to a finished, professional product. devconf-us-2026-3038-from-idea-to-industry-bridging-the-gap-to-professional-application-delivery-with-agentic-ai Application and Services Development Sruthi Duvvuri en false https://pretalx.devconf.info/devconf-us-2026/talk/NRW9P3/ https://pretalx.devconf.info/devconf-us-2026/talk/NRW9P3/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T11:00:00-04:00 11:00 00:15 Too many banking platforms still operate like internal service desks: slow, opaque, and overloaded with manual approvals. This fast talk challenges that model and argues for a better cloud native experience built around self-service, policy guardrails, and product thinking. In 15 minutes, we will reframe platform teams as builders of internal financial infrastructure products, not owners of endless operational tickets. The examples will show how standardized delivery workflows, golden templates, and observable deployment patterns reduce lead time, cut audit pain, and improve engineering trust across lines of business. The message is simple: if the safest path is also the easiest path, teams will use it. devconf-us-2026-3105-your-platform-team-is-not-a-ticket-queue Application and Services Development Francisco Zompa en false https://pretalx.devconf.info/devconf-us-2026/talk/CNLH37/ https://pretalx.devconf.info/devconf-us-2026/talk/CNLH37/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T11:20:00-04:00 11:20 00:15 A feature can work perfectly...until it stops scaling under real-world demands. In this talk, I’ll share a production experience where a real-time Android feature started to break when new requirements were introduced. What initially looked like a stable implementation quickly became tightly coupled, fragile, and difficult to extend safely. Instead of continuing to patch the existing system, we stepped back and re-architected it: isolating the feature into a dedicated module, redefining responsibilities, and introducing a more scalable structure before building further on top of it. You’ll learn how to: - recognize early signals that a system is reaching its scalability limits - approach large-scale refactoring in a way that minimizes delivery disruption - balance short-term velocity with long-term maintainability This session is aimed at engineers working with evolving production systems who want practical strategies for managing complexity and making better architectural decisions as systems grow. devconf-us-2026-3046-when-features-stop-scaling-refactoring-real-time-systems-for-growth Application and Services Development Tetiana Synytsyna en false https://pretalx.devconf.info/devconf-us-2026/talk/979CNB/ https://pretalx.devconf.info/devconf-us-2026/talk/979CNB/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T11:40:00-04:00 11:40 00:15 As consumer BCI devices move from research labs into everyday products, designers face a new and largely unexplored challenge: what happens to a user's sense of control when an interface changes based on their brain signals, without them asking it to? This talk introduces a working research paper examining user agency and perceived control in passively adaptive BCI systems. Drawing on a Wizard-of-Oz study design and mixed-methods methodology, the research identifies four experiential themes, surveillance discomfort, misattribution of cause, adaptive trust collapse, and emergent co-agency, and proposes a preliminary neural transparency design framework with four actionable principles for designers building BCI-integrated interfaces. The talk aims to open a conversation about what responsible, legible design looks like when the system reads your mind. devconf-us-2026-2955-when-the-interface-reads-your-mind-user-agency-and-control-in-passively-adaptive-brain-computer-interfaces Open Track Yuti Vora en false https://pretalx.devconf.info/devconf-us-2026/talk/PKRQ7G/ https://pretalx.devconf.info/devconf-us-2026/talk/PKRQ7G/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T13:00:00-04:00 13:00 00:15 For edge devices with limited bandwidth or spotty connectivity, the size of container image updates is a critical issue. This is where tar-diff comes in. In just two key steps, it permits the user to seamlessly update their container image within a fraction of the time and with significantly less system overhead. This lightning talk focuses on the intersection of that technology and the personal experience of how I, an an intern with minimal industry experience, took a 6-year-old project and fine-tuned it for Fedora and RHEL distributions. I'll be talking about bridging the gap between existing logic and modern container standards, including what it’s like to take ownership of a tool that will be a key feature in bootable container images. devconf-us-2026-3080-optimizing-container-image-updates-modernizing-tar-diff-from-an-intern-s-perspective Open Track Rosy-Glorious Miki en false https://pretalx.devconf.info/devconf-us-2026/talk/9PU3PN/ https://pretalx.devconf.info/devconf-us-2026/talk/9PU3PN/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T13:20:00-04:00 13:20 00:15 Let’s face it, a degree isn’t enough anymore to secure a job. In today’s current job market, career readiness hinges on what you’ve done outside the classroom. University Co-Op Programs, Internships, and taking part in an Early Access Mentoring program are some factors that can propel you forward and give you a real advantage. You might be wondering what this looks like in practice? Luckily, you’re in the right place. This talk breaks down what that actually looks like. I’ll walk through my experience at Red Hat as a CO-OP, the challenges I faced, what I learned and how mentorship played a huge role – not just from my experience as a mentee, but also from my mentor’s experience as well. When you leave, you should have a better understanding of the experience opportunities that can help you in your career. devconf-us-2026-3203-real-world-ready-why-co-ops-internships-and-mentors-aren-t-just-extras-they-re-essential Open Track Amy MarrichHoang Truc Kim en false https://pretalx.devconf.info/devconf-us-2026/talk/NXQMSJ/ https://pretalx.devconf.info/devconf-us-2026/talk/NXQMSJ/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T13:40:00-04:00 13:40 00:15 NetworkManager has become the de facto standard for network management across many Linux distributions, known for its reliability and broad feature set. Originally designed with the desktop user experience in mind, it introduced “connection profiles” as a convenient abstraction for managing Wi-Fi and VPN connections. Over time, NetworkManager expanded to support server and edge use cases. However, this evolution introduces friction for system administrators: behaviors like automatic connection activation can be surprising, and managing multiple connection profiles for a single device can feel unintuitive. Join us for this talk as we explore how we’re designing network management solutions from the ground up to better serve a wide range of environments—including Kubernetes and containerized systems. We’ll walk through our design approach and conclude with a short demo of our project. devconf-us-2026-2990-rethinking-linux-network-management-from-connection-profiles-to-cloud-native Open Track Rahul Rajesh en false https://pretalx.devconf.info/devconf-us-2026/talk/H3YU3Q/ https://pretalx.devconf.info/devconf-us-2026/talk/H3YU3Q/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T14:00:00-04:00 14:00 00:15 Let’s be honest: most engineers view Scrum as a collection of pointless meetings that get in the way of actual work. If you’ve been told you have to do it, or if your team is struggling to manage a backlog without a dedicated Scrum Master, it usually feels like more overhead than it’s worth. During this lightning talk, I’ll share my experience as a Scrum Master of how the RHEL Core Services teams survived our first year of Scrum adoption while navigating the sudden rise of AI. I’ll talk about why finishing what you started matters way more than having perfect charts and why real collaboration is better than sitting through every meeting just because "the Scrum Master says so." I’ll also show you which AI tools we leverage to automate the boring administrative stuff, fix our estimations, and keep the backlog from becoming a graveyard. devconf-us-2026-3095-surviving-scrum-a-guide-for-people-who-have-to-do-it-anyway Open Track Lenka Kulajtova en false https://pretalx.devconf.info/devconf-us-2026/talk/XSFXMK/ https://pretalx.devconf.info/devconf-us-2026/talk/XSFXMK/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T14:20:00-04:00 14:20 00:15 As we enter a post-LLM world, we face a critical trade-off: the immediate Efficiency of AI versus the long-term cultivation of human Expertise. While LLMs can execute hours of human labor in minutes, the "expertise" an AI builds is fleeting, as it persists only as long as its context window. In contrast, human labor produces a trove of expertise: insights, foresight, and contextual understanding that span a career. When we offload cognition to AI, we risk losing the very ingenuity required to innovate beyond the training data. While LLMs are a powerful tool, their use carries risks and trade-offs that must be managed. In this talk, we identify three key elements for balancing this trade-off: * Intention: Choosing when and how to use AI by understanding the cost of personal expertise loss. * Innovation: Combating LLM-induced stagnation caused by a data-driven regression to the mean. * Integrity: Maintaining honesty and trust when claiming ownership of AI-generated work. Drawing on academic research and real-world industry examples we highlight that while LLMs can mimic the results of expertise, they struggle to replicate the meta-cognition and abstraction required to solve the problems of tomorrow without expert help. devconf-us-2026-3091-don-t-outsource-your-brain Open Track Aseef ImranSana Sharma en false https://pretalx.devconf.info/devconf-us-2026/talk/HMDMBR/ https://pretalx.devconf.info/devconf-us-2026/talk/HMDMBR/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T14:40:00-04:00 14:40 00:15 You don’t jump ~1,197 spots on the PyTorch contributor leaderboard by accident. It was our PyTorch Engineering Team that did the high-speed driving—writing, refining, and getting their code merged to make this massive leap possible. This talk pulls back the curtain on how the team evolved their day-to-day practices to scale our open-source footprint. I’ll share how our developers streamlined community contributions, removed friction for external collaborators, and adapted their internal Agile workflows to match the breakneck speed of the broader PyTorch ecosystem. If you want to amplify your own organization’s open-source impact, come see how a async-first workflow transformed from a process requirement into a massive competitive advantage. devconf-us-2026-2965-the-climb-nobody-expected-from-1200-to-3-rank-on-the-pytorch-leaderboard Open Track Saiesh Prabhu en false https://pretalx.devconf.info/devconf-us-2026/talk/TUQZQJ/ https://pretalx.devconf.info/devconf-us-2026/talk/TUQZQJ/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T15:20:00-04:00 15:20 00:15 Digital transformation has become an important focus for organizations seeking to modernize systems, improve operational efficiency, and adapt to changing technological demands. This session examines practical approaches used in enterprise environments to modernize technology ecosystems through cloud adoption, scalable architectures, data-driven decision making, and enterprise automation. The objective of this session is to provide a clearer understanding of how transformation initiatives are structured and implemented in complex organizational settings. It will explore common challenges such as legacy systems, coordination across distributed teams, governance processes, and the integration of modern technologies into existing infrastructures. Attendees will gain insights into key components of enterprise transformation, including architectural modernization, automation strategies, and the role of data in guiding decision making. The session aims to help participants better understand the technical and organizational considerations involved in large-scale modernization efforts and how these factors influence long-term technology strategy and implementation. devconf-us-2026-2942-powering-enterprise-transformation-with-ai-cloud-and-modern-platforms Cloud, Hybrid Cloud, and Hyperscale Infrastructure Sridhar Rangu en false https://pretalx.devconf.info/devconf-us-2026/talk/Y3JACD/ https://pretalx.devconf.info/devconf-us-2026/talk/Y3JACD/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T15:40:00-04:00 15:40 00:15 Hosted Control Planes (HCP) enable efficient multi-tenant Kubernetes deployments, but managing storage within each HCP cluster can be resource-intensive and operationally complex. This talk demonstrates a practical pattern: deploying the Ceph CSI Operator on lightweight HCP clusters to consume storage from a centralized Rook-managed Ceph cluster running on dedicated HCI (Hyperconverged Infrastructure) nodes. We'll show: - Why separating storage and compute makes sense for HCP architectures - Quick overview of Ceph CSI Operator vs full Rook deployment - Setting up Ceph CSI Operator on an HCP cluster - Connecting to external Rook-managed Ceph storage on HCI - Live demo: Provisioning PVCs on HCP using remote Ceph storage - Benefits: reduced resource overhead, centralized storage management, simplified operations Perfect for platform engineers exploring efficient storage patterns for multi-tenant HCP environments. Attendees will learn a practical, production-ready approach to providing persistent storage to HCP clusters without the overhead of running full storage infrastructure in each cluster. devconf-us-2026-3200-smart-storage-for-hosted-control-planes-connecting-to-hyperconverged-infrastructure-with-ceph-csi-operator Cloud, Hybrid Cloud, and Hyperscale Infrastructure Nikhil LadhaRewant Soni en false https://pretalx.devconf.info/devconf-us-2026/talk/UBDVLN/ https://pretalx.devconf.info/devconf-us-2026/talk/UBDVLN/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T16:00:00-04:00 16:00 00:15 Disaster recovery and data replication are critical for production Kubernetes workloads, yet implementing them for persistent storage remains challenging. This lightning talk demonstrates how RADOS namespace mirroring in Ceph RBD, orchestrated through Rook, enables seamless cross-namespace and cross-cluster block storage replication. We'll explore: - Quick overview of RBD mirroring architecture and RADOS namespaces - Setting up namespace-based mirroring pools in Rook-managed Ceph clusters - Configuring cross-namespace mirroring for multi-tenant isolation - Demo: Automated failover scenarios and recovery workflows - Performance considerations and best practices for production deployments Attendees will leave with practical knowledge to implement robust disaster recovery strategies for their stateful Kubernetes applications, leveraging Rook's declarative approach to manage complex Ceph mirroring topologies. Perfect for platform engineers and SREs managing critical data workloads. devconf-us-2026-3000-a-smarter-approach-to-disaster-recovery-mirroring-across-namespaces-with-ceph-and-rook Cloud, Hybrid Cloud, and Hyperscale Infrastructure Nikhil LadhaRewant Soni en false Ceph - Open Source Distributed Storage System Ceph Rados - Object Storage Utility Rook - Storage Orchestration for Kubernetes https://pretalx.devconf.info/devconf-us-2026/talk/TKLVGN/ https://pretalx.devconf.info/devconf-us-2026/talk/TKLVGN/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T16:20:00-04:00 16:20 00:15 Internal Developer Platforms aim to create golden paths, reduce cognitive load, and standardize how teams build and operate software. But there’s a blind spot: documentation. READMEs, onboarding guides, and operational runbooks are often treated as static artifacts. Over time they drift from reality — even as the platform itself evolves. The result is slower onboarding, brittle self-service workflows, and increased support burden on platform teams. In this talk, I’ll explore documentation as an unverified surface within Internal Developer Platforms — and introduce a practical approach to making it executable. By treating markdown instructions and runbooks as workflows that can be executed and validated inside CI or ephemeral environments, platform teams can detect drift automatically. Setup steps, service bootstrapping commands, and health checks become verifiable contracts rather than informal guidance. We’ll cover: • Why documentation drift increases cognitive load and support tickets • How to integrate executable documentation into platform pipelines • How this approach strengthens golden paths and reduces onboarding time • What changes in platform team workflows when documentation becomes testable Internal platforms shouldn’t just provide paved roads — they should guarantee that the map is accurate devconf-us-2026-2947-your-outdated-docs-are-costly-why-you-should-be-writing-tests-for-your-docs DevOps and Automation Omari Gaskins Jr en false https://pretalx.devconf.info/devconf-us-2026/talk/NBJQGQ/ https://pretalx.devconf.info/devconf-us-2026/talk/NBJQGQ/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T16:40:00-04:00 16:40 00:15 The decade-old DevOps workflow—defined by dashboard-watching, ticketing, and developer context-switching—is a fatal flaw that results in unacceptable Mean Time to Resolution (MTTR). This system cannot cope with the scale and velocity of AI-generated code. This talk introduces the True Shift Left: a necessary disruption that collapses the feedback loop by embedding live production telemetry and AI-driven fixes directly into the developer's IDE. By moving observation and immediate remediation left, we eliminate siloed insights, enable self-healing code, and free DevOps engineers to architect fully automated systems devconf-us-2026-3227-devops-is-dead-long-live-devops DevOps and Automation Russ Whitman en false https://pretalx.devconf.info/devconf-us-2026/talk/EYHGQ3/ https://pretalx.devconf.info/devconf-us-2026/talk/EYHGQ3/feedback/ Hewitt Boardroom (Capacity 35) Lightning talk 2026-09-24T17:00:00-04:00 17:00 00:15 As quantum computing matures, the vulnerability of current cryptographic standards poses a systemic risk to global digital infrastructure. Q-FENCE, a transformative initiative funded by the Horizon Europe Research Programme, addresses this by developing a robust hybrid framework that integrates classical, quantum, and post-quantum cryptographic (PQC) techniques. By establishing a dual-layer security model, Q-FENCE ensures digital sovereignty and data protection across critical sectors, including finance, healthcare, and satellite networks. In this session, we will provide a high-level overview of the Q-FENCE project and the strategic roadmap required to bring quantum-resistant solutions to real-world applications. We will explore the critical role of innovation management and quality oversight in bridging the gap between theoretical cryptographic primitives and scalable, compliant deployments. Furthermore, we will discuss how the project navigates the transition from research to production-ready environments. Key highlights include: The Q-FENCE Roadmap: Managing KPIs and stakeholder feedback to refine a framework that supports secure multi-party computation (MPC) and Quantum Key Distribution (QKD). Compliance & Resilience: Aligning PQC protocols with industry regulations such as GDPR and HIPAA to ensure "compliance-by-design." Ecosystem Integration: Best practices for software resilience in open-source environments, including the development of PQC-enhanced boot processes within the CentOS Stream ecosystem. Scaling for the Future: Exploring SaaS models and replication strategies for the phased adoption of quantum-ready security in diverse digital infrastructures. This talk is of particular interest to security architects, infrastructure leads, and innovation managers tasked with future-proofing sensitive data against the emerging quantum threat. devconf-us-2026-3067-q-fence-a-hybrid-framework-for-quantum-resistant-digital-infrastructure Security and Compliance Paul Power en false https://pretalx.devconf.info/devconf-us-2026/talk/FMSXVD/ https://pretalx.devconf.info/devconf-us-2026/talk/FMSXVD/feedback/ 107 (Capacity 20) Workshop 2026-09-24T10:00:00-04:00 10:00 01:20 When an AI agent goes wrong, it doesn’t fail in one log line. It fails across a chain: model decisions, retrieval, retries, and tool calls that jump between services. The painful part isn’t the bug, it’s the visibility. What happened for this specific user request? Where did the time go? Which step actually broke? This session is a practical guide to end-to-end tracing for AI agents using OpenTelemetry and MLflow Tracing. You’ll see how to carry one trace context from the user request through the agent, orchestrator, and tool servers, so every model step and tool invocation appears in a single, navigable timeline. We’ll use that trace to pinpoint latency spikes, identify the failing tool or prompt path, and explain agent behavior with agent-native signals: time to first action, step latency, retries, success rate, and token and tool cost. devconf-us-2026-3098-operating-ai-agents-in-production-end-to-end-tracing-with-opentelemetry-and-mlflow Artificial Intelligence and Data Science Roberto Carratalá en false https://pretalx.devconf.info/devconf-us-2026/talk/XYAATW/ https://pretalx.devconf.info/devconf-us-2026/talk/XYAATW/feedback/ 107 (Capacity 20) Workshop 2026-09-24T13:00:00-04:00 13:00 01:20 Modern distributed architectures are built from diverse components, yielding potentially complex interactions and dependencies. Validated Patterns enhance typical reference architectures or established use cases with automation and rigorous validation. While reference architectures provide a conceptual framework for building a given solution, Validated Patterns offer a deployable software artifact that automates and optimizes the framework, ensuring consistent, repeatable, extensible, and efficient deployments. The Red Hat Validated Patterns Program is an open source project providing repositories of Validated Patterns for use by the greater community. Since patterns are open source, anyone can easily use, fork, modify and contribute to patterns. In this workshop participants will be immersed in foundational knowledge for creating, using and extending a GitOps pattern with the Validated Patterns framework. In this workshop participants will: - Learn GitOps fundamentals - Deploy a Validated Pattern - Extend an existing Validated Pattern With many patterns available to choose from, including both vertical and horizontal use cases spanning hybrid and multicloud, Artificial Intelligence, Modern Virtualization, Automation, and Digital Sovereignty, participants be poised to use existing patterns, and learn how to fork and modify patterns for their own use. devconf-us-2026-3158-codify-distributed-architectures-build-maintain-deploy-with-validated-patterns Cloud, Hybrid Cloud, and Hyperscale Infrastructure Michael St-JeanDrew Minnear en false https://pretalx.devconf.info/devconf-us-2026/talk/QLNAJD/ https://pretalx.devconf.info/devconf-us-2026/talk/QLNAJD/feedback/ 107 (Capacity 20) Workshop 2026-09-24T15:20:00-04:00 15:20 01:20 Device Mapper is the invisible engine under your LVM volumes, your dm-crypt containers, your thin pools, and your multipath setup. You quite likely use it every day. But do you know it? This is the one where we open the bonnet: we'll cover dmsetup power moves — the low-level commands that let you inspect, manipulate, and sometimes terrify your storage stack in ways the higher-level tools don't expose. We'll dive into dmstats, the criminally underused performance measurement framework that lets you track I/O at per-region, per-object granularity and actually answer the question "where is my storage bottleneck?" And we'll look at dmpy, a Python automation library that lets you drive all of this programmatically without shelling out to dmsetup like it's 2003. The workshop will provide practical, useful, hands-on exercises that users can try out right away using provided VM images/KS files. No prerequisites beyond basic system admin skills. devconf-us-2026-3051-everything-you-always-wanted-to-know-about-device-mapper-but-were-afraid-to-ask Open Track Neal Gompabmr.southpaw en false https://pretalx.devconf.info/devconf-us-2026/talk/EWG9CL/ https://pretalx.devconf.info/devconf-us-2026/talk/EWG9CL/feedback/ Brookline Room (Capacity 18) Meetup 2026-09-24T10:30:00-04:00 10:30 01:20 BoF to discuss all things containers. devconf-us-2026-3270-containers-bof Cloud, Hybrid Cloud, and Hyperscale Infrastructure Matthew Heon en false https://pretalx.devconf.info/devconf-us-2026/talk/MA9T9E/ https://pretalx.devconf.info/devconf-us-2026/talk/MA9T9E/feedback/ Brookline Room (Capacity 18) Talk 2026-09-24T14:00:00-04:00 14:00 02:30 Join the Parasol Insurance Corporation as we use automation to save time and money so the company can focus on innovation in the insurance industry and  reduce security risks on AWS in their Red Hat Enterprise Linux (RHEL) environment used for managing their critical infrastructure. devconf-us-2026-3275-game-day-aws-and-red-hat-enterprise-linux-automation-quest-day-1 Open Track Eyal Gutkind en false https://pretalx.devconf.info/devconf-us-2026/talk/7YPVRU/ https://pretalx.devconf.info/devconf-us-2026/talk/7YPVRU/feedback/ Show Floor Booth 2026-09-24T09:00:00-04:00 09:00 08:00 Meet and network with the following communities on the show floor! - Foreman, Katello, and Pulp Community Booth - Fedora & CentOS: RHEL Upstreams Ecosystem - OpenSUSE - UXD devconf-us-2026-3265-booths-day-1 General en false https://pretalx.devconf.info/devconf-us-2026/talk/EC7JFA/ https://pretalx.devconf.info/devconf-us-2026/talk/EC7JFA/feedback/ Offsite Location Meetup 2026-09-24T18:00:00-04:00 18:00 03:00 Details TBD devconf-us-2026-3267-conference-party General en false https://pretalx.devconf.info/devconf-us-2026/talk/DCHSRP/ https://pretalx.devconf.info/devconf-us-2026/talk/DCHSRP/feedback/ Ladd Room (Capacity 170) Lightning talk 2026-09-25T09:00:00-04:00 09:00 00:15 AI workloads are exposing the limits of traditional scheduling assumptions in Kubernetes. When GPUs and other specialized accelerators enter the picture, platform design becomes far more complex. This session explains how Kubernetes must evolve to support accelerated computing at scale, with a focus on GPU allocation, Dynamic Resource Allocation (DRA), scheduling behavior, quota design, and capacity planning. The talk connects these technical mechanisms to the broader goal of building reliable and efficient AI platforms. Attendees will understand the operational implications of running accelerated workloads, the common pitfalls teams encounter, and the architectural patterns that can help improve fairness, utilization, and performance. devconf-us-2026-3239-gpus-dra-and-smarter-scheduling-for-ai-preparing-kubernetes-for-accelerated-workloads Artificial Intelligence and Data Science Heber Romero TellezIsmael Flores en false https://pretalx.devconf.info/devconf-us-2026/talk/7CCPUA/ https://pretalx.devconf.info/devconf-us-2026/talk/7CCPUA/feedback/ Ladd Room (Capacity 170) Lightning talk 2026-09-25T09:20:00-04:00 09:20 00:15 As organizations adopt Large Language Models in production systems, a critical gap is emerging: model trust and supply chain security. Unlike container ecosystems, where image signing, scanning, and provenance are well-established practices, LLM artifacts are often downloaded, shared, and deployed with minimal verification. This creates a blind spot in modern AI infrastructure where untrusted or tampered models can be introduced into production environments. In this talk, we explore how cloud-native security practices can be extended to AI workloads using tools like Sigstore and Clair. We will cover: - Signing and verifying LLM artifacts to ensure provenance and integrity - Scanning model containers for vulnerabilities and unsafe dependencies - Building a trusted supply chain for AI artifacts - Integrating model verification into CI/CD and deployment pipelines Through practical examples and workflows, this session demonstrates how teams can apply existing container security principles to AI systems without introducing entirely new infrastructure. The goal is to make LLM deployment as trustworthy as container deployment already is today. devconf-us-2026-3190-unsigned-models-are-the-new-curl-bash-securing-the-llm-supply-chain Artificial Intelligence and Data Science Shubhra Jayant DeshpandeHarish en false https://pretalx.devconf.info/devconf-us-2026/talk/MMPEZG/ https://pretalx.devconf.info/devconf-us-2026/talk/MMPEZG/feedback/ Ladd Room (Capacity 170) Lightning talk 2026-09-25T09:40:00-04:00 09:40 00:15 Most skin cancer AI models are trained on perfect, high-resolution images taken by dermatologists in a clinic. But in the real world, people just take pictures of their skin with their phones, which are often blurry, poorly lit, or off-centered. This lightning talk is about building an AI screening tool that actually works with the messy photos regular people take. I will be talking about using the new SLICE-3D dataset (from the ISIC 2024 Grand Challenge) to train a machine learning model that classifies skin lesions. I'll cover my process for tackling the gap between clinical data and smartphone images, including exploring lightweight models like CNNs with transfer learning and quantized Vision Transformers, and discussing the trade-offs between cloud deployment and keeping it as a local, privacy-first tool. Finally, I will show a quick live demo of an easy-to-use web interface for the model. The goal isn't to replace doctors, but to create a fast, unintimidating pre-screening app that can look at a phone picture and tell a user, "Hey, this looks irregular, you should probably go see a dermatologist." devconf-us-2026-3199-real-world-skin-disease-prediction-bridging-the-gap-from-clinical-data-to-smartphone-screens Artificial Intelligence and Data Science Sun Cho en false Github Repo Article describing the slice-3d dataset https://pretalx.devconf.info/devconf-us-2026/talk/P7GAD7/ https://pretalx.devconf.info/devconf-us-2026/talk/P7GAD7/feedback/ Ladd Room (Capacity 170) Lightning talk 2026-09-25T10:00:00-04:00 10:00 00:15 Writing high-performance GPU kernels should be a tight developer loop: edit, run, measure, repeat. In Helion, a Python DSL that lowers to Triton, that loop is often dominated by autotuning. Full random search could find excellent kernels, but it often took 10 to 20 minutes per compile. A strategy that starts from a default kernel configuration finished in seconds, but produced kernels 14-31% slower. Worse, the autotune cache was tied too closely to source identity: rename a variable, move code around, or change a comment, and prior tuning work could be lost. This talk presents `FROM_BEST_AVAILABLE`, a warm-start strategy I contributed to Helion - now the default for quick autotuning - that seeds search from configurations previously tuned for the same input characteristics and device, even when the kernel source has changed. Instead of forcing developers to choose between “slow but good” and “fast but worse,” it reuses prior tuning work to start from a promising neighborhood while still allowing the autotuner to search. This reduced MatMul autotuning time from 1238 seconds to 92 seconds while matching full-search quality across the seven kernels we benchmarked. I’ll cover how the loose-match key was designed, the trade-offs behind it, and concrete examples of how this approach can improve developer iteration without sacrificing kernel quality. devconf-us-2026-3171-warm-starts-over-fresh-runs-cutting-gpu-kernel-autotuning-from-20-minutes-to-90-seconds-in-helion Artificial Intelligence and Data Science Alessandro Sangiorgi en false https://pretalx.devconf.info/devconf-us-2026/talk/JCUVCP/ https://pretalx.devconf.info/devconf-us-2026/talk/JCUVCP/feedback/ Ladd Room (Capacity 170) Lightning talk 2026-09-25T10:20:00-04:00 10:20 00:15 The explosive demand for Large Language Models has created a global GPU bottleneck, forcing platform engineers to seek alternative hardware for production inference. Enter the vLLM engine on Google Cloud TPUs. Traditionally optimized for GPUs, vLLM now brings its industry-leading PagedAttention and continuous batching capabilities to the TPU ecosystem, offering a high-throughput, cost-effective alternative for serving models like Llama-3.3-70B-Instruct. In this session, we dive into the architecture of running vLLM on Google Kubernetes Engine (GKE). We will demonstrate the practicalities of deploying vLLM on TPU v6e slices and utilizing GKE for seamless orchestration. devconf-us-2026-3092-llm-inference-using-vllm-on-tpu-and-gke Artificial Intelligence and Data Science Tahmid Muttaki en false https://pretalx.devconf.info/devconf-us-2026/talk/LVXBND/ https://pretalx.devconf.info/devconf-us-2026/talk/LVXBND/feedback/ Ladd Room (Capacity 170) Lightning talk 2026-09-25T10:40:00-04:00 10:40 00:15 **Are you deploying Large Language Models and struggling to squeeze every ounce of performance out of your costly GPU infrastructure?** While engines like vLLM are industry standards, using their default configurations for your unique complex workload shape \- involving long prefill, extreme sequence lengths, or high concurrency \- can often leave performance on the table. Traditionally, tuning these parameters meant relying on manual tuning or black-box Bayesian Optimization. But what if the tuning could *reason* about why a configuration failed? This session introduces the next evolution of **llm-tuna**, an open-source framework for automated LLM serving optimization. Building on our research published in the ACM ([link](https://dl.acm.org/doi/10.1145/3774904.3792953)), we introduce an **agentic feedback loop** where an AI agent manages a persistent Performance Knowledge Base. Instead of just navigating a parameter space, the agent proactively: 1. **Reads and Interprets:** Analyzes vLLM logs and engine metrics to identify memory pressure or compute bottlenecks. 2. **Profiles and Diagnoses:** Triggers low-level **PyTorch profiling** and kernel-level analysis to understand *why* certain batch sizes or CUDA graph settings underperform. 3. **Learns and Adapts:** Grows its knowledge base with every experiment, allowing it to bypass inefficient search paths and suggest optimizations that pure statistical models might miss and accelerate the search for newer users of the framework. We will showcase the architecture—leveraging a kubernetes cluster for distributed, isolated trials—and demonstrate how this "Expert-in-the-Loop" approach outperforms standard baselines. This study will show how the progression improves over traditional statistical approaches. Attendees will see real-world case studies on models like **Qwen2.5** and the massive **DeepSeek-R1-671B** on H100/H200 clusters. ### **Key Takeaways:** * **The Agentic Edge:** How a reasoning agent identifies bottlenecks that Bayesian Optimization ignores. * **Closing the Loop:** Integrating PyTorch profiling and log analysis into the automated tuning cycle. * **Building a Performance Moat:** Leveraging a persistent, research-backed knowledge base to accelerate deployments across diverse GPU architectures (H100/H200). * **Multi-Objective Optimization:** Balancing the trade-offs between prefill latency, decode throughput, and VRAM efficiency. devconf-us-2026-3208-llm-tuna-2-0-agentic-profiling-and-knowledge-driven-optimization-for-vllm Artificial Intelligence and Data Science Thameem Abbas Ibrahim BathushaAanya Sharma en false https://pretalx.devconf.info/devconf-us-2026/talk/9SMF9X/ https://pretalx.devconf.info/devconf-us-2026/talk/9SMF9X/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T11:00:00-04:00 11:00 00:35 90% of GenAI systems fail in production because teams struggle to evaluate and resolve failures. Observability tools like OpenTelemetry and MLflow log massive traces, but hide critical reasoning failures. They tell you where a request traveled, but not why an LLM agent lost its way. This session moves beyond basic observability into the realm of failure mode analysis for agentic systems. Using a real world AI system as a case study, we will dissect why traditional monitoring fails to catch silent agent failures like context window saturation and tool-calling loops. Attendees will walk away with a practical toolkit for: 1) Defining a Failure Taxonomy: Moving from vague bad outputs to structured categories like retrieval gaps or reasoning drift 2) Building a Tracing-to-Resolution Pipeline: Leveraging OpenTelemetry and MLflow traces to map anomalies directly to code-level fixes, eliminating the guesswork of manual prompt engineering 3) Human-in-the-Loop Evaluations: Scaling quality control by using LLMs to surface high-risk anomalies for critical human review Learn to stop operating blind and build resilient, production-grade AI systems that your teams can actually trust. devconf-us-2026-2948-from-traces-to-fixes-building-resilient-agentops-with-failure-mode-analysis Artificial Intelligence and Data Science Hema VeeradhiSurya Pathak en false https://pretalx.devconf.info/devconf-us-2026/talk/VKBKSS/ https://pretalx.devconf.info/devconf-us-2026/talk/VKBKSS/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T12:30:00-04:00 12:30 00:35 Building an agent that calls one tool is straightforward. Building one that orchestrates multiple MCP-connected tools to complete a real task is where things get architecturally interesting and quietly dangerous. When an agent hands off to an external tool, something subtle happens: control leaves your system. The tool executes, returns a result, and your agent trusts it. Most developers don't think carefully about that moment until something goes wrong like a tool returns unexpected output, an agent takes an action it shouldn't, or a chain of tool calls produces a result nobody intended. This talk is about the architectural decisions that happen at those handoff points. We'll look at how MCP structures the relationship between agents and tools, where trust gets implicitly granted in ways developers don't notice, and what composing multiple tools together actually looks like when the task is non-trivial. The demo walks through an agent completing a real multi-step task using several MCP-connected tools, deliberately hitting the failure modes that show up when tool outputs are ambiguous, conflicting, or outside the agent's expected context. We'll look at how to structure tool composition so the agent stays in a predictable, auditable state throughout. You'll leave with a mental model for reasoning about trust in agentic systems and concrete patterns for composing MCP tools without losing control of what your agent is actually doing. devconf-us-2026-2959-who-s-in-charge-here-trust-boundaries-and-tool-composition-in-production-agentic-systems Artificial Intelligence and Data Science Sharan Shirodkar en false https://pretalx.devconf.info/devconf-us-2026/talk/VZ3ADH/ https://pretalx.devconf.info/devconf-us-2026/talk/VZ3ADH/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T13:10:00-04:00 13:10 00:35 In this talk, we will introduce vLLM and explore why monitoring matters for LLM serving. We'll start from why serving LLMs is hard in the first place and build up to what that complexity looks like as real, observable metrics. vLLM is a high-performance library designed for LLM inference and serving. Its core optimizations, including PagedAttention, continuous batching, and memory management, directly shape the behavior you'll see in production. Understanding what those techniques are doing under the hood makes it easier to understand what your metrics are actually telling you. The session will include a demo showing how to instrument vLLM with observability tooling and interpret the signals that matter: KV cache usage, request queue depth, and end-to-end latency. No GPU or production cluster required. Just a small model running locally and some practical monitoring tools. By the end of this session, you'll have a clearer mental model of LLM serving, a working understanding of vLLM's built-in observability, and the monitoring foundation to understand what's happening inside your server before something goes wrong. devconf-us-2026-2953-portrait-of-a-server-on-fire Artificial Intelligence and Data Science Rafael Vasquez en false https://pretalx.devconf.info/devconf-us-2026/talk/ZZBY9J/ https://pretalx.devconf.info/devconf-us-2026/talk/ZZBY9J/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T13:50:00-04:00 13:50 00:35 In distributed inference, large language model workloads are split across multiple GPUs on separate nodes. When a GPU fails during inference, the serving system has to detect the failure, reconfigure, and resume, as quickly as possible. The vLLM community is actively building this capability through multiple approaches, from elastic scale-down to masked degraded operation to fault-tolerant collective backends. All of them depend on the same foundation: the ability to detect that a GPU is gone and to recover communication state without the dead participant. We tested that foundation. Using NCCL 2.29's elastic primitives, we ran fault recovery scenarios across five nodes on an OpenShift cluster, a multi-node, TCP-only environment where vLLM will actually need to recover from failures. The primitives worked: shrinking a communication group after failures and running collective operations with survivors produced correct results across a variety of configurations, including simultaneous and sequential failures. The more important finding was about failure detection. When we killed a pod on one node, the other nodes didn't notice; we found GPU communication sockets still in ESTABLISHED state minutes after the remote pod was destroyed. This is a gap between how Kubernetes tears down pods and how TCP detects connection loss, and it affects every approach to GPU fault tolerance on Kubernetes, not just the one we tested. We'll show the /proc/net/tcp evidence, walk through the diagnosis, and cover the fix options from per-socket keepalive to what platform-level changes would eliminate the problem entirely. This talk covers what we learned testing GPU fault recovery in the conditions it will actually face: real failures, across real nodes, on a real Kubernetes cluster. We'll discuss how these findings apply to vLLM's fault tolerance roadmap and what anyone running distributed GPU workloads on Kubernetes should know. devconf-us-2026-3224-when-gpus-die-mid-inference-cross-node-fault-tolerance-for-vllm-serving-on-kubernetes Artificial Intelligence and Data Science Sean McGovern en false https://pretalx.devconf.info/devconf-us-2026/talk/B77P98/ https://pretalx.devconf.info/devconf-us-2026/talk/B77P98/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T14:50:00-04:00 14:50 00:35 You are tasked with standing up a large multi-project ecosystem that you are not familiar with. What do you do? Do you find yourself stuck reading pages of documentation, overwhelmed at the idea of understanding and deploying all these new components? Turns out, learning such systems by deploying components one at a time — with an AI partner tracing failures, explaining architecture, and handling mechanical work — can be significantly faster and more effective. This talk presents a week-long experiment in using AI-assisted collaboration to build a comprehensive understanding of a Model Context Protocol (MCP) ecosystem spanning ~7 different open source projects. The approach followed a deliberate loop: broad question, minimal deploy, let it fail, deep trace with the model to understand why, then scope the next increment. The result is a reproducible reference architecture that stands up a full MCP stack in ~10 minutes — catalog-driven server discovery, lifecycle operator managed deployment, gateway routing, Keycloak identity, per-tool authorization via Kuadrant AuthPolicy, TLS, Vault-backed credential injection, and namespace-isolated multi-tenancy with virtual MCP servers for group-based tool filtering. Beyond the technical aspects, this talk examines the collaboration pattern itself. AI accelerated breadth — cross-component context, YAML mechanics, integration debugging — while the human supplied direction, skepticism, and architectural judgment: deciding when to push back on over-engineering, when a workaround was acceptable versus when it needed upstreaming, and where to draw the boundary between temporary scaffolding and lasting patterns. Attendees will come away with practical insights on using AI as a learning partner for complex integration problems and a perspective on how critical thinking changes shape, but doesn't necessarily disappear when AI enters the workflow. devconf-us-2026-2973-empty-cluster-to-a-production-shaped-mcp-ecosystem-using-ai-as-a-learning-accelerator Artificial Intelligence and Data Science Jaideep Rao en false https://pretalx.devconf.info/devconf-us-2026/talk/WZGWBY/ https://pretalx.devconf.info/devconf-us-2026/talk/WZGWBY/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T15:30:00-04:00 15:30 00:35 What if you could combine the speed of a small model with the quality of a large one? Speculative decoding makes this possible by using a lightweight draft model to propose tokens that a larger verifier checks in parallel, delivering 2-5x inference speedups with mathematically identical quality output. This talk introduces the vLLM project's Speculators library: an end-to-end framework for training, packaging, and deploying speculative decoding models. We will start with the intuition behind speculative decoding, walk through the full Speculators training pipeline, and finish with a live demonstration of serving a speculative decoding model to speed up inference. Along the way, we will dive into the engineering challenges we solved to make this work at scale. Extracting training data from large language models generates hundreds of megabytes per request, which need to be transferred out of vLLM. Therefore we built a novel hidden states extraction system that repurposes vLLM's KV Connector infrastructure to efficiently stream internal model representations to the training processes, all while preserving vLLM's tensor parallelism and paged attention optimizations. We will share what we learned scaling this across multi-GPU setups and across speculative decoding algorithms like Eagle-3 and DFlash. Attendees will leave with a practical understanding of how speculative decoding works, how to train their own draft models using Speculators, and how to deploy them for accelerated inference in vLLM. devconf-us-2026-3072-speculators-accelerating-llm-inference-through-speculative-decoding Artificial Intelligence and Data Science Fynn Schmitt-Ulms en false https://pretalx.devconf.info/devconf-us-2026/talk/PQ8KNJ/ https://pretalx.devconf.info/devconf-us-2026/talk/PQ8KNJ/feedback/ Ladd Room (Capacity 170) Talk 2026-09-25T16:10:00-04:00 16:10 00:35 Join us for the closing of the conference and for a chance to win some prizes by participating in a trivia! devconf-us-2026-3268-closing-trivia General Dorka VolavkovaUrvashi MohnaniSally O'Malley en false https://pretalx.devconf.info/devconf-us-2026/talk/GQFNKB/ https://pretalx.devconf.info/devconf-us-2026/talk/GQFNKB/feedback/ 106 (Capacity 45) Talk 2026-09-25T09:00:00-04:00 09:00 00:35 Two tectonic shifts are converging to rewrite the rules of digital security and most organizations are not ready for either. Quantum computing is advancing toward cryptographically relevant scale, threatening to shatter the RSA and elliptic-curve foundations that protect virtually every digital transaction today. Simultaneously, the rise of Agentic AI is unleashing fleets of autonomous software agents that act, decide, and communicate across systems -none of which have passports, no conventional way to authenticate them, and an attack surface that grows with every delegation chain. The response to both threats converges on the same two disciplines: cryptography and identity. But traditional approaches designed for human users, static workloads, and long-lived certificates were never built for this world. This session argues that what we need is not just stronger algorithms, but a fundamental rethinking of how trust works: trust that is algorithm-agnostic (crypto-agile), trust that extends to machine and AI actors, and trust that can be composed, delegated, and revoked across dynamic, multi-party pipelines at machine speed. We will examine the real threat timelines for quantum cryptographic attacks, the identity and authorization gaps exposed by agentic AI architectures, how modern trust frameworks must evolve to address both simultaneously, and what a practical crypto-agility strategy looks like from NIST PQC algorithm adoption to SPIFFE/SVID-based machine identity and zero-trust policy enforcement. Attendees will leave with a clear mental model of why these two threats are linked, an architectural blueprint for a post-quantum, agentic-ready trust stack, and concrete steps to begin the migration journey today. devconf-us-2026-3248-trust-in-the-quantum-age-how-crypto-agility-and-identity-frameworks-must-evolve-to-survive-quantum-computing-and-agentic-ai Security and Compliance Chaitanya ChallaSridhar Narayanan en false https://pretalx.devconf.info/devconf-us-2026/talk/JGGCCG/ https://pretalx.devconf.info/devconf-us-2026/talk/JGGCCG/feedback/ 106 (Capacity 45) Talk 2026-09-25T09:40:00-04:00 09:40 00:35 This is a live tutorial of hacking against keyboards of all forms. Attacking the keyboard is the ultimate strategy to hijack a session before it is encrypted, capturing plaintext at the source and (often) in much simpler ways than those required to attack network protocols. In this session we explore available attack vectors against traditional keyboards, starting with plain old keyloggers. We then advance to "Van Eck Phreaking" style attacks against individual keystroke emanations as well as RF wireless connections, and we finally graduate to the new hotness: acoustic attacks by eavesdropping on the sound of you typing! Use your newfound knowledge for good, with great power comes great responsibility! A subset of signal leak attacks focusing on keyboards. This talk is compiled with open sources, no classified material will be discussed. devconf-us-2026-3198-all-your-keyboards-are-belong-to-us Security and Compliance Federico Lucifredi en false https://pretalx.devconf.info/devconf-us-2026/talk/MYHTLR/ https://pretalx.devconf.info/devconf-us-2026/talk/MYHTLR/feedback/ 106 (Capacity 45) Talk 2026-09-25T10:20:00-04:00 10:20 00:35 Software Bill of Materials (SBOM) has become a foundational requirement for software supply chain security. But modern applications increasingly embed machine learning models, datasets, feature stores, prompts, vector databases, and training pipeline artifacts that traditional SBOMs were never designed to describe. This talk explores extending SBOM concepts into an **AI Bill of Materials (AI-BOM)** that captures machine learning artifacts across the lifecycle. We will examine: * Why SBOM alone is insufficient for ML systems * What additional metadata is required for AI systems * Mapping ML artifacts into CycloneDX/SPDX extensions * Provenance, reproducibility, and compliance challenges * Security risks in models, datasets, and prompt supply chains * How AI-BOM supports governance, auditability, and responsible AI The session includes a practical architecture walkthrough and a focused demo showing how AI-BOM artifacts can be generated and integrated into existing DevSecOps workflows. devconf-us-2026-3070-extending-sbom-into-ai-bom-managing-ml-artifacts-beyond-traditional-software Security and Compliance Ayushi Tiwari en false https://pretalx.devconf.info/devconf-us-2026/talk/KPN7LF/ https://pretalx.devconf.info/devconf-us-2026/talk/KPN7LF/feedback/ 106 (Capacity 45) Talk 2026-09-25T11:00:00-04:00 11:00 00:35 Most agent security testing uses models that refuse malicious prompts, so infrastructure controls never get exercised. We tested which OpenShift defenses actually hold when the model says yes to everything. We deployed OpenClaw on Red Hat OpenShift (ROKS) with an abliterated Qwen3.5-35B-A3B served via vLLM: 100% attack cooperation, zero refusals. TrojAI calls this "crash test dummy" methodology. The model cooperates with every attack, forcing each infrastructure layer to prove itself independently. We wrote 15 custom garak probes across six attack categories (credential exfiltration, persistence poisoning, sandbox escape, tool abuse, Kubernetes API escalation, guardrails bypass) and ran 91 adversarial prompts against three progressive hardening tiers: bare agent, sandbox with NetworkPolicy, and sandbox with a prompt injection classifier. The results separate load-bearing controls from cosmetic ones. Credential isolation (routing tool execution to a separate pod) dropped exfiltration from 67% to 0%. NetworkPolicy blocked K8s API abuse, but only after we discovered that ipBlock rules can't target ClusterIPs because kube-proxy DNAT translates before policy evaluation. DNS tunneling worked until we restricted egress to cluster DNS pods by label. A prompt injection classifier caught encoding-based attacks (56% to 0%) but missed every tool-use attack phrased as a legitimate instruction. Persistence poisoning, where the agent writes attacker content into its own memory, passed all three tiers because it looks identical to normal agent behavior. No tested control addresses it. Attendees leave with the three-tier testing framework, garak probe configurations, and a checklist for validating agent isolation on Kubernetes. All probes, scan scripts, and deployment manifests are open source. devconf-us-2026-2954-red-teaming-ai-agents-on-openshift-what-actually-stops-the-attacks Security and Compliance Roy Belio en false https://pretalx.devconf.info/devconf-us-2026/talk/VRR9M8/ https://pretalx.devconf.info/devconf-us-2026/talk/VRR9M8/feedback/ 106 (Capacity 45) Talk 2026-09-25T12:30:00-04:00 12:30 00:35 To capture enterprise adoption and retain contributions from major vendors, our Operators must run flawlessly on opinionated distributions like OpenShift. Yet, requiring every drive-by contributor to spin up a heavy, resource-intensive local OpenShift cluster just to run the project's test-suite is a surefire way to kill contribution velocity. In this session, we will explore a strategy for architecting a "Fidelity Curve" in your testing pipeline. We will use the standard CNCF testing projects (envtest, Kwok, KinD) but in a way that gives us early feedback for a runs-on-OpenShift component. In the final part of the session, we will discuss migrating from ArgoCD to Tilt (both CNCF projects) for convenient component orchestration during development. devconf-us-2026-3173-the-contributor-tax-supporting-openshift-without-crushing-upstream-velocity Application and Services Development Jiří Daněk en false https://pretalx.devconf.info/devconf-us-2026/talk/T8VHVL/ https://pretalx.devconf.info/devconf-us-2026/talk/T8VHVL/feedback/ 106 (Capacity 45) Talk 2026-09-25T13:10:00-04:00 13:10 00:35 Every major software methodology shift — TDD, DevOps, CI/CD — was ultimately about compressing feedback loops. AI coding has just shattered the speed of code generation while doing nothing to improve the quality of feedback. This talk proposes Observability-Driven Development (ODD) as the missing practice: instrumenting not just production, but every stage of the SDLC with runtime-deep signals so that AI-generated code is validated at the same speed it's produced. The argument is that without this, AI doesn't accelerate software delivery — it just accelerates technical debt. devconf-us-2026-3231-observability-driven-development-the-missing-link-for-the-ai-coding-era Application and Services Development Russ Whitman en false https://pretalx.devconf.info/devconf-us-2026/talk/VJ9SPL/ https://pretalx.devconf.info/devconf-us-2026/talk/VJ9SPL/feedback/ 106 (Capacity 45) Talk 2026-09-25T13:50:00-04:00 13:50 00:35 How do you scale frontend development across 20+ applications and teams without losing UX consistency? We did it with an Nx-based monorepo, shared libraries, and independent deployments. The hardest problems weren’t technical, they were about ownership and team autonomy. This talk covers our journey from scattered repositories to a unified monorepo serving millions of monthly users. We'll share: - Nx workspace configuration for 20+ React/Vite applications - Building a shared UI library (80+ components) with PatternFly - Independent CI/CD pipelines: deploy only what changed - Code sharing strategies that don't create coupling nightmares - Real metrics: 40% faster builds, 60% less duplicated code Whether you're consolidating legacy apps or starting fresh, you'll learn patterns for scaling frontend development without sacrificing team autonomy. Includes practical tips on dependency management, testing strategies, and when NOT to share code. devconf-us-2026-3170-one-monorepo-25-independent-frontend-apps-what-worked-and-what-didn-t Application and Services Development Rohit Bharmal en false https://pretalx.devconf.info/devconf-us-2026/talk/QJJW9C/ https://pretalx.devconf.info/devconf-us-2026/talk/QJJW9C/feedback/ 106 (Capacity 45) Talk 2026-09-25T14:50:00-04:00 14:50 00:35 Performance issues in Go applications often hide in plain sight. Your service works fine in development but slows down in production. Memory usage creeps up over time. API response times degrade under load. Without proper profiling, you're guessing where the problem is.This talk teaches you how to find and fix performance bottlenecks in Go services using Go's built-in profiling tools. Through live demonstrations and real-world examples, you'll learn to identify CPU hotspots, memory leaks, goroutine issues, and inefficient code patterns. What you'll learn: - How to add profiling to your Go services with minimal code changes - Understanding different profile types: CPU, memory, goroutine, and blocking - Reading and interpreting pprof output and flame graphs - Common performance problems in Go and how to detect them (string concatenation, N+1 queries, goroutine leaks, excessive allocations) - Using benchmarks to validate your optimizations - When to optimize and when to leave code alone Live demonstrations include: - Profiling a microservice to find CPU bottlenecks - Detecting and fixing memory leaks with heap profiles - Identifying goroutine leaks in concurrent code - Comparing performance before and after optimization with hard numbers Whether you're debugging production issues or improving service efficiency, this talk gives you practical skills to make your Go applications faster and more reliable. All examples use standard library tools - no external dependencies required. devconf-us-2026-3075-go-performance-optimization-a-practical-guide-to-profiling Application and Services Development Ashu sharma en false https://pretalx.devconf.info/devconf-us-2026/talk/TJVQWD/ https://pretalx.devconf.info/devconf-us-2026/talk/TJVQWD/feedback/ 106 (Capacity 45) Talk 2026-09-25T15:30:00-04:00 15:30 00:35 ## Abstract Consensus in distributed systems is often seen as one of the hardest problems in computer science. Even simple operations must deal with unreliable networks, node failures, and the absence of a global clock. This talk presents an intuitive, step-by-step approach to understanding consensus. Instead of starting with established algorithms or formal proofs, we begin with a naïve solution and iteratively refine it by exposing its failures under realistic conditions. Each refinement introduces a key idea that leads toward a correct and practical consensus approach. Along the way, we will build an understanding of why consensus is fundamentally challenging, what constraints make it impossible in some settings, and why real-world algorithms are designed the way they are. By the end, the audience will have a clear mental model of consensus and be able to reason about protocols such as Raft or Paxos with greater confidence. ## Objectives - Tackle the problem of consensus using first principles and simple reasoning. - Demonstrate how realistic failure scenarios shape the design of consensus protocols. - Provide a mental framework to reason about correctness and trade-offs in distributed coordination. ## Requirements Basic familiarity with backend systems. devconf-us-2026-3026-consensus-101 Application and Services Development Shivansh Kuchchal en false Presentation [Work in Progress] Excalidraw Slide 1 - Introduction to the Problem Excalidraw Slide 2 - Simplifying the Problem - State Machines Excalidraw Slide 3 - Attacking the Problem - Democracy Excalidraw Slide 4 - Attacking the Problem - Two Phase Commit Excalidraw Slide 5 - The Problem Strikes Back https://pretalx.devconf.info/devconf-us-2026/talk/VYLPZM/ https://pretalx.devconf.info/devconf-us-2026/talk/VYLPZM/feedback/ 101 (Capacity 48) Talk 2026-09-25T09:00:00-04:00 09:00 00:35 ## Managing Scarce ML Accelerator Resources The demand for TPUs and GPUs to power Large Language Models is exploding, far outpacing the months-long lead times for new hardware. This creates intense competition for scarce resources. The critical question for infrastructure teams is: How do you guarantee reliable, predictable, and fair access to chips that take months to provision? Simply measuring hardware uptime is insufficient when users care about getting their ML workloads completed. This session will dissect the complexities of managing platform-agnostic large-scale ML accelerator fleets, independent of the specific hardware type (TPUs, GPUs, ASICs) within open-source platforms like Kubernetes or for running whale customer LLM workloads like Gemini. We will cover: * **Holistic SLO Framework:** Defining, measuring, and defending meaningful Capacity SLOs (e.g., available chip hours, scheduling latency) and Workload SLOs (e.g., Goodput, training throughput). * **Multi-Tenant Scheduling:** Strategies for fair share, priority-based queuing, and minimizing head-of-line blocking. * **Hardware Fragmentation:** Identifying and mitigating internal and external fragmentation that reduces usable capacity. * **Preemption Logic:** Designing and implementing preemption mechanisms to enforce SLOs and priorities, including the impact on workload Goodput. * **Quota Management & Demand Shaping:** Best practices for assigning quotas and influencing user behavior to smooth out peaks. * **Handling Burst Requests:** Strategies for accommodating episodic high-demand training cycles without compromising base SLOs. We will explore the Site Reliability Engineering practices essential for robust accelerator fleet management: * **Establishing Realistic SLOs:** How to set achievable targets for capacity and workload performance. * **Error Budgets for Accelerators:** Implementing effective error budgets tailored to capacity, demand fluctuations, and workload characteristics. * **Monitoring & Alerting:** Crucial metrics and strategies to track SLO performance, detect saturation, identify fragmentation, and diagnose workload-specific issues. * **Communication:** Transparently communicating resource constraints, SLOs, and the impact of burst requests to users. * **Balancing Efficiency & Fairness:** Techniques for optimizing fleet utilization in multi-tenant environments with diverse requirements. Attendees will leave with a robust, platform-agnostic framework for implementing holistic Capacity and Workload SLOs for high-demand ML accelerators. You'll gain actionable SRE principles and techniques to enhance reliability and techniques to enhance t devconf-us-2026-3093-the-hardware-hunger-games-why-your-ai-training-depends-on-infrastructure-slos Cloud, Hybrid Cloud, and Hyperscale Infrastructure Sania AlexSwetha Vijayaraghavan en false https://pretalx.devconf.info/devconf-us-2026/talk/MXQC9E/ https://pretalx.devconf.info/devconf-us-2026/talk/MXQC9E/feedback/ 101 (Capacity 48) Talk 2026-09-25T09:40:00-04:00 09:40 00:35 Karpenter is a high-performance, flexible cluster autoprovisioner for Kubernetes, which has become an important part of any cluster administrators toolbox. In a world where digital sovereignty is becoming a central issue for any organization with cloud computing resources, limiting Karpenter to only the most popular clouds means limiting your options. But, what if you could deploy a single Karpenter that can address dozens of infrastructure providers all while keeping a common interface? Enter Karpenter for Cluster API. In this presentation, Max and Michael will demonstrate how Karpenter for Cluster API can be used to create truly hybrid cloud infrastructures. You will see how Karpenter interfaces with Cluster API, how Cluster API can be used to create global resources, and how specialized hardware like GPUs can be included in your choices. Come learn how you can build hybrid cloud Kubernetes deployments that can self-manage their resources and drive down your operational costs. devconf-us-2026-3187-hybrid-cloud-karpentry-autoprovisioning-on-all-infrastructures Cloud, Hybrid Cloud, and Hyperscale Infrastructure Michael McCuneMax Cao en false https://pretalx.devconf.info/devconf-us-2026/talk/JGDX3Z/ https://pretalx.devconf.info/devconf-us-2026/talk/JGDX3Z/feedback/ 101 (Capacity 48) Talk 2026-09-25T10:20:00-04:00 10:20 00:35 KubeVirt is changing the conversation around modernization by allowing organizations to run virtual machines and containers side by side on Kubernetes. This session removes the confusion and fear often associated with the technology by explaining how KubeVirt works, what use cases it solves, and how it can help unify operations across traditional and cloud native workloads. The talk covers virtual machine lifecycle management, networking, storage, day-2 operations, and the practical trade-offs of adopting KubeVirt in enterprise environments. Attendees will see how platform teams can reduce fragmentation, simplify operations, and create a common control plane for both legacy and modern applications. devconf-us-2026-3005-kubevirt-without-fear-running-vms-and-containers-together-on-one-platform Cloud, Hybrid Cloud, and Hyperscale Infrastructure Heber Romero TellezJoel Hernandez en false https://pretalx.devconf.info/devconf-us-2026/talk/8KHTEE/ https://pretalx.devconf.info/devconf-us-2026/talk/8KHTEE/feedback/ 101 (Capacity 48) Talk 2026-09-25T11:00:00-04:00 11:00 00:35 The Open Education Project (OPE) uses open source infrastructure to make advanced computing more accessible in education. By introducing a GPU batch scheduling system on OpenShift AI with Kueue we were able to support a GPU programming class to run for tens of dollars, rather than hundreds. This allows students to take part in the future of AI, and help understand and reimagine how we can use GPUs to improve performance, pushing AI innovation forward. devconf-us-2026-3210-gpus-in-the-classroom-using-kueue-on-openshift-ai-to-make-gpu-use-in-academia-cost-effective Cloud, Hybrid Cloud, and Hyperscale Infrastructure Meera Malhotra en false https://pretalx.devconf.info/devconf-us-2026/talk/NNRWJ8/ https://pretalx.devconf.info/devconf-us-2026/talk/NNRWJ8/feedback/ 101 (Capacity 48) Talk 2026-09-25T12:30:00-04:00 12:30 00:35 Fedora CoreOS has consistently grown over the past five years, eventually becoming a top level edition and now competing with the Server and Cloud editions for most active node count on any given week. With operating system and container technology continuing to evolve at a breakneck pace, Fedora CoreOS sits nicely at the intersection of this evolution; providing a nice stable ride along the way. In this session we'll discuss what is next for Fedora CoreOS; our goals for the project and the community, and how we can achieve those goals through coordinated technical and non-technical efforts. Topics will include fedora-bootc, konflux, sysexts, confidential compute and more! devconf-us-2026-3236-fedora-coreos-in-2026 Cloud, Hybrid Cloud, and Hyperscale Infrastructure Dusty Mabe en false https://pretalx.devconf.info/devconf-us-2026/talk/BFKC8C/ https://pretalx.devconf.info/devconf-us-2026/talk/BFKC8C/feedback/ 101 (Capacity 48) Talk 2026-09-25T13:10:00-04:00 13:10 00:35 In the inception of Kubernetes, a core design philosophy was Pods are "cattle" rather than "pets" where they can be easily replaced and replicated. As Kubernetes has dominated the world of computing, that design philosophy continually grows fuzzier. Today, application designers have many pet Pods that are difficult to schedule, start, and run, and they'd take the suggestion to "move" rather than tear down and replace. In the Kubernetes Checkpoint/Restore working group, we're looking to canonically solve this problem. There has already been rudimentary checkpointing support, but we're looking to do more. Join Peter Hunt as they walk through what the WG has been working on, and learn about the state of the art of process migration at enterprise scale. And yes, it can be used for AI applications too. devconf-us-2026-3205-we-should-take-our-pods-and-push-them-somewhere-else-checkpoint-restore-in-kubernetes Cloud, Hybrid Cloud, and Hyperscale Infrastructure Peter Hunt en false https://pretalx.devconf.info/devconf-us-2026/talk/SYX3QX/ https://pretalx.devconf.info/devconf-us-2026/talk/SYX3QX/feedback/ 101 (Capacity 48) Talk 2026-09-25T13:50:00-04:00 13:50 00:35 Moving from single containers to full-scale Kubernetes orchestration can feel like 'A Bridge Too Far' for many developers and sysadmins. This session explores a pragmatic, lightweight path to bridge that gap using RHEL 10 and MicroShift. We will demonstrate a rapid-deployment methodology to build a local lab using KVM. The journey starts with simple Podman containers, navigates through essential SELinux security contexts, and culminates in a functional Kubernetes environment using MicroShift. Key takeaways include: * How to leverage a lightweight footprint for Kubernetes learning and Edge use cases. * Best practices for transitioning container manifests to Kubernetes objects. * Understanding the symbiotic relationship between the OS (RHEL 10) and the orchestrator. Attendees will gain a clear roadmap to master orchestration basics without needing massive cloud infrastructure, proving that learning Kubernetes doesn't have to be a 'Doomsday Machine' for local resources. devconf-us-2026-2728-honey-i-shrunk-the-cluster-a-pragmatic-learning-path-from-podman-to-kubernetes-via-microshift Cloud, Hybrid Cloud, and Hyperscale Infrastructure Alex Callejas en false https://pretalx.devconf.info/devconf-us-2026/talk/LS7MCS/ https://pretalx.devconf.info/devconf-us-2026/talk/LS7MCS/feedback/ 101 (Capacity 48) Talk 2026-09-25T14:50:00-04:00 14:50 00:35 Deploying OS images to bare metal clusters is painful. Unicast scales linearly with node count. Multicast stalls if one node is slow. Past BitTorrent approaches either transfer entire raw partitions (wasting bandwidth) or require RAM buffering for image conversion (size limited). EZIO's provisioning time depends on image size and bandwidth, not node count. It transfers only used filesystem blocks and writes directly to raw disk by calculating offsets on the fly. No RAM buffering, no image conversion, no size limit. Each node works independently. Broken nodes can rejoin after recovery. This enables deploying large HPC environments with pre-installed software and data. Clonezilla has integrated EZIO for production use. Benchmarks: On HDD (50GB, 32 nodes), 11x faster than unicast, 50% faster than multicast. In the cluster with NVMe SSD and 10G network at Taiwan's National Center for High-performance Computing (NCHC), 500 MB/s across 32 nodes. Lab tests reach 700 MB/s. devconf-us-2026-2718-ezio-predictable-fast-scalable-bittorrent-based-bare-metal-provisioning Cloud, Hybrid Cloud, and Hyperscale Infrastructure Date (Yu-Chiang) Huang en false https://pretalx.devconf.info/devconf-us-2026/talk/KUSV3T/ https://pretalx.devconf.info/devconf-us-2026/talk/KUSV3T/feedback/ 101 (Capacity 48) Talk 2026-09-25T15:30:00-04:00 15:30 00:35 Academic courses increasingly depend on complex software environments. Reproducing those environments across student laptops is difficult, fragile, and time-consuming. For some classes, a better model is to move the course environment out of individual laptops and into shared cloud infrastructure, where students can access consistent, preconfigured environments through a browser. This work started as part of the Open Education Project (OPE), which focuses on using modern open source technologies to help educators create, publish, and operationalize open educational materials. OPE provides tools for authoring course content, including open textbooks and containerized learning environments. This presentation shifts the focus from authoring course materials to operating courses at scale. We will explore how academic courses can be run on OpenShift, drawing from lessons learned supporting hundreds of students in the Mass Open Cloud (MOC) every semester. The focus will be on the infrastructure and operational patterns needed to support real courses: deploying course environments, provisioning student access, managing shared cluster resources, and supporting browser-based workflows. We will discuss how OpenShift can reduce student setup friction, improve reproducibility, and give educators a flexible platform for running modern computing courses. devconf-us-2026-3225-teaching-at-scale-with-openshift Cloud, Hybrid Cloud, and Hyperscale Infrastructure Isaiah Stapleton en false https://pretalx.devconf.info/devconf-us-2026/talk/YTXPND/ https://pretalx.devconf.info/devconf-us-2026/talk/YTXPND/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T09:00:00-04:00 09:00 00:35 Agile tools like Jira excel at tracking work as it moves from "To Do" to "Done". But when we rely on tickets to capture context and decisions made during task implementation, the issue tracker also unintentionally becomes a store of knowledge. Communicating solely through tickets eliminates nuance and empathy, and makes work more siloed and inhuman. This talk explores common pitfalls, strategies for managing knowledge outside of Jira, and techniques for using AI to reclaim and reorganize that knowledge into a more human-centric workflow. devconf-us-2026-2981-why-jira-is-a-terrible-knowledge-base-using-ai-to-move-knowledge-out-of-the-backlog Open Track Kevin Howell en false https://pretalx.devconf.info/devconf-us-2026/talk/LQMHR9/ https://pretalx.devconf.info/devconf-us-2026/talk/LQMHR9/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T09:40:00-04:00 09:40 00:35 What happens when a Linux company hires you to work with the Windows Operating System? At Red Hat, I contribute to an OLM operator written in Go that configures Windows Server instances into OpenShift worker nodes. I debug Windows issues from a Fedora laptop, and contribute to a Kubernetes SIG literally called "sig-windows". When I tell people at conferences what I do, the first reaction is always the same: "Wait, Windows at Red Hat?" This talk is the honest story behind that reaction. I'll share a career lesson hiding in a weird job description, a different perspective on where to find meaningful open source work, concrete strategies for contributing to large upstream projects, and maybe the courage to navigate a role that doesn't fit the obvious narrative but creates a unique opportunity for impact. devconf-us-2026-3167-why-a-linux-company-hired-me-to-build-for-windows Open Track JR Valdes en false https://pretalx.devconf.info/devconf-us-2026/talk/XZQV8P/ https://pretalx.devconf.info/devconf-us-2026/talk/XZQV8P/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T10:20:00-04:00 10:20 00:35 Within the context of security and user freedom, firmware is often regarded as a necessary evil - an inescapable gatekeeper whose involvement and even permission is required before the software you actually want to run can start. While open source bootloaders and firmware have been written for some platforms and even the notion of Linux as a bootloader is not unprecedented, there is almost always some other code open or not that runs first and so at least one more thing to understand and trust. This begs the question: could a highly specialized embedded Linux kernel be prepared such that it itself can act as the target of the CPU's reset vector - in other words: can the first instruction my CPU executes be from Linux? Certainly a very open and well documented hardware platform would be required, as would customizing and minimizing the footprint of the kernel to the max, but even so trying to answer that question led me definitively into the unknown, off the beaten path, and down a wild goose chase through some of the most obscure, unexplored, and tricky corners of the Linux kernel, the RISC-V specification, and the SiFive FU540-C000 platform. This talk will try to tell the whole story, shedding light on hardware bringup, emulation vs reality, the Linux kernel development process, and what your CPU and firmware are really doing. devconf-us-2026-3242-linux-as-firmware-where-we-re-going-we-don-t-need-bootloaders Open Track Charles Mirabile en false https://pretalx.devconf.info/devconf-us-2026/talk/WXQQED/ https://pretalx.devconf.info/devconf-us-2026/talk/WXQQED/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T11:00:00-04:00 11:00 00:35 In this talk, I share strategies for managing cognitive fatigue drawn from my recovery after a mild Traumatic Brain Injury (mTBI). As AI accelerates the pace of our work, the ability to protect and direct our focus has never been more critical. You’ll gain a deeper understanding of how the brain processes information differently from machines and leave with practical, human-centered tips to boost your productivity and mental well-being. devconf-us-2026-3035-single-threading-for-the-human-brain Open Track Kaitlyn Carcia Poulin en false https://pretalx.devconf.info/devconf-us-2026/talk/TTJFVP/ https://pretalx.devconf.info/devconf-us-2026/talk/TTJFVP/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T12:30:00-04:00 12:30 00:35 As vibe coding and LLM-driven development lower the barrier to building functional interfaces, the distance between an idea and a deployed product has never been shorter. However, this speed often comes at a hidden cost: the inadvertent scaling of deceptive patterns. Essentially, your AI-generated UI is shipping deceptive behavior you didn't explicitly code, and you can still be held responsible for it. This begs the question: When we prompt our way to a UI, what are the consequences of the deceptive UX debt of the training data we are inheriting? In this session, we dive into the murky waters of deceptive UX, from classic "roach motels" – a UX pattern where it is incredibly easy to sign up for a service but intentionally difficult or hidden to cancel– to the new era of AI-driven prototyping, where personalized algorithms can exploit cognitive biases at an individual scale. **Talk structure:** In this talk, we'll walk through a live, demo-driven narrative we are calling "The Evolution of Deceptive UX Patterns," structured in three phases: **Phase 1: The Magic** We open with a live (or pre-recorded) vibe-coding demo, prompting Cursor using Claude Opus 4.6 to generate a polished, high-conversion mobile ordering UI for a taco truck in seconds. The result looks stunning and feels like the future. - What are the pros of vibe coding this fast? What things did Claude get right here? **Phase 2: The Hidden Tax** We re-examine the "Magic UI" from Phase 1 using a "magnifying glass" effect to look under the hood, specifically at deceptive patterns. - Confirm-shaming example - Harms: emotional manipulation, erosion of trust - Nudging example - Harms: loss of autonomy/control, capitalizing on users' impulses - Data tracking/surveillance framed in a positive way example - Harms: loss of autonomy/control, emotional manipulation - The truth: This isn't a glitch; it's an inheritance. AI doesn't "choose" to be deceptive, it mirrors the deceptive patterns ubiquitous in its training data - Why is it ubiquitous in training data you might ask? - Well, when was the last time you saw a “Buy” button that was a significantly different color than the rest of the buttons on the screen? - Show examples from Amazon, Etsy, online shopping sites - When was the last time you were confirmed-shamed? - Show a bunch of examples on the presentation - By vibe coding without checks and filters, we're effectively scaling a legacy of UIs that have deceptive patterns embedded into them **Phase 3: The New Toolkit** We show how to use the same AI tools that build these interfaces to identify, flag, and neutralize deceptive patterns before they reach the user. - Demo: Using an AI Agent (like Cursor) as an ethical auditor - The takeaway: A 3-step "Sanity Check" framework for auditing AI-generated interfaces. **What attendees will gain from this talk:** Attendees will walk away with a framework for ethical prompting and a toolkit for auditing AI-generated interfaces, ensuring that the future of development is as transparent as it is fast. Key takeaways include: - Ability to identify modern deceptive patterns that specifically leverage AI and machine learning - Understand the ethical implications of using "vibe coding" (natural language programming) in production environments - How to use AI, particularly Cursor skills, to implement automated and manual "sanity checks" to ensure AI-generated UIs remain user-centric and honest **Why this talk:** DevConf is about the intersection of craft and technology. As designers and developers alike move toward becoming "orchestrators" of AI-generated code, understanding the ethics of the software and interfaces we ship is not just a designer's job, it's a core engineering responsibility too. devconf-us-2026-2987-the-evolution-of-deceptive-ux-patterns Open Track Kevin HatchouaYahav Manor en false https://pretalx.devconf.info/devconf-us-2026/talk/UK9GRG/ https://pretalx.devconf.info/devconf-us-2026/talk/UK9GRG/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T13:10:00-04:00 13:10 00:35 Within openSUSE, transactional systems, based on btrfs snapshotting are offered, through the MicroOS product. Transactional systems offer a middle ground between Fedora Atomics, and their image based updating, and read-only filesystems and Traditional Fedora, with it's read/write filesystems, as they can be configured to do either, offering great flexibility. In a read-only context, transactional Fedora offers a minimal system, and workloads are handled through podman or docker containers, for server usage. On the desktop, toolbox, distrobox, flatpaks, and potentially other application delivery mechanisms can be used, while still providing the possibility of local modifications to the read-only filesystem, for things that just make sense to be delivered via RPM. In a read-write context, Transactional systems offer Atomic updating, offering the possibility of more reliable updating, more stable systems over time, and the ability to "rollback" snapshots, in case of issues. or for troubleshooting purposes. This talk will discuss the basic ideas behind Transactional Updates, how they're used in openSUSE, and what it takes to bring them to Fedora. devconf-us-2026-2997-transactional-systems-in-the-fedora-ecosystem Open Track Neal GompaShawn W Dunn en false https://pretalx.devconf.info/devconf-us-2026/talk/UFLDJZ/ https://pretalx.devconf.info/devconf-us-2026/talk/UFLDJZ/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T13:50:00-04:00 13:50 00:35 Open source projects power everything from small experiments to major production systems, yet most maintainers still have very little visibility into how their work is actually being used. Stars, forks, and download counts only capture a thin slice of reality, and they often fail to answer the questions that matter most: Who is using this? How are they using it? What should I focus on next? This talk is a practical introduction to modern usage analytics for OSS maintainers. We will look at what meaningful signals really look like today, how to instrument your project in a way that respects users and community norms, and how to interpret usage patterns so you can guide your roadmap, prioritize issues, and understand the true impact of your project. If you are tired of guessing what is happening with your project, or relying on metrics that do not match what you see day to day, you will leave with a clear framework and a lightweight toolkit for bringing reliable usage insight to your open source work. devconf-us-2026-3017-open-source-analytics-101 Open Track Avi Press en false https://pretalx.devconf.info/devconf-us-2026/talk/WBRWFZ/ https://pretalx.devconf.info/devconf-us-2026/talk/WBRWFZ/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T14:50:00-04:00 14:50 00:35 The traditional tech career path (student, intern, junior, mid-level, senior) is breaking. With the rise of Agentic AI and "vibecoding," Gen Z engineers are no longer waiting to be mentored on basic syntax; we are using AI to orchestrate entire systems from day one. As a 19-year-old full-time student and Founding Engineer at KanoParty, I use AI to bypass traditional corporate hierarchies and ship production-ready features for a rapidly scaling marketplace. This talk isn't about how to prompt an LLM; it's about the mindset of the developer prompting it. Senior engineers possess a decade of architectural wisdom, but the incoming generation brings unprecedented execution velocity. In this session, we will explore the "Gen Z Builder Blueprint." For tech leads, open-source maintainers, and senior developers, I will break down how high-agency, AI-native developers operate. We will discuss how to manage, mentor, and integrate a generation that prioritizes shipping velocity over climbing the traditional corporate ladder, and what this means for the future of open-source collaboration. devconf-us-2026-2974-the-end-of-the-junior-developer-how-gen-z-builders-are-redefining-engineering-culture Open Track Artemis Leonardou en false https://pretalx.devconf.info/devconf-us-2026/talk/3MASYJ/ https://pretalx.devconf.info/devconf-us-2026/talk/3MASYJ/feedback/ Hewitt Boardroom (Capacity 35) Talk 2026-09-25T15:30:00-04:00 15:30 00:35 The rapid ascent of Generative AI has disrupted traditional UX workflows, forcing teams to move beyond "business as usual." At Red Hat, our User Experience Design team is navigating this shift by integrating AI directly into our research and design processes to increase velocity by transforming raw feedback into polished design updates faster than ever before. In this session, we share a transparent look at our journey toward becoming an AI-first UX team. We will showcase real-world applications of AI-driven tooling, including: **- Augmented Research Synthesis:** Using custom scripts and LLMs to extract user needs and pain points from hours of meeting transcripts in seconds. **- Prototyping with Code:** Leveraging AI-powered code editors like Cursor to deliver interactive prototypes built on our design system, moving beyond the limitations of static Figma mocks. **- Quality Agents:** Deploying numerous AI agents to ensure design and content consistency across complex product features. **The Perspectives** We believe the "human" side of AI adoption is just as important as the tech. Our discussion features three distinct viewpoints: **- The Strategist:** Tasked with identifying an AI roadmap and managing the cultural and procedural rollout. **- The Architect:** An AI-savvy designer who embraced the tech early and built the custom tooling empowering the rest of the team. **- The Skeptic:** A self-described "AI newb" who values stability and will share the honest challenges of being pushed into an AI-driven workflow. **We’ll talk about:** - How our UX team identified and built AI-driven tools to solve specific workflow bottlenecks. - Challenges we encountered while shifting a team’s culture and processes toward an "AI-first" mindset. - Lessons we’ve learned from our experience and what we see coming next for the UX craft. devconf-us-2026-3235-becoming-an-ai-first-ux-team-lessons-for-experts-and-newbs Open Track Beau Morley en false https://pretalx.devconf.info/devconf-us-2026/talk/LSZQWG/ https://pretalx.devconf.info/devconf-us-2026/talk/LSZQWG/feedback/ 107 (Capacity 20) Workshop 2026-09-25T09:00:00-04:00 09:00 01:20 Prompt optimization is still mostly hand-crafted: edit the wording, rerun a few examples, inspect failures, and repeat. That is like hand-crafting image kernels for every new vision problem. It can work for simple cases, but it does not scale well, and it is hard to reproduce. GEPA offers an algorithmic alternative. It is a gradient-free form of RL for LLM systems: sample candidate behaviors, evaluate them, use feedback from failures, and search for better policies. But instead of updating model weights with PPO or GRPO, GEPA optimizes the text artifacts that shape model behavior: prompts, and system instructions. This talk is for engineers building LLM applications or agent workflows who want to move from prompt tweaking to evaluation-driven optimization. We’ll walk through the core GEPA recipe: writing an evaluation callable, returning both reward and natural-language feedback, exposing one or more text variables to optimize, and running the optimizer on a small dataset. Attendees will leave with a runnable notebook, a mental model for when GEPA is useful, and a reusable recipe for applying automatic prompt optimization to their own LLM systems. devconf-us-2026-3222-the-cheapest-way-to-rl-tune-llms-getting-started-with-gepa Artificial Intelligence and Data Science Rohan Awhad en false https://pretalx.devconf.info/devconf-us-2026/talk/3FHZHW/ https://pretalx.devconf.info/devconf-us-2026/talk/3FHZHW/feedback/ 107 (Capacity 20) Workshop 2026-09-25T12:30:00-04:00 12:30 01:20 In this workshop you will assemble a small but realistic solution from a few products and integrations using the Helmet framework—not by writing a custom orchestrator from scratch, but by composing charts, wiring integrations, and driving configuration the way Helmet expects. We start from an embedded installer layout: charts on disk, a blueprint that declares what is in the bundle, and merged configuration for settings, products, and integrations. In guided exercises you will add or adjust pieces, run topology to see resolved order, exercise config workflows (including dry-run), and connect integration metadata to consuming charts. By the end, you will have walked the path from “empty bundle” to “coherent multi-chart story” with clear seams for swapping demo vs production values. Prerequisites: Laptop with kubectl and cluster access (or local Kubernetes) as announced by organizers; Helm basics; comfortable editing YAML. No prior Helmet experience required. Format note: Hands-on, goal-oriented steps with helper repos or embedded examples; instructors troubleshoot common Helm/topology mistakes. Takeaways: - Scaffold or extend an installer that combines multiple Helm charts under one CLI. - Express dependencies and integrations so installs stay reproducible. - Practice the demo → tighter PoC leap using the same composition model. devconf-us-2026-3230-build-a-multi-product-kubernetes-solution-with-helmet-hands-on DevOps and Automation David PerazaRomain Arnaud en false https://pretalx.devconf.info/devconf-us-2026/talk/XWZLYQ/ https://pretalx.devconf.info/devconf-us-2026/talk/XWZLYQ/feedback/ Brookline Room (Capacity 18) Meetup 2026-09-25T09:30:00-04:00 09:30 01:20 How do you use AI to generate code? Do you have a project that you've built with AI that you'd like to share? Let's talk about Cursor, OpenCode, Claude Code, Codex, spec coding, building websites, games, and frontend apps. All levels are welcome to join! devconf-us-2026-3249-ai-coding-agents Open Track Justin SunBill Murdock en false https://pretalx.devconf.info/devconf-us-2026/talk/RZNRUA/ https://pretalx.devconf.info/devconf-us-2026/talk/RZNRUA/feedback/ Brookline Room (Capacity 18) Talk 2026-09-25T12:30:00-04:00 12:30 02:30 Join the Parasol Insurance Corporation as we use automation to save time and money so the company can focus on innovation in the insurance industry and  reduce security risks on AWS in their Red Hat Enterprise Linux (RHEL) environment used for managing their critical infrastructure. devconf-us-2026-3276-game-day-aws-and-red-hat-enterprise-linux-automation-quest-day-2 Open Track Eyal Gutkind en false https://pretalx.devconf.info/devconf-us-2026/talk/JQ8WYC/ https://pretalx.devconf.info/devconf-us-2026/talk/JQ8WYC/feedback/ Show Floor Booth 2026-09-25T09:00:00-04:00 09:00 07:00 Meet and network with the following communities on the show floor! - Foreman, Katello, and Pulp Community Booth - Fedora & CentOS: RHEL Upstreams Ecosystem - OpenSUSE - UXD devconf-us-2026-3266-booths-day-2 General en false https://pretalx.devconf.info/devconf-us-2026/talk/FQQEFJ/ https://pretalx.devconf.info/devconf-us-2026/talk/FQQEFJ/feedback/