# From HACMS and ARES to Your First seL4 System: A Learning Path for Small Defense Firms, and How to Design With Frontier AI

DARPA&#39;s HACMS and AFRL&#39;s ARES showed what the seL4 kernel can do. A learning path for small firms and job seekers, plus a worked AI-assisted redesign of a Raspberry Pi ADS-B feeder.

Author: J.A. Watte
Published: November 19, 2026
Source: https://jwatte.com/blog/sel4-hacms-ares-learning-path-frontier-ai/

---

Two things happened in the last few weeks that make the seL4 microkernel worth learning right now if you work in, or want to work in, the defense industrial base.

On October 30, 2026, the seL4 Foundation shipped seL4 17.0.0 and thanked Anthropic for reporting "a number of" the issues it fixed, after an AI-assisted audit of the kernel. Every issue was outside what seL4's mathematical proofs cover. Then on November 12, MIT Lincoln Laboratory won an R&D 100 Award for [Magnetite](/blog/magnetite-secure-embedded-os-lincoln-lab/), an operating system built on seL4 that is being integrated into Department of War space and flight platforms.

The same year, frontier AI models found thousands of serious vulnerabilities in every major operating system. Verified kernels are one of the few designs where a single AI-found bug does not hand over the whole machine. Demand for people who can build on them is rising faster than the supply. Proofcraft, the company that maintains the seL4 proofs, told WIRED that interest easily outpaces what it and its competitors can provide.

This article covers:

1. What DARPA's HACMS and AFRL's ARES programs actually proved, and how small companies built businesses around them.
2. A step-by-step learning path through the material at [sel4.systems](https://sel4.systems/), for a small firm or for one engineer.
3. How to use frontier AI models to design around seL4 without fooling yourself.
4. A worked example: what it would take to move the open-source ADS-B Exchange aircraft-tracking feeder from a stock Raspberry Pi onto seL4, based on its GitHub source.

## Part 1: what HACMS and ARES proved

### DARPA HACMS: the helicopter that stayed safe after a hack

DARPA's High-Assurance Cyber Military Systems program started with an uncomfortable demonstration. A red team quickly took over the baseline version of Boeing's Unmanned Little Bird helicopter and reached its flight-control computer. DARPA's case study says plainly that "the Red Team owned the entire system."

The fix was not a patch. It was an architecture change, done in steps. The seL4 whitepaper describes what it calls "incremental cyber-retrofit," a term coined by then-DARPA program director John Launchbury:

1. **Put seL4 underneath and run the entire existing Linux stack in one virtual machine.** This step "buys nothing in terms of security," the whitepaper says. It sets a baseline.
2. **Break out the riskiest pieces.** The untrusted camera software moved into a second Linux VM, and the network stack came out of Linux into a native seL4 component.
3. **Pull every remaining critical module into its own isolated component.** That included the mission manager, ground station link, crypto, and even the untrusted GPS software. The original main VM disappeared. What was left was a set of native components plus one VM running Linux and the camera.

The red team then got six weeks with full source code access and failed. DARPA then gave it a foothold in the camera partition. The attackers "could compromise the Linux system and do whatever they wanted with it," the whitepaper says, "but were unable to break out." DARPA repeated the test in flight with two pilots aboard. On a quadcopter earlier in the program, the team rewrote about 80,000 of 100,000 lines with formal methods, and DARPA says the approach later went into satellites and self-driving convoy trucks.

**The lesson that matters for you:** HACMS did not rewrite everything. It drew boundaries. The camera's Linux was still hackable. It just could not reach anything that mattered.

### AFRL ARES: seL4 as the base for Air Force weapon systems

The Air Force Research Laboratory's Agile and Resilient Embedded Systems program took seL4 into Air Force systems. A 2019 paper by DornerWorks engineers and an Army ground-vehicle researcher, presented at an NDIA symposium, describes ARES as using "the seL4 microkernel as the foundation for a layered software environment" that:

- "Fully isolates and controls applications"
- "Protects and monitors processes, memory, interfaces, and communication"
- "Provides formally verifiable access control"
- "Secures communication via dynamic encryption"

The paper says ARES delivered drivers, a common library, secure communication between processes and process and memory introspection. That gave a "significant increase in the ability to detect, isolate, and recover from high priority cyber effects." It also records a design point every newcomer should absorb. The Air Force recognized that a typical military trusted computing base mixes verified software (seL4) with unverified software (Linux), and that "the use of unverified software in the trusted computing base significantly degrades assurance."

The Trusted Computing Center of Excellence, a defense-oriented nonprofit that promotes seL4 adoption, publishes a table of available platforms. It lists ARES software stacks from the small company Trusted Science and Technology on a Xilinx ZCU-102 board, an Arm Morello board with CHERI and a PolarFire RISC-V board. The stack also runs with GE Aviation flight management software on a GE Aviation M-100 mission computer, which completed "fixed-wing flight tests using mission-relevant scenarios and realistic attacks." Every row is marked government-off-the-shelf and "not turnkey."

Each row also carries a footnote worth memorizing: "This software is a modification of seL4, not seL4 itself, and has not been formally verified by the seL4 Foundation." Modify the kernel and you no longer have the proof. The seL4 whitepaper says the same thing more bluntly: "you must not make any verification claim if you are using a kernel that is not verified for your platform, or that is in any way modified."

### How small businesses built on this

The pattern in the public record is SBIR-funded companies taking DARPA and AFRL research into fieldable products.

- **Trusted Science and Technology.** A 2022 Army presentation describes the company's work under Army SBIR topic 19-103. It ported "the seL4-based AFRL ARES Secure Kernel" to RISC-V on a PolarFire board, and added "just-in-time" loading so a mission function "is loaded and executed only when necessary," shrinking how long it is exposed. The presentation says the result would be offered to the government and its performers through a private TCCoE repository. It also listed GE Aviation, Northrop Grumman, Draper and Lockheed Martin as potential transition partners.
- **DornerWorks.** A founding member of the seL4 Foundation and one of its endorsed service providers. Its 2019 paper describes an seL4 virtual machine monitor for Army ground-vehicle electronics. The TCCoE table lists its seL4 stack on a Collins Aerospace VPM as "demonstrated on fieldable hardware for SBIR," running guest operating systems including Deos, VxWorks 7, Linux, RTEMS and FreeRTOS.
- **The endorsed service providers.** The seL4 Foundation lists DornerWorks, Kry10, Proofcraft and UNSW's Trustworthy Systems group as endorsed service providers. To be endorsed, a provider "must have one or more in-house experts who have already contributed in the area they are endorsed for." For a small firm, that rule says how you get credibility in this ecosystem: you contribute.

## Part 2: a learning path through sel4.systems

seL4 is open source and free to use. Its development is funded by Foundation memberships. Everything below is free unless noted. The sequence is ordered so each step makes the next one make sense.

### Step 0: prerequisites (a few weeks if you are rusty)

The seL4 docsite says most tutorials "require C programming experience and some understanding of operating systems and computer architecture." It points to a C tutorial, Tanenbaum's *Modern Operating Systems* and UNSW's COMP3231 operating systems slides. If you write embedded C already, skip ahead.

### Step 1: read the whitepaper and the proof pages (one weekend)

Start with [The seL4 Microkernel: An Introduction](https://sel4.systems/About/seL4-whitepaper.pdf) by Gernot Heiser. It explains capabilities, the Microkit, mixed-criticality scheduling, performance and the HACMS retrofit in plain language. Then read three short pages that most newcomers skip and most experts quote:

- [seL4 Proofs](https://sel4.systems/Verification/proofs.html): what is proven, and the record of "no functional correctness defects in verified code" since 2009.
- [What the Proofs Assume](https://sel4.systems/Verification/assumptions.html): the parts that are reviewed rather than proven, including cache and TLB handling, handwritten assembly and boot code.
- [Verified Configurations](https://docs.sel4.systems/projects/sel4/verified-configurations.html): exactly which architecture, board and option combinations carry which proofs. It notes that no verified configuration yet covers device address translation (SMMU or IOMMU), debug interfaces or kernel startup.

You'll need these three pages for every design decision later.

### Step 2: the Microkit tutorial (one to two weeks)

The docsite recommends starting with the [Microkit tutorial](https://docs.sel4.systems/projects/microkit/tutorial/welcome.html). It says CAmkES, the older component framework HACMS used, "is being superseded by Microkit." You build a Wordle game made of "a device driver," "a trusted server (which has the secret word)" and "an untrusted client." It's a toy, but it has a real security architecture. Everything runs in the QEMU emulator, so you need no hardware.

The Microkit has very few concepts. A **protection domain** (PD) is like a process. By default it "cannot do much except execute its code." **Channels** connect two PDs for notifications or protected procedure calls. **Memory regions** are shared buffers mapped into PDs with specific permissions. The whole system is written in one XML **system description file**. The whitepaper states the Microkit's promise: "no interactions are possible beyond those defined in the SDF." That file is your security architecture, and Part 3 is mostly about getting it right.

### Step 3: the core seL4 tutorials (two to four weeks)

The [seL4 tutorials](https://docs.sel4.systems/Tutorials/) teach the kernel API underneath: capabilities, untyped memory, threads, IPC, notifications, interrupts and fault handling. Use the [seL4 manual](https://sel4.systems/Info/Docs/seL4-manual-latest.pdf) as the reference. The Microkit hides this layer, but you need it to debug, to write drivers and to review someone else's design.

### Step 4: Rust on seL4 (two weeks)

The [Rust on seL4 tutorial](https://docs.sel4.systems/projects/rust/tutorial/introduction.html) covers writing root tasks and Microkit components in Rust with the rust-sel4 crates (version 6.0.0 shipped alongside seL4 17.0.0). This is where most new component code is heading. Lincoln Lab's Magnetite writes its services in Rust, and Google reported a 1000x lower memory-safety vulnerability density for Rust than for C and C++ in Android.

### Step 5: virtualization and retrofit (two to four weeks)

Real systems run legacy Linux in a VM next to native components. That's the HACMS pattern, and the Microkit tutorial includes a part on running virtual machines. Practice the three-step retrofit on something you own: whole stack in a VM, then break out the riskiest piece, then the critical pieces. The worked example below gives you a target.

### Step 6: drivers (ongoing)

seL4 runs drivers as ordinary isolated components, not inside the kernel. The [seL4 Device Driver Framework (sDDF)](https://github.com/au-ts/sddf) from UNSW is the place to start. Read its driver directory before promising a customer anything. As of its November 2026 source tree, it has driver classes for block storage, GPU, I2C, network, serial and timers, and no USB class. That single fact drives the hardware choices in the worked example below.

### Step 7: verification literacy (ongoing)

You don't need to write Isabelle proofs to be valuable, but you need to read a release note like a verifier. Practice on the [seL4 17.0.0 release notes](https://docs.sel4.systems/releases/sel4/17.0.0.html). For every fix, ask: does it affect a verified configuration, why wasn't the proof violated, and which assumption did it touch? If you want to go further, the proofs live in the [l4v repository](https://github.com/seL4/l4v), and the seL4 site lists university courses on microkernels and verification.

### Step 8: show up (ongoing)

- **The seL4 Summit** is the annual conference. The 2026 videos and slides are online. Lincoln Lab's two Magnetite talks are a model of how to present seL4 work.
- **The TCCoE Summit** runs alongside the High Confidence Software and Systems conference in Annapolis, and is where the defense side of the community meets.
- **Contribute** a driver, a board port, a tutorial fix or a Rust example. The endorsed-provider rule shows how much contributions count.

### What to put on a resume or capability statement

For an individual: a public repository with a working Microkit system on real hardware, a short design note explaining your system description file and which verified configuration you targeted, and one contribution upstream. For a small firm: one board you can bring up from scratch, one retrofit you can demonstrate, and a clear statement of which parts of your stack are verified, which are memory-safe, and which are neither. That last item is what program offices and primes will test you on.

## Part 3: designing around seL4 with frontier AI

Frontier models are now useful at every stage of seL4 work, and dangerous at every stage if you trust them blindly. Here is a workflow with the checks that keep it honest.

### Why AI changes the economics

Verification has always been the expensive part. Anthropic's formal verification research notes that seL4 took "two person-years to implement" but "20 person-years to formally verify." (Other sources give 27 or 30. The numbers depend on what is counted.) That ratio is what kept verified software in a niche, and it is the part AI is now attacking:

- A February 2026 paper, AutoReal, reported a 7-billion-parameter model that proved 51.67% of 660 seL4 theorems, against 27.06% for earlier attempts, small enough to run locally.
- Anthropic and the startup Theorem reported using Claude to prove security properties at the assembly level across 123 open-source libraries. Theorem published a [Claude skill](https://github.com/theorem-labs/oss-verify/blob/main/.claude/skills/add-project/SKILL.md) so other developers can try the same pipeline.
- DARPA's PROVERS program aims to make formal methods usable by "traditional software developers and systems engineers," building on its PEARLS project, which showed AI could help generate and maintain proofs at scale.

The other side matters just as much. The October seL4 release came from an AI-assisted audit that found real crash bugs in verified configurations, in code the proofs assume rather than prove. Proofcraft warns that AI-generated specifications can create "unjustified trust," and says the questions to ask are "did it prove the right property" and "did it prove something about the right code." In WIRED's reporting, Antithesis, a testing company, said it found bugs in software that customers had already formally verified.

So the working rule is: **use AI to go faster at drafting, and to be more thorough at attacking your own design. Never let it be the one who signs off.**

### The workflow

**1. Tutor, then check.** Ask a model to explain capabilities, the Microkit entry points or a specific release note. Then check its answer against the manual or docsite, every time, until you've caught it wrong a few times and learned where it drifts. Models are often out of date on seL4 because the APIs and the Microkit change between releases.

**2. Decompose the system with the whitepaper's first question.** The whitepaper says the first step is "to identify the critical assets you need to protect," then to make that part "as modular as feasible, with each module becoming an seL4-protected (Microkit) component." Give the model your current architecture and ask it to list the assets, the untrusted inputs and the smallest set of components that must be trusted. Make it argue for each boundary.

**3. Draft the system description file.** Have the model write the SDF. It's short, structured XML, and models are good at it. Then do the next step, which is the important one.

**4. Attack your own design.** In a fresh session, give a model the SDF and your intended policy ("the network-facing component must never write to the uplink buffer," "nothing reaches the signing key except one call") and ask it to break the policy using only what the SDF permits. Also have it write a small script that parses the SDF and prints every channel, map and permission as a graph, and check that script's output yourself. A deterministic listing beats a model's summary. Typical findings: a buffer mapped `rw` where `r` was intended, a channel that lets the low-trust side notify the high-trust side when you didn't mean it to (notifications default to allowed in both directions), one component quietly bridging two trust levels, or a protected procedure call pointing the wrong way. The Microkit only allows those calls to strictly higher-priority components.

**5. Write components, mostly in Rust.** Let the model write protection domains with rust-sel4. Keep `unsafe` to the driver code that must touch hardware, and review every unsafe block by hand. That is where Anthropic found a memory-corruption bug in a production memory-safe virtual machine monitor. Test on QEMU first, then on the board.

**6. Audit the unverified parts the way attackers will.** The proof covers the kernel's code. It does not cover your components, your drivers, your boot chain or the kernel's own hardware assumptions. Run AI-assisted review over all of it. Anthropic's Mythos write-up describes a simple method: rank every file by how likely it is to hold a bug, starting with anything that parses outside input, then have agents work file by file and confirm each finding before reporting it.

**7. Use AI on proofs only with an expert in the loop.** If you take on verification of a component, pair the model with someone who can judge whether the specification says what you need. A machine-checked proof of the wrong property is worse than no proof, because people believe it.

**8. Keep controlled information out of public tools.** Defense design data is often export-controlled or Controlled Unclassified Information. Use an AI environment your contract and your security officer have approved for that data, and keep public chat tools for public material such as the seL4 docs and open-source code.

## Part 4: worked example: an ADS-B feeder on seL4 instead of a stock Raspberry Pi

### Why this example

ADS-B is the radio broadcast aircraft use to report identity and position. ADS-B Exchange runs a large network of volunteer receivers, and its feeder software is open source on GitHub. A feeder is a small embedded system with the same shape as many defense sensors: an untrusted radio input, signal processing, local state, and an authenticated uplink to a remote service. The same architecture turns up in airfield sensors, counter-drone sensors and ISR payloads. It is a realistic practice target, and the code is public.

To be clear up front: this is a design exercise, not a criticism of ADS-B Exchange. A stock Raspberry Pi is the right choice for a volunteer feeder. The question is what the same function would look like if it had to meet a defense customer's assurance bar.

### What the GitHub source shows today

I cloned the main repositories on November 19, 2026.

| Component | Repository | What it is |
|---|---|---|
| Installer and services | `feedclient` | Shell scripts that install the feed and MLAT services on an existing Raspberry Pi OS or other Linux receiver |
| Decoder | `readsb` | About 54,000 lines of C (GPL v3). It demodulates the radio samples, decodes Mode S and ADS-B, tracks aircraft and serves network feeds, JSON and an API |
| Radio drivers | inside `readsb` | Back ends for RTL-SDR, bladeRF, HackRF, PlutoSDR, SoapySDR, Beast hardware and recorded-sample files. RTL-SDR is linked through `librtlsdr` and `libusb-1.0` |
| Multilateration | `mlat-client` | Python with a C extension (about 3,500 and 2,500 lines, GPL v3). It forwards timestamped messages so a server can locate aircraft that don't broadcast position |
| SD card image | `image-builder` | Builds the feeder image on Raspberry Pi OS Lite (32-bit Arm, Buster and Bullseye bases) |
| Extras | `adsbx-webconfig`, `remote-mgmt`, `tar1090` | A PHP web configuration page, an optional remote management add-on, and the web map |

The data flow, from the feed configuration: readsb decodes locally and offers Beast-format frames on port 30005. A second readsb instance in "net-connector" mode reads those frames and sends a reduced Beast feed to the exchange's servers, while mlat-client sends timing data to a separate MLAT server.

Everything runs on one Linux kernel, with one set of system privileges and one network stack. A memory bug in any piece is a bug in the same machine as everything else. That's normal for a Pi appliance. It's also exactly the shape HACMS started from.

The decoder's size breaks down usefully. The core radio logic is small: `demod_2400.c` (759 lines), `mode_s.c` (2,243), `cpr.c` (374) and `crc.c` (566). The network and output code is much larger: `net_io.c` (5,944), `json_out.c` (2,324), `api.c` (2,141) and `globe_index.c` (3,804). For an isolated design, that split matters more than the total.

### The hardware facts that decide the design

Three facts from the seL4 and sDDF documentation shape everything:

1. **The Raspberry Pi 4B is a verified seL4 platform.** It is on the verified list for the AArch64 configuration, in which seL4 runs as a hypervisor. The kernel can be the same one with the proofs.
2. **seL4's hardware table lists no SMMU for the Pi 4B.** An SMMU (or IOMMU) stops a device from using direct memory access to reach memory it shouldn't. Without one, any component you give a DMA-capable controller, such as the USB host controller, can program that controller to read or write any physical memory. That defeats isolation. Even where an SMMU exists, the verified configurations don't cover it yet.
3. **sDDF has no USB driver class.** The RTL-SDR dongle every hobby feeder uses is a USB device, so a native seL4 component can't talk to it today without writing a USB stack.

Together these rule out the obvious design, "run Linux in a VM just for the USB radio, and do everything else natively on the same Pi 4." On a board with no SMMU, the Linux VM that owns the USB controller is effectively trusted with all of memory.

### Three ways to do it

**Option A: retrofit step one (a week).** Boot verified seL4 17.0.0 or later on the Pi 4 and run the entire existing Raspberry Pi OS feeder in one Linux VM. As in HACMS, this buys no security. It proves the board, the boot chain and the VM monitor work, and gives you a baseline to measure against. Stay current on releases, because two of the 17.0.0 fixes were exactly in Arm hypervisor mode with guest VMs, one of them critical ("any guest VM" could halt the kernel).

**Option B: same board, partial split (weeks, with a big caveat).** Keep Linux, USB and the demodulator in the VM, and move the uplink, the feeder identity key and a frame validator into native components. This mirrors HACMS step two. On the Pi 4 the security gain is limited for the reason above: the VM holds a DMA-capable USB controller and no SMMU confines it. It's still worth building as a learning step, as long as nobody describes it as isolated.

**Option C: split the radio from the trusted box (the defensible design).** Treat the radio side as untrusted hardware and put a network between it and the trusted computer:

- **Radio front end:** a stock Pi or any small Linux board runs the RTL-SDR, readsb and the demodulator, and outputs Beast-format frames over Ethernet. readsb already does this today. That's what port 30005 is.
- **Trusted feeder:** a separate board on verified seL4, such as a second Pi 4, uses only its Ethernet controller, which sDDF supports through its GENET driver. It runs a handful of native Rust components:
  - `eth_rx`: receives frames from the front end and writes them to a one-way buffer.
  - `beast_parser`: reads that buffer and checks frame format, CRC and message types (a Rust port of the small `crc.c` and `mode_s.c` logic). It writes only validated frames to a second buffer.
  - `uplink`: reads validated frames and sends them to the exchange.
  - `signer`: holds the feeder's identity key and answers one kind of request.

  The JSON output, API and globe history (about 8,300 lines of readsb) and the web map stay off the trusted box entirely. They can live on the front end or anywhere else.

What Option C buys you: a compromised front end can send malformed frames, but it can only write to one buffer that one small parser reads. The parser can't touch the network directly, and nothing but the uplink can ask the signer to sign. Each step is a boundary the kernel's proof enforces.

What it doesn't buy you: ADS-B itself is unauthenticated, so a spoofed aircraft broadcast is valid data as far as any receiver knows. No operating system fixes that. MLAT also depends on precise sample timestamps that come from the radio side, so a compromised front end can corrupt timing even if it can't escape. Those are limits of the sensor, and the design should say so.

### The system description file for Option C

This is a sketch of the trust split, written with the elements the Microkit tutorial documents. A real build also needs the sDDF network driver components, device memory and interrupt entries, and flow control in the shared buffers, all left out here.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<system>
    <!-- Raw frames from the untrusted radio front end -->
    <memory_region name="rx_frames" size="0x10000" />
    <!-- Frames that passed validation -->
    <memory_region name="clean_frames" size="0x10000" />

    <protection_domain name="eth_rx" priority="200">
        <program_image path="eth_rx.elf" />
        <map mr="rx_frames" vaddr="0x4000000" perms="rw" setvar_vaddr="rx_frames" />
    </protection_domain>

    <protection_domain name="beast_parser" priority="150">
        <program_image path="beast_parser.elf" />
        <map mr="rx_frames" vaddr="0x4000000" perms="r" setvar_vaddr="rx_frames" />
        <map mr="clean_frames" vaddr="0x5000000" perms="rw" setvar_vaddr="clean_frames" />
    </protection_domain>

    <protection_domain name="uplink" priority="100">
        <program_image path="uplink.elf" />
        <map mr="clean_frames" vaddr="0x5000000" perms="r" setvar_vaddr="clean_frames" />
    </protection_domain>

    <protection_domain name="signer" priority="250">
        <program_image path="signer.elf" />
    </protection_domain>

    <!-- eth_rx tells the parser new frames are waiting; the parser cannot notify back -->
    <channel>
        <end pd="eth_rx" id="1" />
        <end pd="beast_parser" id="1" notify="false" />
    </channel>
    <channel>
        <end pd="beast_parser" id="2" />
        <end pd="uplink" id="1" notify="false" />
    </channel>
    <!-- uplink may call the higher-priority signer; nothing else can reach it -->
    <channel>
        <end pd="uplink" id="2" pp="true" />
        <end pd="signer" id="1" notify="false" />
    </channel>
</system>
```

Read it the way an attacker would: `eth_rx` can only write `rx_frames`. The parser can read raw frames and write clean ones, but it can't map the uplink's memory. The uplink can read clean frames and call the signer. No component maps memory it doesn't need, and `signer` has no memory regions and one inbound call.

### Where AI does the work in this example

- **Module map.** Give a model the readsb source and ask which functions the trusted side actually needs. The size breakdown above came from exactly that kind of pass, and it should be checked against the code, as it was here.
- **The SDF review.** Step 4 of the workflow on this file. Ask it to find any path from `eth_rx` to the signer, any writable mapping that should be read-only, and any default you didn't set on purpose.
- **The Rust port, with differential testing.** Have the model port the CRC and Mode S checks to Rust. Then test it the boring way. readsb can replay recorded samples from a file (`sdr_ifile.c`), so record real traffic once and require the Rust parser and the original C code to agree frame for frame. A model writing the port and a different model writing the test harness is a reasonable split, as long as the pass condition is a deterministic diff.
- **Attack the parser.** Fuzz `beast_parser` with malformed frames, and have a model audit it as hostile input handling, since that's what it is.
- **The license check.** readsb and mlat-client are GPL v3. A port derived from them carries GPL obligations if you distribute it. A defense customer's lawyers will ask about this before its engineers do, so settle it before you write code: clean-room the logic or plan for GPL.

### Is it worth it?

For a volunteer feeder, no. The Pi does the job. As a training project, yes, and the reason is the point of this whole article. The jump from "one Linux box" to "isolated components on a verified kernel" is the same jump HACMS made for a helicopter, ARES for Air Force mission computers and Magnetite for satellites. The steps are the same every time: find the critical assets, check the hardware against the verified configurations and the driver framework, move the untrusted parts behind boundaries, and keep honest notes about what the proof does and doesn't cover. A small firm that has done this end to end on a public example has something concrete to show a program office.

## Why this is worth the effort: the short version

- **Monolithic systems fall to chained bugs.** Anthropic reported Mythos Preview chaining two to four Linux kernel vulnerabilities into full root, and finding a 27-year-old crash bug in OpenBSD. On seL4, one bug in one component gets the attacker that component.
- **The proof has held.** No functional correctness defects in verified seL4 code since 2009, including through a 2026 AI-assisted audit that found real bugs in the code around the proven part.
- **The defense programs are real and fielded.** HACMS flew under attack with pilots aboard. ARES stacks completed fixed-wing flight tests on a GE Aviation mission computer. Magnetite is going into Department of War space and flight platforms.
- **Small firms got in through SBIR.** Trusted Science and Technology and DornerWorks show the path: take government research, make it run on fieldable hardware, and contribute back.
- **AI is cutting the cost of the expensive part.** The proof work that took tens of person-years is where AI-assisted proving is making its fastest gains. The people who understand both sides will be scarce.

## Fact-check notes and sources

- **HACMS:** DARPA, [HACMS case study](https://www.darpa.mil/news/resources/case-studies/hacms) (red team results, six weeks, camera partition, in-flight test, quadcopter rewrite, later systems). seL4 whitepaper, [The seL4 Microkernel: An Introduction](https://sel4.systems/About/seL4-whitepaper.pdf), Chapter 7 (incremental cyber-retrofit, the three steps, the quotes, the "must not make any verification claim" rule, the "identify the critical assets" advice) and Chapter 3 (Microkit abstractions, the SDF promise, the note that verification does not cover timing channels).
- **ARES:** R. VanVossen et al., [The seL4 Microkernel: A Robust, Resilient, and Open-Source Foundation for Ground Vehicle Electronics Architecture](https://events.esd.org/wp-content/uploads/2019/08/The-seL4-Microkernel-A-Robust-Resilient-and-Open-Source-Foundation-for-Ground-Vehicle-Electronic.pdf), NDIA GVSETS 2019 (the four ARES bullets, deliverables, the verified and unverified trusted computing base quote). Trusted Computing Center of Excellence, [Existing Platforms and Capabilities](https://trustedcomputingcoe.org/resources/platforms-and-capabilities/) (Trusted ST and DornerWorks rows, flight tests, the modification footnote). [TCCoE home](https://trustedcomputingcoe.org/) for the mission and the HCSS co-location.
- **Army SBIR example:** T. Barnett, U.S. Army DEVCOM Aviation and Missile Center, [Secure Architecture for Mission Critical Systems](https://static-gcs.edit.site/users-files/62fd8041e419a5e5ddd285a51921016f/barnett-secure-architecture-for-mission-critical-systems-v2.pdf?dl=1), TCCoE Summit, February 2022 (SBIR topic 19-103, porting the ARES Secure Kernel to RISC-V, just-in-time loading, the TCCoE private repository, the stakeholders listed).
- **seL4 resources:** [seL4 home](https://sel4.systems/), [Learn](https://sel4.systems/Learn/index.html), [tutorial overview](https://docs.sel4.systems/Tutorials/) (prerequisites, CAmkES being superseded), [Microkit tutorial](https://docs.sel4.systems/projects/microkit/tutorial/welcome.html) and its [part 1](https://docs.sel4.systems/projects/microkit/tutorial/part1.html) and [part 2](https://docs.sel4.systems/projects/microkit/tutorial/part2.html) (protection domains, channels and the `pp` and `notify` attributes, memory regions and maps, the priority rule), [Commercial Support](https://sel4.systems/Services/) (endorsed providers and the endorsement rule), [Supported platforms](https://docs.sel4.systems/Hardware/) (Pi 4B row, no SMMU) and [Verified Configurations](https://docs.sel4.systems/projects/sel4/verified-configurations.html) (Pi 4B in AArch64, unverified SMMU, debug and boot).
- **Proofs and the October release:** [seL4 Proofs](https://sel4.systems/Verification/proofs.html), [What the Proofs Assume](https://sel4.systems/Verification/assumptions.html), seL4 [News](https://sel4.systems/news/) and [17.0.0 release notes](https://docs.sel4.systems/releases/sel4/17.0.0.html).
- **Drivers:** [sDDF repository](https://github.com/au-ts/sddf), driver directory read at commit cbbcfe0 (November 17, 2026).
- **AI and verification:** Anthropic, [LLMs are making formal software verification feasible at a much larger scale](https://www.anthropic.com/research/formal-verification) (2 and 20 person-years, 123 libraries, the Theorem skill). The 30 person-year figure is from Lincoln Laboratory's [2023 seL4 Summit talk](https://www.sel4.systems/Summit/2023/slides/day2-02-furgala.pdf). [AutoReal, arXiv 2602.08384](https://arxiv.org/abs/2602.08384). DARPA, [PROVERS](https://www.darpa.mil/program/pipelined-reasoning-of-verifiers-enabling-robust-systems). Proofcraft, [News 2026](https://proofcraft.systems/news-2026/). WIRED, [The 'Pain in the Ass' Math That Could Save Vibe Coding From Itself](https://www.wired.com/story/software-verification-is-the-hot-new-answer-to-the-ai-safety-crisis/) (demand outpacing supply, Antithesis's view). Anthropic Frontier Red Team, [Claude Mythos Preview's cybersecurity capabilities](https://red.anthropic.com/2026/mythos-preview) (Linux chains, OpenBSD, the memory-safe VMM bug, the file-ranking method). Google, [Rust in Android](https://blog.google/security/rust-in-android-move-fast-fix-things/).
- **ADS-B Exchange source:** repositories at [github.com/ADSBexchange](https://github.com/ADSBexchange), cloned November 19, 2026: [feedclient](https://github.com/ADSBexchange/feedclient) (ports and feed targets from `configure.sh` and `scripts/adsbexchange-feed.sh`), [readsb](https://github.com/ADSBexchange/readsb) (line counts from the files named, Makefile libraries, GPL v3), [mlat-client](https://github.com/ADSBexchange/mlat-client) (GPL v3), [image-builder](https://github.com/ADSBexchange/image-builder) (Raspberry Pi OS Lite bases). Line counts are raw file lengths, including comments.
- **Not claimed:** none of the seL4 designs for the feeder exist as far as I know. They are a worked exercise. Nothing in this article describes a flaw in ADS-B Exchange's software.

## Related reading

- [Magnetite: How MIT Lincoln Lab's Secure Embedded OS Works](/blog/magnetite-secure-embedded-os-lincoln-lab/): a full operating system on seL4, and what the October AI audit showed.
- [How to Build the Skills a Defense Data Platform Job Asks For, and What It Pays](/blog/becoming-defense-data-platform-engineer/): another skills path into defense work.
- [The high-risk research bet: how DARPA and AFRL are built for a few huge wins and many failures](/blog/darpa-afrl-portfolio-hits-misses/): the system that produced HACMS and ARES.
- [How ARTEX Works: A Defender's Guide to Agentic Attacks](/blog/how-artex-agentic-pentest-framework-works-defense/): what AI-driven attackers do, from the defender's side.
- [Ponytail Tells the Agent What to Do. These 9 Repos Check That It Did](/blog/nine-repos-enforce-ai-coding-rules/): keeping AI coding agents honest with checks, not trust.

*This post is informational, not security-engineering, legal, licensing or export-control advice. Confirm contract, data-handling and license obligations with your own counsel and security officer. Mentions of seL4, DARPA, AFRL, Boeing, GE Aviation, DornerWorks, Kry10, Proofcraft, Trusted Science and Technology, Collins Aerospace, UNSW, Anthropic, Claude, Theorem, Google, Raspberry Pi and ADS-B Exchange are nominative fair use. No affiliation is implied.*


---

Canonical HTML: https://jwatte.com/blog/sel4-hacms-ares-learning-path-frontier-ai/
RSS: https://jwatte.com/feed.xml
JSON Feed: https://jwatte.com/feed.json
Hero image: https://jwatte.com/images/sel4-hacms-ares-learning-path-frontier-ai.webp
