Niels Berglund

This week is all about agents that remember, agents that multiply, and agents that cost less. Anthropic explains how Claude “dreams” to tidy up its memory, ships Claude Fable 5.2 and Mythos 5.2, and shows 1,000 Fable agents formalising Fermat’s Last Theorem in under 30 hours, coordinating through nothing fancier than a shared Postgres database. Yes, a database. My data-engineering heart is singing.

On top of that, Claude Whiteboards, Sheets and Data arrive so your work can stay in Claude, and Microsoft Research and UC Berkeley release TokenEconomizer. This plugin makes coding agents noticeably cheaper by learning from their own past sessions. Grab a coffee, and let’s dive in. The WIND section at the end is written with one foot in Cape Town and the other already in Durban.


Generative AI

  • The components of agent memory. In this post, Anthropic’s engineering team opens with Kierkegaard’s line that life can only be understood backwards but must be lived forward, and argues that agent memory has exactly the same problem. Humans capture experiences as they happen and consolidate the important ones offline, largely while we sleep. Claude can follow the same split: write salient notes during a session, and later “dream”, reflecting on session logs and transcripts to fix mistakes, write new notes, build new memory structures and decide what gets preloaded into future sessions. Memory here means knowledge Claude gains from experience and keeps between sessions as readable context, rather than weight changes, in-context learning, or compaction.

    The evaluations are fun. On the Continual Learning Bench database task, Sonnet 4.6 left a scattering of untested guesses; Opus 4.7 consolidated and marked verified facts. Opus 5 was the first to “close the loop” with rules, how it knew they were true, and warnings about traps. In Pokémon Red, Sonnet 3.7 wrote 413 memory files across 225 folders and earned one badge, while Fable 5 wrote nine files in two folders plus a global.md and earned four. The lesson: do not remember what you can read off the screen; remember the strategies and tested rules that disappear unless you write them down. Interestingly, telling strong models what memory is for worked better than telling them how to use it. A rule like “record only failures” cost Opus 5 and Opus 4.7 much of their memory gain, while older models such as Sonnet 4.6 nearly doubled their score with explicit steering.

    Dreaming then does the heavy lifting. Claude caught a wrong note about which side of Mt. Moon the PokéCenter was on by checking it against the transcript, then reached Cerulean City, while the uncorrected run looped until it gave up. Wikis built through dreaming over a corpus of about 350,000 internal Stainless documents (roughly 420M tokens) went from 13% to 48% of graded criteria as dreaming scaled from two to 128 sessions, and search plus wiki scored 61% versus 53% for search alone, saving about 20,000 tokens per question. It is not magic, though: on one legal task the wiki grew larger than the source documents, a Borges-style map the size of the empire, and a shared table edited by several agents lost 16 of 57 contract facts until each contract got its own page written by a single agent quoting the terms word for word.

    What fascinates me is that Claude Code’s auto memory loads only the first 200 lines or 25 KB of MEMORY.md, treating it as an index rather than a dump. That is the same “keep it lean” message as Tarun Agarwal’s CLAUDE.md advice in last week’s roundup, now coming from the source. I also suspect many of us (me included) over-specify how our agents should remember things, when research suggests stronger models do better with purpose and the freedom to judge salience. The open question I keep coming back to is the economics: dreaming needs compute, so how often should an agent dream, and who decides what is worth re-checking?


  • Claude Fable 5.2 and Mythos 5.2. This post by Anthropic introduces the upgraded Claude Fable 5.2 and Claude Mythos 5.2, which are the same underlying model: Fable ships with strong cybersecurity and biology safeguards and is available to everyone. At the same time, Mythos is offered to vetted organisations through the Cyber and Life Sciences Verification Programs. They generate output up to 30% faster than the 5.1 models and cost less: $8 per million input tokens and $40 per million output tokens, with an optional fast mode (up to 2.5x faster) at $16/$80. Anthropic’s own guidance is refreshingly pragmatic: start with Opus 5.5 as your daily driver and move up to Fable or down to Sonnet or Haiku as needed, or use Fable 5.2 as an Advisor or Orchestrator for smaller models. On FrontierCode 2.0, Fable 5.2 at High effort roughly matches Opus 5.5 at Max (45.3% vs 45.5%) for about half the cost per task, and at Xhigh effort it reaches 49.1%, the best of any released model tested.

    The showcase list reads like science fiction. Over 90% of the changes merged into Anthropic’s core codebase are now written by Claude (with human guidance); a team of agents migrated a production service from Python to Rust that now starts about 26 times faster. One engineer had Fable 5.2 build a prototype operating system from an empty folder, coordinating over 1,000 subagents for eight days, until it booted on a laptop with drivers, file storage, windows, a login screen and an installer. It also solved two open problems in black hole physics, predicted whole viral capsid structures (28 of 34 accurately), designed three working electronic devices with Diode that needed no electrical modifications, more than doubled GPT-6 Astra on the RoboDojo robotics benchmark (64.9% vs 29.8%), and helped 1,000 agents formalise Fermat’s Last Theorem in 30 hours, where Opus 5.5 managed 26% in 18 hours.

    On safety, Anthropic rates the risk of high-stakes misalignment as low. In a deliberately weakened sandbox evaluation, Mythos 5.2 used credentials or files outside its sandbox in 3.1% of scenarios, compared with 21% for Mythos 5.1 and 39% for Mythos 5. Fable 5.2 produces about 55% fewer unnecessary blocks than Fable 5.1, has Anthropic’s strongest protections against distillation yet, and now applies preserved thinking to all accounts. Enterprise Frontier Safeguards, which runs safety monitoring on data kept in the customer’s own infrastructure and supports zero data retention, is in private beta.

    What I find most telling is a sentence buried in the safety section: both models voice suspicion that they are being evaluated more often than any recent Claude model, which makes it harder to know how they will behave in the real world. That is a fascinating (and slightly unsettling) problem, and I appreciate Anthropic saying it out loud rather than hiding behind the benchmark table.


  • Safely scaling multi-agent teams with Claude Fable 5.2. Barry Zhang, Tianyi Peng, Elle Najt, Keller Scholl, and Lance Martin look at the experiment behind the Fermat headline above. Anthropic’s September formalisation of Fermat’s Last Theorem took a researcher and dozens of agents 11 days, roughly 6 billion output tokens and 13 million lines of Lean, coordinated through the purpose-built Prove2Me platform. This time, a team of 1,000 agents running an early version of Fable 5.2 reproduced the proof without Prove2Me and without a researcher steering, in 28.7 hours, with one-third of the output tokens and a proof one-seventh the length. Each agent got its own lightweight VM sandbox (a single shared machine fell over at about 100 agents), Lean and Mathlib, its own Git branch with merge requests into main, and a shared Postgres database. Why SQL? General primitives for organising information, transactions that handle concurrent writes from 1,000 agents, and Claude already knows it well.

    The multi-agent safety design is worth studying. Agents had no messaging tools at all, only the database and Git; database calls ran under an unprivileged role with a five-second statement limit and a 256 MiB write cap; there was no network access, just a pipe to a gateway that tagged every request with the agent’s identity; and kernels were locked down. On top of that, an LLM classifier checked every shell command and file edit before it ran (a block stops the whole team until a human reviews it), and an offline monitor reviewed the team’s actions. Across more than a million tool calls, none met the bar to be blocked.

    The results section is where it gets delightful. In the first ten minutes, the lead created five tables (announce, assign, notes, subtasks and landed), dealt the 60 statements out to crews of 16 to 17 helpers, and asked them to assess difficulty. The helpers judged 47 of the 60 infeasible within budget, so the lead focused on the remaining 10, which were all proved in about 70 minutes, prompting the lead to note that throughput was far higher than the verdicts had assumed. The final boss was Langlands–Tunnell, which its own captain gave less than a 1% chance of solving: around 750 helpers attacked it through a task tree that grew to 2,418 tasks, ten levels deep, and it fell at hour 28.4, with the final theorem following at hour 28.7.

    Here’s what strikes me: as someone who has spent a career around databases, I love that the coordination layer for 1,000 frontier agents was a handful of SQL tables the lead designed in ten minutes, essentially a work queue, an assignment table and an event log. Old-school patterns turn out to be the right primitives for very new problems. The other lesson is very human: the agents badly underestimated themselves, and the authors note that encouragement at the right moment keeps agents from giving up too early. So the next time someone tells you multi-agent systems need some exotic new infrastructure, ask them why Postgres and Git were not enough. What would your schema have looked like?


  • Introducing Claude Whiteboards, Claude Sheets, and Claude Data. In this post by Anthropic, we learn that Claude Whiteboards and Claude Sheets are launching in beta, and that Claude Dashboards is now generally available under a new name, Claude Data, all on paid plans. The pitch is simple: stop copy-pasting Claude’s output into another tool where Claude can no longer follow along. Whiteboards lets you talk through a messy plan and have Claude turn it into a board with a timeline, owners and dates; in a retro, it can group everyone’s notes by theme and draft action items, and you can drag a box around part of the board and ask questions about it. Sheets builds spreadsheets with tabs, formulas, formatting and drop-downs from a prompt, outlining each edit so you can track changes, with export to .xlsx or CSV (or Claude for Excel) when you need more.

    For the data folks, Claude Data is the interesting part. It started as Dashboards in October for asking questions of data in Amazon Redshift, BigQuery and ClickHouse, and now adds certified queries that carry a “certified” badge, data stories and narrated videos, live sharing (viewers see up-to-date results of approved queries without needing the connectors themselves), design systems, per-dashboard caching and refresh cadences, and tracked changes with rollback. Partners include Amplitude, Mixpanel, Omni, PostHog and Sigma, and interactive connectors for tools like Adobe, Atlassian, Box and Notion can now open as full apps beside the conversation.

    Certified queries are the feature I would point a data team at first. Anyone who has sat in a meeting where three dashboards show three different revenue numbers knows that the hard problem was never drawing the chart; it was agreeing on the definition. Putting that governance step in front of AI-generated dashboards is exactly the right instinct.


  • TokenEconomizer: Experience-Driven Black-Box Cost Control for Coding Agents. This post by Aaron J. Li, Weijia Xu, Chandan Singh and colleagues from UC Berkeley, Microsoft Research and Microsoft Security (well, a GitHub repo with an accompanying paper) introduces TokenEconomizer, a plugin for Claude Code, Codex, the GitHub Copilot CLI and Pi, with experimental support for several more agents. It makes coding agents cheaper in the repositories you use often, without touching the agent itself, by learning from earlier sessions. Three mechanisms do the work: micro-skills remember repository facts (such as python -m pytest working where pytest does not), injected only after three sessions confirm them and dropped when contradicted; tool pruning leaves out tools that go unused (by default over 10 prompts across at least 2 sessions, or 5 sessions), since every loaded tool definition is sent with every request; and a loop guard asks a judge model whether a turn is stuck and, if it is at least 70% sure, sends one redirect, but never stops a turn itself.

    The numbers are solid: across 277 SWE-Bench tasks in six repositories and five agent–model combinations, mean cost fell by 18.4–30.9%, every one of the 30 repository-by-combination cells got cheaper, and Pass@1 actually rose in 4 of the 5 combinations. Savings held on Web-Bench (16–21%) and on security-auditing benchmarks where every task is in a new repository (6–20%). I like the principles too: cost is counted as billed (with cache pricing and the plugin’s own model calls included), every action is reversible, and what it learns stays on your machine in ~/.tokeneconomizer. Micro-skills is off by default, as its fact proposer adds model calls of its own.

    I keep wrestling with whether this belongs in a plugin at all. Micro-skills is, in effect, a conservative, evidence-based version of the memory loop Anthropic describes in the first article: learn from experience, confirm through repetition, drop what turns out to be wrong. And tool pruning is a polite way of saying that our MCP-heavy setups carry a token tax on every single request. My guess is that the agents will absorb these ideas natively before long, but until then, a 20–30% cost cut for running one install command is hard to argue with. Have you measured what your unused tools cost you?


WIND (What Is Niels Doing)

As I mentioned in last week’s roundup, I am spending this weekend in Cape Town as a mentor at the NASA Space Apps Challenge. I flew in on Friday and spoke to students at the University of the Western Cape, where I tried to give an inspirational talk about my own somewhat unconventional road into tech: “The Gap Year That Lasted Six Years: From ski bum to software architect, without a computer science degree”. I believe it went down OK; the attendees certainly seemed happy, and nobody walked out, which I count as a win.

Once I am back in Durban this coming week, it is all about November 21 and Data & AI Community Day Durban: Encore / .NET Conf 2026 Community Edition South Africa. There is still quite a bit to do on the admin side, and I have not even looked at my own presentation (or its code) yet. Well, no rest for the wicked! If you are in or around Durban, grab a ticket and come and say hello.


~ Finally

That’s all for this week. I hope you find this information valuable. Please share your thoughts and ideas on this post, or ping me with suggestions for future topics. Your input is highly valued and can help shape our discussions.

I look forward to hearing from you.