Open Source Summit + Embedded Linux Conference North America 2026

Modern embedded systems look to minimize power consumption without compromising the performance of the system. To address this challenge, Linux provides comprehensive frameworks for dynamic power management that adapt system performance in response to workload demands. This talk explores the pieces that form the foundation of Linux power optimization and demonstrates how to leverage these tools in real-world scenarios.
The key principles for reducing the power consumption of the embedded system include turning off inactive devices, reducing clock frequency, and lowering supply voltage. Linux provides frameworks such as Runtime PM to suspend inactive devices, CPUIdle for intelligent idle state management, DevFreq for memory and device frequency optimization, and CPUFreq for dynamic CPU frequency scaling. By leveraging these tools, systems can reduce power dissipation while still meeting the demands of the application use case, without sacrificing performance. Through a practical case study on a TI AM62L SoC running a display application, this talk explores how different power optimization techniques interact and sometimes conflict, requiring iterative tuning to find optimal operating points.

Attendees will gain actionable optimization strategies, awareness of common pitfalls when subsystems interact, and practical debugging approaches applicable to their own embedded Linux projects.

Due to increased interest in fine-grained analysis of kernel composition and security (due to the CRA and other recent cybersecurity legislation), there have been a number of recent projects to 1) generate SBOMS for the linux kernel, and 2) finish adding the remaining SPDX-License-Identifier lines to the kernel source tree. In this talk, Tim will describe the current status of both of these efforts. Good progress has been made to add missing SPDX id lines, but more work is needed to complete this project. Tim proposes a kselftest test to make sure there are no regressions in this area. The status of different kernel SBOM generation tools, and upstream status, will be described.

This work should be of interest to companies interested in complying with cybersecurity requirements, as well as those involved with license compliance efforts.

This talk explores using Large Language Models (LLMs) to automate Linux kernel crashdump analysis at scale. At Cloudflare, we operate Linux across hundreds of thousands of servers. At this scale, kernel crashes are inevitable.
Typical crash analysis requires deep kernel expertise and significant time investment, slowing down time to resolution.
I'll share our journey building an LLM-powered agent that performs initial crash analysis autonomously. First, I'll cover our infrastructure for collecting and managing crashdumps across our fleet. Then I'll explain crashdump analysis fundamentals: using the crash utility, interpreting stack traces, identifying common failure patterns, and correlating crashes with kernel subsystems.
This talk focuses on teaching an LLM agent to replicate expert analysis workflows. I'll show how we structured prompts and created skills. I'll show examples of the agent analyzing real crashes.

AI agents don’t execute a single path, they explore many. They try different code changes, commands, or configurations in parallel, then keep the one that works. Today, running this safely on Linux requires fragile combinations of temp directories, git tricks, containers, or VM snapshots.

This talk introduces branch contexts, a new Linux execution model built for AI agents. A branch context gives each exploration path an isolated, copy-on-write filesystem and coordinated process group, with a simple lifecycle: fork, explore, commit or abort. The first successful branch commits atomically; all others are automatically invalidated.

We present two Linux implementations: BranchFS, a FUSE-based branching filesystem with O(1) branch creation and atomic commit without root privileges, and branch(), a proposed Linux syscall that composes filesystem branching, namespaces, and process lifecycle management into a single atomic operation.

We’ll explain why existing Linux mechanisms fall short for agent workloads and how fork/explore/commit semantics fit naturally into the future of Linux process and filesystem design.

As a Linux Kernel Developer at Ampere Computing, I focus on optimizing the scheduler for high-density ARM64 systems. My work culminates in a patch merged for the Linux 7.0 release that refines avg_idle tracking a critical metric the scheduler uses to decide how long to search for an idle CPU before giving up. In my session "The Hidden Cost of Sleep", I will break down the try_to_wake_up() path to show how even minor inaccuracies in idle-time accounting lead to poor CPU selection and increased cache misses. I’ll explain how my Linux 7.0 optimizations [commit
36ae1c45b2cede] specifically reduce the 'search cost' during wakeups, directly improving the responsiveness of AI inference workloads. By sharing raw performance data and trace analysis, I’ll demonstrate why getting the wakeup path right is the only way to achieve the deterministic performance needed for autonomous AI agents and scalable trust infrastructure.