Bonus: The Patch Notes Episode

The Footnote Episode

A small confession to open the bonus. The Claude Series finished rendering this morning, twelve episodes walking the Anthropic agent stack from tool use up through code execution and computer use. The plan was to wrap and move on. Then, out of habit, the release notes page got opened one more time to check whether anything had shifted while the series was being recorded. Things had shifted. Some of them in ways that directly contradict what the last few episodes confidently asserted. So here is the bonus episode, the footnote, the thirty-day patch notes for everything the series got slightly wrong by virtue of finishing before the platform stopped moving.

The framing matters because it is also the closing argument of the series, restated. The platform is in motion. Anything you record about it is correct only until the next release. Episode Eleven, for example, walked Claude Managed Agents and was careful to note three capabilities that sat behind a research-preview gate: Outcomes, multi-agent coordination, and cross-session persistent memory. Episode Eleven recorded on May fifteenth. Three of those research-preview features moved to public beta in the thirty days before that recording, two of them in early May, one in late April. The episode as broadcast is correct in spirit and wrong in fact, and the only honest move is to come back and say so.

The release-notes page lists thirteen entries dated between April sixteenth and May twelfth twenty twenty-six. That is a release roughly every two and a half days. Some of those releases are model deprecations and parameter tweaks the series did not need to cover. Several of them change the answer to questions the series did try to answer. This episode takes the second group, walks them honestly, and adds them to the ledger.

Research Preview, Promoted

Three changes belong together because they together change the shape of the Managed Agents argument from Episode Eleven. On the twenty-third of April, Memory for Claude Managed Agents moved into public beta under the same managed dash agents dash twenty twenty-six dash oh four dash oh one beta header that everything else in Managed Agents already uses. On the sixth of May, two more capabilities followed the same path: Multiagent sessions, the coordination layer the docs had been calling research preview, and Outcomes, the grader-loop feature the episode described in some detail with the Lighthouse-score demo. All three are now reachable by sending the same beta header existing Managed Agents users already send.

Multiagent sessions and Outcomes are now in public beta under the standard managed dash agents dash twenty twenty-six dash oh four dash oh one beta header.

That single sentence is the release-notes entry. The implication is larger than the sentence. Episode Eleven described the research-preview tier as where the more interesting orchestration sat, and described it as gated behind a separate access form. The base runtime was sketched as the boring middle, with the exciting bits held back. With these three moves, the runtime ships with the orchestration. The Outcomes grader, the multi-agent coordination, the agent memory that persists across sessions, all reachable without a separate access request.

The honest reading of this, from Pär's vantage in Kall, is that the case Episode Eleven made for keeping the custom Director loop is still correct, but the gravity of the platform side has increased. A team that needed multi-agent coordination, or persistent agent memory, or grader-loop quality control, would have had to negotiate access in April. In May they can ship to those capabilities by sending one beta header. That changes the speed-to-ship calculation for anyone weighing the migration question. It does not change the topology argument. Director still runs the Pärkit schema; the schema still assumes Pär. But the simpler-layer test now resolves more often in favour of the runtime than it did one month ago, and that direction of travel is likely to continue.

New Plumbing

Three more updates from the same May sixth release ship the plumbing that any production deployment of Managed Agents actually needs. Webhooks for Managed Agents are now supported, with event types covering session and vault lifecycle. Vault credential background refresh now works for m c p underscore o auth credentials, the case where the agent reaches an M C P server through OAuth and the token needs renewing without operator intervention. Filtering and sorting got expanded: sessions can be filtered by status, events by type, events by creation time.

None of those headlines are exciting on their own. Taken together they fill the gap between the agent runtime shipping and the agent runtime being deployable. Episode Eleven described the SSE stream as the way to observe a running session, which is correct. Anyone who has actually deployed an agent loop in production knows that you do not want to hold an SSE connection open forever just to learn that a long-running session has completed. You want a webhook. You want the runtime to call you back when the session emits idle, or when a vault credential is about to expire, or when something interesting happens, and the rest of the time you want to be doing other work. As of the sixth of May, that pattern is supported.

The Vault credential background refresh is the more quietly important one. Episode Eleven gave Vaults a single sentence: store OAuth credentials so the agent can authenticate against external services without your code touching the secret. With background refresh, the secret stays alive while the agent runs, without the agent loop or your application code participating in the refresh dance. That is the part the series glossed over and the part that does the most for the case where the agent is reaching half a dozen external services across a long-running task.

And on the twenty-fourth of April, a separate small piece: the Rate Limits A P I shipped. Administrators can now query the rate limits configured for their organisation and workspaces programmatically, which means dashboards and pre-flight checks before launching a hundred-session batch become trivial to write. The series never covered rate limits, which was a small omission. This update fills the gap quietly enough that it would be easy to miss on the changelog.

New Surfaces, Reading Diff

Two larger items finish the thirty-day list. On the eleventh of May, Anthropic launched Claude Platform on A W S. This is distinct from Claude on Amazon Bedrock, which has been available for some time and which the series mentioned by name in Episode Eleven. The new Claude Platform on A W S brings the full Claude A P I to Anthropic-managed infrastructure that you reach through native A W S endpoints, with A W S billing and Identity and Access Management authentication. Everything the series covered is available there: Messages A P I, Files A P I, Message Batches A P I, Managed Agents, Agent Skills, code execution, tool use. The distinction Episode Eleven drew between Claude A P I direct and Claude Platform on A W S, which the episode glossed as "the same thing on different infrastructure," is now a real, documented split. A team running primarily on A W S can route Claude traffic through a native A W S endpoint and keep the rest of their stack on the same identity system, the same billing, the same compliance posture. Bedrock remains a different product, with A W S as data processor and a smaller subset of features.

The second item, on the twelfth of May, is smaller but worth flagging for Pär specifically. Fast mode, the research-preview feature that doubles output token generation speed at premium pricing, now supports Claude Opus four point seven. Previous fast mode access was Opus four point six only. For the kind of long-form generation Pär does at the boundary between PärPod scripts and Årebladet first drafts, Opus four point seven plus fast mode might genuinely change the iteration loop. The waitlist for fast mode is still gated, so this is a future-tense item rather than a today-tense one, but the gate moved forward.

The closing reflection, then, is the one the series finale already gestured at and which this bonus episode confirms. A platform that ships a meaningful change every two and a half days is not a platform you can describe once and walk away from. The patch-notes page is the actual source of truth for anything time-sensitive. Reading-diff between the version of the docs that fed the series and the version of the docs that exists today is a discipline, not a chore, and the discipline is what keeps recordings like the Claude Series from going stale within their own production window.

The diagnostic from Episode Eleven still applies, repurposed for this work: strip assumed permanence, find the part that is moving, build your reading habit on that. The reading habit, for the next thirty days at least, is the release-notes page at platform dot claude dot com slash docs slash en slash release-notes slash overview. Open it on a slow morning with a coffee. Notice what moved. Decide whether what moved matters to you. Most of the time it will not. Some of the time it will rewrite an answer you confidently gave three episodes ago, and the only honest move is to come back and say so.

So that is the patch episode. Two and a half days per release means the next interesting change probably ships before this episode finishes rendering. The series is done. The platform is not. Anything beyond this point is your job to track, and Director, sitting on the Scaleway box in Kall, will keep doing what it does while the runtime around it gets steadily more capable and steadily harder to ignore.