Sulat.com / Writing on AISaturday, November 21, 2026
Agent Engineering/21 November 2026

Sashiko, Google’s open-source Linux reviewer, catches 75.8% of bugs that humans missed on its benchmark

Google's open-source Sashiko reviews Linux kernel patches with parallel Gemini specialists. Google says it catches 75.8% of bugs human reviewers missed, on a benchmark of nearly 1,000 real kernel bugs.

Glossy 3D indigo stitched Sashiko patches above a glass slab of glowing code, fed by seven translucent reviewer orbs

At a glance

  • Google says Sashiko, its open-source Gemini code reviewer for the Linux kernel, catches 75.8% of bugs that human reviewers missed, on a benchmark of nearly 1,000 real kernel bugs.
  • Sashiko has completed 241,000 patch reviews since March, and is cited in more than 2,000 mainline commits and 528 of this year's kernel CVEs.
  • The share of merged commits needing a fix within 60 days fell from a 3.4% average to 2.2% in Linux 7.2; Google says it doesn't credit Sashiko for the whole drop.
  • Commits that got a clean Sashiko review needed a fix 0.9% of the time, against 7.6% for commits merged despite a critical warning.
  • Sashiko runs a seven-specialist pipeline, then gives each hard case its own verification agent; you can run it locally with cargo install sashiko.

Google published a post on 18 November describing Sashiko, an open-source system that reviews proposed Linux kernel patches with Gemini. Roman Gushchin of Google’s AI and Infrastructure team wrote it with Google Fellow Eric Brewer. Google says Sashiko catches 75.8% of bugs that human reviewers missed on its benchmark, has completed 241,000 reviews since March, and sits alongside a fall in how often merged kernel commits need a quick follow-up fix.

What Sashiko is

Gushchin announced Sashiko on the kernel mailing list on 17 March. It’s written in Rust and licensed under Apache 2.0, and ownership moved to the Linux Foundation. Google pays for the compute and tokens behind the public instance at sashiko.dev, so patch authors don’t need their own API keys. The review runs on Gemini by default.

The problem Google describes is review capacity, not code generation. Linux spans more than 35 million lines, over 85,000 changes land each year, and maintainers read hundreds of patches by hand every day. Google says some of the extra AI-written patches and security reports are slop that adds to the pile. Fuzzers such as Syzkaller catch crashes and build errors, but review is what the kernel leans on for stability.

Why it splits finding from proving

Google lists three traits of LLM reviewers that shaped the design. They cut corners to save tokens. They’re easy to bias: a model that finds one obvious problem tends to stop looking, and the commit message can sway the result. And they’ve no memory, which helps, because the same patch can be reviewed against 100 slightly different branches as if it were new each time.

Hand-drawn flowchart: gather context, seven parallel specialists, triage, one agent per hard case, then the review report
Sashiko finds candidate bugs first and makes a separate agent prove the hard ones. Source: Google Cloud Blog.

Sashiko starts by pulling in the modified functions, struct definitions and direct callers, and loading the subsystem’s guides. A planner then picks which specialists to run and sets a reasoning budget for each. Up to seven run in parallel, each on one class of problem: commit intent, implementation match, control flow, resource lifetimes, locking, security and hardware. Each averages about 100 git tool calls per review and hands back two lists. One holds the concerns it thinks are real. The other holds concerns it ruled out, with the code that supports each dismissal.

A lead verifier audits both lists together. Clear bugs pass through and provable dismissals are dropped. Everything else gets its own verification agent, including shaky dismissals, where a specialist saw a real bug and talked itself out of it by assuming some caller or lock would prevent it. The rule is symmetrical: neither a bug claim nor a dismissal is accepted without code proof across all call sites. LWN’s report of Gushchin’s Kernel Recipes talk gives the reasoning. A system told to report only what it can prove misses a lot, while one that lists concerns and then tries to knock them down does better.

The final report reads like a maintainer asking questions, in the style of the mailing list. Everything is public, down to each prompt, tool call and ruled-out bug. The first prompts came from Chris Mason’s open-source review prompts. Sashiko has since moved to its own code notes, generated and checked against each source tree, plus maintainers’ notes for things the code can’t say. More than 100 contributors have helped.

What the production numbers show

Hand-drawn stat cards: 241,000 reviews, 2,000+ mainline commits, 528 kernel CVEs, 75.8% of human-missed bugs caught
241,000 reviews in eight months, with the 75.8% score from Google’s own benchmark. Source: Google Cloud Blog.

Sashiko reviews patches across more than 100 kernel mailing lists and emails its results only to lists that opt in. More than 70 have. More than 1,500 developers have replied, and Google says their pushback on false alarms changed its prompts and verification engine. LWN’s development statistics for Linux 7.3, which Linus Torvalds released on 18 October, credit Sashiko with 304 Reported-by tags. That’s 19.4% of the total and ahead of Syzbot’s 239. Google’s post calls Sashiko the top bug reporter in the 7.2 cycle, but the LWN page it links covers 7.3.

Google compared the share of merged commits that needed a follow-up fix within 60 days. Across the 18 releases before Sashiko, Linux 6.2 to 6.19 and 254,000 commits, the average was 3.4%. It fell to 2.8% in Linux 7.1 and 2.2% in 7.2, a 35% drop, and the 30-day rate went from 2.3% to 1.4%. Google says many factors move release-to-release numbers and doesn’t credit Sashiko for the whole drop.

Hand-drawn bar chart of 60-day fix rates: 0.9% after a clean Sashiko review, 3.4% before Sashiko, 7.6% with a critical warning
A clean review means few follow-up fixes; a critical warning means many. Source: Google Cloud Blog.

The better test is whether the warnings mean anything. Across 21,500 tracked mainline commits, patches that got a clean Sashiko review needed a fix within 60 days 0.9% of the time. Patches merged despite a critical warning needed one 7.6% of the time. That’s 8 times as often, or 6.3 times after adjusting for patch size.

The bugs Sashiko stops before a merge leave no commit to count. What can be counted are the older bugs it turns up while reviewing new code. Google says it’s cited in more than 2,000 mainline commits and in over 500 of this year’s kernel CVEs. LWN’s account of the Kernel Recipes talk adds that Sashiko now holds back reports on bugs that were already there, because developers didn’t welcome hearing about them. They go into a separate database of about 5,000 bugs that anyone listed in the MAINTAINERS file can query.

Where the 75.8% comes from

Google built a benchmark of nearly 1,000 real kernel bugs. Each was a mistake that passed expert human review, reached mainline and was later fixed, and every major change to Sashiko is scored against it. With Gemini 4 Carbon at a high thinking level, Sashiko catches 75.8%. In March, Gushchin put it at 53% with Gemini 3.1 Pro on 1,000 recent upstream issues tagged with Fixes, and said human reviewers had missed all of them. The project’s README lists 58.5% for GCC on Gemini 4 Argon, and puts false positives under 20% by manual sampling, mostly gray-area concerns.

Those scores come from Google’s own benchmark, and the output is probabilistic, so a rerun on the same patch can differ. LWN’s May report of a kernel maintainers’ session recorded the same weak spots Google describes. Review quality drops on large patch sets, and a commit log that says it fixes real bugs can bias the result.

What Torvalds said

Google quotes two posts from Linus Torvalds on the kernel mailing list, written a few weeks after launch. The first:

“As you say, 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.”

Linus Torvalds, as quoted in Google’s post

The second frames the issue as trust rather than AI:

“Now, I think the other side of AI – and this is where Sashiko comes in – is that it basically does end up being a tool that can then increase the trust in the patch. So AI giveth, and AI taketh away. But the basic issue shouldn’t be AI per se, it should be that notion of ‘trust’.”

Linus Torvalds, as quoted in Google’s post

Google’s three lessons

First, benchmark-driven development beat intuition, because many reasonable-looking ideas failed against the bug set. Second, coding agents aren’t great at reviewing their own code. Writing a working solution is often only 5 to 10% of the job, and the rest is fitting it into the surrounding code without subtle regressions. Third, open ownership built trust, since anyone could run Sashiko with other models, change the prompts or point it at another project.

Running it yourself

Install it with cargo install sashiko, run sashiko init and set an API key. Running sashiko review inside a kernel checkout reviews the latest commit, and a range such as HEAD~3..HEAD reviews a series. The --cheap flag folds the exploratory stages into one pass to save tokens. It needs Rust 1.90 or newer and Git. Gemini is the default provider, and Vertex AI and AWS Bedrock are among the others the README lists. The README warns that multi-stage reviews can incur significant API costs, and that patch data goes to whichever provider you pick. Google doesn’t say what a review costs.

Beyond Linux, GCC is an official pilot with a public instance at gcc.sashiko.dev, QEMU and Zephyr are pilots, and Sashiko reviews its own GitHub pull requests. Google says the playbook of an open pipeline, community-owned guides and a benchmark mined from past bugs can likely carry over to GCC, LLVM or Git. Gushchin is the contact for projects that want to pilot it.


Discover more from Sulat AI & Tech News

Subscribe to get the latest posts sent to your email.