Claude Formalized Fermat's Last Theorem While Chatbots Still Flub Election Day

Three stories landed within days of each other this week, and they don't agree on how mature conversational AI actually is. One lab published proof that an agent fleet can sustain nearly two weeks of unsupervised, mathematically rigorous work. An independent study found the same class of technology getting ordinary voting questions wrong nearly a third of the time. And an enterprise vendor quietly admitted its autonomous agents needed audit logs it hadn't shipped at launch. Read together, they're a more honest snapshot of where things stand than any single benchmark: capability, reliability, and governance are all real trends right now, and they're moving at completely different speeds.

1. Eleven Days, Dozens of Agents, One 389-Year-Old Theorem

Anthropic published research this week describing how a fleet of Claude agents — running on an internal research model roughly comparable to Claude Fable 5.1 — produced the first complete, computer-checked proof of Fermat's Last Theorem in the Lean proof assistant. Over 11 days of largely autonomous work, the agents wrote around 13 million lines of Lean, proved roughly 29,500 intermediate lemmas, and burned about 6 billion output tokens, coordinated as a multi-agent workflow rather than one model looping alone. The important caveat: this isn't a new proof of the theorem — Andrew Wiles settled that in 1994. What's new is the formalization — translating Wiles's proof and the modern number theory underneath it into a form a computer can verify line by line, with no step resting on a human's judgment call. The project leaned on Prove2Me, an open Lean formalization platform built by Tianyi Peng and collaborators at Columbia, and on 106 files contributed upstream by Kevin Buzzard's Imperial College London FLT project and the Mathlib community; Anthropic is upfront that none of this was possible in 11 days without that existing scaffolding.

The part worth stealing for your own agent designs isn't the theorem, it's the shape of the run: dozens of agents each own a sub-lemma, and every attempt is checked by a kernel that only accepts a proof if it actually type-checks — no plausible-sounding near-miss gets through. That's the version of "long-horizon autonomy" that actually holds up: not one agent grinding for 11 days, but an orchestrator that decomposes a huge task into pieces small enough to verify against ground truth, so the human only has to set the goal.

// Rough shape of the FLT run: decompose, assign, verify — never trust, always check
async function formalizeLemma(lemma: Lemma, agents: AgentPool): Promise<CheckedProof> {
  const attempt = await agents.next().prove(lemma);
  const checked = await leanKernel.typecheck(attempt); // ground truth: compiles or it doesn't
  if (!checked.ok) return formalizeLemma(lemma.simplify(), agents); // no partial credit
  return checked;
}

2. Meanwhile, Chatbots Still Get Election Day Wrong

Days later, the Institute for Strategic Dialogue published a far less flattering result. Testing six leading chatbots — Meta's Muse Spark, xAI's Grok 4.3, DeepSeek's V4 Pro, OpenAI's GPT-5.5, Anthropic's Sonnet 4.6, and Google's Gemini 3.5 — on fifteen basic voting questions ahead of the 2026 midterms, researchers found 29% of answers were inaccurate, unclear, or outdated. A further 16% were technically correct but left out a deadline or ID requirement a voter would actually need. DeepSeek was the worst offender, in some cases citing 2024 election dates. And the gap widened, not narrowed, in Spanish: every model's accuracy dropped when the same questions were asked in Spanish instead of English.

This isn't a capability problem — these are the same model families that, per the previous story, can hold a formal proof together for 11 days without a single unverified step. It's a grounding and freshness problem: registration deadlines and ID rules are jurisdiction-specific, change yearly, and sit behind a citation the model either doesn't retrieve or doesn't trust over its own training data. If your product answers anything where "correct six months ago" and "correct today" diverge — filing deadlines, eligibility thresholds, compliance rules — this study is a reminder that a capable base model plus a system prompt isn't a substitute for a pipeline that forces a current, dated source before it answers, in every language you serve, not just the default one.

# Refuse to answer a date-sensitive question without a fresh, dated source —
# don't let the model reason from training data it can't timestamp
def answer_time_sensitive(question, retrieved_sources):
    fresh = [s for s in retrieved_sources if s.age_days < FRESHNESS_LIMIT_DAYS]
    if not fresh:
        return "I don't have a current source for this — check your local election office."
    return synthesize(question, fresh)

3. Enterprises Answer "What If the Agent Is Wrong" With Audit Logs

xAI opened Grok Bot — its always-on "AI teammate" agents that sign into a company's existing tools and work autonomously across sales, recruiting, marketing, finance, and engineering — to enterprise customers on September 3, adding governance it hadn't shipped at the original August launch: access controls, network controls, and audit controls meant to let a company see and constrain what a fleet of Bots is doing. Legora, Supermicro, and ServiceTitan are named early customers, and xAI is sweetening adoption with a two-week free trial for Grok and Cursor Enterprise customers — arriving as its AI unit reportedly lost $2.47 billion on $818 million in revenue in Q1, with enterprise contracts one of the more direct paths to closing that gap.

The telling part isn't the pricing push, it's the sequencing: ship the autonomous agent first, retrofit governance once it's already touching production systems. That's a pattern worth designing around rather than reacting to — an agent with real access to a company's tools needs an audit trail from the first deployment, not as a feature request filed after the first Bot does something nobody can explain in hindsight.

// Wrap every tool call an agent makes so there's an audit trail before the fact,
// not a reconstruction attempt after something breaks
async function auditedToolCall(agent: Agent, tool: Tool, args: unknown) {
  const entry = await auditLog.record({ agentId: agent.id, tool: tool.name, args });
  const result = await tool.invoke(args);
  await auditLog.complete(entry.id, { result });
  return result;
}

Three Speeds, One Technology

These aren't three unrelated headlines — they're the same technology under three different kinds of pressure. The model family that held together an 11-day, 13-million-line formal proof with zero tolerance for error can also confidently hand a voter the wrong registration deadline, because the two tasks demand completely different things from it: one is checked by a kernel that never lies, the other depends on the model choosing a fresh source over its own training data, and it doesn't always choose well. And the response once agents get real access to production systems is exactly what you'd expect — ship the capability, then race to add the governance rails once someone asks what happens when it's wrong. If you're building on any of this, match your own guardrails to the failure mode you're actually exposed to: a proof-style pipeline that mechanically checks its own output, a freshness pipeline that refuses to guess on dated facts, or an audit trail that at least tells you what happened after the fact — because the underlying model won't reliably tell you which one you need.

Suggested visuals for this post: a timeline showing agent count and lemma-proving rate over the 11-day FLT run; a bar chart comparing the six chatbots' error rates on the voting-questions study, split by English vs. Spanish; and a simple flow diagram of an audited agent tool call (agent → audit log entry → tool invocation → audit log completion).

— Maya