Anthropic's Killer Multi-Agent Blueprint: One Loop, Skills, Harness & Snapshot Eval

Anthropic's Shared Multi-Agent Paradigm

Anthropic recently disclosed two internal "killer" multi-agent systems built with the same underlying recipe: a single-model Agent Loop + Skills for long-tail tasks + tool calls to existing systems + a Harness that enforces rules in code + snapshot-style evaluation. The two systems are a production e-commerce agent deployed with retail, travel, and telecom clients, and a Lean 4 formalization of Fermat's Last Theorem (FLT) completed in 11 days by a cluster of Claude agents.

E-Commerce Agent Anatomy

Architecture: One Model + Skills, Not Sub-Agents

The core counter-intuitive claim: do not create a sub-agent per business domain . Three reasons: conversations are tightly coupled, domain boundaries are messy, and models keep getting stronger. Instead, package domain-specific instructions into Skills that are loaded on demand into a single agent that already holds the full conversation history. Cross-enterprise deployments show single-agent + Skills consistently outperforms both "one giant prompt" and "sub-agent" designs in quality, with lower per-task cost and latency.

What goes in the system prompt vs. a Skill? Split by frequency : anything covering >1/3 of traffic goes in the system prompt (product search, cart/checkout semantics, presentation rules); the long tail goes into Skills. Safety, legal, brand constraints, and critical user info (e.g., allergies) always stay in the prompt.

Tool Engineering & UI Components as Tools

Tools must wrap existing core systems. E-commerce companies already have mature search ranking, cart, inventory, and promotion engines. Tools should call them, not re-implement logic in the model. search_products should return pre-sorted results; the model decides which to show, how many, and how to present them.

Tool results are context. Return only fields the model needs for reasoning; strip the rest (e.g., image URLs on every search result line are a common waste). Error cases should return instructions, not raw codes: e.g., "Please provide product ID when querying inventory" instead of a bare 403.

Latency & Cost: Three Levers + Caching

Task latency is decomposed into three levers to optimize jointly: fewer turns, faster tools, faster tokens .

Fewer turns: pre-load context (when a user opens the assistant from a product page, inject that page's data); use smarter models (they plan more efficiently, often ending up faster); let the model call multiple independent tools in parallel within a single turn.

Faster tools: optimize tool backends; eager dispatch — fire the tool as soon as its parameters start streaming, while the model continues generating other output. This turns seconds of idle time into hundreds of milliseconds. Claude Agent SDK does this by default.

Perceived latency: stream and render components as they arrive (a typical e-commerce reply is 500–700 output tokens; without streaming that's 5+ seconds of spinner); show plain-language progress at each step ("Looking for seaside hotels").

The biggest cost lever is Prompt Caching — no other lever comes close:

Cached input token read cost = 1/10 of fresh input; write premium ≈ 1.25×; break-even on second use.

Best e-commerce deployments run at 90–99% cache hit rates .

At ~100k token scale, cache reads are also 1.5–2× faster.

Model selection is data-driven: define business metrics and pass thresholds, run the full eval suite on every candidate model × every effort tier (merchant agent starts from Opus, consumer agent from Sonnet), and compare cost per completed task , not cost per API call.

Memory: Cross-Session Relational Asset

Long-term memory is a three-part system:

Store: facts live in your own database, not in the model. A fact = key (e.g., shoe_size, default_store) + short value + category + source session.

Write: async write . After each turn, an independent extractor thread reads/writes the memory store.

Read: three layers — a few critical facts resident in context every turn; relevant facts pre-fetched per turn based on signals.

Safety & Eval: Rules Live in Harness, Evaluation Uses Snapshots

Safety stance: prompt is the starting point for safe behavior, but never the enforcement point. E-commerce failures are monetary and often irreversible; every rule is enforced in code:

Model only stages actions; a human or policy applies them.

Writes and renders only accept server-issued IDs.

Purchase limits validated against post-write state; session writes serialized to prevent parallel tool calls from stacking past limits.

All third-party content sanitized uniformly.

Formalizing Fermat's Last Theorem in 11 Days

Result: Largest Lean Proof to Date

Anthropic researcher Tianyi Peng used Claude to formalize FLT in Lean 4, following the Darmon-Diamond-Taylor simplification of Wiles' proof. Human input was limited to occasional high-level nudges (e.g., "Jacobian as a scheme sounds high priority"). The outcome:

29,511 statements all proved; root node FLT closed on Day 11 (2026-08-17).

Kevin Buzzard (Imperial College, leader of the community FLT formalization project) reviewed: "This extraordinary automated formalization achievement… proved FLT in 11 days with no assumptions beyond mathematical axioms. We saw automated formalization across algebra, harmonic analysis, geometry, and number theory, and the artifacts are solid enough to build upon; this proof is multi-layered."

From Chaos to Convergence

Early attempts failed: agents lost project state, collaboration broke down. Those failed runs contributed ~7% of non-template code lines in the final proof. The turning point was adopting Prove2Me .

Claude's own log at completion: "!!! The FLT ROOT 62eb32c0 reads PROVED. R = T closed and cascaded to the root. This is the campaign's goal: e2e FLT on prove2me."

Prove2Me: Keeping Dozens of LLM Agents Coordinated

Prove2Me (designed by Tianyi Peng and Columbia collaborators) is an open mathematical formalization collaboration platform solving three core multi-agent math problems:

Maintain a DAG of theorem statements: agents decide which proof to tackle next — directly mitigates memory decay in long-horizon tasks and enables parallel multi-agent work.

Separate theorem statements and proofs into different files with independent links: dramatically speeds up Lean compilation and reduces resource consumption.

Maintain natural-language descriptions for each theorem statement: enables retrieval and reuse, yielding shorter proof paths.

Combined with a Claude Code-based multi-agent harness, the team finished in under two weeks. The same recipe was rapidly validated: an Anthropic researcher used three personal Claude Max subscriptions collaborating entirely through Prove2Me to formalize Vinogradov's three-prime theorem (application of the Hardy–Littlewood circle method) in three days .

Implication: Verification Burden in Mathematics Shifts

The novelty isn't "new math" but verification — checking a 129-page proof like a calculator. Historical verification pain: Hales' Kepler conjecture proof took four years of review for a "99% certain" verdict (leading to the 20-person Flyspeck formalization project); Perelman's Poincaré proof took four years plus three 300-page expositions to digest.

Buzzard's take: if automated FLT formalization is now feasible, we've taken a giant step toward automatically formalizing the entire modern mathematical literature . These technologies can uncover errors in published math, reduce reviewer load, and enable rigorous checking of LLM-generated mathematics. Future norm: every human-readable paper ships with a machine-checkable formal proof.

Side observation: writing Lean seems to help Claude prove new results . Recent Claude-coauthored results often advance proof and formalization in parallel; Claude appears to treat parts of the formalization as "numerical simulation" to sanity-check hypotheses.

Conclusion

Model intelligence proposes; system engineering disposes. In e-commerce, the model's most dangerous move is a proposal; approval goes through the business's existing maker-checker flow. In math, the model can write endless proofs, but the Lean kernel has the final say. The key to killer multi-agents isn't just model smarts — it's the scaffolding that lets intelligence scale, be verified, and be governed in production.

Fermat's Last Theorem Lean 4 proof:
https://www.anthropic.com/research/formalizing-fermats-last-theorem
https://github.com/anthropics/fermats-last-theorem

Anthropic commerce-agents:
https://claude.com/blog/the-anatomy-of-effective-commerce-agents
https://github.com/anthropics/commerce-agents/tree/main