The Margin Was Plenty: Claude Proves Fermat’s Last Theorem in 11 Days

🎙️ Listen while you go

Prefer to listen on the go? Here’s the audio edition — Avery and Jordan walk through today’s eleven stories.

Decode Daily audio edition · 2026-09-05 · ~6.3 min

Security

NVD

Actively exploited Chromium sandbox RCE: CVE-2026-85046 patches all Chromium versions

CVE-2026-85046 is a type-confusion vulnerability in V8, Chromium's JavaScript and WebAssembly engine, that allows a remote attacker to execute arbitrary code inside the browser sandbox; it is rated CVSS 8.8 and is already being exploited in the wild. Google patched it in Chrome Stable 152.0.7977.82/.83, making it the sixth Chrome zero-day exploited in 2026, and the flaw has been added to CISA's Known Exploited Vulnerabilities catalog.

Because it affects all Chromium-based browsers, the practical exposure extends beyond Chrome to any embedder that has not yet shipped the engine update — a reminder that V8 type confusion remains the dominant browser exploitation primitive.

Why read it A concrete, actively exploited sandbox escape with a CVE and patch — relevant to browser security, and to the explosion of browser-based and computer-use agents that multiply the attack surface.

AI & Models

Anthropic

Claude formalizes Fermat's Last Theorem in Lean 4: 11 days, 13 million lines, 29,500 theorems

Anthropic reports the first complete, computer-checked proof of Fermat's Last Theorem, produced largely autonomously by Claude over 11 days in the Lean proof assistant. The campaign wrote 13 million lines of Lean and proved 30,300 intermediate theorems (29,500 used in the final proof), following a simplified version of Wiles's proof due to Darmon, Diamond, and Taylor — with occasional high-level human nudges such as 'push the Mazur theorem to be done soon'.

Earlier attempts failed when agents lost track of project state; the breakthrough came from Prove2Me, an open collaborative platform that maintains a directed acyclic graph (DAG) of theorem statements for parallel agents, separates statements from proofs to speed compilation, and keeps natural-language descriptions for search. The finished proof uses Lean's three standard axioms, matches Mathlib's statement of the theorem, and was reviewed by Kevin Buzzard. Kevin Buzzard has reviewed the result, calling it an extraordinary autoformalization achievement whose artifacts are robust enough to build upon.

Why read it A landmark result for multi-agent LLM systems and formal verification — the largest Lean proof ever constructed, demonstrating that agent teams with structured state (a theorem DAG) can sustain multi-day, memory-heavy collaboration.

Spotify

Spotify's Portal shunt routes grunt work to cheap models, cutting Claude Code tokens ~90%

Most of what an AI coding agent does is I/O, not reasoning — bulk file reads, boilerplate test generation, doc updates — and feeding that to a frontier model is expensive. Spotify's Portal 'AiKA Modes' are declarative agents that run on an ephemeral runtime (like a Lambda for agents), and a Claude Code plugin called shunt enforces routing: PreToolUse hooks block reads of large files and redirect Claude to a bulk-reader mode, and a code-writer mode generates patterned code directly to disk so Claude never sees the output.

Benchmarked on a Java monorepo, mean bulk-read token savings were around 90%. The design degrades gracefully, cannot delegate editing or reasoning (a worker model missed a thread-safety bug the frontier model caught), and turns model routing from a systems-engineering problem into a configuration problem.

Why read it A concrete, production-scale pattern for agent cost engineering — routing grunt work to cheap models while reserving frontier tokens for real reasoning, with measured 90% savings.

arXiv

CORAL: an LLM-native harness that self-optimizes production recommender systems

CORAL is an LLM-native agentic harness designed to autonomously optimize a production recommender system in a closed loop. It observes real-time operating signals, reasons over past decisions, and invokes tools — including a numerical optimizer — to reconfigure the recommender, while managing constraints and learning from measured outcomes.

This is a concrete instance of autonomous system management: instead of ranking as a fixed pipeline, the harness continuously tunes the live system and evaluates the effect of its own reconfigurations.

Why read it A concrete agentic harness for closed-loop, constraint-aware optimization of a live system — a direct analog of autonomous network management patterns.

arXiv

EarlyEval predicts agent outcomes early, cutting evaluation cost by up to 44% of input tokens

Evaluating LLM agents has grown prohibitively expensive: a single pass of a frontier model over an agentic benchmark can cost hundreds to thousands of dollars, paid repeatedly across development cycles. EarlyEval trains LightGBM success and failure classifiers on behavioral, textual, and reference-solution features, then halts an agent run once either classifier crosses a calibrated threshold.

Across SWE-bench Verified, TerminalBench, and Toolathlon, this cuts 13-26% of agent steps and up to 44.1% of input tokens and 29.4% of output tokens at 89-97% prediction accuracy, with per-agent resolve rates moving only one to two points on average.

Why read it A concrete technique for cheapening agent evaluation — relevant to agent development loops, benchmark economics, and CI/CD for agent systems.

Kubernetes

Kubernetes 1.37 lets HorizontalPodAutoscaler scale workloads down to zero replicas

Kubernetes 1.37 graduates HorizontalPodAutoscaler scale-to-zero support to Beta and enables it by default. HPA can now scale queue consumers and batch processors all the way down to zero replicas using object or external metrics — such as queue length — that persist even when no pods are running, unlike CPU or memory metrics that vanish with the last pod.

While a workload is held at zero, HPA records a ScaledToZero condition in its status, distinguishing an intentional scale-down from a failure, and can spin pods back up when demand genuinely arrives.

Why read it A concrete cloud-native efficiency feature — relevant to event-driven and batch workloads, idle-cost reduction, and on-demand compute patterns.

Ben Houston

Three-LLM runs GPT-2, Qwen, and Phi in the browser via Three.js TSL compute shaders on WebGPU

Three-LLM demonstrates running large language models locally in the browser by turning their inference graphs into Three.js TSL compute shaders that execute on WebGPU. It runs GPT-2, SmolLM2, Qwen, and Phi models client-side, using storage buffers, compute dispatches, and workgroup memory to express model inference as GPU compute.

This pushes client-side inference forward as a practical pattern: models run on the user's own GPU, enabling privacy-preserving applications and reducing server-side inference cost — though it remains a technical demonstration of general compute rather than a general inference engine.

Why read it A concrete edge-inference technique on WebGPU — relevant to on-device models, privacy-preserving serving, and pushing compute to the edge.

arXiv

Harness-of-Harness: multi-day autonomous software development with continual improvement

Modern coding agents operate within a harness, and Harness-of-Harness (HoH) studies what it takes for LLM coding agents to sustain multi-day, fully autonomous software development. It structures executions into iterative planning, coding, and testing loops, balancing repair of existing code with capability growth, scoping development into small verifiable increments, separating implementation-time testing from independent evaluation, and maintaining versioned project histories.

On the GameCraft-Bench benchmark, HoH outperforms standalone harnesses by more than 50%, showing that harness architecture and state management matter as much as model capability for long-horizon agentic development.

Why read it A concrete framework for sustained autonomous software development — relevant to agent harness design, long-horizon reliability, and autonomous coding.

arXiv

KC-Bench: a controlled benchmark for knowledge conflicts in tool-using LLM agents

As LLMs increasingly act through tools, they must reconcile user instructions, parametric knowledge, and dynamic environmental observations before taking actions. KC-Bench is a controlled multi-turn benchmark for measuring exactly this, covering world-knowledge conflicts, input inconsistencies, and multi-source temporal conflicts, with 238 tasks manually screened from more than 1,000 candidates.

The benchmark isolates the knowledge-conflict capability: when the environment contradicts what the model believes, can it trust the observation, and when the user contradicts both, how does it decide?

Why read it A concrete, controlled evaluation for knowledge conflicts in agents — relevant to agent reliability, tool grounding, and the memory-versus-observation trade-off.

arXiv

DNative-Twin: graph-native digital twins make agentic decisions reconstructable

AI agents increasingly gather evidence, invoke tools, apply constraints, and produce decisions that people or software may commit to action — but a final output alone cannot show which evidence, tool state, rule, authorization, or action path produced it. DNative-Twin is a graph-native digital twin that records a committed agentic decision as a typed trajectory and can re-execute its decision mechanism.

It is a decision-provenance layer: every committed agent decision becomes a typed, re-runnable artifact, so the reasoning behind an action can be reconstructed and audited after the fact.

Why read it A concrete provenance mechanism for agentic decisions — relevant to auditability, digital-twin patterns, and trustworthy autonomous decision-making.

Research & World Models

Nginx

Nginx 1.31.5 gains a Control API, predicate locations, and native JSON parsing

Nginx 1.31.5 mainline introduces a Control API providing an HTTP/1 REST interface for runtime management — querying processes and dumping configurations dynamically — plus predicate locations, which are evaluated at runtime to enable declarative, variable-driven routing without external scripting, and early request-body inspection with a built-in ngx_http_json_module.

These additions move Nginx from a configuration-file-driven server toward a programmable platform: traffic logic can respond to complex conditions natively, and operational control no longer requires config reloads.

Why read it A concrete network-infrastructure evolution with direct implications for dynamic routing, observability, and operational control in distributed systems.