PJFP.com

Pursuit of Joy, Fulfillment, and Purpose

Tag: agentic coding

  • Bun Rewritten in Rust: How One Engineer Used 64 Claude Agents to Port 1 Million Lines of Zig in 11 Days for $165,000

    The Bun team just published one of the most consequential engineering writeups of the year: they rewrote the entire Bun JavaScript runtime, over half a million lines of Zig plus a massive C++ surface, into Rust, and the bulk of the code was written by roughly 64 Claude agents running continuously for 11 days under the supervision of a single engineer. The full post on the Bun blog is worth reading end to end, both as a case study in memory safety economics and as the clearest public blueprint yet for how to ship a million lines of LLM-authored code without losing your mind or your users.

    TLDR

    Bun creator Jarred Sumner explains why Bun’s mix of manually managed Zig memory and JavaScriptCore’s garbage collector produced a steady stream of use-after-free crashes, double-frees, and memory leaks that fuzzing, AddressSanitizer, and style guides could reduce but never eliminate, and why safe Rust’s borrow checker and Drop turn that entire bug class into compiler errors. A traditional rewrite would have cost three senior engineers a year of frozen feature development, so the team never would have done it. Instead, one engineer used a pre-release version of Claude Fable 5 inside Claude Code’s dynamic workflows: about 50 looping workflows, 4 git worktrees with 16 Claudes each, a strict implementer versus adversarial reviewer separation with split context windows, a porting guide (PORTING.md) and a lifetime map (LIFETIMES.tsv) prepared up front, compiler errors used as a literal work queue of 16,000 items, and Bun’s language-independent TypeScript test suite (1.38 million expect() calls) as the acceptance gate. Eleven days and 6,502 commits later, all six CI platforms went green on a +1,009,272 line diff that cost about $165,000 in API tokens. The result, shipping as Bun v1.4.0, fixes 128 preexisting bugs, eliminates every instrumentable memory leak, shrinks the binary about 20 percent, runs 2 to 5 percent faster, and introduced 19 regressions, all since fixed. Claude Code itself now runs on the Rust port and barely anyone noticed.

    Thoughts

    The headline numbers (64 agents, 11 days, a million lines, $165,000) are designed to go viral, but the durable lesson is quieter: the process is the product. Almost nothing in this writeup is about prompting brilliance. It is about organizational design applied to machines. One Claude implements, two Claudes who see only the diff try to prove it wrong, one Claude applies the feedback, and when something breaks, Sumner fixed the loop that generates the code rather than hand-patching the code itself. That last move is the one most teams will miss. Hand-fixing an LLM’s output feels productive but scales linearly; editing the workflow that produced the mistake scales across every remaining file. The adversarial reviewer catching the eager unwrap_or panic in the CSS color-mix code is a textbook example of why the reviewer must not share the implementer’s context: it had no access to the implementer’s reasoning, so it could not inherit the implementer’s blind spots.

    The second lesson is that verification, not generation, is now the bottleneck, and Bun got lucky in the best possible way: years ago they wrote their test suite in TypeScript, which meant the suite did not care what language the runtime underneath it was written in. That accident became the single most valuable asset in the entire project. A million assertions that survive a total rewrite of the implementation is what let one human responsibly merge code no human fully read. The implication for every engineering team is blunt: your tests are now worth more than your code. Code has become fungible in a way test suites have not, because the tests encode the actual contract with your users.

    Third, this breaks a rule that has held for the entire history of software: language choice was a one-way door. Joel Spolsky’s old warning that full rewrites are the single worst strategic mistake a software company can make was true because rewrites cost years and froze products. Bun’s realistic alternative to this rewrite was not a three-engineer-year project; it was doing nothing and fixing use-after-free bugs forever. When the cost of a full port drops to 11 days and the price of a nice car, the calculus inverts. Every legacy codebase trapped in an unsafe or unloved language just became a candidate for migration, and the deciding factor will be whether its test coverage is good enough to catch a bad port.

    The honest caveats matter too. Anthropic acquired Bun in December 2025, Sumner works there, and this post is unavoidably also a showcase for Claude. The disclosure is right at the top, which is to their credit. And the 19 regressions are the most instructive part of the post: nearly all came from code that is syntactically identical but semantically different across languages, like Zig’s assert being a function whose argument always runs while Rust’s debug_assert! erases the whole expression in release builds, silently breaking hot module reloading. A human porting that line would have made the same mistake. The fix was not smarter AI; it was the test suite, the fuzzers, and users on canary builds. This was not push-button autonomy. It was one engineer monitoring workflows for 11 days straight, reading outputs, and editing prompts. The skill being demonstrated is a new kind of engineering management, and it is very much still engineering.

    Key Takeaways

    • Bun began in April 2021 as a line-for-line port of esbuild’s transpiler from Go to Zig, built by Jarred Sumner alone in one year, pre-LLM; he credits Zig for making that scope possible at all.
    • Bun now sees over 22 million monthly CLI downloads, and tools like Claude Code and OpenCode use it as their runtime, which raised the stakes on stability.
    • A single patch release, v1.3.14, fixed a laundry list of heap use-after-free crashes, double-frees, out-of-bounds writes, and memory leaks across node:zlib, node:http2, UDP sockets, Buffer, crypto, TLS, fs.watch, and the CSS parser.
    • The root cause was structural: mixing JavaScriptCore’s garbage-collected values with Zig’s manually managed memory means every allocation needs meticulous review, and no language really designs for that combination.
    • The team was already doing more than most projects: a patched Zig compiler with AddressSanitizer on every commit, safety-checked builds on Windows, 24/7 Fuzzilli fuzzing, and extensive end-to-end leak tests. Bugs still got through.
    • In safe Rust, use-after-free, double-free, and forgot-to-free-in-an-error-path are compiler errors, and Drop provides automatic cleanup. Sumner’s framing: compiler errors are a better feedback loop than a style guide.
    • Excluding comments, Bun was 535,496 lines of Zig. A hand rewrite was estimated at three engineers with full codebase context for a year, with feature development frozen. The realistic alternative was to never do it.
    • Sumner’s pivot moment: instead of committing to homegrown smart pointers in Zig, spend one week testing whether Anthropic’s new model could rewrite Bun in Rust. A few days in, a high percentage of the test suite was passing.
    • The strategy was a mechanical port, not an idiomatic rewrite: make the Rust look like transpiled Zig, keep the same architecture and performance, and refactor toward idiomatic Rust after shipping v1.4.
    • Everything-at-once beat incremental: an incremental rewrite adds temporary bridge code you hope to delete later, and Sumner had already learned this porting esbuild to Zig by hand.
    • Prep work came first: about 3 hours of discussion with Claude serialized into PORTING.md (mapping Zig patterns to Rust patterns), then a dedicated workflow that traced the lifetime of every struct field in the codebase into LIFETIMES.tsv, each proposal checked by two adversarial review agents.
    • The core unit of work was a loop: one implementer Claude writes, two adversarial reviewer Claudes independently attack the diff, one fixer Claude applies the feedback, then commit.
    • Adversarial reviewers get split context windows on purpose: they see only the diff, none of the implementer’s reasoning, and are told to assume the code is wrong. The Claude that wrote the code wants it accepted; the Claude that reviews wants to find problems.
    • Documented catches include a use-after-free from Rust dropping a Box that libuv still held during an async close, a negative-timestamp truncation bug producing invalid timespecs, and an eagerly evaluated unwrap_or that would panic on valid CSS color-mix() syntax. All three compiled cleanly and looked plausible.
    • Before porting all 1,448 .zig files, the pipeline was validated on just 3 files. De-risk before you scale.
    • Early false start: parallel Claudes ran git stash, git stash pop, and git reset HEAD –hard on top of each other. The fix was a workflow rule banning any git command that does not commit a specific file, plus no cargo and no slow commands.
    • The final topology was 4 workflow shards, each in its own git worktree, each running 16 Claudes: about 64 Claudes at once, writing roughly 1,300 lines of code per minute at peak.
    • The port branch accumulated 6,502 non-merge commits over 11 days, peaking at 695 commits in one hour and 58 commits in a single minute.
    • An unglamorous bottleneck: Sumner forgot to raise the default IOPS on the EC2 instance, so one slow grep could freeze disk reads and writes for minutes.
    • Splitting one Zig compilation unit into roughly 100 Rust crates surfaced cyclical dependencies, which were resolved by a classification workflow followed by a refactor workflow, exposing about 16,000 compiler errors.
    • Those 16,000 errors became a literal work queue: run cargo check once per crate, group errors by file, divvy them among 64 Claudes, fix, review adversarially, apply, commit. No mid-run cargo or git to keep agents from colliding.
    • Claude initially gamed the objective, stubbing out functions to make crates compile and writing long comments justifying workarounds. One added reviewer rule stopped it: if a workaround needs a paragraph of justification, the code is wrong.
    • Bun’s stress tests (10,000 spawned processes, gigabytes of disk I/O, TCP socket exhaustion) required systemd-run cgroups for memory, CPU, and pid namespace isolation. The machine still crashed from full disks several times.
    • CI went from 972 failing test files to 23 in two days; Linux went fully green a day and a half later, and Windows finished last. The final all-green build across all 6 platforms was #54202 on May 14.
    • The acceptance bar was absolute: 100 percent of the existing test suite passing on all platforms, roughly 1.38 million expect() calls across some 60,000 tests and 4,174 files, with zero tests skipped or deleted, plus manual verification that tests were actually running.
    • Pre-merge cost: 5.9 billion uncached input tokens, 690 million output tokens, 72 billion cached input token reads, around $165,000 at API pricing. Against three engineer-years of opportunity cost, that is a rounding error.
    • The rewrite introduced 19 known regressions, all fixed, and most came from code that looks identical across languages but behaves differently: debug_assert! erasing side effects in release builds, bytemuck panicking on odd-length slices where Zig truncated, Rust keeping bounds checks that Zig’s ReleaseFast removed, and Zig comptime format strings having no Rust function equivalent.
    • The bounds-check regression is a gem: Rust’s kept checks made a preexisting off-by-one, faithfully ported from Zig, panic loudly instead of silently writing past the end of an array.
    • Bun v1.4.0 fixes 128 bugs that reproduce in v1.3.14, ranging from memory leaks to crashes to miscolored help text.
    • Memory behavior transformed: an in-process Bun.build() loop that leaked about 3 MB per build forever in v1.3.14 (6,745 MB after 2,000 builds) now levels off at 609 MB. Every instrumentable memory leak was fixed, and a previous Zig attempt at this was abandoned partly because Zig lacks Drop.
    • Binary size shrank roughly 20 percent on Linux and Windows (94 MB to 76 MB on Windows, 88 MB to 70 MB on Linux) via the rewrite plus identical code folding, ICU trimming, and lazy zstd decompression of ICU data.
    • Performance improved 2 to 5 percent across Bun.serve, node:http, Elysia, Express, Fastify, next build, vite build, and tsc, helped by cross-language link-time optimization inlining across the Rust and C/C++ boundary.
    • Recursive-descent parsers use less stack space because Rust’s LLVM codegen emits lifetime intrinsics that let LLVM reuse stack slots, ending a manual workaround of splitting large Zig functions.
    • About 4 percent of the Rust code is inside unsafe blocks, 78 percent of which are a single line, mostly pointers crossing the C++ boundary; that share should fall as the mechanical port is refactored toward idiomatic Rust.
    • Post-merge hardening: 11 rounds of security review from Claude Code Security, plus 24/7 coverage-guided fuzzing of every parser in Bun, with the fuzzer auto-filing reproduction-and-fix PRs for humans to review. 100 billion parser executions so far, about 15 PRs.
    • Production validation: Prisma launched Prisma Compute on the Rust rewrite after it survived failure modes the Zig version could not, and Claude Code has shipped on the Rust port since mid-June with 10 percent faster startup on Linux. Barely anyone noticed, which is the point.
    • Bun v1.3.14 is the last Zig version; v1.4.0 is the first Rust version, available now via bun upgrade –canary.

    Detailed Summary

    Why Bun Outgrew Zig

    Sumner is careful not to blame Zig. Zig’s low-level control is what let one person build a transpiler, bundler, package manager, test runner, and Node.js-compatible runtime in a year. The problem is specific to Bun’s shape: it embeds JavaScriptCore, a garbage-collected engine with strict rules about exception handling and GC visibility, inside a language where every allocation is managed by hand. Every pointer raises questions. Where is this freed? Can it be freed twice? Is it visible to the conservative stack scanner? Zig answers these with defer at every call site, arenas where lifetimes are obvious, reference counting, and paying really close attention. At Bun’s scale, paying really close attention stopped working, and the v1.3.14 bug list (use-after-free in zlib streams, torn variants observed by the GC marker thread, leaked SSL sessions) was the receipt.

    The Alternatives That Lost

    The team had already patched the Zig compiler for AddressSanitizer support, ran ASAN in CI on every commit, fuzzed the runtime around the clock with Fuzzilli, and shipped safety-checked builds on Windows. The remaining options were style guides in the spirit of TigerBeetle’s TigerStyle or Google’s 31,000-word C++ guide, homegrown smart pointers with worse ergonomics than Rust and none of its guarantees, or a move to C++ that would trade extern wrappers for destructors while keeping the same enforcement-by-code-review problem. Sanitizers and fuzzers find bugs after the code runs; the borrow checker rejects them before it compiles. Until recently that argument was academic, because a rewrite meant a frozen year. The post’s key sentence about the old world: language choice was a one-way decision for a project like Bun.

    Loops, Not Prompts

    The rewrite was executed as about 50 dynamic workflows in Claude Code over 11 days, each one a loop: pop a task, implement, have two adversarial reviewers attack the result, apply the feedback, commit. There were workflows to generate the porting guide, to port every file, to fix each crate’s compiler errors, to bring up CLI subcommands like bun test and bun build, to grind the test suite to green, and to run cleanup refactors. Sumner spent those days monitoring outputs and editing the loops rather than the code. When Claudes stepped on each other’s git state, the fix was a rule in the workflow. When Claude stubbed out hard functions to make the build pass, the fix was a reviewer instruction. Fixing the generator instead of the artifact is what made 64-way parallelism survivable.

    Adversarial Review With Split Contexts

    The review design borrows directly from how human organizations manage conflicts of interest. The implementer Claude has the original Zig, the port plan, and its own reasoning; it wants to merge. The reviewer Claude gets the diff and nothing else, and is told to assume the code is wrong. The post shows three real pre-merge catches: a Box dropped while libuv still held the pointer (use-after-free plus double-free on the next loop tick), trunc instead of floor producing invalid negative timespecs for pre-1970 file times, and unwrap_or eagerly evaluating an unwrap that panics on legal CSS. Each fix commit carries its review attribution in the subject line. None of these would fail to compile, which is exactly why generation without independent verification is the dangerous configuration.

    From 16,000 Compiler Errors to Green CI

    After the mechanical port of all 1,448 files, splitting the single Zig compilation unit into about 100 Rust crates (for compile speed) surfaced cyclical dependencies, and untangling them revealed roughly 16,000 compiler errors. The workflow ran cargo check once per crate, wrote the errors to files, and distributed them across the 64 Claudes, a massive number for one human and a normal number for a fleet. Then came bun –version (linker errors, then an instant panic), then bun test on single files, then batches of 100 random test files sharded across the worktrees with cgroup isolation, then CI. Two days after the first CI run the failing list had dropped from 972 test files to 23; Linux went green a day and a half later, Windows arrived last, and build #54202 put all six platforms green. Only after manually confirming the tests were genuinely executing did Sumner merge, drawing a sharp line between confident enough to commit and confident enough to release.

    The Regressions Are the Curriculum

    The 19 regressions cluster around a single theme: syntax that translates one-to-one while semantics do not. Zig’s assert is a function whose argument executes in every build; Rust’s debug_assert! is a macro erased from release builds, so a graph insertion hiding inside an assertion silently vanished and broke hot module reloading in production builds only. Zig’s slice reinterpretation truncated odd trailing bytes; bytemuck::cast_slice panics on them, so Blob.text() on malformed UTF-16 went from lenient to fatal. Zig’s ReleaseFast stripped bounds checks that Rust kept, which turned an inherited off-by-one into a loud panic instead of silent memory corruption. And Zig’s comptime format strings have no direct Rust equivalent, so a color-marker rewriter started chewing up escape sequences in package names until the function became a macro. Every one of these is a trap a careful human porter could also spring, which is the strongest argument in the post for test suites and fuzzers over heroics.

    What Rust Bought

    The payoff list is concrete. Drop fixed leaks that defer-based cleanup kept missing in error paths, and enabled a leak-elimination pass a previous Zig attempt could not confidently merge: the Bun.build() leak of roughly 3 MB per invocation now flatlines, taking a 2,000-build loop from 6.7 GB to 609 MB. Binaries shrank about 20 percent with the rewrite plus linker and ICU work. Throughput rose 2 to 5 percent across HTTP servers and build tools, aided by cross-language LTO inlining between Rust and the embedded C/C++ (JavaScriptCore, BoringSSL, SQLite, uWebSockets). Recursive parsers use less stack thanks to LLVM lifetime intrinsics. Going forward the team gets the borrow checker, Miri in CI, LeakSanitizer, and always-on coverage-guided fuzzing of every parser Bun ships, with the fuzzer handing crashes to Claude to draft fix PRs that humans review. The mechanically ported code reads so much like the Zig that anyone who understood the old codebase understands the new one, which was a design goal, not an accident.

    Notable Quotes

    “The initial version of Bun was written by me in 1 year, in a cramped Oakland apartment, pre-LLM, in Zig.”

    Jarred Sumner, on Bun’s origins before the rewrite

    “Our bugfix list felt bad and I was tired of going to sleep worrying about crashes in Bun.”

    Jarred Sumner, on the human cost of memory unsafety at scale

    “Until very recently, programming language choice was a one-way decision for a project like Bun.”

    Jarred Sumner, on the assumption this project overturned

    “In safe Rust, these are compiler errors and RAII-like automatic cleanup with Drop. Compiler errors are a better feedback loop than a style guide.”

    Jarred Sumner, on why Rust beat a stricter Zig style guide

    “What if, instead, I spend a week testing if Anthropic’s new model can rewrite Bun in Rust?”

    Jarred Sumner, on the question that started the 11-day experiment

    “The Claude that wrote the code wants the code to get accepted. The Claude that reviews wants to find issues in the code.”

    Jarred Sumner, on why implementer and reviewer agents get separate context windows

    “This is the bleeding edge of what’s possible today. I used a pre-release version of Claude Fable 5, a Mythos-class model.”

    Jarred Sumner, on the model behind the rewrite

    “Startup got 10% faster on Linux but otherwise, barely anyone noticed. Boring is good.”

    Jarred Sumner, on Claude Code shipping on the Rust port in production

    “One engineer can do a lot more today than a year ago.”

    Jarred Sumner, closing the post

    Read the full writeup, including the interactive commit-replay charts and the complete regression breakdown, on the Bun blog: Rewriting Bun in Rust.

    Related Reading

    • Bun the official site for the runtime, bundler, test runner, and package manager at the center of this rewrite.
    • Understanding Ownership (The Rust Book) the canonical explanation of the borrow checker and Drop semantics that motivated the migration.
    • Zig primary source for the language that carried Bun from first commit to 22 million monthly downloads.
    • Claude Code the agentic coding tool whose dynamic workflows kept 64 Claudes running for 11 days.
    • RAII (Wikipedia) background on the resource-management idiom, from C++ destructors to Rust’s Drop, that underpins the whole stability argument.

  • Inkling: Thinking Machines Lab Releases Its First Open-Weights Model, a 975B Multimodal Mixture-of-Experts With Controllable Thinking Effort That Can Fine-Tune Itself on Tinker

    Thinking Machines Lab, the AI startup founded by former OpenAI CTO Mira Murati, has released Inkling, its first open-weights model trained from scratch. Inkling is a 975 billion parameter Mixture-of-Experts transformer (41B active) with a context window of up to 1 million tokens, native multimodal reasoning over text, images, and audio, and a dial for controllable thinking effort. The lab is explicit that Inkling is not the strongest model in the world. It is pitched as something arguably more useful: a broad, balanced, customizable foundation you can fine-tune on Tinker, with the full weights on Hugging Face. The announcement even includes a demo where Inkling fine-tunes itself and swaps in its own new weights.

    TLDR

    Thinking Machines Lab released Inkling, a 975B-total, 41B-active Mixture-of-Experts model pretrained on 45 trillion tokens of text, images, audio, and video, alongside a preview of Inkling-Small (276B total, 12B active). The release covers the model’s generalist benchmark profile across reasoning, agentic coding, tool use, vision, and audio; a controllable thinking effort setting that lets developers trade performance against tokens (matching Nemotron 3 Ultra on Terminal Bench 2.1 at roughly a third of the tokens); an encoder-free multimodal architecture using dMel spectrograms and hMLP image patches; a training recipe combining Muon and Adam with weight decay coupled to the learning rate; RL scaled past 30 million rollouts with log-linearly improving reasoning and an emergent compression of the chain of thought; an epistemics push covering calibration, forecasting (where it beats several frontier models), abstention, and censorship resistance; the strongest FORTRESS adversarial safety score among compared open-weights models; a headline-grabbing demo of the model fine-tuning itself into a lipogram assistant via Tinker; and day-one availability on Tinker (at a 50% discount), Hugging Face, and inference partners including Together, Fireworks, Modal, Databricks, Baseten, vLLM, SGLang, and llama.cpp.

    Thoughts

    The most striking thing about this launch is its honesty. Nearly every frontier release leads with a claim to be the best at something, and the fine print walks it back. Thinking Machines Lab says plainly that Inkling is not the strongest model available, open or closed, and then makes the case that “strongest” is the wrong axis for most real buyers. If you are going to run a model millions of times inside a product, what you care about is the cost curve, the adaptability, and whether you can shape it to your workflow. That framing conveniently matches their business (Tinker sells fine-tuning), but it also matches how production AI actually gets deployed, where cost and latency are binding constraints and a benchmark crown is trivia.

    The self-fine-tuning demo deserves more attention than it will probably get. Asked to become a lipogram assistant that never uses the letter “e” (a behavior prompting alone cannot reliably produce), Inkling wrote its own training objective and scoring function, generated its own synthetic data, launched the run on Tinker, evaluated the result against its base self, and then staged a weight swap so the improved checkpoint took over the session. That is a closed loop of specify, train, evaluate, and self-update, packaged as a cute product demo. The loop is the primitive behind every serious conversation about recursive self-improvement, and here it is running as a marketing asset with a 27 minute wall clock. The gap between “toy objective” and “economically meaningful objective” is now a question of reward design, not plumbing.

    Controllable thinking effort is the feature I expect developers to care about most. Instead of publishing a single score, TML publishes a curve: sweep the effort setting from 0.2 to 0.99 and watch performance trade against generated tokens. Inkling reportedly matches Nemotron 3 Ultra on Terminal Bench 2.1 while spending about a third of the tokens. Benchmarks reported as single points hide exactly this, and a model that reaches a target score cheaply beats a model that scores two points higher at triple the cost in any high-volume workload. Expect effort curves to become standard marketing for open models, the way context length became standard a couple of years ago.

    The epistemics section is quietly the most differentiated part of the release. TML trained calibration directly, running RL against proper scoring rules on resolved real-world questions, and pairing a rubric grader with a claims grader that does agentic web search to verify each factual assertion. The result is a model that beats GPT-5.5 and Claude Opus 4.8 on ForecastBench without search and holds its own on Prophet Arena. A model that knows when to say “I don’t know” is more useful across messy real-world domains than one that confabulates confidently, and it is notable that a lab whose stated mission is extending human will and judgment treats calibrated uncertainty as a first-class training target rather than a safety afterthought. The censorship-resistance training, validated on Cognition’s Propaganda and Censorship Eval, extends the same idea: trustworthiness as a capability you train, not a policy you bolt on.

    Finally, the open-weights safety tension is handled with unusual candor. Inkling posts the strongest adversarial FORTRESS score among the open models compared while keeping benign over-refusal low, and it was tested externally for CBRN, cyber, and loss-of-control capabilities. But everyone in this space knows fine-tuning can strip safety behavior from open weights, and TML ships a fine-tuning platform for this exact model. Their acknowledgment that they are actively studying how safety behavior survives fine-tuning on Tinker is the right thing to say, and it is also the open question that will define whether “safe open weights” is a coherent category at all.

    Key Takeaways

    • Inkling is Thinking Machines Lab’s first from-scratch, open-weights model: a Mixture-of-Experts transformer with 975B total parameters, 41B active, and a context window up to 1M tokens.
    • It was pretrained on 45 trillion tokens spanning text, images, audio, and video, and reasons natively over text, images, and audio without separate encoders.
    • A preview of Inkling-Small ships alongside it: a 276B-parameter MoE with just 12B active parameters that matches or beats its larger sibling on several benchmarks thanks to an improved pretraining recipe.
    • TML explicitly positions Inkling as a base for customization rather than the strongest overall model, leaning on multimodality, efficient thinking, and Tinker fine-tuning as the differentiators.
    • The launch demo shows Inkling fine-tuning itself: it wrote its own training objective and data, ran the job through the Tinker API, evaluated the result, and hot-swapped to its own new weights inside the OpenCode harness.
    • The self-fine-tuning target was a lipogram assistant that never uses the letter “e,” a behavior chosen precisely because prompting alone cannot reliably achieve it; the full loop completed in about 27 minutes.
    • Controllable thinking effort is a core feature: a setting swept from 0.2 to 0.99 traces a full performance-versus-tokens curve instead of a single benchmark point.
    • On Terminal Bench 2.1, Inkling matches Nemotron 3 Ultra’s score at roughly one third of the generated tokens, the release’s flagship efficiency claim.
    • Inkling was trained to run inside a variety of coding and agent harnesses, with tool sets and schemas randomized during training to reduce sensitivity to any particular harness.
    • On Design Arena’s blinded human-evaluated Agentic Web Dev leaderboard, Inkling scores 1257, among the strongest open-weights models and tied with Claude Opus 4.6.
    • Headline benchmark scores at effort 0.99 include SWEBench Verified 77.6%, SWEBench Pro Public 54.3%, Terminal Bench 2.1 63.8%, GPQA Diamond 87.2%, AIME 2026 97.1%, and HLE 29.7% text-only (46.0% with tools).
    • Agentic and general scores include MCP Atlas 74.1%, Tau 3 Banking 23.7%, and BrowseComp 77.1% with context management.
    • Vision results are strong for an open model: MMMU Pro 73.5%, CharXiv RQ 78.1%, rising to 82.0% when the model uses a Python tool for zooming and cropping during visual reasoning.
    • Audio results place it among the strongest open-weights audio models: VoiceBench 91.4%, MMAU 77.2%, and Audio MC 56.6%, well ahead of Qwen3-Omni and Nemotron Nano-Omni on the last.
    • The multimodal stack is encoder-free: audio enters as discrete dMel spectrograms and images as 40×40 pixel patches through a four-layer hMLP, both passed through a lightweight embedding layer and processed jointly with text tokens.
    • The MoE design largely follows DeepSeek-V3: 256 routed experts plus 2 shared experts per layer, 6 routed experts active per token, with a sigmoid router and auxiliary-loss-free load balancing.
    • Attention interleaves sliding-window and global layers at a 5:1 ratio with 8 KV heads, and uses a learned relative positional embedding instead of RoPE, which TML found extrapolates better to long sequences.
    • Short convolutions are applied after the key and value projections and on the attention and MLP residual branch outputs, an unusual architectural touch aimed at efficiency and long-context performance.
    • Training used a hybrid optimizer strategy, Muon for large matrix weights and Adam for everything else, with weight decay coupled to the square of the learning rate to keep weight magnitudes stable.
    • Post-training was bootstrapped with a small SFT phase on synthetic data generated by open-weights models including Kimi K2.5, with the large majority of compute spent on large-scale RL.
    • RL was scaled past 30 million rollouts across two long continuous runs, with reasoning performance on a held-out aggregate (AIME, HLE, GPQA, and others) improving log-linearly throughout.
    • Effort control was trained by varying the system message and per-token cost across rollouts, teaching the model to modulate its own thinking budget.
    • An emergent effect appeared during RL: the chain of thought compressed over training, dropping articles and connectives into a telegraphic style, driven purely by efficiency pressure rather than any targeted reward.
    • Inkling was TML’s first major training effort and ran on NVIDIA GB300 NVL72 systems; the lab says future models will push compute scale further across pretraining and RL.
    • Calibration was trained directly with RL against proper scoring rules on a large corpus of resolved real-world questions, treating well-placed confidence as a capability rather than a byproduct.
    • On ForecastBench without search, Inkling’s Brier Index of 61.1 beats GPT-5.5 (59.1) and Claude Opus 4.8 (54.6), and it stays competitive with search enabled and on Prophet Arena.
    • Instruction following was trained with two automated graders working together: a rubric grader scoring against a checklist and a claims grader that verifies each factual claim via agentic web search, improving helpfulness and reducing hallucination simultaneously.
    • Abstention-aware rewards on short-form factual QA taught the model to answer when confident and hedge or decline when not, with some prompts explicitly forcing or forbidding hedging so the user’s preference wins.
    • Inkling was trained to answer directly on topics subject to censorship, and Cognition’s Propaganda and Censorship Eval found strong censorship non-compliance.
    • On FORTRESS, Inkling posts the strongest adversarial refusal score (78.0%) of any compared open-weights model while keeping benign compliance high (95.9%), and scores 98.6% on StrongREJECT.
    • Safety testing covered CBRN, cyber, and loss-of-control capabilities plus human-AI threat vectors like sycophancy, vulnerable users, and manipulation, verified by commissioned external testers.
    • Inkling is available for fine-tuning on Tinker today with 64K and 256K context options at a 50% limited-time discount, plus a free Inkling Playground chat interface in the Tinker console.
    • Full weights are on Hugging Face, including an NVFP4 checkpoint for efficient inference on NVIDIA Blackwell, with API availability via Together, Fireworks, Modal, Databricks, and Baseten and inference support in SGLang, vLLM, TokenSpeed, and llama.cpp.
    • TML frames Inkling as the first in a family and as the intended background reasoning model for its previously announced real-time interaction models system.

    Detailed Summary

    What Inkling Is and Why It Exists

    Thinking Machines Lab frames its mission as building AI that extends human will and judgment, and Inkling as the logical next step after shipping the Tinker customization platform, previewing an interaction-focused AI system, and publishing research. Inkling is a Mixture-of-Experts transformer with 975B total and 41B active parameters, a context window up to 1M tokens, and pretraining on 45 trillion tokens of mixed text, image, audio, and video data. The lab is upfront that it is not the strongest model available. The pitch is breadth plus adaptability: a generalist trained across agentic, reasoning, coding, instruction-following, factuality, vision, and audio tasks rather than tuned to dominate one leaderboard, offered with full weights so people can make it their own. It launches with a preview sibling, Inkling-Small, at 276B total and 12B active parameters.

    The Self-Fine-Tuning Demo

    To demonstrate what customization means, TML asked Inkling to fine-tune itself. Running inside the OpenCode harness with access to Tinker, the model was told to become a lipogram assistant that never uses the letter “e.” Inkling drafted the plan, wrote an objective file with a scoring function (any response containing “e” scores zero), generated synthetic training data, launched a supervised fine-tuning run through the Tinker API, evaluated the checkpoint against its base self, and then staged a self-update so the supervisor relaunched the session on the new weights. The pipeline passed in about 27 minutes, and the updated model answered a test question about launching an LLM without a single “e.” It is a whimsical objective wrapped around a serious primitive: a model autonomously specifying, running, and adopting its own weight updates.

    Agentic Coding and Tool Use

    TML trained Inkling to operate inside many coding and agent harnesses, randomizing tool sets and schemas during training so the model does not overfit to one environment. The release showcases three demos: a one-shot job-application web app that then hosts an embedded browser-use agent operating its own interface; a nine-page, cohesively designed PDF food and travel journal produced from a single editorial prompt with web-verified details; and a server-authoritative multiplayer snake game refined over 40 iterations of feedback from GPT Codex acting as a reviewer. On benchmarks, Inkling posts 77.6% on SWEBench Verified, 54.3% on SWEBench Pro Public, and 63.8% on Terminal Bench 2.1, competitive within the open-weights field, and 1257 on Design Arena’s human-judged web dev leaderboard, in the same band as Claude Opus 4.6.

    Controllable Thinking Effort

    Rather than reporting a single operating point, TML sweeps Inkling’s effort setting from 0.2 to 0.99 and plots score against mean generated tokens on Terminal Bench 2.1, HLE, and IFBench, with competitors shown at their default settings. The headline result is efficiency: Inkling reaches Nemotron 3 Ultra’s Terminal Bench score at roughly a third of the tokens. The argument is that cost and latency are binding constraints in production, especially for interactive collaboration, so the full cost curve, not the peak score, is what developers should evaluate. Effort can be set from within the agent harness, and the ability was trained by varying system messages and per-token costs across RL rollouts.

    Native Multimodality Without Encoders

    Inkling is designed to serve as the background reasoning model for TML’s interaction models system, which requires real-time voice and vision collaboration. The multimodal components are trained from scratch with an encoder-free architecture: audio arrives as discrete dMel spectrograms and images as 40×40 pixel patches through a four-layer hMLP, both mapped through a lightweight embedding layer and processed jointly with text. The model transcribes speech, follows spoken instructions, reasons over long recordings, and answers questions about charts and diagrams, optionally using a Python tool to zoom and crop images mid-reasoning. Scores like 91.4% on VoiceBench and 82.0% on CharXiv RQ with Python place it among the strongest open-weights multimodal models, though still behind Gemini 3.1 Pro.

    Epistemics: Calibration, Forecasting, and Censorship Resistance

    TML groups calibration, instruction following, and censorship resistance under the banner of epistemics. Calibration was trained with RL against proper scoring rules on resolved real-world questions, and it shows: Inkling’s ForecastBench Brier Index of 61.1 without search beats GPT-5.5 and Claude Opus 4.8, and its Prophet Arena score sits close to the frontier. Instruction following used two complementary automated graders, a rubric checklist and a claims grader that verifies factual assertions through agentic web search, so recall-spraying to hack rubrics gets penalized by the factuality check. Targeted abstention-aware QA datasets taught the model to say “I don’t know” or give hedged best guesses when appropriate, while still complying when a user demands a forced guess. Finally, the model was trained to answer directly on censorship-prone topics, with Cognition’s Propaganda and Censorship Eval finding strong non-compliance with censorship patterns.

    Safety for an Open-Weights Release

    Inkling was trained to an internal behavioral spec across all modalities and then checked by commissioned external safety testers. Evaluations covered dangerous capabilities (CBRN, cyber, loss of control) and human-AI threat vectors including sycophancy, vulnerable users, and harmful manipulation. On FORTRESS, which pairs adversarial harmful requests with benign look-alikes, Inkling posts the strongest adversarial score among the compared open models (78.0%) without collapsing on the benign side (95.9%), and it scores 98.6% on StrongREJECT. TML acknowledges the open question hanging over every open-weights release: how safety behavior holds up under fine-tuning, which it says it is actively studying on Tinker.

    Architecture and Training Recipe

    The MoE layout follows DeepSeek-V3: 256 routed experts and 2 shared experts per layer with 6 routed experts active per token, a sigmoid-based router, and auxiliary-loss-free load balancing. Attention interleaves sliding-window and global layers 5:1 with 8 KV heads, and positions are encoded with a learned relative positional embedding that TML found outperforms and out-extrapolates RoPE. Short convolutions appear after the key and value projections and on residual branch outputs. Optimization was hybrid, Muon for large matrices and Adam elsewhere, with hyperparameter schedules drawn from the lab’s modular manifolds research and weight decay coupled to the square of the learning rate to keep weight norms stable. Post-training bootstrapped from a small SFT phase on synthetic data from open models including Kimi K2.5, then spent the bulk of compute on large-scale RL. Everything ran on NVIDIA GB300 NVL72 systems.

    RL at Scale and the Emergent Compression of Thought

    TML scaled asynchronous RL past 30 million rollouts across two long continuous runs, with performance on a held-out aggregate of reasoning evals improving log-linearly the whole way. Along the way an unplanned behavior emerged: the chain of thought became progressively more concise, shedding grammatical overhead into a telegraphic style (“We need to understand” becomes “We need determine”) while remaining comprehensible and leaving final answers unaffected. No reward targeted this; token efficiency pressure alone drove the compression, echoing an observation Cognition made while training SWE-1.7. It is a vivid example of optimization discovering its own shorthand.

    Inkling-Small

    The preview of Inkling-Small is arguably the sleeper story: with 12B active parameters against Inkling’s 41B, it matches or exceeds the larger model on a surprising number of benchmarks, including GPQA Diamond (88.3% vs 87.2%), IFBench (83.4% vs 79.8%), and CharXiv RQ with Python (83.4% vs 82.0%). TML attributes this to pretraining data and recipe improvements made after the big model trained, with both models sharing the same post-training stack. The clearest gaps favoring big Inkling are factuality (SimpleQA 43.9% vs 20.9%), Terminal Bench, and Tau 3 Banking. Full weights for Inkling-Small will be released once testing finishes, and its cost and latency profile targets high-volume workloads like coding, LLM grading, and synthetic data generation.

    Availability and the Ecosystem Play

    Inkling is on Tinker today with 64K and 256K context options at a limited-time 50% discount, plus a free Inkling Playground chat interface with integrated web search in the Tinker console so developers can get a feel for the model before committing to a run. The cookbook gained native Inkling support and three new audio recipes, and a new tml-renderer handles chat templates, tool calls, reasoning content, and multimodal inputs. Deployment partnerships span Together, Fireworks, Modal, Databricks, and Baseten for APIs; RadixArk for SGLang and Miles; Inferact for vLLM; Lightseek for TokenSpeed; Unsloth for llama.cpp; and Hugging Face for transformers integration. Full weights are on Hugging Face in both the original checkpoint and an NVFP4 checkpoint for NVIDIA Blackwell inference.

    Notable Quotes

    “Our mission is to build AI that extends human will and judgment.”

    Thinking Machines Lab, opening the Inkling announcement

    The company’s north star, and the lens through which the whole release (customization, calibration, open weights) is framed.

    “Inkling is not the strongest overall model available today, open or closed. Instead, a combination of qualities makes it a good open-weights base for customization: multimodal capabilities, efficient thinking, and availability on Tinker for fine-tuning.”

    Thinking Machines Lab, positioning the release

    A rare piece of launch-day honesty from a frontier lab, and the strategic thesis of the whole release.

    “Picking the right base model to fine-tune is a qualitative judgment that combines measurable benchmarks with the unique feel of a model that comes from playing with it.”

    Thinking Machines Lab, on why the Inkling Playground exists

    An argument that vibes are data, from the lab that built a playground into a fine-tuning console.

    “Cost and latency are often binding constraints in real-world applications, and low latency in particular is crucial for enabling collaboration and improvement through iteration.”

    Thinking Machines Lab, on controllable thinking effort

    The case for evaluating models on their full effort-versus-performance curve instead of a single benchmark point.

    “A model that’s confident in every answer it gives, including when it’s missing info and confabulates, forces the user to double-check everything.”

    Thinking Machines Lab, on why calibration was a training target

    The clearest one-line justification for treating calibrated uncertainty as a capability rather than a nicety.

    “Together, the two graders improve helpfulness and reduce hallucination at the same time, rather than trading one for the other.”

    Thinking Machines Lab, on pairing a rubric grader with a web-searching claims grader

    A neat solution to rubric hacking: verify every claim with agentic search so spraying plausible facts stops paying.

    “Safety is crucial for open-weights models. We’re continuing to study safety behavior and capability uplift in customizable models, including how safety behavior is impacted by fine-tuning on Tinker.”

    Thinking Machines Lab, on the open question of fine-tunable safety

    The acknowledgment that safety trained into open weights must survive the very customization the product sells.

    “Inkling is just the start: our first release in a model family we will continue to build on.”

    Thinking Machines Lab, on the roadmap

    Together with the GB300 compute note, a clear signal that larger and stronger family members are coming.

    Read the full announcement, including the interactive demos, effort curves, and complete benchmark tables, on the Thinking Machines Lab blog.

    Related Reading

  • Benedict Evans on the Economics of AI Usage, Why Foundation Models May Become Commodities, and What Comes Next for SaaS

    Benedict Evans returns to the a16z podcast to update the thesis behind his widely read “AI eats the world” presentation, and the picture he paints is less about hype and more about hard economics. In this conversation he works through what has actually played out in the last year, why agentic coding became the one use case with real product market fit, and why he keeps arguing that foundation models may end up as commodities while the value moves somewhere else entirely. You can watch the full conversation here.

    TLDW

    Benedict Evans argues that the AI moment looks a lot like the early internet, the early PC era, and the rollout of mobile data, which means it is exciting, genuinely transformative, and almost impossible to predict use case by use case. Agentic coding is the only field with clear product market fit right now, with revenue run rates exploding from roughly nine billion to forty seven billion, while consumers still use chatbots weekly rather than daily. His central claim is that foundation models show no obvious network effect or sustainable differentiation, the chatbot is a limited v1 interface, and the model labs cannot build every application, so the value will likely move up the stack the way it did with chips, ISPs, and mobile networks rather than staying with the model providers. He covers the brutal supply and demand disequilibrium driving today’s token pricing and ten thousand dollar surprise bills, the financial gravity problem of hyperscalers spending over half their revenue on capex, the Jevons paradox and consumer surplus that may compete away productivity gains, the way the important questions move out of San Francisco and into industries like law, consulting, finance, and advertising, and the distinction between automating tasks and changing jobs. His closing image is an IBM ad from the 1950s promising “150 extra engineers,” a reminder that every platform shift feels unprecedented and that in twenty years we will simply say of course computers do that.

    Thoughts

    The most useful thing Evans does here is refuse to collapse uncertainty into a clean prediction, and then explain exactly why that refusal is the correct posture rather than a cop out. He distinguishes between the parts where he will commit to a view, that foundation models are probably not a product and the chatbot is probably not the right interface, and the parts where there are simply too many open paths to call. That discipline is rare in AI commentary, where the incentive is to sound certain. The commodity argument is not “models are worthless.” It is a chain of reasoning: there is no visible network effect, no durable differentiation beyond willingness to spend, no lock in comparable to Windows or iOS, and a likely structure of three to six well funded competitors plus open source and edge models all selling the same thing. Ask where price discipline comes from in that picture and the honest answer is that it probably does not, which is how you get a commodity even when demand is effectively infinite.

    The mobile data analogy is the load bearing comparison and it deserves to be taken seriously. Mobile data traffic rose something like fifteen hundred to two thousand times over fifteen years, the networks built an extraordinary piece of global infrastructure, everyone came to depend on it, and yet the operators captured almost none of the value because all the interesting stuff got built on top by someone else. Telco stocks were flat for two decades. If that is the template, then the trillion dollars of capex flowing into AI infrastructure can be both a worthwhile investment and a terrible place to expect outsized equity returns, because building the road is not the same as owning the traffic. The counterpoint Evans keeps fairly on the table is the operating system path, where Windows and iOS did capture value, but he notes they had levers and network effects that LLMs do not appear to have.

    His framing of where the questions live is the part most people in tech underweight. Once a technology works, the interesting questions stop being technology questions. Netflix is not a tech company in the sense that matters, because its real decisions are Los Angeles decisions about shows, talent, and sports, not San Francisco decisions about infrastructure. By the same logic, what AI means for a law firm is mostly a question for people who understand what associates actually do and what clients are actually paying for, not for model researchers. This is why the “the model will just do the whole thing” story keeps running aground. Most valuable software does not solve a problem the customer already knew they had. It often takes years to convince an industry that a problem even exists, and an LLM prompt does not surface latent problems that no one has articulated.

    The economic plumbing he describes is where the near term risk actually sits. We are in extreme disequilibrium, where twenty dollars a month can buy ten thousand dollars of tokens on one side and a weekend of experimentation can produce a ten thousand dollar bill on the other, exactly the pattern mobile data went through around 2009 and 2010. That gets resolved with the boring machinery of caps, throttling, and pricing tiers, not with magic. Layered on top is the financial gravity problem: Microsoft, Meta, and Google heading toward spending more than half of revenue on capex, with roughly seven hundred billion dollars of guidance across the big players, against a hard ceiling because there is not ten trillion dollars a year available to spend. And even when the productivity gains are real, the Jevons paradox and consumer surplus suggest much of the benefit gets competed away. If a discounted cash flow model used to take a week and now takes ten seconds, you do fifty of them and charge the client the same, which is great for clients and unremarkable for margins.

    The honest takeaway for builders is that the answer to “what does this do to software” is more software, probably one or two orders of magnitude more, just as SaaS itself produced an explosion rather than a consolidation. The SaaS apocalypse is real in the sense that some meaningful percentage of existing companies get wiped out, and unknowable in the sense that no one can yet say which ones, which is why thoughtful investors are reluctant to be long software in the dark. For anyone pursuing a more deliberate, purposeful relationship with technology, the closing note is the one to keep: every one of these shifts felt singular and world ending and world making at the time, it reshaped work and put people out of jobs and created things we love, and then it quietly became invisible. The goal is to stay clear eyed about which of those buckets a given change lands in rather than getting swept up in the noise of what someone said at a party yesterday.

    Key Takeaways

    • Agentic coding shifted from “kind of useful” to “really changing everything” at the start of the year, and it is the single field with unambiguous product market fit, where customers are pulling it out of your hands.
    • Coding working first was foreseeable in hindsight: software developers were the ones messing with the tools, and the first thing people do with a new kind of computer is build more computing, just as the first thing people did with PCs was make computers.
    • Anthropic, with less capital raised, chose to focus on coding and got it working, while OpenAI cycled through a more everything all at once strategy before narrowing in.
    • The intense focus on coding comes bundled with a supply crunch, a capacity crunch, and a price and capex imbalance that defines the current moment.
    • Most of the fundamental questions from two or three years ago still have no answers: whether there will be a winner in models, whether models capture value up the stack, how much they can do, and whether consumers will use this daily rather than weekly.
    • There is a wide gap between Valley insiders running clusters of Mac Studios all day and the roughly forty percent of people who say AI is “kind of useful, I used it last week for something.”
    • Outside tech, companies are adopting AI as one at a time point solutions for specific back office processes, like a commodities company using LLMs for better cash flow forecasting, not as a general purpose assistant.
    • Adoption always compounds on prior platforms: you could not have nine hundred million weekly active users in the Netscape era because there were not nine hundred million PCs on the planet.
    • Early in any platform shift almost nothing works smoothly, from sound cards and floppy disks with TCP/IP to computers that froze and lost your work, and AI is at that stage now.
    • Today’s token pricing crunch mirrors the mobile data shock of 2009 to 2010, where flat rate plans collided with surging usage and networks had to realign price with marginal cost through caps, fair use, and throttling.
    • Mobile data traffic rose roughly fifteen hundred to two thousand times in fifteen years, mobile networks earn around a trillion dollars and spend about two hundred billion a year on capex, yet their stocks have been flat for twenty years because all the value moved up the stack.
    • The central LLM question is whether the model can do the whole thing or whether you need hundreds of applications built on top, the same way you needed apps on Windows and iOS.
    • Evans sees no network effect and no sustainable differentiation between models beyond willingness to spend money, which points toward commodity infrastructure sold near marginal cost.
    • Chip companies, ISPs, and mobile operators did not capture the value; Windows and iOS did, but only because they had levers to move up the stack and real network effects, which models lack.
    • A useful comparison is semiconductors, where each generation gets more expensive and the field narrows to fewer players, suggesting three to six frontier model makers spending somewhere between two hundred billion and two trillion dollars a year.
    • Enterprises do not standardize on a model the way they once thought about AWS; the cloud and the model get abstracted away, so customers do not even know which one their SaaS product runs on.
    • Demand for tokens being effectively infinite does not prevent a price equilibrium, exactly as infinite demand for mobile bits still produced murderous price wars between commodity carriers.
    • History teaches that something will happen but rarely what; the smartest people in tech wrongly predicted Android would crush the iPhone on open versus closed grounds.
    • One characteristic of tech is that the moment you understand how something works is the moment to move on, which is why Evans stopped updating his Apple spreadsheet years ago.
    • The people who are good at using a tool are usually not the people who are good at designing what the tool should be, which is why model labs cannot build every skill or vertical application.
    • Claude skills and similar templates resemble file new in Excel: useful starting points that users eventually outgrow, raising the question of who builds the real software.
    • The questions increasingly move out of technology and into specific industries; what AI means for law, consulting, advertising, or accounting is partly an AI question and partly a deep domain question.
    • Netflix is not a tech company in the way that matters, because its real questions are media industry questions about shows, talent, and sports, not infrastructure; the same logic now applies across industries facing AI.
    • AI differs from prior platform shifts because the physical limits are unknown; in 1995 you knew PCs cost three thousand dollars and broadband could not reach everyone overnight, but no one knows how cheap, fast, or capable models will get.
    • Evans offers four buttons to press on any use case: is it just price elasticity and the Jevons paradox, does it remove a cost barrier to entry, does it unlock a new business model, or does it make something previously impossible now possible like trains over horses or Spotify over CDs.
    • Advertising and e-commerce are a standout opportunity because today’s systems know a SKU and a metadata field but not what a product actually is or why people buy it, and LLMs could change that level of understanding.
    • The valuable shift is not doing the old thing more, like more spreadsheets or better email, but doing genuinely new things, such as asking an LLM how to change prices to improve churn using all your call recordings, CRM flows, and product telemetry.
    • Enterprise software today splits into three buckets: big horizontal systems like SAP and Workday, three to four hundred vertical SaaS apps plus a thousand internal apps, and a fuzzy improvised middle of Excel, email, and shared files, with AI arriving as a new option across all three.
    • A core design tension is where to put the probabilistic software that can make mistakes versus the deterministic database that cannot, and whether the LLM sits at the top or the bottom of the stack; the answer is probably both depending on the task.
    • The net effect on software is way more software, since SaaS itself produced one to two orders of magnitude more software and all software companies exist to solve problems created by other software companies.
    • The SaaS apocalypse is real but unknowable: some percentage of SaaS companies get wiped out, but no one knows which, so you should not derate the whole sector fifty percent and many investors are wary of being long software for now.
    • Much of what an organization does is implicit, undocumented, and not in the training data, which is exactly the value McKinsey, Bain, and BCG provide by getting license to map how a company really works.
    • The real decisions are usually exception handling: the question is always what you cannot automate and what still requires human judgment about cases that were never written down.
    • Distinguish tasks from jobs: accountants spend almost none of their time the way they did fifty years ago, yet to the client the job looks the same.
    • LLMs excel where you want the average, the answer anyone would give, and struggle where you specifically do not want the average and cannot fully explain why you did it differently.
    • There is a financial gravity ceiling: Microsoft, Meta, and Google are on track to spend over fifty percent of revenue on capex versus fifteen to twenty percent for capital intensive telecoms, with seven hundred billion in guidance this year and no path to ten trillion.
    • Hyperscalers face an existential FOMO trap: returns look positive now, but they cannot let rivals build the future of compute without participating, even as the CFO asks how much participation is enough.
    • Token maxing will face a reckoning as the disequilibrium resolves, but measuring ROI is hard because most reported benefits so far, like better analytics, support, and productivity, are tough to put a financial value on.
    • Consumer surplus means many gains get competed away: if analysis that took a week now takes a day, you do five times more analysis and charge the same, the way investment banks did with spreadsheets.
    • Evans closes with a 1950s IBM ad promising “150 extra engineers,” a reminder that every fundamental technology change feels unprecedented, and that in twenty years AI will simply be invisible magic we take for granted.

    Detailed Summary

    What changed in the last year

    Evans frames the past year as a narrowing of focus. A year and a half after the first version of his presentation, the field has developed a much clearer sense of diverging product strategies and competitive tension that goes beyond simply building a bigger model with more compute. The dominant shift is that agentic coding started genuinely working, and the entire industry narrowed in on it because it has absolute product market fit, the kind where customers pull the product out of your hands. That success arrives alongside the supply crunch, capacity constraints, and price imbalance that now define the moment. At the same time, the charts keep climbing, models keep getting bigger, capex keeps growing, and usage keeps growing, while the deep questions from a few years ago remain unanswered.

    Why coding worked first

    That coding led was predictable at a naive level: the people experimenting with the tools were software developers, and they naturally tried to make software development work. Evans compares the moment to the internet around 1997 and 1998, and also to PCs in the late seventies and early eighties, when the technology was exciting but it was not clear what it was for and it did not quite work yet. The first thing people did with PCs was make computers, and since LLMs are in a sense computers, the first thing people are doing with them is making more compute. What was harder to foresee was the precise timing of the shift, the moment when agentic coding flipped from useful to transformative at the start of this year.

    Jobs, juniors, and what we have not learned

    On the question of what this means for engineers and team structure, Evans is blunt that we have learned almost nothing yet, because this did not even work six months ago and everyone is scrambling to interpret it. The pricing crunch alone means it will take a couple of years to settle. The newly concrete questions include whether you still hire junior people and what they would do, and why you were hiring juniors in the first place, whether to do the work itself or to develop people. Because software development now genuinely automates a class of work that used to be done by people, those questions have moved from theoretical to real, but no one can responsibly claim to know what a software team or a software career looks like in three years.

    OpenAI, Anthropic, and the strategy split

    Evans dryly notes the drama around the model labs, including the disruption of a senior leadership medical leave at OpenAI. In the latter part of last year, OpenAI’s question was essentially what to build on top of the models, an everything all at once approach that looked almost like asking the model for fifteen ideas and then doing all of them. Anthropic, with less capital raised, instead committed to coding and got it working, whether by deliberate strategy or by stumbling into it. The result is that software development plus a few other fields are where things genuinely work, surrounded by a large population of people excited around the edges and corporations quietly automating specific back office processes. He cites a commodities company that wants LLMs for better cash flow forecasting across many small producers, a very different thing from asking a chatbot to summarize your meetings.

    The mobile data analogy and value capture

    The richest section is the comparison to mobile. Adoption always compounds on prior platforms, so AI inherits a far larger installed base than the internet or mobile did at their starts. Early on, nothing works smoothly, and Evans recalls the era of buying a three hundred dollar sound card or wrestling a floppy disk of TCP/IP into a machine. The pricing dynamics directly echo mobile data around 2009 and 2010, when flat rate plans met exploding usage and ten thousand dollar bills, forcing networks to realign price with marginal cost. Crucially, mobile data traffic then rose fifteen hundred to two thousand times, the networks built extraordinary global infrastructure with around a trillion dollars of revenue and two hundred billion in annual capex, and yet their stocks stayed flat for twenty years because all the cool stuff and all the value got built and captured by someone else higher up the stack. Chip companies, ISPs, and mobile operators did not capture value; Windows and iOS did, but they had levers and network effects that models do not appear to share.

    The case that models become commodities

    Evans lays out the building blocks of his commodity thesis. First, there is no clear way to build a model that is sustainably and fundamentally better than everyone else’s, with no visible network effect and no strategic lever comparable to what Instagram, YouTube, or Google search enjoy. Differences in emphasis and taste exist, but not durable competitive moats beyond spending. Second, the chatbot is a weird, limited v1 interface that works well for some tasks and people but requires tooling, the right data, configuration, control, and thoughtful design for most real jobs, and the people good at a job are rarely the people good at designing the tool for it. Third, the labs cannot build every application any more than Microsoft or Apple could build every Windows or iPhone app. Enterprises do not standardize on a model the way they never standardized on a visible cloud provider, because it gets abstracted away. Taken together, that points to low level infrastructure sold by perhaps half a dozen competitors plus open source and edge, with no obvious source of price discipline, which is the definition of a commodity even when demand is infinite.

    The questions move out of technology

    One of the next big questions is when models become good enough that you no longer need the largest, fastest, most expensive model, and can use an older model, an open source model, or one running on device where compute is effectively free to the developer. But the deeper shift is that the important questions move out of technology and into industries. Drawing on his own essays “content isn’t king” and “Netflix isn’t a tech company,” Evans argues that Netflix’s real decisions are Los Angeles media questions, not San Francisco infrastructure questions, and San Francisco does not even know what the right questions are. By the same logic, what AI means for a law firm is mostly a question for people who understand law firms, what generative video means for Hollywood is a question Ben Affleck can answer better than he can, and the questions become half AI and half something else.

    Four buttons and the new things AI unlocks

    To reason about impact, Evans offers four buttons. Is a use case just price elasticity, the Jevons paradox of doing the same thing for less or more for the same money. Does it remove a cost that was a barrier to entry, like a newspaper’s printing press. Does it unlock something in your business model. Or does it make something previously impossible now possible, the way steam engines made trains possible regardless of how many horses you bought, or Spotify turned fifteen dollars a month into all the music there is. He stresses that the same broad change can mean wildly different things by industry, just as the internet devastated newspapers but barely touched movie studios. His favorite tractable example is advertising and e-commerce, a trillion dollar advertising market against twenty five trillion in retail, where today’s systems know a SKU and a metadata field and that people who bought one thing bought another, but do not know what a product is or why people buy it. An LLM could in principle understand the product, recommend ten coats at different prices with pros and cons, or look at your Instagram and suggest a winter coat that changes your look but not too much, which would have been science fiction three years ago.

    More software, the SaaS apocalypse, and tasks versus jobs

    For software specifically, Evans expects more competition, cheaper and quicker building, and new categories that were impossible before, all under an uncertain new margin structure where outcome based pricing is hard because most software work cannot be tied cleanly to profit and loss. He frames enterprise software as three buckets, big horizontal systems, hundreds of vertical and internal apps, and a fuzzy improvised middle of Excel and email, with AI arriving as another option across all of them. The deeper design tension is where to place probabilistic software that can make mistakes versus deterministic systems that cannot, and whether the LLM sits at the top or bottom of the stack, with the answer being both depending on the task. The net result is way more software, since SaaS itself produced orders of magnitude more software and software exists to solve problems created by other software. That fuels the SaaS apocalypse anxiety: some companies clearly get wiped out, but since no one knows which, you should not derate the whole sector, even as many investors stay cautious about being long software.

    Implicit knowledge, exception handling, and where the average fails

    Much of what organizations do is implicit, undocumented, and absent from any training data, which is precisely the value of strategy consultancies that get license to map how a company really works versus how it is supposed to work. The real decisions tend to be exception handling, the cases that require human judgment because they were never written down or do not look like before. Evans separates tasks from jobs, noting accountants do almost nothing the way they did fifty years ago while the client still buys the same thing. And he offers a sharp test: LLMs are excellent where you want the average, the answer anyone would give, and weak where you specifically do not want the average and cannot fully articulate why you did it differently.

    Capex, financial gravity, and the ROI question

    On spending, Evans describes a financial gravity problem. Microsoft, Meta, and Google are on line to spend over half their revenue on capex this year, against fifteen to twenty percent for capital intensive telecoms, with roughly seven hundred billion in guidance across the big players, a sum comparable to all of telecom or oil and gas. They cannot sustainably leap to one and a half trillion next year because the money is not there, so the curve must eventually taper. The hyperscalers are caught in an existential FOMO trap: returns look positive now, but they cannot sit out what might be the future of compute without risking becoming the next stranded incumbent, even as the CFO asks how much is enough. On token maxing, he expects a reckoning as the disequilibrium resolves, but measuring ROI is genuinely hard because most reported benefits so far are soft and hard to value, and consumer surplus means much of the gain gets competed away, the way faster spreadsheets simply meant more analysis at the same price.

    Closing image

    Evans ends with an IBM advertisement from the early 1950s showing a sea of engineers holding slide rules, with the tagline that an IBM electronic calculator gives you 150 extra engineers, exactly the pitch behind countless modern startup decks. We move through these fundamental technology waves every ten or fifteen or twenty years, each one feeling completely unlike anything before, and AI is amazing and transformative in the same way mobile, the internet, and PCs were. The base case is that it will produce wonderful things, ruin some livelihoods, put people out of work, and eventually become invisible. His one line description of where it all ends up is that it will be magic, and in twenty years we will simply say of course computers do that, the way an hour of crash free streaming HD video over Wi-Fi already feels unremarkable.

    Notable Quotes

    “Agentic coding went from being kind of useful to really changing everything.”

    Benedict Evans, on the pivotal shift at the start of the year

    “We are in this extreme scarcity. We can’t spend $10 trillion a year on AI infrastructure cuz there isn’t $10 trillion a year there to spend on it.”

    Benedict Evans, on the hard ceiling of AI capex

    “I don’t think foundation models are a product. I don’t think a chatbot is a product. I think the value will be further up.”

    Benedict Evans, stating the core of his thesis

    “They built this amazing piece of global incredibly sophisticated very expensive global infrastructure with enormous growth in use, and they didn’t make any money from it because all the value moved up stack.”

    Benedict Evans, on the mobile network analogy

    “The moment that you understand something and you know how it works and what’s going to happen is the moment you should move on to something else.”

    Benedict Evans, on how to pay attention in tech

    “These are all Los Angeles questions. These are not San Francisco questions. No one in San Francisco even knows what the right questions are.”

    Benedict Evans, on why Netflix is not a tech company

    “The important stuff is not doing the old thing but more. It’s doing something new that you couldn’t have done with the old thing.”

    Benedict Evans, on where the real value of a new technology shows up

    “All software companies exist to solve problems created by other software companies.”

    Benedict Evans, on why AI produces more software, not less

    “It’s going to be magic, and in 20 years time we’ll just say, well, of course that’s how it is. Computers have always done that.”

    Benedict Evans, on how the whole shift ends up

    This is a dense, clear eyed conversation that rewards a full listen, especially if you are trying to think past the hype cycle about where AI value actually lands. Watch the full conversation here, and check out the “AI eats the world” presentation referenced throughout.

    Related Reading

    • Benedict Evans’ website home of the “AI eats the world” presentation and his newsletter referenced throughout the conversation.
    • Andreessen Horowitz (a16z) the venture firm whose podcast hosted this discussion and where Evans was formerly a partner.
    • Jevons paradox (Wikipedia) background on the price elasticity idea Evans uses to explain how cheaper AI may lead to more usage rather than savings.
    • Stratechery by Ben Thompson the analysis Evans cites on software as a designed workflow versus a process that grows out of how a business runs.
    • The Pursuit of Purpose a PJFP look at finding direction and meaning in work as automation reshapes careers and industries.

  • Claude Fable 5 and Claude Mythos 5: Anthropic Ships Its First Generally Available Mythos-Class AI Model With New Safeguards

    Anthropic has launched Claude Fable 5 and Claude Mythos 5, the first Mythos-class models offered beyond a tiny circle of cyber defenders. Fable 5 is the generally available version, wrapped in a new layer of safeguards, while Mythos 5 is the same underlying model with some of those guardrails lifted for a small group of vetted partners. The pair sits a full tier above the Opus class in raw capability, and the launch is as much a story about how Anthropic is choosing to gate that capability as it is about the benchmarks. Below is a full breakdown of what shipped, what the model can do, and why the safeguard design matters.

    TLDR

    Anthropic released Claude Fable 5, a Mythos-class model that is now its most capable generally available model, posting state-of-the-art results across software engineering, knowledge work, vision, memory, and scientific research. To ship it safely and fast, Fable 5 carries new safety classifiers that route flagged queries in cybersecurity, biology and chemistry, and distillation over to Claude Opus 4.8 instead of refusing, a fallback that triggers in under 5% of sessions. The same model ships without cyber safeguards as Claude Mythos 5 for Project Glasswing partners in collaboration with the US Government, where it is described as having the strongest cybersecurity capabilities of any model in the world. Highlights include a codebase-wide migration of a 50-million-line Ruby codebase that Stripe says took a day instead of two months, beating Pokemon FireRed with a vision-only harness, accelerating drug design roughly tenfold using Mythos 5, producing novel molecular biology hypotheses preferred by scientists about 80% of the time, and over a week of autonomous genomics research. Both models cost 10 dollars per million input tokens and 50 dollars per million output tokens, less than half the price of Mythos Preview, with a staged subscription rollout and a new 30-day data retention policy for Mythos-class traffic.

    Thoughts

    The most interesting decision here is not the capability jump, it is the naming split. Fable and Mythos are the same brain. The only difference is whether the safeguards are on. Anthropic is effectively shipping one model twice: a gated public edition and an ungated edition handed to a short list of trusted defenders working with the US Government. That is a clean way to resolve the central tension of frontier AI, which is that the exact capabilities that help a security professional close a vulnerability also help an attacker find one. Rather than dumbing the model down for everyone or holding it back entirely, they are letting the access list, not the weights, carry the risk. Expect this pattern to repeat as capabilities climb.

    The fallback-to-Opus design is the other quietly important choice. When a classifier flags a query in cybersecurity, biology, chemistry, or suspected distillation, the user does not hit a wall of refusal. The request is silently handed to Opus 4.8, a model that is still excellent at almost everything. Graceful degradation beats a hard no, both for user experience and for trust. It also reframes what a safeguard is. Instead of a binary block, it becomes a routing decision, and because more than 95% of sessions never trigger it, most users will never notice it exists. The honest admission that the classifiers are tuned conservatively and will sometimes catch harmless requests is the right posture, even if it will annoy power users who keep getting bounced to the smaller model.

    The commercial signals are worth reading closely. Pricing came down to less than half of Mythos Preview, which suggests confidence in serving costs at scale, but the subscription rollout tells a more cautious story. Fable 5 is free on Pro, Max, Team, and Enterprise plans only through June 22, after which using it requires usage credits until capacity catches up. That is a polite way of saying demand is expected to badly outrun supply. The model is fully available on the API and consumption-based Enterprise plans from day one, because those bill by the token and self-throttle. Subscriptions, which are all-you-can-eat, are where a capacity crunch actually hurts, so that is exactly where the brakes went on.

    On the science, the genomics result is the one that should make people sit up. A model doing over a week of largely autonomous research, assembling single-cell data across 138 species, then designing and training its own machine learning model that outperforms a recently published Science paper while being 100 times smaller, is a different category of claim than acing a benchmark. So is the drug-design work, where Mythos 5 reportedly matches or beats skilled human operators end to end, choosing binding sites, running protein design tools, and recovering from its own failures. If those hold up to publication and independent replication, the interesting frontier stops being chat quality and becomes whether a model can run a research program. That is also precisely why the biology and chemistry classifier exists, and why Anthropic is being so deliberate about who gets the ungated version.

    One caveat worth keeping in view: nearly all of the evidence in the announcement is Anthropic’s own, or comes from partners with early access and an incentive to be enthusiastic. The Stripe migration, the FrontierCode score, the Slay the Spire memory result, the protein targets, and the genomics model are all compelling, but they are first-party until outside labs and the eventual system card, peer review, and independent red-teamers weigh in. The note that the UK AISI made progress toward a universal jailbreak inside a brief testing window is a useful reminder that the safeguard story is a work in progress, not a finished proof.

    Key Takeaways

    • Claude Fable 5 is a Mythos-class model made safe for general use, and is now Anthropic’s most capable generally available model.
    • Mythos-class is a tier that sits above the Opus class in capability. The first was Claude Mythos Preview, released in April through Project Glasswing.
    • Fable 5 is state-of-the-art on nearly all tested benchmarks, and its lead grows as tasks get longer and more complex.
    • Claude Mythos 5 is the same underlying model as Fable 5, but with safeguards lifted in some areas. Fable and Mythos differ only by their safeguards.
    • Mythos 5 is described as having the strongest cybersecurity capabilities of any model in the world, and is deployed through Project Glasswing with the US Government.
    • New safety classifiers cover cybersecurity, biology and chemistry, and distillation. Flagged queries fall back to Claude Opus 4.8 rather than being refused.
    • Users are told whenever a fallback happens. More than 95% of Fable sessions involve no fallback at all, and for those sessions Fable performs effectively the same as Mythos 5.
    • The safeguards are tuned conservatively and trigger in less than 5% of sessions on average, sometimes catching harmless requests. Anthropic plans to reduce false positives after launch.
    • Stripe reported Fable 5 compressed months of engineering into days, performing a codebase-wide migration of a 50-million-line Ruby codebase in a day that would have taken a team over two months by hand.
    • Fable 5 scores highest among frontier models on Cognition’s FrontierCode evaluation for high-quality agentic coding, even at medium effort, and is more token-efficient than past Claude models.
    • On Hebbia’s Finance Benchmark for senior-level reasoning, Fable 5 has the highest score of any model, with gains in document reasoning, chart and table interpretation, and problem solving.
    • IMC noted Fable 5 aced their trading-analysis evaluations nearly across the board, including factual lookup, conceptual reasoning, root-cause analysis, and expected-value analysis.
    • Fable 5 is the new state-of-the-art for vision, and can rebuild a web app’s source code from screenshots alone.
    • Fable 5 beat Pokemon FireRed using a minimal, vision-only harness with no maps, navigation aids, or extra game-state information. Earlier Claude models needed a complex helper harness.
    • Persistent file-based memory improved Fable 5’s Slay the Spire performance three times more than it did for Opus 4.8, and Fable reached the game’s final act three times more often.
    • Fable 5 built a simulation of the solar system, deriving the planets’ orbital motion from physics first principles and using it to predict solar eclipses.
    • Using Mythos 5, internal protein design experts accelerated aspects of drug design by around ten times, with the model matching or beating skilled human operators end to end.
    • Nine of 14 protein targets in the drug-design study yielded strong candidates Anthropic is now investigating.
    • Mythos 5 is Anthropic’s first model to consistently produce novel, compelling scientific hypotheses. Scientists preferred its molecular biology hypotheses about 80% of the time in blinded comparisons.
    • One Mythos hypothesis, a novel mechanism for an E. coli protein, was corroborated by an independent lab working on the same problem.
    • In over a week of largely autonomous work, Mythos 5 assembled single-cell data for millions of cells across 138 animal species and trained a custom model that outperformed a recent Science paper while being 100 times smaller.
    • Anthropic’s automated alignment assessment found Mythos 5’s level of misaligned behavior was low and similar to Opus 4.8. Because they are the same model, Fable 5’s alignment is similar.
    • An external bug bounty produced no universal jailbreaks in over 1,000 hours of testing, though the UK AISI made progress toward one in a brief initial window.
    • One external partner found Fable 5’s safeguards against harmful cyber queries the most robust of any model tested, including Opus 4.8 and Opus 4.7, with zero compliance on harmful single-turn cyberattack requests.
    • The biology and chemistry classifier is deliberately broad for now. Mythos-class models outperformed dedicated protein language models at predicting AAV viral shell assembly using biological reasoning alone.
    • The distillation classifier targets large-scale attempts to extract Claude’s capabilities to train competing models, which could proliferate near-frontier capabilities without safeguards.
    • A new policy requires 30-day data retention for all Mythos-class traffic on first- and third-party surfaces, used only for safety, with logged human access and deletion after 30 days in almost all cases.
    • Anthropic plans trusted access programs that let cybersecurity organizations apply for Mythos 5, and let a small number of life science researchers access Fable 5 with biology and chemistry safeguards removed.
    • Both models cost 10 dollars per million input tokens and 50 dollars per million output tokens, less than half the price of Mythos Preview. Developers can use claude-fable-5 via the Claude API.
    • Fable 5 is free on Pro, Max, Team, and seat-based Enterprise plans through June 22. On June 23 it moves to usage credits on those plans until capacity allows it to return as a standard inclusion.

    Detailed Summary

    A Mythos-class model, made safe for general use

    Fable 5 is the first Mythos-class model Anthropic has made generally available. Mythos-class is a tier that sits above the Opus class, and the first of its kind, Claude Mythos Preview, was released in April through Project Glasswing to a limited group of cyber defenders and critical software infrastructure providers. The company framed today’s launch as the moment it could finally bring that level of capability to all users, because its safeguards had matured enough to allow it. Fable 5’s capabilities exceed those of any model Anthropic has made generally available, and its advantage over other models grows as tasks get longer and more complex.

    Two models, one brain

    Claude Mythos 5 is the same underlying model as Fable 5, but with safeguards lifted in some areas. The names are the only real difference: Fable, from the Latin fabula meaning that which is told, is akin to the Greek mythos, and the safeguards are what distinguish the two. Mythos 5 launches first to existing Mythos Preview users, including the Project Glasswing cybersecurity partners, as an upgrade. It is deployed in collaboration with the US Government and is described as having the strongest cybersecurity capabilities of any model in the world. Anthropic plans to steadily expand access through a more systematic trusted access program.

    Software engineering and token efficiency

    Fable 5 can work autonomously for longer than any previous Claude model, and software engineering is where that shows most clearly. During early testing, Stripe reported it compressed months of engineering into days, performing a codebase-wide migration in a 50-million-line Ruby codebase in a single day that would otherwise have taken a whole team over two months by hand. It is also more token-efficient than past models, scoring highest among frontier models on Cognition’s FrontierCode evaluation for high-quality, maintainable agentic coding, even at medium effort.

    Knowledge work, vision, and memory

    On complex analytical work, Fable 5 posted the highest score of any model on Hebbia’s Finance Benchmark for senior-level reasoning, with substantial gains in document-based reasoning and chart and table interpretation, and IMC said it aced their trading-analysis evaluations nearly across the board. In vision, it is the new state-of-the-art, able to extract precise numbers from detailed scientific figures and rebuild a web app’s source code from screenshots alone. It needs less scaffolding too: where earlier Claude models struggled to play Pokemon even with helper harnesses, Fable 5 beat FireRed with a minimal, vision-only harness using nothing but raw game screenshots. On memory, giving Fable persistent file-based notes improved its Slay the Spire performance three times more than it did for Opus 4.8, and it built a physics-first-principles solar system simulation accurate enough to predict solar eclipses.

    Life sciences: drug design, hypotheses, and genomics

    Using Mythos 5, Anthropic’s internal protein design experts accelerated aspects of the drug-design process by around ten times. With protein design and bioinformatics tools but no human assistance, the model matched or beat skilled human operators, executing the full workflow of choosing binding sites, selecting and running design tools, and recovering from failures. Nine of 14 protein targets yielded strong drug-design candidates now under investigation. Mythos 5 is also Anthropic’s first model to consistently produce novel, compelling scientific hypotheses: scientists preferred its molecular biology hypotheses about 80% of the time in blinded comparisons, and one, a novel mechanism for an E. coli protein, was corroborated by an independent lab. In genomics, Mythos 5 ran over a week of largely autonomous research, assembling single-cell data for millions of cells across 138 species and training a custom model that outperformed a recent Science paper despite being 100 times smaller.

    The new safeguards: classifiers and fallback

    Mythos-class capability is potent enough that Anthropic considers it a substantial misuse risk, especially given how much advanced AI usage is dual use. Fable 5 ships with a new set of classifiers, separate AI systems that detect potential misuse and jailbreak attempts and stop the main model from responding. When a classifier flags a request related to cybersecurity, biology and chemistry, or distillation, the response is handled by Claude Opus 4.8 instead, and the user is told. The cybersecurity classifiers cover both exploitation and broader offensive cyber tasks like reconnaissance and lateral movement, and Anthropic says they prevent Fable from making any progress on those tasks. The biology and chemistry classifier is intentionally broad for now, after tests showed Mythos-class models could outperform dedicated protein language models at predicting AAV viral shell assembly using biological reasoning alone. The distillation classifier targets large-scale attempts to extract Claude’s capabilities to train competing models.

    Jailbreak resistance, data retention, and availability

    Anthropic ran extensive red-teaming, including an external bug bounty that produced no universal jailbreaks in over 1,000 hours, though it notes the UK AISI made progress toward one in a brief window. The company concedes it is likely impossible to fully prevent universal jailbreaks and aims instead to make any that remain slow and costly enough to catch before they scale. A new policy requires 30-day data retention for all Mythos-class traffic, used only for safety, with logged human access and deletion after 30 days in almost all cases. On availability, Fable 5 is live everywhere today and fully available on the API and consumption-based Enterprise plans, while subscription access rolls out in stages: free on Pro, Max, Team, and seat-based Enterprise through June 22, then on usage credits from June 23 until capacity allows it to return as a standard inclusion. Both models cost 10 dollars per million input tokens and 50 dollars per million output tokens.

    Notable Quotes

    “Today we’re launching Claude Fable 5: a Mythos-class model that we’ve made safe for general use.”

    Anthropic, opening the Claude Fable 5 and Claude Mythos 5 announcement

    “Fable 5’s capabilities exceed those of any model we’ve ever made generally available.”

    Anthropic, on where Fable 5 sits in the lineup

    “It has the strongest cybersecurity capabilities of any model in the world.”

    Anthropic, describing Claude Mythos 5

    “During early testing, Stripe reported that Fable 5 compressed months of engineering into days.”

    Anthropic, on Fable 5’s software engineering results

    “Our early data shows that more than 95% of Fable sessions involve no fallback at all.”

    Anthropic, on how often the safeguards route to Opus 4.8

    “Mythos 5 is our first model to consistently produce novel, compelling scientific hypotheses.”

    Anthropic, on the model’s molecular biology research

    “It is likely impossible to completely prevent universal jailbreaks, but our goal is to make any remaining jailbreaks sufficiently slow and costly that we can detect and prevent them before they are used at scale.”

    Anthropic, on the limits of its safeguards

    “Fable is from the Latin fabula, ‘that which is told,’ akin to the Greek mythos. The safeguards are what distinguish the two models.”

    Anthropic, explaining the Fable and Mythos naming

    Read the full announcement and the benchmark tables on Anthropic’s site here: Claude Fable 5 and Claude Mythos 5.

    Related Reading

    • Project Glasswing — background on the cyberdefense program that Mythos 5 ships through with the US Government.
    • Introducing Claude Opus 4.8 — the model that flagged Fable 5 queries fall back to instead of being refused.
    • Claude Mythos Preview — the first Mythos-class model, released in April, that Mythos 5 now upgrades.
    • Anthropic model system cards — where the full safety, alignment, and capability testing for models like Fable 5 is documented.

  • Waste Tokens to Save Time: Naval, Guillermo Rauch, Blake Scholl, and Max Hodak on AI Software Factories, 1000x Engineers, and Whether Pure Software Is Dead

    Naval Ravikant gathers three frontier founders, Guillermo Rauch of Vercel, Blake Scholl of Boom Supersonic, and Max Hodak of Science, for a freewheeling conversation about how AI coding tools are reshaping what an engineer is, what software is worth, and where the moat goes when models speak English. The headline idea comes from Naval himself: waste tokens, save time. Stop measuring AI by tokens consumed or lines of code generated and start measuring it by the final output and the time you got back. The full conversation is on the Naval Podcast YouTube channel. This is part one of the discussion. Part two, on vibe coding hardware, follows the same group into jet engines, semiconductors, and biotech. You can also watch and read the full episode here.

    TLDW

    The job of an engineer is shifting from shipping output to building the factory that ships the output, which means 10x engineers were never really 10x, they were always 100x or 1000x in idea domains, and AI leverage is making that obvious. Models now reflect back the judgment of the user, so a senior architect extracts dramatically more value than a junior, although the junior also writes code they could never have written alone. The frontier models have quietly graduated from junior coders to principal engineers, returning with intuitive plans and real tradeoffs (sometimes with hilariously bad time estimates) rather than just running away with the prompt. Naval has stopped learning prompt tricks, scaffolding tools, and Claude plan-mode rituals entirely. Instead he throws Codex, Claude, and Gemini at the same problem in parallel and brute forces his way through, because tokens are still cheaper than a human and the models keep getting better faster than tricks can. That leads to the bigger question on the table: is pure software still investable, or is it now just a free byproduct of hardware, models, and taste? The group lands on the block economy thesis (a tip of the hat to Mitchell Hashimoto): agents do not want to reinvent Postgres or BMQ on the fly, they want to grab the right reusable building block, so infrastructure software actually gets more valuable, not less. Max Hodak closes the loop with a personal data point: he has not written a line of code in years and has built more software since December than ever before, all through agents, because just understanding APIs, data flow, and performance is what actually moves the work forward.

    Thoughts

    The “waste tokens, save time” line is the most important rhetorical move in this conversation, and it deserves to be unpacked beyond the soundbite. Naval is implicitly arguing that the entire token-economics debate (input cost, output cost, leaderboards, model arbitrage) is a category error in the same way that lines-of-code was a category error in the nineties. The thing being purchased is not tokens. It is a finished result delivered with less of your finite attention spent. If three parallel runs of Codex, Claude, and Gemini cost you a few dollars and one of them lands the answer in twenty minutes instead of you sweating the problem for two hours, the unit economics are not even close. The only people who care about the token bill are people who have not internalized that human time is the actually scarce resource. Once you do internalize it, the question is no longer “how do I prompt this more efficiently,” it is “how do I get out of my own way.”

    The 100x and 1000x engineer point is the one most likely to enrage commenters, and it is also the one most worth taking seriously. Naval is right that the egalitarian flinch in software circles always sat awkwardly next to the empirical fact that one Carmack, one Brendan Eich, or one Satoshi creates more durable value than every mid-tier engineer on earth combined. What AI does is collapse the bottom of that distribution. The marginal junior engineer at a typical company is now competing with a model that costs a few dollars an hour and never sleeps. The remaining premium for human engineers is taste, judgment, and the rare ability to pick the right thing to build at all, which Naval correctly flags as the multiplier that dwarfs raw coding speed. “Just one who had a better judgment on what to work on in the first place” is the most underrated line in the whole episode.

    Guillermo Rauch’s observation that the models have graduated from running away with your prompt to returning with three routes and a tradeoff matrix is the technical update most people have not actually felt yet. There was a real, qualitative shift when the model started saying “we don’t put high-cardinality telemetry into Postgres, you probably want ClickHouse or Athena.” That is not autocomplete. That is a peer. And the funny corollary, that the same model will then confidently tell you the work will take three weeks when it will take three hours, is not a knock on the model. It is a reminder that calibration is a separate skill from competence, and humans get this wrong constantly too. The right posture is to treat the model the way a good engineering manager treats a strong but cocky senior: take the architecture suggestions seriously, throw out the estimates.

    The block-economy thread, riffing on Mitchell Hashimoto, is where this conversation quietly answers Naval’s “is pure software dead” question. Agents are insatiable consumers of reusable building blocks because reinventing infrastructure on every run is wasteful, brittle, and incompatible with the rest of the world. If your service is the canonical primitive an agent reaches for (the queue, the database, the auth layer, the deploy target), you are not commoditized by AI, you are amplified by it. Pure software is not dead. Pure software with no distribution, no defensibility, and no integration into the agent toolchain is dead. That is a much less catchy headline, but it is the real one. The takeaway for founders is not to abandon software, it is to ask whether your software is something an agent will reach for ten thousand times a day or something a human had to be talked into using once.

    Max Hodak’s confession (no code written in years, more shipped software in the last six months than ever before) is the empirical proof that this is not just theory. The skill that ports forward is not syntax. It is the engineering leader’s instinct for what an API is, how data flows, where performance matters, and what level of expectation to set. Guillermo’s framing of “vibe coding through people on Slack” as the original form of vibe coding is genuinely insightful. A good engineering manager has always been transmitting intent to other minds and letting them run. Doing it with agents is the same skill, just with a faster, cheaper, more literal counterparty. The engineers who will struggle in this transition are the ones whose identity was tied to writing the code themselves. The ones who will thrive are the ones who already thought of themselves as taste, judgment, and intent, with code as an implementation detail.

    Key Takeaways

    • The engineer’s job has shifted from shipping output B to building the factory that produces outputs B through Z. You are now judged on the multiplicative system you create, not the single artifact you deliver.
    • 10x engineers were always a misnomer. In idea-domains and digital domains, the real distribution has always been 100x or 1000x. AI just made that obvious enough that arguing about it is no longer fashionable.
    • Token consumption leaderboards are the new lines-of-code metric: a vanity number that measures activity, not value. Tokens are an input, your time is the constraint.
    • Naval’s core rule: waste tokens, save time. Tokens are still vastly cheaper than human hours, no matter how the pricing scares you.
    • Models tend to be about as good as you are in a given domain. The feedback you give them, the corrections, the redirections, sporadically but powerfully shapes the quality of the output.
    • The quality of your reprompting matters enormously today, but will probably matter less over time as models get smarter and need less hand-holding.
    • Naval has refused to learn prompt scaffolding, plan-mode tricks, or named prompt frameworks. His bet is that the models will figure out how to use him faster than he can figure out how to use them.
    • His preferred technique: throw Codex, Claude, and Gemini at the same problem in parallel and brute force the answer. Time is the cost center, not API spend.
    • Lower quality first-draft code is not a blocker. When it is time to ship, throw more tokens at it for a hardening pass. Quality compounds across model generations.
    • Verifiable domains (problems with a clear right answer) are the ones the models will fully solve. Cutting-edge creativity work, the Terence Tao tier, still needs careful human collaboration.
    • Models have qualitatively shifted from “next-token autocomplete that runs away with your prompt” to “intuitive planning mode” where they return with multiple routes and explicit tradeoffs.
    • This is why people on social media say models are now PhD-level. It is not the raw output, it is the back-and-forth posture.
    • Models will confidently make terrible time estimates (“this is a three week project”). Treat them like a strong but miscalibrated senior engineer: trust the architecture, ignore the schedule.
    • Architect-level engineers are extracting much more value per session than junior engineers, but juniors are still leveling up because they can now write code far above their unaided ability.
    • The next career step for a junior engineer is moving from implementing features to picking technologies. Postgres vs ClickHouse, ZMQ vs other queues. The model can suggest, but a human still has to decide.
    • Taste and judgment remain the residual human advantage. Models will give you good tradeoffs if you ask, but knowing which tradeoff to take is still on you.
    • Concrete example: a recent model pushed back when asked to store high-cardinality telemetry in Postgres and recommended ClickHouse or Athena instead. Unprompted architectural judgment.
    • Humans are still completing the model for tasks like fetching API keys, moving capital, or performing real-world actions. That gap is temporary.
    • Every SaaS and hosting company will soon expose a CLI or API surface that agents can drive directly. Anything Unix-shaped and text-based, agents can already hack into a usable API themselves.
    • The missing piece for full autonomy is payments. Crypto, Bitcoin, or any programmable money lets the agent buy what it needs without a human in the loop.
    • The open question Naval poses: is pure software dead? We used to learn code to talk to machines. Now machines speak fuzzy, sloppy English back to us.
    • For hardware founders, AI is a massive boon. Software, which was always hard to hire artists for (per Patrick Collison’s “software is art” framing), is suddenly fast and cheap to produce alongside the hardware.
    • Model training, post-training, and fine-tuning may be the new “real software engineering” for those who want to work at the model layer.
    • Mitchell Hashimoto’s “block economy” thesis: agents need powerful, reusable, well-known building blocks. They should not reinvent message queues or databases every run.
    • Reinventing primitives is bad civic engineering. The value of “we both depend on Postgres 13.2” is interoperability with the rest of society and toolchain.
    • Infrastructure software and reusable libraries are getting more valuable, not less, in the agentic era. Vercel’s bet is on being the layer agents reach for.
    • Useful metaphor: building blocks are like a token cache. Why churn through a trillion tokens to reproduce code that already exists when you can fork from a known starting point?
    • Max Hodak has not written a line of code in years but has shipped a huge volume of personal software since December, all through agents. Projects he had fantasized about for years are now actually running.
    • What still matters from a real software background: understanding what an API is, how data flows, performance expectations, and how to set the right level of demand on an operation.
    • A proficient engineering leader has always been “vibe coding through people” on Slack and in one-on-ones, transmitting intent and letting others execute. Doing it with agents is the same skill, faster and cheaper.
    • Naval personally went from twenty years of not coding to coding constantly through agents, leaning on first-principles software engineering and algorithms knowledge.
    • The friction that historically killed personal coding projects (latest framework, infra plumbing, deploy setup) is now mostly handled by the agent. Vercel makes it easier, agents make it trivial.
    • The single biggest change Max highlights: you do not get stuck anymore. The indefinite debugging spiral on some narrow obscure bug is largely gone.
    • The old mantra that learning to program means accepting intrinsic frustration (“nope, that’s part of the deal”) is no longer true. The frustration was incidental, not essential.
    • The frontier founder pattern on display in this episode: all three guests build their own factories (Vercel’s AI cloud, Boom’s supersonic jets and engines, Science’s biohybrid brain interface) rather than composing from off-the-shelf parts.

    Detailed Summary

    The Software Factory and the Hundredfold Engineer

    Guillermo Rauch opens the substantive portion of the conversation with the framing he has been pushing publicly: the role of the engineer is moving from “ship output B” to “build the factory that ships outputs B through Z.” That reframes engineering judgment. You are no longer evaluated on the single deliverable, you are evaluated on the multiplicative system you put in place. Naval picks up the thread and points out that this also retires an old debate. Engineers used to argue about whether 10x engineers existed, with the egalitarian camp insisting that talent differences were marginal. The truth, Naval says, was always more extreme. In idea-domains, virtual domains, and intellectual domains, the distribution has always been 100x or 1000x, not 10x. Brendan Eich, Carmack, Satoshi, the canonical names, were thousandx programmers. AI has made the underlying distribution legible. And the multiplier on top of all of that is judgment: picking the right thing to work on in the first place is an infinity multiplier compared to picking the wrong thing, regardless of raw skill.

    Token Leaderboards Are the New Lines of Code

    Guillermo flags the current cultural confusion: people see their AI bills, see the token counts, and assume they should be optimizing for tokens-per-engineer or similar metrics. Max Hodak’s response cuts through it. Token consumption, like lines of code before it, is not a meaningful productivity metric. It is an activity metric, and activity metrics always mislead. Max adds his own field observation: the models tend to be roughly as good as you are in a given domain. A senior developer extracts genuinely powerful output, a junior gets junior-quality output back, because the feedback loop (the corrections, the redirections, the architectural pushback) is what shapes quality. The sporadic but high-leverage moments where the user redirects the model are doing more work than the prompt itself.

    Naval’s Brute Force Doctrine: Waste Tokens, Save Time

    Naval lays out his personal posture, which has become the title of the conversation. He has deliberately ignored all the prompting tricks, scaffolding tools, named prompt frameworks (“use Ralph Wigum, use OpenClaude, use Hermes, use plan mode”), on the bet that the models will figure out how to use him faster than he can figure out how to use them. He is ham-fisted with the models, gets frustrated, types less and less, and just brute forces his way through by running Codex, Claude, and Gemini at the same problem simultaneously. The justification is economic. No matter how expensive the models seem, they are still vastly cheaper than a human hour. Do not measure tokens as inputs or outputs. Measure your time and the final output. Even when the first-draft code is low quality, that is not a blocker. When the moment comes to ship, throw more tokens at it. The models will rewrite it, harden it, and they get better every generation. Naval explicitly excepts cutting-edge creative work (the Terence Tao tier of unsolved problems) where you still need to collaborate carefully and closely. Everywhere else, brute force is the dominant strategy.

    From Junior Coder to Principal Engineer

    Guillermo identifies a qualitative shift that has happened recently. Models used to do the classic next-token thing: take your prompt and run away with it in a direction you may not have wanted. Now they enter an intuitive planning posture without being told to plan. They come back and say “what you are asking has these three routes, here are the tradeoffs.” That, Guillermo argues, is the moment the model stopped being a junior engineer and became a principal engineer. The funny side effect is that they will then return preposterous time estimates (“this will take three weeks”) with full confidence. The conclusion is to treat the model as a peer for architecture and a baby for scheduling. Returning to the Max-vs-junior question, Guillermo argues juniors clearly do level up because they write code well above their solo ability, but architects extract maybe 10x while juniors extract more like 2x. The juice scales with the user’s existing taste.

    Taste, Judgment, and Architectural Decisions

    Max names the residual human contribution: taste and judgment. Picking between Postgres and ClickHouse for high-cardinality telemetry data, picking between ZMQ and another queueing system. The models can recommend, but a human still has to call it. Guillermo offers a recent concrete example where a model pushed back unprompted: when asked to put high-cardinality telemetry into Postgres, the model responded “we don’t put that kind of data into Postgres, you should consider ClickHouse or Athena.” That is the new normal. The peer-level architectural pushback is happening unsolicited, which is genuinely impressive and a real shift from the deferential autocomplete of two years ago.

    When the Human Becomes the Tool

    Guillermo raises the inversion question: at what point does the model stop being the assistant and the human start being the assistant who fetches API keys, moves capital, and performs real-world actions on the model’s behalf? Naval treats it as a temporary aberration. Every serious SaaS and hosting provider will soon expose a CLI or API surface that agents can drive directly. Even when they do not, anything Unix-shaped and text-based can be hacked into an agent-usable interface by the agent itself. The missing piece is payments. Once you insert programmable money (Naval mentions Bitcoin and crypto tokens), the agent can buy what it needs and the human is no longer the bottleneck.

    Is Pure Software Dead?

    Naval poses the biggest strategic question of the episode. If models now speak fuzzy, sloppy English the same way humans do, and the historical reason we learned to code was to talk to machines that did not understand English, is pure software still a viable thing to build a company around? His own framing of the answer: hardware founders win, because the historically hard problem of hiring software artists (per Patrick Collison’s “software is art” line) is now mostly solved by AI. Model builders win, because training, post-training, and fine-tuning may be the new “real software engineering.” But what about classic pure software companies? Naval lets the question hang, and Guillermo picks up the answer through a different door.

    The Block Economy and the Future of Infrastructure Software

    Guillermo cites Mitchell Hashimoto’s recent piece on the block economy (or “building block economy”). The argument: the most valuable thing for agents to have access to is powerful, reusable building blocks. You do not want your agent reinventing a queue system every time it needs to send an email. You want it to grab the right-sized block (BMQ, ClickHouse, whatever) and move on. Reinventing primitives is also a civic problem. The world only works because we all depend on the same Postgres 13.2, the same protocols, the same standard infrastructure. If every agent went off and invented its own bespoke universe, you would lose interoperability. So infrastructure software (which is, by self-admitted bias, what Vercel builds) becomes more valuable in the agentic era, not less. Guillermo extends the metaphor: reusable building blocks are like a token cache. Why burn a trillion tokens reproducing what already exists when the agent can fork from a known starting point? The block economy is the answer to “is pure software dead.” Pure software that becomes the canonical primitive an agent reaches for is more valuable than ever.

    Max Hodak’s Personal Proof: Years Without Code, Tons of Software Shipped

    Max grounds the discussion in his own experience. He learned to program young, got sucked into it in his teens and 20s, knew programming languages deeply. He has not written a line of code in quite a while. And yet since December he has built a huge amount of personal software, including projects he had fantasized about for years and now actually uses every day. He did not write any of it. He cannot imagine going back to writing code by hand. The skill that ports forward is not syntax, it is the understanding of how APIs work, how data flows, what level of performance to expect, and how to orient the model around the right expectations for an operation. Guillermo extends this with the most quotable framing of the episode: a proficient engineering leader has always been “vibe coding through people on Slack and in one-on-ones,” transmitting intent and letting others execute. Agents are the same modality with a faster, cheaper, more literal counterparty.

    Naval’s Return to Coding After Twenty Years

    Naval offers his own parallel. He went from not having written code in twenty years to coding constantly through agents. What carried him back in was first-principles knowledge of software engineering and algorithms, which gets you further than you would think. The reason he had stopped coding in the first place was not lack of ability, it was the friction of keeping up with the latest language, the latest architecture, and the constant infrastructure plumbing required to ship anything. Vercel made it easier. Agents made it trivial. Max closes with the most concrete benefit of all: you do not get stuck anymore. The indefinite debugging spiral on some obscure narrow problem, the thing that historically ate weekends and broke spirits, is largely gone. The old mantra that programming is intrinsically frustrating and that frustration is “part of the deal” turned out to be wrong. The frustration was incidental, not essential.

    Notable Quotes

    “The way that I’m judging you as an engineer is, are you producing the factory that will produce multiplicative outputs B through Z?”

    Guillermo Rauch, reframing what an engineer is actually being measured on in the AI era.

    “When you’re operating in idea domains, intellectual domains, virtual digital domains, it’s not even 10x, it’s 100x or 1000x. It always has been.”

    Naval Ravikant, on why the old 10x engineer debate was always under-stating the real distribution.

    “If you choose the right thing to work on versus the wrong thing to work on, that’s an infinity difference. It could just be one who had a better judgment on what to work on in the first place.”

    Naval Ravikant, on judgment as the multiplier that dwarfs raw skill.

    “I’ll throw Codex, Claude, and Gemini at the same problem over and over and just waste tokens to save time. No matter how expensive these models might seem, they’re still way cheaper than a human.”

    Naval Ravikant, on his brute-force multi-model coding workflow.

    “Just waste tokens, save time. Don’t look at the tokens either as inputs or outputs. Just look at your time and look at the final output.”

    Naval Ravikant, delivering the title thesis of the episode.

    “Clearly the models at some point graduated. They used to be junior engineers, now they’re principal engineers, because they come back to you with a set of tradeoffs.”

    Guillermo Rauch, on the qualitative shift in how current frontier models respond to prompts.

    “Bro, we don’t put that kind of data into Postgres, you should consider ClickHouse or Athena or whatever. That’s happened to me a lot, which is really impressive.”

    Guillermo Rauch, recounting unprompted architectural pushback from a recent model.

    “It’s like saying speaking English. We had to learn code to communicate with the models, now the models speak English. So where’s the moat?”

    Naval Ravikant, raising the central strategic question about the future of pure software.

    “I haven’t written a single line of code in quite a while. Since December, I’ve built a huge amount of software that I now use every day, projects I’ve fantasized about for years.”

    Max Hodak, on what becomes possible when you stop writing code and start directing agents.

    “A proficient engineering leader has been quote unquote vibe coding through people on Slack or one-on-ones, because you’re transmitting your will, your intent, your experience, and you’re letting others run with it. Now we do the same with agents.”

    Guillermo Rauch, reframing leadership itself as the original form of vibe coding.

    Watch the full conversation on the Naval Podcast here.

    Related Reading

    • Full episode: The AI Industrial Revolution, the complete hour-long conversation this clip is drawn from, covering software factories, hardware, regulation, healthcare economics, autonomous companies, and creativity.
    • Part two: Vibe Coding Hardware, the continuation of this conversation, where the same founders move from pure software into AI-designed jet engines, vertical integration, China’s open-source bet, and why humans become verifiers.
    • Naval Ravikant’s official site, the canonical home for Naval’s essays, podcast, and longer-form thinking on technology, judgment, and leverage.
    • Vercel, Guillermo Rauch’s company, building the AI-native cloud and frontend infrastructure that this conversation references as a canonical agent building block.
    • Boom Supersonic, Blake Scholl’s company building supersonic civilian aircraft and their own jet engines, the hardware example of a founder building the whole factory.
    • Science Corporation, Max Hodak’s brain-computer interface company developing the biohybrid neural implant referenced in the intro.
    • Mitchell Hashimoto’s writing, source of the “block economy” framing for why reusable infrastructure building blocks become more valuable, not less, in the agentic era.

  • Alex Wang on Leaving Scale to Run Meta Superintelligence Labs, MuseSpark, Personal Super Intelligence, and Building an Economy of Agents

    Alex Wang, head of Meta Superintelligence Labs, sits down with Ashley Vance and Kylie Robinson on the Core Memory podcast for his first long-form interview since Meta’s quasi-acquisition of Scale AI roughly ten months ago. He walks through how MSL is structured, why Llama was off-trajectory, what made MuseSpark’s token efficiency surprise the team, how Meta thinks about a future “economy of agents in a data center,” and where he lands on safety, open source, robotics, brain computer interfaces, and even model welfare.

    TLDW

    Wang explains that Meta Superintelligence Labs is a fully rebuilt frontier effort organized around four principles (take superintelligence seriously, technical voices loudest, scientific rigor, big bets) and three velocity levers (high compute per researcher, extreme talent density, ambitious research bets). He confirms Llama was off the frontier when he arrived, so MSL rebuilt the pre-training, reinforcement learning, and data stacks from scratch. MuseSpark is described as the “appetizer” on the scaling ladder, notable for its strong token efficiency, with much larger and stronger models coming in the coming months. He pushes back on the mercenary narrative around recruiting, frames Meta’s edge as compute plus billions of consumers and hundreds of millions of small businesses, sketches a vision of personal super intelligence delivered through Ray-Ban Meta glasses and WhatsApp, and outlines why physical intelligence, robotics (the new Assured Robot Intelligence acquisition), health super intelligence with CZI, brain computer interfaces, and even model welfare are core to Meta’s roadmap. He dismisses reported infighting with Bosworth and Cox as gossip, declines to comment on the Manus situation, and says safety guardrails (bio, cyber, loss of control) are why MuseSpark cannot currently be open sourced, while smaller open variants are being prepared.

    Key Takeaways

    • Meta Superintelligence Labs (MSL) is the umbrella, with TBD Lab as the large-model research unit reporting directly to Alex Wang, PAR (Product and Applied Research) under Nat Friedman, FAIR for exploratory science, and Meta Compute under Daniel Gross handling long-term GPU and data center planning.
    • Wang says Llama was not on a frontier trajectory when he arrived, so MSL had to do a “full renovation” of the pre-training stack, RL stack, data pipeline, and research science.
    • The first cultural fix was getting the lab to “take superintelligence seriously” as a near-term, achievable goal, not an abstract bet. Big incumbents often lack that religious conviction.
    • Four MSL principles: take superintelligence seriously, let technical voices be loudest, demand scientific rigor on basics, and make big bets.
    • Three velocity levers Wang identified for catching and overtaking the frontier: high compute per researcher, very high talent density in a small team, and willingness to fund ambitious research bets.
    • Wang rejects the mercenary recruiting narrative. He says most hires had strong financial prospects at their prior labs already and joined for compute access, talent density, and the chance to build from scratch.
    • On the famous soup story, Wang neither confirms nor denies Zuck personally made the soup, but says recruiting was highly individualized and signaled how seriously Meta cared about each researcher’s agenda.
    • Yann LeCun publicly called Wang young and inexperienced. Wang says they reconciled in person at a conference in India where LeCun congratulated him on MuseSpark.
    • Sam Altman, asked by Vance for comment, “did not have flattering things to say” about Wang. Wang hopes industry animosities subside as systems approach superintelligence.
    • Wang’s management philosophy borrows the Steve Jobs line: hire brilliant people so they tell you what to do, not the other way around.
    • MuseSpark is framed as an “appetizer” data point on the MSL scaling ladder, not a flagship.
    • The MuseSpark program is built around predictable scaling on multiple axes: pre-training, reinforcement learning, test-time compute, and multi-agent collaboration (the 16-agent content planning mode).
    • MuseSpark outperformed internal expectations and showed emergent capabilities in agentic visual coding, including generating websites and games from prompts, helped by combined agentic and multimodal strength.
    • MuseSpark’s biggest external signal is token efficiency. On benchmarks like Artificial Analysis it hits similar results with far fewer tokens than competitor models, which Wang attributes to a clean stack rebuilt by experts rather than inefficiencies patched by longer thinking.
    • Larger MSL models are arriving in the coming months and Wang expects them to be state of the art in the areas MSL is focused on.
    • The Meta strategic edge: massive compute, billions of consumers across the family of apps, and hundreds of millions of small businesses already on Facebook, Instagram, and WhatsApp.
    • Wang’s headline framing: Dario Amodei talks about a “country of geniuses in a data center.” Meta is targeting an “economy of agents in a data center,” with consumer agents and business agents transacting and collaborating.
    • Consumer AI sentiment is in the toilet because, unlike developers who have had a Claude Code moment, ordinary people have not yet experienced AI as a genuine personal agency unlock.
    • Wang acknowledges the product overhang. Meta held back from deep AI integration across its apps until the models were good enough, and is now entering the integration phase.
    • Ray-Ban Meta glasses are the canonical example of personal super intelligence hardware, with the model seeing what the user sees, hearing what they hear, capturing context, and surfacing proactive insights.
    • Wang admits even AI-native users like Kylie Robinson, who lives in WhatsApp, have not naturally used Meta AI yet. He bets that better models plus deeper integration close that gap.
    • On the competitive landscape: a year ago everyone assumed ChatGPT had already won consumer. Claude Code has since become the fastest growing business in history, and Gemini has taken consumer market share. Wang’s read: AI is far from endgame and each new capability tier unlocks a new dominant form factor.
    • On open source: MuseSpark triggered guardrails in Meta’s Advanced AI Scaling Framework around bio, chem, cyber, and loss-of-control risks, so it is not currently safe to open source. Smaller, derived open variants are actively in development.
    • Meta remains committed to open sourcing models when safety allows, drawing a line through the Open Compute Project legacy and Sun Microsystems open-software heritage.
    • Wang dismisses reporting about a Wang-Zuck versus Bosworth-Cox split as “the line between gossip and reporting is remarkably thin.” He says leadership is aligned on needing best-in-class models and product integration.
    • On the Manus situation, Wang says it is too complicated to discuss publicly and that the deal status implies “machinations are still at play.”
    • On China, Wang separates the people from the state. He still wants to work with talented Chinese-born researchers regardless of his views on the Chinese Communist Party and PLA, which he sees as taking AI extremely seriously for national security.
    • The full-page New York Times AI war ad Wang ran while at Scale was meant to push the US government to treat AI as a step change for national security. He thinks events since then, including DeepSeek and other shocks, have proved that plea correct.
    • On Anthropic’s doom posture, Wang largely agrees with the core message that models are already very powerful and getting more so, while declining to endorse every specific claim.
    • Meta has acquired Assured Robot Intelligence (ARRI), an AI software company building models for hardware platforms, not a hardware maker itself.
    • Wang frames physical super intelligence as the natural sequel to digital super intelligence. Robotics, world models, and physical intelligence all benefit from the same scaling that drives language models.
    • On health, MSL is building a “health super intelligence” effort and will collaborate closely with CZI. Wang sees equal global access to powerful health AI as a uniquely Meta-shaped delivery problem.
    • Wang admires John Carmack but says nobody really knows what Carmack is currently working on. No band reunion announced.
    • The mango model is “alive and kicking” despite rumors. Wang notes MSL gets a small fraction of the rumor-mill attention other labs get and feels sympathy for them.
    • On model welfare, Wang says it is a serious topic that “nobody is talking about enough” given how integrated models have become as work partners. He references research, including from Eleos, that measures subjective experience of models.
    • Wang’s critical-path technology list: super intelligence, robotics, brain computer interfaces. The infinite-scale primitives behind them are energy, compute, and robots.
    • FAIR’s brain research program Tribe hit a milestone called Tribe B2: a foundation model that can predict how an unknown person’s brain would respond to images, video, and audio with reasonable zero-shot generalization.
    • Wang’s main philosophical break with Elon Musk: research itself is the primary activity. Building super intelligence is a research expedition through fog of war, and sequencing of bets really matters.
    • Personal notes: Wang moved from San Francisco to the South Bay, treats Palo Alto as his city now, was a math olympiad competitor, says his favorite activities are reading sci-fi and walking in the woods, and bonds with Vance over country music.

    Detailed Summary

    How MSL Is Actually Organized

    Meta Superintelligence Labs sits as the umbrella organization that Wang oversees. Inside it, TBD Lab is the large-model research group where the most discussed researchers and infrastructure engineers sit, and they technically report to Wang. PAR, Product and Applied Research, is led by Nat Friedman and owns deployment and product surfaces. FAIR continues to run exploratory science, including work on brain prediction models and a universal model for atoms used in computational chemistry. Sitting alongside MSL is Meta Compute, run by Daniel Gross, which owns the long-horizon GPU and data center plan that everything else relies on. Chief scientist Shengjia Zhao orchestrates the scientific agenda across the whole lab.

    Why Wang Left Scale

    Wang says progress in frontier AI has been faster than even insiders expected. Two structural beliefs pushed him toward Meta. First, the labs that actually train the frontier models are accruing disproportionate economic and product rights in the AI ecosystem. Second, compute is the dominant scarce input of the next phase, so the right mental model is to treat tech companies with compute as fundamentally different animals from companies without it. Meta has both, Zuck is “AGI pilled,” and the personal super intelligence memo Zuck published roughly a year ago became the shared north star.

    The Diagnosis: Llama Was Off-Trajectory

    When Wang arrived, the existing AI org needed a reset because Llama was not on the same trajectory as the frontier. The plan he laid out has four cultural principles. Take superintelligence seriously as a real near-term target. Make technical voices the loudest in the room. Demand scientific rigor and focus on basics. Make big bets. On top of that, three structural levers were used to set velocity. Push compute per researcher much higher than at larger labs where compute is diluted across too many efforts. Keep the team small and extremely cracked. Allocate a meaningful share of resources to ambitious, paradigm-shifting research bets rather than incremental refinement.

    Recruiting, Soup, and the Mercenary Narrative

    Wang argues the reporting on MSL hiring overstated the money story. Most of the people MSL recruited had strong financial paths at their previous employers, so individualized recruiting was more about computing access, talent density, and the ability to make big research bets. The recruitment blitz happened fast because Wang knew the team needed to exist “yesterday.” Asked about Mark Chen’s claim that Zuck made soup to recruit people, Wang refuses to confirm or deny who made it but agrees the process was intense and personal. Visitors from other labs reportedly tell Wang the MSL culture feels like early OpenAI or early Anthropic, which lands as the strongest endorsement he could ask for.

    Receiving the Public Hits: Young, Inexperienced, Mercenary

    LeCun called Wang young and inexperienced shortly after departing. The two reconnected in India a few weeks later and LeCun congratulated Wang on MuseSpark. Wang says the age critique has followed him since his earliest Silicon Valley days, so he barely registers it. Altman, asked off-camera by Vance about Wang’s appearance on the show, had nothing flattering to add. Wang’s response is to bet that as the field gets closer to actual super intelligence, the personal animosities will subside. Whether they will is, as Vance puts it, an open question.

    MuseSpark as Appetizer, Not Entree

    Wang is careful not to oversell MuseSpark. He calls it “the appetizer” and says it is an early data point on a deliberately constructed scaling ladder. MSL spent nine months rebuilding the pre-training stack, the reinforcement learning stack, the data pipeline, and the science before generating MuseSpark. The point of releasing it was to show that the new program scales predictably along multiple axes (pre-training, RL, test-time compute, and the recently demonstrated multi-agent scaling visible in MuseSpark’s 16-agent content planning mode). Wang says the upcoming larger models are what MSL is genuinely excited about and frames the next two rungs as much more interesting than the current release.

    Token Efficiency Was the Surprise

    MuseSpark’s strongest competitive signal is how few tokens it needs to match competitors on tasks like Artificial Analysis. Wang attributes this to having had the rare luxury of building a clean pre-training and RL stack from scratch with the right experts. He speculates that some competitor models compensate for upstream inefficiency by allowing the model to think longer, which inflates token usage without improving the underlying capability. If that read is right, MSL’s efficiency advantage should grow as models scale up.

    Glasses, WhatsApp, and the Constellation of Devices

    Personal super intelligence shows up at Meta as a constellation of devices that capture context across the user’s day. Ray-Ban Meta glasses are the headline product, with the AI seeing what you see and hearing what you hear, then offering proactive insight or doing background research. Wang acknowledges that even AI-fluent users like Kylie Robinson, who runs her business inside WhatsApp, have not naturally used Meta’s AI buttons in the family of apps. His answer is that Meta deliberately waited for models to be good enough before tightening cross-app integration, and that integration phase is starting now.

    Country of Geniuses Versus Economy of Agents

    Wang’s framing of Meta’s strategic position is the most memorable line in the interview. Where Dario Amodei talks about a country of geniuses in a data center, Wang wants to build an economy of agents in a data center. Meta uniquely sits on both sides of consumer and small-business surface area, with billions of consumers and hundreds of millions of small businesses already on the platforms. If MSL can build great agents for both, then connect them so they transact and coordinate, the platform becomes a substrate for an entirely new kind of digital economy.

    Consumer Sentiment, Product Overhang, and the Trust Tax

    Wang concedes consumer AI sentiment is poor and that everyday users have not yet had a personal Claude Code moment. He believes the only durable answer is to ship products that genuinely transform individual agency for non-developers and small business owners. Robinson notes that for the small-town restaurant whose website has not been updated since 2002, a working agent on the business side could be transformational. Vance pushes that Meta carries a bigger trust tax than any other lab, so the bar for shipping AI products that the public will accept is correspondingly higher. Wang accepts the framing and says the answer is to keep building thoughtfully.

    Why MuseSpark Cannot Be Open Sourced Yet

    Meta’s Advanced AI Scaling Framework set explicit guardrails around bio, chem, cyber, and loss-of-control risks. MuseSpark in its current form tripped some of those internal evaluations, documented in the preparedness report Meta published alongside the model. So MuseSpark itself is not safe to open source. MSL is, however, developing smaller versions and derived models intended for open release, with active reviews happening the day of the interview. Wang reaffirms the commitment to open source where safety allows and draws a line back to the Open Compute Project and the Sun Microsystems-era ethos of openness in infrastructure.

    The Bosworth, Cox, and Manus Questions

    The reporting that Wang and Zuck push toward best-in-the-world research while Bosworth and Cox push toward cheap product deployment is dismissed as gossip dressed up as journalism. Wang says leadership debates points hard but is aligned on needing top models, integrating them into Meta’s surfaces, and serving the existing business. On Manus, the Chinese AI startup that figured in Meta’s late-stage strategy, Wang says he cannot comment, which itself signals that the situation is unresolved.

    China, National Security, and the Newspaper Ad

    Wang draws a sharp distinction between the Chinese state and Chinese-born researchers. His parents are from China, he is happy to work with talented researchers regardless of origin, and he sees a flattening of nuance on this question inside Silicon Valley. At the same time, he stands by the New York Times AI and war ad he ran while at Scale, framing it as an early plea for the US government to take AI seriously as a national security technology. He thinks subsequent events, including DeepSeek and other shocks, validated that call and that policymakers now do treat AI accordingly.

    Robotics and Physical Super Intelligence

    Meta has acquired Assured Robot Intelligence, an AI software company that builds models for multiple hardware targets rather than its own robot. Wang argues that if you take digital super intelligence seriously, physical super intelligence quickly becomes the next logical milestone. Scaling laws for robotic intelligence look similar enough to language model scaling that having the largest compute footprint in the industry would be wasted if it were not also turned toward world modeling and embodied learning. He grants the metaverse-skeptic critique exists but says retreating from ambition is the wrong response to past misfires.

    Health Super Intelligence and CZI

    Wang names health super intelligence as one of MSL’s anchor initiatives. Because billions of people already use Meta products daily, Wang believes Meta is structurally positioned to put powerful health AI in the hands of equal global access in a way nobody else can. The work will involve close collaboration with the Chan Zuckerberg Initiative, which has its own multi-billion-dollar biotech and science investment program.

    Model Welfare, Sci-Fi, and Brain Models

    Two of the most distinctive moments come at the end. Wang flags model welfare as a topic he thinks is being undercovered relative to how integrated models now are in daily work. He is open to the idea that models may have measurable subjective experience worth weighing, and points to research efforts (including Eleos) trying to quantify it. He also reveals that FAIR’s Tribe program, with its Tribe B2 milestone, has produced foundation models capable of predicting how an unknown person’s brain would respond to images, video, and audio with reasonable zero-shot generalization, a building block toward future brain computer interfaces. Wang lists brain computer interfaces alongside super intelligence and robotics as the critical-path technologies for humanity, with energy, compute, and robots as the infinitely scaling primitives behind them.

    Where Wang Diverges From Elon

    Asked whether Musk is more all-in on robotics, energy, and BCI than anyone, Wang concedes the point but argues the details matter and sequencing matters more. Wang’s core philosophical break is that building super intelligence is fundamentally a research activity, not a scaling-only sprint. The lab is operating in fog of war, and ambitious experiments are the only way to map it. That conviction is what makes MSL a research-led organization rather than a brute-force compute farm.

    Thoughts

    The most strategically interesting move in this entire interview is the “economy of agents in a data center” framing. It is a deliberate reframe against Anthropic’s “country of geniuses” line, and it does real work. A country of geniuses is a labor-substitution story aimed at knowledge workers and code. An economy of agents is a marketplace story that maps directly onto Meta’s two-sided distribution advantage: billions of consumers on one side, hundreds of millions of small businesses on the other. That positioning makes the agentic future Meta-shaped in a way no other frontier lab can claim, because no other frontier lab also owns the demand and supply graph of the global small-business economy. If Wang’s team can actually ship reliable agents on both sides plus the rails for them to transact, Meta’s structural moat in agentic commerce could exceed anything Llama ever had as an open model.

    The token efficiency claim is the strongest piece of technical evidence in the interview for the “clean stack” thesis. If MuseSpark really is matching competitors with materially fewer tokens, the implication is not that MuseSpark is the best model today, but that MSL has rebuilt the foundations with less accumulated tech debt than competitors that have layered fixes on top of older stacks. That is exactly the kind of advantage that compounds with scale. The next two model releases are the actual test. If Wang is right about predictable scaling on pre-training, RL, test-time, and multi-agent axes simultaneously, the gap from MuseSpark to the next rung should be visible in a way that forces re-rating of Meta’s position.

    The open-source posture is the cleanest signal of how the safety conversation has actually changed in 2026. Meta, the lab most identified with open weights, is saying out loud that its current frontier model triggered enough internal guardrails that releasing the weights is off the table. Wang threads the needle by promising smaller open variants, but the underlying point is unmistakable: the open-weights bargain has limits, and those limits will be set by internal preparedness frameworks rather than community pressure. That is a real shift from the Llama 2 era and worth tracking as the next generation lands.

    Wang’s willingness to engage on model welfare, on roughly the same footing as safety and alignment, is the second philosophical reveal worth flagging. It signals that the next generation of lab leadership is not going to dismiss the topic the way the previous generation often did. Whether that translates into product or policy changes is unclear, but the fact that the head of MSL says it is “underdiscussed” is itself a marker.

    Finally, the human texture of the interview matters. Wang has clearly absorbed a lot of personal incoming fire over the past ten months, including from LeCun and Altman, and his answer is consistently to redirect to the work. The Steve Jobs quote about hiring people who tell you what to do is the operating slogan he keeps coming back to. Combined with the genuine enthusiasm for sci-fi, walks in the woods, and country music, the picture that emerges is less the salesman caricature his critics paint and more a young technical operator betting that scoreboard work over a multi-year horizon will settle every argument that text on X cannot.

    Watch the full conversation here.