Sashiko: Google's open-source agentic code reviewer is now part of the Linux kernel's daily workflow — 60-day fix rate down from 3.4% to 2.2%
Google's open-source agentic code reviewer for the Linux kernel separates bug-finding from verification, and the production numbers show maintainers are acting on it.

Google's Sashiko, an open-source agentic code reviewer for the Linux kernel, has run in production since March 2026. Maintainers are acting on its output: the 60-day post-merge fix rate across the kernel has dropped from 3.4% to 2.2%, and a clean Sashiko pass predicts a follow-up fix just 0.9% of the time versus 7.6% for patches merged despite a critical warning. Google donated the project to the Linux Foundation, and it now reviews roughly 1,200 patches a day across more than 100 kernel mailing lists.
What shipped
Sashiko is a self-contained agentic review harness written in Rust, licensed Apache-2.0, and owned by the Linux Foundation (GitHub). It targets the Linux kernel but ships profiles for GCC, QEMU, Zephyr RTOS, and Sashiko itself. It is model-agnostic: Gemini is the default, with support for Claude, OpenAI-compatible endpoints, Bedrock, Vertex AI, and several CLI providers. Google funds the compute and token budget for the public instances at sashiko.dev, so contributors do not pay for reviews.
The public instance watches lore.kernel.org and posts reviews to mailing lists whose maintainers opt in — over 75 have done so. Since launch it has completed 241,000 reviews; Google reports it is cited in over 2,000 mainline kernel commits and in 528 of this year's official Linux kernel CVEs (Google Cloud blog). LWN's 7.2 development statistics corroborate the footprint: 252 patches in 7.2 carry Reported-by tags crediting Sashiko, and 568 commits mention it in their changelogs (LWN).

Why the architecture matters
Sashiko's defining design decision: it separates finding candidate bugs from verifying them, and every pass must record what it ruled out. The pipeline runs: gather context and plan → parallel specialist sessions → triage → per-bug deep checks → review report.
The split responds to three documented LLM reviewer failure modes (Google Cloud blog):
- Token minimization. LLMs are trained to spend fewer tokens, so they cut corners — dismissing concerns without investigation or flagging false positives without due diligence.
- Task bias. A model given one focused task (e.g., "prove this patch for memory leaks") performs far better than one asked to explore varied concerns at once. A model that finds one obvious issue tends to stop looking for others. Commit-log text can also skew results unpredictably.
- No persistent memory. For review this is a feature: the same patch can be re-checked against many branches as if new.
Up to seven specialist sessions run in parallel, each with a single focus — commit intent, implementation match, control flow, resource lifetimes, locking, security, and hardware (the GitHub docs enumerate eight analysis stages, adding a performance pass the planning stage may select). Each session searches the repo with git tools (averaging about 100 tool calls per review) and returns two lists: concerns it believes are real, and candidate concerns it investigated and ruled out, with the code supporting each conclusion.
A lead verifier then audits both lists together. This is where the "record what you ruled out" requirement pays off: it catches shaky self-dismissals — cases where a specialist spotted a real bug and talked itself out of it by assuming, without proof, that some unseen caller or lock would prevent it. Difficult cases get their own per-bug verification agent running in parallel, under a symmetrical rule: neither a bug claim nor a dismissal is accepted without concrete code proof across all call sites. If a specialist dismissed a real bug on a false assumption, this step promotes it back to a finding.
The final report reads like a human maintainer asking questions on a Linux mailing list — the format the audience expects.
Why it matters
The strongest evidence is the outcome data. Across 21,500 tracked mainline commits, patches with a clean Sashiko review required a follow-up fix within 60 days just 0.9% of the time — less than a third of the historical baseline — while patches merged despite a critical Sashiko warning needed a fix 7.6% of the time, an 8× higher risk (6.3× after adjusting for patch size). That gap is what makes the tool useful: a clean pass is real confidence, a critical warning is a reason to look again (Google Cloud blog).
The aggregate trend points the same way. Across the 18 releases before Sashiko (Linux 6.2–6.19, 254,000 commits), an average of 3.4% of merged commits needed a follow-up fix within 60 days; since rollout that fell to 2.8% in 7.1 and 2.2% in 7.2 — a 35% drop, with the 30-day rate down from 2.3% to 1.4%.
For anyone building agentic review or verification systems, the transferable lesson is the one Google leads with: benchmark-driven development beats intuition. The team built a benchmark from nearly 1,000 real Linux kernel bugs — mistakes that passed human review, got merged, and later had to be fixed — and evaluated every major change against it. On that set, Sashiko with Gemini 4 Carbon at high thinking level catches 75.8% of the bugs human reviewers missed. Several ideas that looked reasonable failed; less obvious ones worked. The benchmark let them tell the difference.
Linus Torvalds, writing on a mailing list a few weeks after launch, put it in terms that matter for adoption: "Sashiko tends to be quite good. Even when it flags something unnecessarily and there's no actual problem, there's likely to be a reason for the question. And we've seen some truly stellar reports too. Things that are deep and subtle, and the AI is 100% correct. So anybody who thinks that all AI is slop is in denial about the current state" (lore.kernel.org, quoted in the Google Cloud blog).
Caveats
- The headline numbers are Google's own, reported on its blog and in its benchmark. The 75.8% catch rate is vendor-reported on a self-built benchmark, and the false-positive rate ("under 20%") is self-assessed.
- Google explicitly says the fix-rate drop cannot be solely credited to Sashiko — many other factors influence release-to-release numbers. Treat the 35% figure as a correlated trend, not a causal effect.
- The clean-vs-warning signal is the more robust claim because it is a within-data comparison, but it too is Google's analysis of its own tracking.
- The Torvalds quote is a single positive anecdote from a few weeks after launch, not a systematic evaluation.
- The blog's full "what we learned" section was not fully captured here; the benchmark-driven-development lesson is the one stated in full.
Sources
- Lessons from building Sashiko, an agentic code review system — Google Cloud Blog
- sashiko-dev/sashiko — GitHub
- Development statistics for the 7.2 kernel — LWN.net
- The Sashiko patch-review system — LWN.net
- Google Engineers Launch "Sashiko" For Agentic AI Code Review Of The Linux Kernel — Phoronix
- sashiko.dev