# NVIDIA releases Boro, a Rust CLI with AI to audit the Linux kernel

> NVIDIA releases Boro, a local-AI Rust CLI that reviews, builds and boots Linux kernel patches without leaving the Git tree.
> By José Maldonado · Technology · 2026-10-16

For months NVIDIA has been developing a tool for Linux kernel programmers to review their patches without leaving their own Git tree. It is called Boro, it is written in Rust, it is distributed under the Apache 2.0 license and it is led by Andrea Righi, an engineer at the company. Righi presented it at the [Linux Plumbers Conference](https://lpc.events/), which the city of Prague hosted from 5-7 October 2026.

The inspiration has a name of its own. For months, [Sashiko](https://observatorioblockchain.com/en/cybersecurity/sashiko-ia-revisa-kernel-no-time-to-pwn/), the AI-powered review tool driven from Google, has been examining the patch series that arrive on the kernel mailing lists and leaving comments that the maintainers themselves have received well. Boro shares the same review prompts, but it targets a different point in the cycle: the local work before publishing, and the maintenance of distribution kernels that never goes through the standard mailing-list process.

That nuance matters because it touches a sensitive point. The Linux kernel is one of the last major projects where the official channel is still email, and any tool that automates technical judgement is scrutinized closely. NVIDIA publishing the code changes the framing: Boro is not a closed service to which patches are sent, but a binary that each developer runs against their own model, on their own machine, with their own tokenizer and their own bill.

## A reviewer that works before the patch is public

The difference between Boro and Sashiko is not in what they review, but in when they review it. The repository's own [README](https://github.com/NVIDIA/boro) explains it bluntly: Sashiko is optimized for reviewing series **after** they appear on the public mailing lists, whereas Boro is optimized for interactive review and repair while the developer is still shaping the series or carrying it on their own.

The use case that justifies the tool is distribution kernel maintenance. When a team at Canonical, Red Hat or SUSE has to carry a security patch from the main branch to a kernel from three years ago, the process does not go through the lists. It is done locally, with cherry-picks that often do not apply cleanly, and with very little automatic safety net. That is the ground Boro wants to cover. Sashiko does not fit there by design, because its architecture is meant to review series that have already been published.

The division of responsibilities between the two tools is what lets them coexist rather than compete: one filters what reaches the public list and the other catches problems before they are sent, which is where the cost of fixing them is lower.

In the [talk he presented at LPC 2026,](https://lpc.events/event/20/contributions/2599/) Righi was explicit about the diagnosis. His argument is that Sashiko's design is meant for interaction in upstream review, which makes it less natural when applied to more iterative flows or to downstream work, such as reviewing backports locally or tracking changes coming from above.

## Getting to know Boro's capabilities

Boro is organized around four verbs. Review is the heart, but building and booting are what set this tool apart from a simple chat wrapper over `git diff`.

Subcommand

What it does

`boro review RANGE`

Multi-stage review of the commit range with per-subsystem prompts and a final summary in LKML style

`boro build RANGE`

Takes each commit to its own worktree, builds it with `vng -b` and asks the model to triage the log

`boro test RANGE`

Same as `build`, boots the kernel under virtme-ng and runs a targeted test chosen by the model

`boro apply RANGE`

Assisted cherry-pick that tries to resolve conflicts that do not apply cleanly

`boro apply --message-id ID`

Downloads a published series with `b4` and applies it in full, from oldest to newest

Review relies on a set of subsystem-specific prompts that live in the repository. There are notes for memory with separate sheets by type: folios, reclaim and page tables. There are also notes for `bpf, io_uring, drm, rcu, scheduler, tracing, vfs, wireless` and `rust`, among some thirty areas in total. The model does not review the patch in the abstract: it receives the specific conventions of the area it touches.

The build and test modes are what justify running this on the developer's machine instead of sending it to a cloud service. Boro feeds the model the real compiler output and the real output of the running kernel, not just the text of the diff. The `test` flow boots the image under `virtme-ng` and runs a quick test selected by the model from among a matching kselftest, a userspace probe on the code touched or, as a last resort, `dmesg`.

## A tool that is not only for the kernel

The repository's prompt structure reveals an ambition greater than reviewing Linux patches. Alongside the `resources/prompts/kernel/` folder sit two more complete sets, one for `libvirt` and another for `qemu`, with their own subsystem notes, false-positive guides, severity scales and report templates.

The pattern repeats: style review, technical patterns, per-area notes and a severity scale of its own. Libvirt comes with notes for cgroups, CPU, domain configuration, events, host devices, locking, networking, storage and security, plus its own false-positive guides. QEMU covers ARM, block, chardev, KVM, firmware, memory, migration, networking, PCI and QAPI, with the same per-area severity scheme.

That suggests Boro was designed as an extensible framework rather than a one-off commission for the kernel. Anyone who wants to adapt it to another free software project only has to write the corresponding prompt set, because the stage engine, the split between models and the token accounting are already solved.

## The cherry-pick that defends itself

The most striking part of the project is assisted patch application. When a cherry-pick fails because the code has diverged, Boro does not stop. For the diff3 conflicts that remain, the main model proposes a resolution for each conflict and a second model, the validator, approves or rejects it. Rejections go back to the main model with the specific reason, for up to ten rounds per conflicting fragment.

When all fragments pass validation, Boro rewrites the files and stages them. It then continues the cherry-pick and updates Git's `-x` trailer so that it says `(backported from commit ...)` instead of the original reference. After the post-application review it runs a source-only check on the new struct field accesses and flags possible gaps in the backport. If that check fails, the validator model receives the exact problem, can edit the file and amend the commit.

That back-and-forth between two models is the project's most interesting design decision, and also the one that will generate the most discussion. Automatically approving the resolution of a conflict in kernel code means accepting that a model has the final say on low-level semantics.

## Two models, two bills

The division of work between models is explicit and designed to control cost. `BORO_MODEL` handles the general discovery and specialist stages, which burn the most tokens and need the least precision. `BORO_VALIDATION_MODEL` takes on the quick full-context review, the validation of new candidates coming out of the general stage and the drafting of the final report.

The recommended combination follows from that separation: a cheap local model for the broad sweep and a more capable remote model for the protected baseline, validation and the report. The summary of each run breaks down token consumption by stage, so it is possible to see where the budget went. There is also a `--fast` mode that makes the initial quick review use the main model instead of the validator.

As for providers, Boro ties no one in. It works against any endpoint compatible with the OpenAI chat API through three environment variables (`BORO_URL`, `BORO_KEY` and `BORO_MODEL`), and it ships local backends for Claude, OpenCode and Codex. Anyone without the compute capacity for a local model can point it at a compatible remote server.

## Testing its capabilities

The requirements are few but specific. The command that downloads published series needs [b4](https://b4.docs.kernel.org/) on the `PATH`, and the build and test modes need [virtme-ng](https://github.com/arighi/virtme-ng), the tool Righi himself maintains. The upstream tracking stage requires `lei`, from the public-inbox package, although without it Boro runs the remaining stages and produces a full report; the only thing lost is the query to lore.kernel.org. Installation, from a copy of the repository, is handled with `cargo install --force --path .`.

There are three limits worth keeping in mind before drawing conclusions about its scope. The first is that Boro has not replaced Sashiko and does not compete with the public review process: it covers the earlier phase. The second is that detecting breakage in out-of-tree modules is a stated plan, not a finished feature. The third is that integrating part of its functionality into Sashiko is a proposal Righi put on the table at LPC, with no decision made.

## What the kernel gains and what it risks with AI inside

The Linux kernel is a 35-year-old project built on an uncomfortable idea: that the best filter for a low-level change is still another human who understands the subsystem. Putting models into that circuit does not eliminate human review, and Boro reflects this well by keeping the validator as a gate and the developer as the one who decides. What changes is the amount of mechanical work that disappears before anyone looks.

The open question is not whether these tools will be used, but by what standard. Boro has just put code, license and prompts on the table, and that makes it possible to audit exactly what it is asking a model when it says a patch is fine. It is a substantial difference from the closed services that do the same without showing their criteria.
