Live
Cloudflare Images Analytics Dashboard Adds 30‑Day Delivery VisibilityAmazon ECS Adds Native Blue/Green, Canary, and Linear Deployments for Safer Container RolloutsGemini agentic tools add LLM‑driven automation to Partner Marketing StudioGitHub Actions makes RHEL 9/10 runner images generally available for larger workloadsIntegrating Decider Models to Reduce Latency and Cost in AI Agent WorkflowsAWS Emulator Enables Local Testing of 200+ Services, but Lacks IAM ValidationSageMaker AI monitoring adds automatic latency drift, idle GPU, and configuration gap detection for inference endpointsEmbedding Proactive Governance into Enterprise‑Scale Agentic AICloudflare Images Analytics Dashboard Adds 30‑Day Delivery VisibilityAmazon ECS Adds Native Blue/Green, Canary, and Linear Deployments for Safer Container RolloutsGemini agentic tools add LLM‑driven automation to Partner Marketing StudioGitHub Actions makes RHEL 9/10 runner images generally available for larger workloadsIntegrating Decider Models to Reduce Latency and Cost in AI Agent WorkflowsAWS Emulator Enables Local Testing of 200+ Services, but Lacks IAM ValidationSageMaker AI monitoring adds automatic latency drift, idle GPU, and configuration gap detection for inference endpointsEmbedding Proactive Governance into Enterprise‑Scale Agentic AI
Google Cloud

Agentic Code Review for Linux: Introducing Sashiko’s Two‑Stage Patch Validation

AI SummaryPowered by AI

Sashiko, an open‑source system built on Gemini, adds a two‑stage, agentic code review workflow for Linux kernel patches. It lets maintainers offload initial bug hunting to LLMs while preserving verification steps, reducing review load and improving trust in AI‑generated changes.

Sashiko brings a new, agentic code review pipeline to the Linux kernel ecosystem, separating bug discovery from verification and recording every decision. For engineers who maintain large code bases, this change offers a way to scale review effort without sacrificing the rigor required for a critical project that powers billions of devices.

Why Traditional Review Is a Bottleneck

The kernel spans more than 35 million lines of code and absorbs roughly 85 000 changes each year. Automated build bots and fuzzers such as Syzkaller catch compile‑time errors and crashes, but human reviewers still read hundreds of patches daily to spot memory leaks, race conditions, and security bugs. The influx of AI‑generated patches and duplicate security reports has amplified the workload, leaving a small group of maintainers as the final gate.

Sashiko’s Architecture and Workflow

Google’s AI & Infrastructure team built Sashiko on top of the Gemini model and contributed it to the Linux Foundation. Its design follows a clear split:

  1. Gather context and plan: The system extracts surrounding functions, struct definitions, and call sites for the diff.
  2. Parallel specialist sessions: Separate LLM agents examine distinct concerns (e.g., memory safety, concurrency) and also record dismissed concerns.
  3. Triage: Results from the specialist agents are aggregated and prioritized.
  4. Per‑bug deep checks: For each candidate issue, a focused verification pass runs to confirm or rule out the finding.
  5. Review report: A structured summary is produced for human maintainers.

This pipeline forces the model to explicitly log what it has ruled out, mitigating the tendency of LLMs to cut corners in order to minimize token usage.

Operational and Security Implications

From an operations perspective, Sashiko can be inserted into existing CI pipelines that already invoke Syzkaller or other bots. Because the model lacks persistent memory, the same patch can be re‑evaluated across multiple branches without state leakage, simplifying scaling across divergent kernel trees.

Security‑wise, the source notes two LLM quirks that practitioners must watch:

  • LLMs are prone to bias; a simple task (e.g., checking for memory leaks) yields better results than a multi‑concern scan, so the specialist‑session split helps contain that bias.
  • Commit‑message text can influence the model’s output in unpredictable ways, meaning that maliciously crafted logs could steer the review away from real issues.

Both concerns reinforce the need for the verification stage and for human oversight of the final report.

Related CloudNinjas coverage: Google Cloud.

What This Means For Practitioners

Teams that already run automated testing on large code bases should consider adding an agentic reviewer like Sashiko to handle the first pass of bug hunting. When doing so, evaluate the false‑positive and false‑negative rates of the specialist agents, and keep a manual verification gate before any patch is merged. Monitoring token consumption can also surface when the model is shortcutting its analysis. Finally, treat the generated report as a supplemental signal rather than a replacement for human expertise, especially when commit metadata may be untrusted.

Originally published atGoogle Cloud Blog