01Top stories

Primary intelligence

Google describes Sashiko's real-world Linux kernel agent code-review results

Publisher-provided image for Google describes Sashiko's real-world Linux kernel agent code-review results
Image: cloud.google.com

Google published a November 19 engineering account of Sashiko, its open-source Gemini-powered Linux kernel code-review system. It reports roughly 1,200 reviews daily across more than 100 mailing lists, with over 70 lists opting into review emails. The architecture separates specialist passes for different bug classes from independent verification of disputed findings and even questionable dismissals.

Google reports Sashiko citations in more than 2,000 mainline commits and 500 kernel CVEs this year. It also observed lower subsequent fix rates after rollout, while explicitly cautioning that many other factors could explain the change.

Why it matters

A deployed AI review system offers rare operational measurements and a reproducible architecture for validating code changes.

via Google Cloud engineering writeup & Sashiko source
Read full briefing Collapse briefing

Detailed briefing

Specialists and verification

Sashiko gathers code around a proposed diff, including relevant callers, structures and subsystem notes, then launches up to seven focused review sessions. They separately investigate intent, control flow, resource lifetimes, locking, security and hardware interactions. Each records not only suspected defects but also concerns it investigated and dismissed. A lead verifier audits both lists and sends ambiguous claims to independent per-bug verification agents, requiring code evidence rather than speculation.

Production data and developer feedback

Google says the system completes around 1,200 reviews a day, with more than 1,500 kernel developers having replied to its reports. It cites more than 2,000 mainline commits and over 500 CVEs that mention Sashiko. The reported 60-day follow-up fix rate fell from a historical 3.4% to 2.2% for a later release, but this before/after comparison is observational. Changes in release mix, review culture and reporting practices may contribute.

Reproduction and engineering implications

The project is open source, with review traces and prompts made public. Its most transferable design principle is to require independent evidence for both positive bug findings and dismissals, rather than treating model confidence as proof. Running similarly deep reviews can be costly: Google funds the public service, and the system averages extensive repository tool use. It complements rather than replaces experienced maintainers.

Limitations & caveats

Reported outcome correlations are not causal proof that the agent reduced bugs.

02Also worth knowing

Rapid scan briefs
AI & Developer Toolsblog.google

Google demonstrates Gemini 4 Neon applications in Blender and WebGL

Google's Gemini 4 Neon release article includes concrete demonstrations of an agent operating Blender through MCP, generating a WebGL2 ski simulator and constructing a spreadsheet image effect using formulas rather than embedded pictures. These examples are more informative than benchmark charts because they expose the kinds of multi-tool artifacts the company is testing.

They remain vendor demonstrations. Complete reproducibility, costs, iteration counts and independent verification are not established in the reviewed article.

via Google release and demonstrations
Read full briefing Collapse briefing

Detailed briefing

Demonstrated outputs

Google describes a Blender lab-bench scene, a terrain-based WebGL ski simulator with custom shaders and a large formula-driven spreadsheet visual. The projects span 3D asset construction, browser rendering and spreadsheet computation.

How to evaluate them

The relevant evidence is the artifact, code and iteration history, not a model's assertion that it completed the task. Developers should inspect geometry, correctness, frame performance and cost before extrapolating to production workflows.

03AI & tooling in practice

Hands-on applications
AI & Developer ToolsTechnical case studycloud.google.com

Sashiko: open agent code review with independent bug verification

Google's Sashiko is a working open-source Linux kernel review service, not a product mockup. It runs focused parallel reviews for resource lifetimes, locking, security and other bug classes, then independently verifies both findings and suspicious dismissals. The public service exposes prompts, tool calls and reasoning traces, making it unusually inspectable.

Google reports approximately 1,200 daily reviews and substantial maintainer interaction. The published measurements are observational and the service's large token budget may limit independent replication.

Publisher-provided image for Sashiko: open agent code review with independent bug verification
Image: cloud.google.com
Engineering walkthroughalso Source code
Read full briefing Collapse briefing

Detailed briefing

What was built

A Gemini-backed reviewer processes real kernel mailing-list patches and emits maintainers' style review messages. It runs on an opt-in basis across dozens of lists and provides publicly inspectable evidence trails.

How to adapt the architecture

The distinctive pattern is to split concern discovery from verification. Each specialist investigates one bug class and logs rejected hypotheses; an independent agent checks contested claims and dismissals against repository code and call sites. Teams can adopt this architecture without claiming Google's production metrics.

Limitations

The public service is funded by Google and uses substantial tool calls per review. Historical changes in fix rates are correlations, not controlled evidence of a causal effect. Human maintainers remain essential.

AI & Developer ToolsInteractive demotabbyml.github.io

Weight-Space Playground: inspect model-weight edits through WebGPU

A Show HN project demonstrates experiments in which one model modifies another model's weights, with a browser interface using WebGPU to make the process inspectable. The project is an unusual alternative to conventional prompting and fine-tuning demonstrations because it focuses on direct parameter-space manipulation.

It is a research-oriented visualization, not evidence that automated weight editing scales to large production models. Browser GPU support and available hardware can affect the experience.

Publisher-provided image for Weight-Space Playground: inspect model-weight edits through WebGPU
Image: tabbyml.github.io
Interactive playground
Read full briefing Collapse briefing

Detailed briefing

What to explore

The interactive page is designed to show model behavior changing as weight-space edits are applied. Readers can inspect the visualization and the surrounding explanation rather than relying on a generated performance claim.

Practical relevance and caveats

The demonstration is useful for understanding the distinction between editing weights and changing inference prompts. It does not establish general transfer to larger architectures or safe production deployment; the result is exploratory.

AI & Developer ToolsInteractive demostarbright.quickthoughts.ca

Starbright: private browser-based speech transcription

Starbright demonstrates a small, roughly 15 MB speech-to-text model that can run on the user's device through a browser interface. The key design choice is local inference rather than uploading every recording to a remote transcription service.

The project is useful for evaluating lightweight voice input in offline-capable applications. Its size does not establish accuracy across accents, noisy rooms or long recordings, and those conditions should be tested directly.

Live demonstration
Read full briefing Collapse briefing

Detailed briefing

Workflow

Open the browser demonstration, allow microphone input when desired and compare transcription behavior on representative short recordings. Its privacy claim depends on the actual runtime and network behavior, which was not independently audited in this review.

Engineering tradeoffs

A small client-side model may offer low latency and reduced data transfer at the cost of recognition quality and device compatibility. Benchmarking should include noise, languages, CPU/GPU support and battery use.