A team at Google says its testing framework for the XLA:TPU compiler, the software that turns AI models into code for Google’s TPU chips, has “driven the resolution of over 142 compiler bugs”. The paper, posted to arXiv on 31 October, says the framework uses AI agent swarms to “autonomously generate stress tests, reproduce failures, and draft fixes”.
The same sentence lists “103 additional findings under review”. By our arithmetic, that is 103 of 245 findings, or 42 per cent, still waiting on review, counting the 142 figure. Because the paper says more than 142 are resolved, the share is at most 42 per cent.
The paper, “XLA from the Trenches: Correctness on TPU Workloads at Scale”, has 22 authors; the corresponding author uses a google.com address. It describes “a battle-tested methodology for verifying and triaging Google’s XLA:TPU compiler at hyperscale”.
The target is the silent bug. According to the abstract, subtle code-generation defects can cause numerical degradation and memory corruption, “invalidating multi-million-dollar training runs and degrading live serving quality without raising obvious compiler errors”.
The paper says the team “deliberately steered our autonomous agent swarms away from loud crashes to focus on silent data corruption”, and that “the vast majority of our resolved bugs are silent numerical miscompilations”.
Left: the paper reports over 142 XLA:TPU compiler bugs resolved and 103 additional findings under review; 142 + 103 = 245 and 103/245 = 42 per cent are our arithmetic, and because more than 142 are resolved the share under review is at most 42 per cent. Right: the share of resolved defects by compiler subsystem, from the paper’s Table 1. Source: Cano et al., XLA from the Trenches: Correctness on TPU Workloads at Scale, arXiv:2611.00624, 31 October 2026.
Business Pill · Verification Cost
An evergreen Business Engineer explainer on verification cost: something cheap to make is not always cheap to check. It teaches the general idea only and does not discuss Google, its TPU compiler or the paper.
The key insight:Google’s compiler team says a framework that pairs fuzzing with AI agent swarms has driven the resolution of over 142 bugs in the XLA:TPU compiler, with 103 more findings under review. By our arithmetic, that is up to 42 per cent of its findings waiting on human review.
What Was Posted on X
Banger paper from Google on using agent swarms to fix Google’s TPU compiler.
The team used swarms of AI agents to find and fix silent compiler bugs, and the framework has resolved over 142 of them so far.
They find silent miscompilations are the most dangerous. The compiler raises no error, but numbers drift, or buffers get corrupted, which can ruin a large training run or degrade live serving.
The team combines fuzzing on synthetic and real production graphs with checks that run alongside the existing autotuner. A bisection pipeline narrows a failure in a full workload down to one operation inside a fused kernel.
The agents generate stress tests, reproduce failures, and write fixes.
The team steered them away from easy crash bugs and toward silent data corruption, and 103 more findings are under review.
They also report that reviewer effort grew faster than the complexity of the fixes, and agent patches needed adversarial pre-filtering before humans looked at them.
On 3 November, @omarsar0 posted a summary of the Google paper. The post describes the bugs as silent compiler bugs; the paper itself gives over 142 compiler bugs resolved overall, with 103 more findings under review. The post pointed us to the paper, which is the source for the figures in this piece.
How the Swarm Works
The paper says the swarms run “in a closed loop on an internal agent harness built for large swarm orchestration and long horizon autonomous work”. A lead agent spawns subagents, which can spawn their own, and each worker can get its own copy of the source tree.
All agents share layered instructions that encode engineering policy, “such as fix root causes, never disable tests, and take no externally visible action without human approval”.
To save chip time, the paper says “fuzzing workers execute primarily on fast instruction-set simulators”, keeping physical TPUs for final bug confirmation. For each confirmed bug, patching subagents shrink the test case and write a small fix; an “independent adversarial review swarm” then audits each candidate patch.
The paper prints four bugs it says were “discovered and patched end-to-end by our autonomous agent swarm”. In one, a single write to index 5 of an array also overwrote index 261, because the compiler built an 8-bit index sequence that wrapped around.
Where Humans Stay in the Loop
The paper says the human author and the compiler maintainers “remain strictly in the loop”. A coordinator agent “queues verified patches and surfaces only the highest-severity fixes”, and every change needs “explicit maintainer approval before any change can land”.
Its lessons section is about reviewer time. Agent patches that were not constrained “often touch hundreds of lines”, so the team forced small, atomic patches; a compact patch with a minimal failing test “allows a human expert to verify in seconds” that a bug is real.
Pre-filtering by the review swarm, severity ranking and opt-in reviewers meant that “human engineers only saw high-confidence, pre-audited fixes”, the paper says.
Where the Bugs Sat
The paper’s Table 1 splits the resolved defects by compiler subsystem: 43 per cent in the lowest-level TensorCore LLO and emitters layer, 25 per cent in high-level HLO simplifiers and rewrites, 14 per cent in precision and emulation rewriters, 10 per cent in SparseCore lowering and 8 per cent in custom kernel lowering.
Two production cases show the stakes, as the paper tells them. Daily fleet fuzzing flagged a divergence days before a customer’s evaluation metrics dropped 100-fold after a compiler update. In a second case, a fix was already in flight when a customer nearest-neighbour pipeline reported silently losing about 30 per cent of top-ranked results.
Among its references for silent errors reaching live inference, the paper cites Anthropic’s September 2025 engineering postmortem, which it describes as a technical report on “XLA:TPU miscompilation and infrastructure issues”.
As we read the paper, the agents now do much of the finding, reproducing and patching, and the scarce input is the maintainer who approves each change. Its lessons section is mostly about how to spend that reviewer time.
As we read it, Google treats compiler correctness as a serving-quality issue for its TPU fleet: the paper ties silent miscompilations to multi-million-dollar training runs and to live serving quality.
Cano et al., XLA from the Trenches, arXiv:2611.00624, 31 October 2026
“Autonomous AI agents proved remarkably effective at both uncovering compiler bugs and synthesizing verified fixes across the stack”
Three Implications
FOR GOOGLE The paper says the agents run on an internal harness with layered instructions that encode engineering policy, and that every change needs explicit maintainer approval before it can land.
FOR TPU CUSTOMERS The paper describes two production cases: a customer whose evaluation metrics dropped 100-fold after a compiler update, and a nearest-neighbour pipeline that silently lost about 30 per cent of top-ranked results.
FOR ENGINEERING TEAMS The paper reports that forcing agents to emit small, atomic patches let a human expert verify in seconds that a bug is real, and that an adversarial review swarm pre-filtered patches before people saw them. By our arithmetic, 103 of 245 findings were still under review.
The framework opens: “The next professional jump is not a better prompt.” It continues: “Without it, AI works for you. With it, AI works for your team.”
As we read it, Google’s paper describes such a harness at compiler scale: shared tools, written engineering policy and human approval gates around the agents. The framework was published before this paper and does not discuss it.
As we read the paper, it does not name the AI models behind the agents, give the cost or compute used by the swarms, state the period the counts cover, or say how many of the 142-plus resolved bugs the agents found or fixed rather than the other fuzzers in the framework.
It gives no acceptance rate for agent-written patches. The 245 total and the 42 per cent share are our arithmetic from the paper’s two figures.
This Week In The AI Supercycle
Anthropic’s Reality Check, The Capital Squeeze, & The New World Order
This week’s issue: for two years the AI build-out was priced as a growthstory. This week it started being priced as a credit story.
Google’s compiler team says a framework that pairs fuzzing with AI agent swarms has driven the resolution of over 142 bugs in the XLA:TPU compiler, with 103 more findings under review. By our arithmetic, up to 42 per cent of its findings are still waiting on human review, and the paper’s own lessons are about protecting that review time.
A note on sourcing. We read the paper on arXiv in full; the figures and quotations come from its abstract and body. The X post by @omarsar0 pointed us to it. The 245 total and the 42 per cent share are our arithmetic from the paper’s two figures.
Gennaro Cuofano is a CRO and tech executive who has worked in AI since late 2015, starting with bringing NLP, natural-language generation, voice and chatbot products to the marketing industry. His background is in law and finance: he holds a Master's degree in Law and an International MBA with an emphasis on corporate finance (LUISS Business School and the University of San Diego, 2012), and worked as a financial analyst at a real-estate investment firm in San Diego and as an assistant controller. His work focuses on business model strategy, business engineering and, more broadly, structural analysis: how companies make money, read from their own filings. He created FourWeekMBA and leads research there and at The Business Engineer, his newsletter on AI and business strategy, with over 95,000 subscribers and more than 1,000 published analyses. His writing has also appeared on Entrepreneur (for example, How to Digitize a Family Business in Europe) and HackerNoon. Find him on LinkedIn and Substack. See how we source.
