Artificial intelligence news.
Straight from the original announcements.

Google uses Gemini and Z3 to find Go bugs fuzzing missed

November 12, 2026By the AI News Bites Editorial TeamSource: Google for Developers
Google uses Gemini and Z3 to find Go bugs fuzzing missed
Image: Google for Developers

A Google developer has used Gemini 4 Argon and the Z3 constraint solver to find runtime crashes that Go fuzzing failed to uncover. The workflow caught three planted parser bugs and uncovered three latent bugs in Google's skill-lint tool.

Key points
  • Gemini 4 Argon translated Go bounds-check paths into Z3 constraints.
  • The workflow found three planted bugs and three latent skill-lint bugs.
  • A 59-byte counterexample exposed a parser crash missed by fuzzing.
  • Z3 provides bug-finding support, not a complete correctness proof.

A solver pipeline for Go bounds checks

Karl Weinmeister, director of Developer Relations at Google, described the approach in a Google Developers Blog post. He developed it while working on skill-lint, a standalone Go command-line tool that checks SKILL.md files and applies LLM-generated line edits.

The method starts with Go's compiled machine code rather than source code alone. Go's compiler removes bounds checks it can prove are safe, leaving explicit runtime panic traps at operations it cannot rule out. Weinmeister compiled selected functions for RISC-V and supplied both their Go source and disassembly to Gemini 4 Argon.

Argon translated the path to each remaining trap into rules for the Z3 constraint solver. Z3 then checked whether those constraints could be satisfied and produced a concrete input when it found a possible crash. Finally, go test replayed the bytes against the real Go function.

Why a solver can find what fuzzing misses

Fuzzing searches by generating inputs, while this workflow works backward from a possible failure condition. That lets the solver target inputs that reach a specific bounds-check trap instead of relying on random sampling.

Weinmeister tested the system on three parsers containing deliberately planted panics. It found all three, then identified three latent bugs in skill-lint. He also tested safe parsers: Go's compiler removed every bounds check in a TOML key parser, while Z3 returned unsat for the remaining traps in an HTTP header scanner and a varint decoder.

The post describes the method as a bug-finding tool rather than a proof system. A sat result provides a concrete input aimed at a suspected trap, and a crash during go test confirms that the bug is real. An unsat result means only that the modeled constraints could not find a crash. According to Weinmeister, this tradeoff makes the approach practical for individual Go functions, while avoiding the effort required for a complete correctness proof.

A concrete example of a missed crash

One test parser, ParseTwoChunkFrame, checked a combined header and body length before slicing a buffer. The parser stored the two lengths as 8-bit values, so their sum could wrap at 256 during the guard check. A later calculation used the full values, allowing the guard to pass before a slice operation reached beyond the buffer's capacity.

Argon's Z3 model found a 59-byte counterexample with hdrLen = 48 and bodyLen = 236. Their sum is 284, but the 8-bit calculation wraps to 28. The guard therefore passes, while the later slice reaches index 288 and panics.

Weinmeister reports that the crash was triggered by 19.4% of possible header and body length pairs, yet an unseeded go test -fuzz run missed it in one 3-second test and three 60-second tests. In a 10-second probe, 89% of 386,741 fuzz calls used views into a shared buffer, while only 0.07% had cap == len. Because Go checks this slice expression against capacity, spare capacity allowed the faulty parser to return bytes beyond the buffer's length without panicking.

What the approach means for Go developers

The workflow is presented as a complement to fuzzing, not a replacement for it. The compiler narrows the search to bounds checks that remain after optimization, Gemini 4 Argon converts the relevant control flow into a solver model, and go test validates any proposed input against the actual implementation.

Weinmeister says Argon's translation took about a minute per function, while Z3 completed its checks in milliseconds. That places the technique between ordinary testing and full formal verification: it can generate concrete reproducers for difficult crashes, but its solver model does not establish that a function is correct.

Related news

JetBrains asks 12 AI models for 1,200 programming hot takes
ResearchNovember 15, 2026, 18:02

JetBrains asks 12 AI models for 1,200 programming hot takes

Twelve AI models overwhelmingly attacked Python, Rust and TypeScript in a JetBrains experiment that collected 1,200 opinions about programming languages. The models also…

Google details Antigravity’s multiagent results in mathematics and engineeringTop story
Products and toolsNovember 13, 2026, 21:47

Google details Antigravity’s multiagent results in mathematics and engineering

Google says its Antigravity /teamwork multiagent systems have helped human researchers address open problems across mathematics, chemistry, systems software and machine…

FPF launches four-part series on agentic AI privacy risks
BusinessNovember 12, 2026, 21:02

FPF launches four-part series on agentic AI privacy risks

The Future of Privacy Forum's Center for Artificial Intelligence has launched a four-part virtual roundtable series examining privacy risks linked to agentic AI. Its…