Share
Anyone who has done a board bring-up knows that typing code is the smallest slice of the day. The rest goes to bring-up, debugging, validation, and the scope traces nobody schedules but everybody runs.
That framing anchored the conversation when BootLoop's Noah and Chris joined Memfault's Francois Baldassari on the Core Dump podcast. Every AI coding tool shipped in the last two years has optimized the part where you type. BootLoop is an AI agent for firmware engineers that targets everything else: the bench time, the bisects, the 2am current-draw measurements.
A few ideas from the episode.
AI in firmware only counts if it touches hardware
General-purpose coding assistants generate code in an editor. They never see your board, never read your datasheet, never know that your SPI_MOSI is on a non-default pin or that your clock tree is running off HSE with a custom PLL config. They are trained on the statistical average of public repositories, which means the output looks right until you put it on a scope.
BootLoop is built around two pillars.
The first is hardware understanding. The agent ingests schematics, datasheets, netlists, and Altium projects so it can reason about your specific chips, register maps, and pin assignments. Datasheet PDFs are notoriously hostile to parsers, with rotated register diagrams, multi-column tables, and errata published in separate documents. A lot of the engineering work sits in normalizing that input into something the model can actually use.
The second is hardware interaction. The agent drives oscilloscopes, logic analyzers, GDB, JTAG, and serial monitors so it can test what it writes against the physical board.
That combination reduces hallucination dramatically. The model is grounded in measurements rather than guesses.
Tight feedback loops are where agents actually work
On a well-supported Cortex-M target, BootLoop averages around 8.5 minutes from prompt to a hardware-tested peripheral driver in our internal benchmarks. Raw generation speed is not the reason. The agent builds, flashes, and tests on device automatically, then iterates with no copy-paste between IDE, terminal, and scope. The engineer reviews the diff once the loop converges, but the loop itself runs without intervention.
The same shape applies to debugging. In our benchmarks on a defined root-cause class (peripheral misconfiguration on a known-good board), the agent closes in on the fault roughly 23x faster than an unaided engineer. It reads status registers, watches lines on the logic analyzer, checks specific bitfields against the datasheet, and rules out hypotheses against measurements rather than intuition.
This matters most in bring-up, where there is often no working UART yet, no printf, and sometimes no clock. Closing the loop through a debug probe rather than serial output is what makes the agent useful before the board is fully alive.
Power optimization is a use case people don't expect
One example from the conversation worth calling out. Feed in the datasheet, connect a power meter, set a target current draw, and let the agent iterate until the code meets the spec. The agent tunes peripheral configs, sleep modes, DMA usage, and clock settings against a live measurement, watching the current trace fall after each change. Closed-loop optimization like this is tedious and error-prone by hand. Having a loop that runs unattended against a real reading is the difference between hitting a 40 µA sleep budget on Friday or on a Wednesday three weeks later.
A few other things from the episode
Support for new chips is not gated by a certification process or a supported list. Upload the documentation and the agent works with it.
BootLoop supports C, C++, Rust, Zephyr, bare metal, and embedded Linux today.
Pricing is a flat fee with unlimited usage, so the commercial incentive points toward shipping correct firmware rather than billing per token.
Listen and see it for yourself
The full episode is on Memfault's site: Hardware at Software Speed with BootLoop.
If you want to see this with your own eyes, book a 30-minute demo.