Skip to main content

This Month in Claude

All levels

A plain-English digest of what's changed recently across Claude — so you can skim "what's new and what it means for me" without reading every changelog. Newest first.

How this page stays current

Entries are added by the community and by an automated watcher that flags upstream changes for a human to write up. Each entry links its official source. See something missing? Add it.

How to read an entry​

Each update is tagged by surface — 🗣️ Apps (chat/voice/mobile), 🛠️ Claude Code, 🔌 API, 🧠 Models — and answers "what it means for you."

Recent updates​

  • 🔌 API — Message threads went to public beta on November 2, 2026: your agent can stop re-uploading the whole conversation every turn. Add thread: {"type": "create"} to a Messages request behind anthropic-beta: message-threads-2026-08-12, and every later turn sends only the new messages plus thread: {"type": "continue", "previous_message_id": …}. Anthropic's published win is median time to first token down about 35% on requests of 500k–1M tokens. What it means: read the next sentence before you plan a migration, because almost every secondhand writeup has this backwards. This does not reduce your bill. Anthropic states it outright — Claude still reads the full conversation on every turn, so token usage is unchanged, and threads change neither pricing nor rate limits. The headline "800 KB down to 1.8 KB" numbers circulating are request payload sizes, not tokens; prompt caching is still the cost lever, and a thread does not enable caching for you. What you do inherit is state management. A thread is explicitly best-effort: held in memory, never written to durable storage, expiring 5 minutes after its last request and deleted within an hour — and no response, create or continue, ever tells you whether a turn was stored. You find out on the next request, when it returns 404 thread_not_found, and the only recovery is replaying the full conversation from your own copy in a fresh create request. Build that handler on day one. Three more edges worth knowing before you ship: parameters split into create-only (system, tools — resending either, even as null, is a 400), fixed (model, thinking, tool_choice, context_management, output_config, top-level cache_control — a change is 400 thread_fingerprint_mismatch) and free (max_tokens and friends); a thread is append-only with one continue per response id, so retrying a continue is not idempotent and branching is impossible; and the cache_control budget drops to 4 breakpoints, where breakpoints on the create request's system and tools recount on every continue. Also unsupported: Message Batches, token counting, compaction on demand, most context editing, Amazon Bedrock, and any org with HIPAA readiness or Inference hooks turned on. Threads are not ZDR eligible. Full guide: Message Threads — and if you also build on OpenAI or Google, Server-side conversation state across providers, because all three shipped this idea with incompatible durability and retention contracts (and on the other two, storing conversations is the default). (Anthropic release notes · Message threads reference)

  • 🔌 API — The Usage and Cost API you built your chargeback reports on became "legacy" on October 29, 2026. Anthropic's replacement, the Usage and Cost Analytics API (beta, anthropic-beta: analytics-usage-cost-2026-08-24), exposes GET /v1/organizations/analytics/usage and GET /v1/organizations/analytics/cost, and groups spend by up to five dimensions at once — model, workspace, API key, service tier, inference geo, and the identity behind each request. The old /v1/organizations/usage_report/messages and /v1/organizations/cost_report, and the Claude Enterprise Analytics endpoints, are still supported, so nothing breaks today. What it means: this is not a drop-in swap, because three things changed shape at once. The response is rows, not time buckets — each row carries its own starting_at/ending_at, dimensions in a group object and metrics in usage or cost, ranked by size rather than by time, so a naive port plots a bar chart that looks like a time series until you set both time_bucket_width and order_by=time. Freshness regressed on purpose: data used to appear within ~5 minutes and now typically takes 4 hours, up to 24, with values revised until about 7 days after the calendar month ends — so October 1 can still change on November 7, and any cost-spike alert built on this endpoint is not an alert. And amount is a decimal string in cents with six decimal places while currency still reads "USD": "41280.000000" is $412.80, a 100× error that passes code review. Two quieter changes to grep for: an unknown workspace ID, API key, or misspelled model name now matches nothing instead of returning an error, and the default workspace stopped being workspace_id: null and has a real wrkspc_ ID. Upside worth the migration: requests counts on both endpoints, code-execution usage as rows with model: null, a cost_type/token_type split that finally shows how much of the bill is not inference, and per-user Claude Code cost in one query (products[]=claude_code&group_by[]=actor). Full row contract, actor semantics, date-range rounding and the legacy migration table: The Usage & Cost Analytics API.

  • 🔌 API — If you resell Claude or run an AI gateway, one end customer could get your whole organization restricted. User profiles, launched October 20, 2026, fix the blast radius. You register each end customer once with POST /v1/user_profiles, store the uprof_ ID it returns, and send it in the anthropic-user-profile-id header on every request you make for them; a safety enforcement action then lands on that one profile instead of your organization, and the rest of your traffic keeps running. The following day, October 21, Anthropic added enforcement_status and enforcement_actions to the profile object, so you can actually see when one of your customers has been restricted or banned, with a reason (unsupported_region, fraud_or_abuse, high_harm, usage_policy_violation, account_compromise, unspecified) and whether the customer can clear it themselves. Profiles aren't billable. What it means: attribution is preventive and has no retroactive form — a request sent without a profile ID is permanently your own organization's usage, so this is work to do before an incident, not during one. Three traps stand between you and a working monitor. Organization webhooks exist but do not fire: the beta (webhooks-2026-10-07) documents user_profile.enforcement_action_opened and …_resolved, and Anthropic's own page states event delivery isn't live, so a registered endpoint receives nothing and polling is the only mechanism that works today. That polling has its own rule: with the enforcement_status[] filter, the service scans a bounded number of profiles per request, so a page can come back short or empty and still carry a next_page — only a null cursor ends the list, and stopping early is how a monitor silently misses banned customers. And leaving user-profiles-2026-09-04 (or earlier) in anthropic-beta omits both enforcement fields entirely and 400s the filter — the symptom is every customer reading as fine. Also platform-dependent in ways that look like success: Claude Platform on AWS always reports unrestricted with no actions, and Bedrock plus Google-managed Google Cloud only format-check the ID, so a well-formed wrong ID returns 200 and attributes nothing. Full field reference, the four enforcement_status values (the API reference documents a pending the narrative docs omit), the polling loop and the per-platform matrix: User Profiles & Enforcement.

  • 🔌 API — The anthropic-version header moved for the first time since 2023. 2026-10-21 shipped on October 21, 2026 and it is a genuine breaking release. 2023-06-01 had been the only answer for three and a half years; the new version brings four wire-level changes and nine SDK/CLI changes, and the one that matters most is that temperature, top_p and top_k are removed outright — a request that sends any of them returns a 400 on every model, even at the parameter's default value. That is stricter than the per-model deprecation most teams already handled, which only rejected non-default values: code that defensively pinned temperature: 1.0 was previously correct and now always fails. Authentication also moves — the SDK and CLI send your key as Authorization: Bearer instead of X-Api-Key. The Claude API accepts both, so your application won't notice; your gateway or egress proxy will, and the resulting 401 appears to come from your own infrastructure. Two more changes fail silently rather than loudly: an X-Api-Key header used to suppress a credential no longer suppresses anything, and a per-request key override now puts two keys on the wire instead of replacing the client's. Also: document blocks in assistant messages and citations on user-message text blocks now 400 (the second one bites retrieval pipelines that echo back search-result metadata); MessageParam splits into a union of three role types; Text Completions, client-side tool-runner compaction and the ant --api-key flag are gone; and seven Admin/Analytics response fields are renamed, with workspace_id on API keys replaced by scope — a semantic fix, since null used to mean either "Default Workspace" or "all workspaces." What it means: you do not adopt this version by editing a header — you adopt it by upgrading a dependency. SDKs send the version that was current when their major shipped, so an unpinned pip install -U anthropic or npm update that crosses the major boundary flips every one of them on at once. Pin your SDK major in the lockfile, then migrate on purpose. There is no deadline pressure (2023-06-01 is not announced as retiring) and two upgrade paths fail quietly — go install on the old module path keeps installing v1, and a TypeScript platform package left on v0 makes npm resolve a second, older core SDK underneath it. Full triage grep, the per-language SDK version table, the proxy fixes and the decision tree: API Version 2026-10-21.

  • 🗣️ Apps — Claude Duet opened as a research preview on October 21, 2026 — a separate app where Claude works as a proactive agent rather than waiting to be prompted. It is included in Pro and Max plans, US only, by waitlist, on claude.ai and as a standalone iOS and Android app. The shape of it: each morning it sends a short brief on the most important items across your connected apps, then keeps tabs on them and messages you only when something needs your attention. It is built around Claude Opus 5.5, and it draws on the 6,000+ connectors and plugins in the Claude Marketplace — email, accounting, payroll, design, ecommerce. Before any consequential action it shows you exactly what it's about to do and waits for approval, and a few things are off-limits even with your approval, specifically trading securities and moving money between accounts. What it means: the interesting design decision is the polling cadence — Duet checks your connected accounts every few hours, and Anthropic says plainly why: "checking nonstop would use up your plan's limits much faster." That is a useful piece of honesty about the economics of always-on agents, and the same tradeoff you face when you build one. Anthropic also names the current rough edges: it might misread a thread or miscalibrate what's urgent, personal tasks aren't quite as strong as work ones, and it can't yet show you its browser — so you approve actions you can't fully watch it take. Treat it as a monitoring-and-triage agent with a human gate, not an autonomous operator. For the connector model underneath it, see Connectors; for the scheduled-work sibling inside Claude itself, see Cowork & Scheduled Tasks.

  • 🔌 API — OpenTelemetry export went to beta on 14 October 2026: the Claude API and the Claude SDK now emit tracing spans themselves, and they see things your own instrumentation cannot. There are two independent paths. SDK tracing needs no permissions — upgrade the SDK (Python, TypeScript, C#, Go, Java, PHP, Ruby), register a tracer provider before your first call, and every request gets an anthropic.messages.create span of kind CLIENT, plus a span for each tool your tool runner runs. API tracing needs no code — an admin registers a destination in the Console (or via POST /v1/organizations/telemetry_destinations with anthropic-beta: telemetry-destinations-2026-08-11), and Anthropic posts spans to your OTLP endpoint with service.name = claude-platform. The API side is the interesting half: it emits one anthropic.model_request span per model call inside a single API request, a span per server tool or MCP connector tool it ran for you, a span per compaction, and for Managed Agents an anthropic.session.turn span per turn plus anthropic.session.outcome_evaluation spans. Twelve partner platforms have integration guides (Arize, Braintrust, Databricks, Datadog, Grafana Cloud, Honeycomb, Langfuse, LangSmith, New Relic, PostHog, Sentry, Splunk). What it means: turn both on and read one rule first, because the two paths overlap — a request's SDK span and API span share the name anthropic.messages.create, so summing both exactly doubles your token numbers. Tell them apart by span kind (CLIENT vs SERVER). Three more traps worth knowing before you build on it: a traceparent whose sampled flag is off suppresses the request's span and every span below it, so head-sampling in your service silently becomes head-sampling of Anthropic-side telemetry; full-content mode is overridden to metadata-only for destinations if your org has a HIPAA, FERPA or K-12 restriction (SDK spans are unaffected — a very confusing symptom), while zero data retention is compatible with it; and a destination whose deliveries all fail for 24 hours is disabled and needs a manual click to resume, as does one that returns a 3xx or resolves to a non-public IP. Also note that delivery is at-least-once and best-effort, so traces are for debugging and cost attribution, not for billing — the Usage API remains the ledger. Setup for both paths, the full token-counting rule, content limits and truncation order, and the delivery semantics: First-party OpenTelemetry tracing.

  • 🗣️ Apps — Two new artifact templates shipped on October 8, 2026, and three others quietly left beta the same day. Claude Dashboards (beta on Pro, Max, Team and Enterprise) takes a plain-language question, writes a SQL query per chart, and runs it against Amazon Redshift, BigQuery, ClickHouse, Databricks or Snowflake — or a connected app such as Salesforce. Every chart exposes its own query and when its data was last refreshed, and dashboards can be sent onward to Amplitude, Grafana, Hex, Mixpanel, Omni, Perplexity, PostHog or Sigma (Databricks Genie, Looker, monday.com and Tableau announced as coming). Claude Motion (beta on Team and Enterprise only, on by default on Team) turns a report into a short animated explainer — and notably does not use a video-generation model: Claude writes editable code for the text, numbers, shapes, charts and timing, which is why it cannot produce realistic footage or people and why you can change one value without disturbing the rest. Exports as MP4. Meanwhile Claude Docs, Slides and Design left beta and became available on every plan, including Free, on by default — on Enterprise they turned on by default on October 15, 2026. What it means: three things to action. (1) Any note, runbook or guide of yours that says Docs/Slides/Design are "paid, beta" is now wrong. (2) Before you share a dashboard, understand that its queries run with the viewer's own connections — two colleagues can see different numbers, a viewer without access sees an error, and a connector-backed artifact can never have a public link, so a dashboard is an internal instrument rather than a client deliverable. (3) The same release set a deadline: the standalone Claude Design site closes December 14, 2026 — migrate design systems from the Artifacts page, and save anything you need out of standalone chats and comments first, because those are deleted. Full write-up: Claude Dashboards & Claude Motion.

  • 🧠 Models — Claude Haiku 5.5 (claude-haiku-5-5) shipped 7 October 2026, and it changed the shape of Claude pricing, not just the numbers. The specs are a straight generational jump: 1M context (up from Haiku 4.5's 200K), 128K max output (up from 64K, 300K on Batches with a beta header), a June 2026 reliable knowledge cutoff instead of Feb 2025, and the first Haiku with adaptive thinking and the effort parameter (default medium). The headline was the price: $0.10 / $0.50 per MTok against Haiku 4.5's $1 / $5, a 90% cut. What it means: the 90% is not what you will pay, for two compounding reasons. First, Haiku 5.5 is the only current Claude model priced by prompt length — Anthropic's long-context section names it as the explicit exception to "the full 1M window at standard pricing." It has two rate cards split at 100,000 tokens, and crossing that line reprices the entire request — input, output, 5m and 1h cache writes, cache reads, and both batch columns — at 5x. It is a repricing, not an overage: a 100,001-token prompt costs five times a 100,000-token one. Second, it moves to the newer tokenizer, so the same text counts ~30% more tokens than on Haiku 4.5 — which both shrinks the discount and moves the cliff ~23% earlier in terms of actual text (≈55,500 English words, or ≈77,000 Haiku 4.5 tokens). Net: budget ~87% less than Haiku 4.5 below the cliff and ~35% above it; either way it stays 75% under Sonnet 5.5. Migration is not free — five things 400 that Haiku 4.5 accepted (budget_tokens thinking, non-default temperature/top_p/top_k, assistant prefill even with thinking off, computer_20250124 on the Claude API and Google Cloud, and thinking blocks replayed after an edit to earlier turns) — and six more changes return 200 and quietly get worse, starting with an unchanged max_tokens that now stops after a thinking block and returns an empty reply. Two consolations: Haiku 5.5 accepts both thinking: {"type": "disabled"} (at high effort or below) and forced tool_choice, which Opus 5.5 and Sonnet 5.5 both reject — so a deterministic classifier the 5.5 generation broke has a home. Note also that Priority Tier is not supported and there is no server-side fallback on refusals. Haiku 4.5 is now listed among the legacy models, and its earliest-possible retirement — 15 October 2026 — is the nearest floor in the lineup, though the status table still lists it Active with no deprecation announced. Full cost model, worked chunking and cache-trimming examples, and the complete migration checklist: Claude Haiku 5.5: The 100K Price Cliff.

  • 🛠️ Claude Code — Mods grew fast in the first week of October 2026 (v2.1.289–v2.1.292), and three of the additions change how you write one. $.model.complete gained prompt caching (v2.1.292): prompt and system take blocks of text, and cache: true on a block caches the request up to it — so a mod that classifies every prompt stops re-paying for its own instructions each turn. turn.step's result now carries serverToolUses (v2.1.290): the tool calls the API ran itself — the advisor — each with id, name, input, start and end. agent.spawn now also fires for agent-team teammates (v2.1.289) and workflow agents, with their run and index (v2.1.292), so a policy mod can refuse them. Smaller but useful: prompt.autocomplete lets a mod add its own rows to the prompt box's autocomplete list (v2.1.292); tool.check gained agentId and ceiling (v2.1.290); claude plugin validate now lists every hook registered at a gating site with whether it has a .catch, as gatingHooks under --json (v2.1.290); and claude plugin install --marketplace <source> adds the marketplace then installs from it (v2.1.292). What it means: two behaviors also changed under existing code. A hook that calls next(e) and then denies is now reported as failed, by name — for config.set, state.set, env.set and agent.spawn in v2.1.292, and for a prompt.submit hook that drops a prompt in v2.1.290, where it had been ignored silently. If you shipped a mod in that first week, re-read your guards: the rule is now unambiguously decide before you call next. The gatingHooks field makes “does this guard fail open?” a CI assertion rather than a code review. Full event map, the six production gotchas and the audit discipline: Mods: In-Process Extensions.

  • 🧠 Models — Claude Sonnet 5.5 (claude-sonnet-5-5) shipped September 28, 2026 at exactly Sonnet 5's prices — $2 / $10 per MTok, same cache and batch rates, same tokenizer — while Anthropic claims output 30%+ faster and up to 30% less per task. Both are true because the saving is in the token and turn counts, not the rate card: fewer output tokens (thinking included, billed as output) and fewer tool calls per task. Same 1M context and 128K max output; default effort stays high, which is higher than Opus 5.5's medium; the minimum cacheable prompt halves to 512 tokens, so 512–1,023-token system prompts become cacheable with no code change. Five breaking changes return 400 on a Sonnet 5 codebase: thinking: {"type": "disabled"} is replaced by between_tools (accepted only at high effort or below, and it rejects display, budget_tokens and block_binding), forced tool_choice is gone, thinking blocks are bound to the model, the conversation prefix and the producing account, computer_20251124 is rejected on the Claude API and Google Cloud (still accepted on Bedrock), and Opus 4.8 / Opus 4.7 / Sonnet 5 are rejected as advisor-tool advisors. A sixth returns 200: text between tool calls arrives in progress-update thinking blocks, empty at the default display, so a UI that renders only text blocks goes silent mid-task. What it means: the benchmark story is not "cheaper and worse" — Sonnet 5.5 beats Opus 5.5 on Terminal-Bench 4.0 (70.6% vs 66.4%) and ties it on knowledge-work Elo, while trailing by ~8 points on FrontierCode 1.1, so the 2× price buys depth on hard open-ended work and little else. Before you swap the ID, note that carrying your Sonnet 5 effort setting across can cancel the whole saving: levels are recalibrated and Anthropic's own starting point for agentic coding is medium, not the high default. Full migration walkthrough, the thinking-binding matrix and the max-effort trick that cut session cost by a third: Claude Sonnet 5.5: The Field Guide.

  • 🔌 API — Cache diagnostics went GA on September 23, 2026, and the cache-diagnosis-2026-04-07 beta header is no longer required. Add a diagnostics object to a Messages request carrying the previous response's id as previous_message_id, and the API compares the two requests and names the first point where the prompt prefix diverged — model_changed, system_changed, tools_changed or messages_changed — along with a cache_missed_input_tokens estimate of how much cacheable prefix you lost. Two further types, previous_message_not_found and unavailable, mean no comparison was produced and are not evidence your prompt changed. What it means: "why is cache_read_input_tokens zero?" stops being a byte-diffing exercise. More usefully, pairing diagnostics with usage finally separates a prefix bug (a *_changed type) from an expired cache entry (diagnostics null, cache reads zero) — two failures that used to look identical and sent teams chasing the wrong one. Walkthrough with the decision matrix and all six reason types: Cache Diagnostics.

  • 🧠 Models — Claude Opus 5.5 (claude-opus-5-5) shipped September 22, 2026 at $4 / $20 per MTok — 20% under Opus 5, with cache reads at $0.20 / MTok (a 5% tier, not the usual 10%). Same 1M context and 128K max output, adaptive thinking always on, and the default effort drops from high to medium. Anthropic positions it at Claude Fable 5.1-level performance on most work while costing 40% less to run than Opus 5. Four breaking changes return 400 on an Opus 5 codebase: thinking can no longer be disabled, forced tool_choice is gone, thinking blocks are bound to the model and conversation that produced them, and computer_20251124 is rejected on the Claude API and Google Cloud. A fifth returns 200 and breaks nothing loudly: text between tool calls now comes back inside thinking blocks whose text is empty at the default display setting — so a UI that streams those as progress updates goes silent mid-task. What it means: this is a cheaper, faster Opus, but it is not a drop-in ID swap. Work the response-shape change first (it fails silently), then the four 400s. Full migration walkthrough with before/after code: Claude Opus 5.5: The Field Guide.

  • 🛠️ Claude Code — Projects were rebuilt as an orchestration layer on September 17, 2026, in beta. A Project is no longer a folder of files and chats: it is now "threads that do the work and a coordinator that directs them." You brief the coordinator in the main project chat with an outcome; it scopes the request, delegates across parallel threads, reviews the outputs, and assembles the result. The key detail is what a thread actually is — a full Claude Code cloud session working on its own branch and copy of the repo, with its own context window, able to open pull requests, run tests, and spawn its own subagents, loops, and workflows. All threads share one memory pool and contribute to a library of files and artifacts. What it means: two consequences follow directly. Usage limits arrive faster, because N threads is roughly N concurrent sessions rather than one session split N ways — and thread model/effort is set separately from the coordinator's, which makes it the cost lever that matters. And the launch eligibility rule is counter-intuitive: beta went to select Pro and Max subscribers who use cloud sessions and have no existing projects on web or desktop, so long-time Projects users were the least likely to see it first. Threads are cloud-only for now. Architecture, the four-way comparison against subagents, worktrees and inter-session messaging, and the cost model: Projects: The Coordinator & Parallel Threads.

  • 🗣️ Apps — Claude Cowork, chat and Claude Design became one Claude on September 16, 2026, and two new document tools shipped with the merge. There is no longer a mode to pick: "Ask Claude for what you need, and it can decide which tool to use." Everything carries over — existing Cowork tasks, projects, connectors, skills, artifacts and files all open as before. What's new is Claude Docs (living, multi-tab rich-text documents you, Claude and your colleagues edit at the same time, with Claude leaving its own inline comments as it drafts and making edits when you @Claude a comment; exports to Word, PDF, Markdown and Google Docs) and Claude Slides (decks built from your notes or the conversation, presentable without leaving Claude, exporting to PowerPoint and PDF). Both, plus Claude Design, are templates in beta on paid plans — on by default on Pro, Max and Team, off on Enterprise until an owner enables each one. Rollout is staged from Pro and Max, with Enterprise given at least 30 days' notice. Four things moved: global instructions → Settings → General; the web-search toggle is removed, not relocated (search is automatic now); research → /deep-research or the + button; files → Settings → Storage folder. What it means: two practical shifts. First, the cost signal moved from the door to the prompt — opening Cowork used to be the moment you knew you were starting expensive work, and now a casually-phrased request in the same box can trigger a long agentic run, so say explicitly when you want a cheap answer. Second, regulated teams should stop here: Claude Docs is unavailable under CMEK, ZDR and HIPAA configurations, and doc activity is not in the Compliance API yet. Also missing today: version history, a comment-only access level, external sharing on Team/Enterprise, conversation branching, "Add from GitHub", and search across older Cowork tasks; mobile is view-only. Full field guide with the relocation table, the sharing matrix, and the eight limits: One Claude: The Merge, Claude Docs & Claude Slides.

  • 🔌 API — The Messages API can compact a conversation on demand since September 14, 2026, in beta behind the compact-2026-09-04 header. Send the top-level compaction parameter with your history and the API returns, in place of a reply, a single signed compaction block holding a readable summary plus a signature — with stop_reason: "compaction". On later requests you send that block first, delete the messages it replaced, and Claude sees the summary where they were. You choose the moment, you can keep recent turns word for word (there is no parameter for this — you just leave those turns out of the compaction request), and the call can run in the background while the conversation continues. What it means: this is the first context-shrinking primitive that compresses instead of deleting — context editing clears old tool results, compaction keeps the narrative. Three traps are worth knowing before you ship it. The top-level input_tokens and output_tokens come back zero because no reply was generated — the real cost is in usage.iterations, so a dashboard that sums the top-level fields will report compaction as free. A failed summarization is a 200 with empty content across five different stop reasons, so branch on stop_reason, never on status. And both ways of botching the swap — leaving summarized messages after the block, or omitting the block — raise no error at all: the first silently resends the history you paid to summarize, the second silently drops the summary. Also note that images, documents, container_upload blocks, and fetched URLs do not survive a summary. Full guide with the swap rules, the four flavors, and the error table: Conversation Compaction.

  • 🧠 Models (cross-AI) — DeepSeek shipped V4.1-Flash on September 10, 2026, API and MIT-licensed weights the same day. Served as deepseek-flash: a 552B MoE on a new "Causal Encoder-Decoder" architecture with Compressed Sparse Attention 2, 8B active parameters at prefill / 16B at decode, native vision, a 1M-token context, 384K max output, and a KV cache of 890 bytes per token (about a quarter of V4-Flash's HBM footprint, an eighth of its SSD storage, 72-hour global cache lifetime). Reasoning is a 1–100 integer dial: DeepSeek's own DeepSWE v1.1 ablation goes from 66.0% at effort 25 to 74.2% at 100 for ~2.5× the output tokens, and every launch benchmark was run at 100. That 74.2 sits a fifth of a point above Claude Opus 5 (74.0); Terminal-Bench 4.0 is 31.2 vs Opus 5's 51.8. Pricing per 1M tokens, peak (01:00–04:00 and 06:00–10:00 UTC weekdays): cache hit $0.006, cache miss $0.30, output $1.20; off-peak exactly half. Two silent routing changes: deepseek-v4-flash and deepseek-v4-flash-vision-exp route to V4.1-Flash from September 10, and every deepseek-v4-pro call routes to V4.1-Flash at Flash rates from 04:00 UTC September 14 until V4.1-Pro launches. What it means: repository-shaped coding work (read a lot, edit a little) is now at Opus parity for an order of magnitude less; many-short-turn terminal agents are not. If you pinned Pro, your model changed on Sunday, so re-run evals. DeepSeek itself flags long-context sparse retrieval as not fully characterized. Full field guide with the six-cell price table, serving stacks, and the effort-dial protocol: DeepSeek-V4.1-Flash.

  • 🧠 Models (cross-AI) — Google shipped Gemini 3.8 Flash on September 2, 2026, twenty days after 3.7 Flash — the third Flash in six weeks. Model ID gemini-3.8-flash, same 1M context and 64K output, thinking_level low / medium (default) / high, and the same $0.75 / $3.75 per MTok introductory price through December 31, 2026 ($1.50 / $7.50 from January 1, 2027). Google's table: DeepSWE v1.1 73.7 (up 8.4 from 65.3; Claude Opus 5 74.0), Terminal-bench 2.1 89.4 (Opus 5 89.1), HLE-Verified 54.9, and a lead over every column including Opus 5 on the finance, legal, and biology agent benchmarks; but Terminal-bench 4.0 is 19.1 vs Opus 5's 51.8 and OSWorld-2.0 59.0 vs 75.4. The catch Google states in its own words: the model "works harder," executing extra reasoning steps and calling tools iteratively, which independent reads put at ~30% more output tokens per task and ~40% more cost per task than 3.7 Flash at the identical sticker. Knowledge cutoff March 2026, but some domains limited to January 2025. A Gemini 3.8 Flash Cyber variant (CWE-Bench 47.2% pass@1, 2.6× more correct Chrome patches than the best commercial models) replaces 3.5 Flash Cyber and is application-only through the new Fairwind Program. What it means: a Sonnet-priced model now at Opus parity on repository-scale bug fixing and ahead on domain agents; interactive terminal and computer-use work stays on Claude. Budget on task cost, not token price, and start thinking_level at low. Migration list, full comparison table, and the Claude-port gotchas that have not changed since 3.6: Gemini 3.8 Flash for Claude users.

  • 🛠️ Claude Code — v2.1.271 (September 14) closed a run of context-budget knobs, and this site now has the audit page to go with them. New in 2.1.271: omitClaudeMd in subagent frontmatter and --agents JSON launches a subagent without the user, project, and local CLAUDE.md files (managed policy files still load); per-command allowed_domains on Bash, PowerShell, and Monitor in auto mode with sandboxing; --accept-command <sha256> on claude plugin install / update to pin a plugin's install command; modelPricing now accepts a multiplier above 1 (up to 10) for contracted markups; fast mode in Claude Code Remote sessions; Monitor watches always get a deadline (at most 30 minutes); and /ultrareview --post posts the PR comment as soon as findings arrive. Earlier in the fortnight: bashOutputMaxChars and taskOutputMaxChars (2.1.261) cap what a command or background task returns inline (defaults ~30,000 and 32,000 characters, range 4,000–128,000), --append-subagent-system-prompt-file (2.1.261), maxEffortLevel (2.1.267), and /skill-doctor (2.1.252). What it means: the six places Claude Code spends context before you type — skill listing (capped at 1% of the window), CLAUDE.md, auto memory, subagent descriptions (15,000-token warning), tool output, and the compaction re-attach budget (25,000 tokens) — each now have a documented setting. Run the checklist once per project: Context budget audit.

  • 🧠 Models — Claude Fable 5.1 (claude-fable-5-1) and Claude Mythos 5.1 (claude-mythos-5-1) shipped September 1, 2026. Same Mythos-class tier above Opus, same 1M context, 128K output, $10 / $50 per MTok, same tokenizer and always-on adaptive thinking as Fable 5, but cache reads dropped from $1.00 to $0.25 per MTok (0.025× base input instead of 0.1×), which is where Anthropic's "about 25% cheaper on typical workloads, up to 45% on highly agentic ones" comes from. Three changes are breaking: tool_choice of type any or tool now returns 400 (keep auto, set strict: true, and name the tool in the prompt); thinking blocks are readable only by Fable 5.1 or newer, so routing a conversation down to Opus 5 silently drops the reasoning unless you send the thinking-binding-controls-2026-08-01 header; and editing anything before a thinking block (system prompt, tools, earlier turns) invalidates later blocks, enforced as a 400 for accounts created on or after August 31, 2026. Five are additive, all beta: per-message effort without a cache miss (mid-conversation-output-config-2026-07-01), turn-scoped system messages via clear_at: "next_user_message" (mid-conversation-system-clear-at-2026-08-21), thinking.display: "updates" to surface progress notes between tool calls (thinking-display-updates-2026-08-18), the cheaper cache read, and a statistical text watermark plus C2PA credentials on generated files. Anthropic's positioning is unchanged: start with Opus 5; use Fable 5.1 when Opus 5 at higher effort still falls short. Now the Claude Code default Fable model (v2.1.257); not on Priority Tier; 30-day retention required. What it means: if you pin claude-fable-5, grep for forced tool_choice and for any code that edits conversation history before flipping the ID. Full migration guide with the seven documented behavior shifts (fewer parallel tool calls, less narration, whole-file rewrites) and Anthropic's launch benchmark table: Claude Fable 5.1: What Changed and How to Migrate.

  • 🧠 Models (cross-AI) — OpenAI's GPT-6 Astra (gpt-6-astra) went GA on September 4, 2026 after a September 3 limited release, ending the five-week "preview with no price" period. Confirmed specs: 1,050,000-token context (922K max input), 128K output, April 30, 2026 cutoff, $10 / $50 per MTok, cached input $1.00, Chat Completions + Responses + Batch (tools need Responses; no Realtime, Assistants, or fine-tuning), reasoning effort low through max, and the GPT-5.6-style 272K cliff (cross it and the whole request is re-priced 2× input / 1.5× output). Independent numbers from Artificial Analysis (September 9): tied with Claude Fable 5.1 at 53 on the Intelligence Index and 62 on the Coding Agent Index, at roughly a third of the output tokens and 40% less cost per task; ahead on Terminal-Bench 4.0 (59% vs 52%); behind GPT-5.6 Sol on GDPval-AA v2. Safety: first OpenAI model at the Critical cyber tier, exploit capability gated behind a vetted-access program, and a system card that says chain-of-thought monitorability decreased versus Sol because the "recurrent depth" architecture moves reasoning inside the model. What it means: Astra and Fable 5.1 are now peers on agentic coding at the same list price, but the bills diverge on long loops (Astra's cache reads are 4× Fable 5.1's) and the benchmarks were run at max effort while the API defaults lower. Full comparison, the four API gotchas, and a per-workload decision table: GPT-6 Astra: The Field Guide for Claude Users.

  • 🛠️ Claude Code — The first two weeks of September (v2.1.257–v2.1.270) shipped a run of practical tooling. /skill-doctor (v2.1.252+, September 4) reports what each loaded skill costs in context per turn, how often it's invoked, and flags never-used skills with instructions for where to turn them off; prune the highest-cost unused ones first (not available over Remote Control). claude plugin eval <plugin> (v2.1.268+, September 11) runs a plugin's eval suite, JSON cases in evals/ or the experimental.evals manifest field, and produces scored, reproducible JSON + HTML reports; claude plugin validate --json --strict turns warnings into CI failures. /diff (v2.1.260) opens a side-by-side panel of uncommitted changes as Claude edits in fullscreen mode. /cost and the status line's prompt_cache field now name the likely cause of a cache miss (tool definitions or system prompt changed, idle past the TTL). For fleets: maxEffortLevel (v2.1.267) caps effort per model on every provider; --permission-prompts none (v2.1.259) auto-denies anything that would prompt on unattended headless hosts; managedMcpServers lets an org push HTTP/SSE MCP servers to every user; bashEditDiffEnabled appends a diff of files a Bash command changed to the tool result; CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS (1–256) raises the Workflow tool's fan-out cap; /output-style [name] now works in headless and Remote Control sessions. What it means: /skill-doctor is the fastest context-budget win available today; run it once per project and delete what it flags. The plugin eval command is the first native way to regression-test a plugin before publishing.

  • 🛠️ Claude Code — A fifth built-in output style, Concise, shipped in v2.1.237 (Week 34, Aug 17–21 2026) — Claude leads with the result, skips preamble and narration, and keeps responses short by default, while doing the engineering work as thoroughly as Default. Ask for detail and it answers in full; error reports, security warnings, and destructive-action confirmations stay complete regardless — Concise never quiets the things you must not miss. Same window also landed force-for-plugin in output-style frontmatter (a plugin can auto-apply its style and override the user's outputStyle setting — use sparingly), and made nested project-level styles resolve closest-directory-wins so a package inside a monorepo can override the workspace default. Styles still don't cross into subagents (each subagent runs its own system prompt), but /fork is the one exception — it copies the parent's full prompt and therefore keeps the style. What it means: if you kept re-prompting for "just the result, no preamble" every session, drop the ceremony and set "outputStyle": "Concise" in ~/.claude/settings.json. Full rewrite with the five-style comparison table, subagent-scope rules, the frontmatter field reference, and a quiz covering all of it: Output Styles.

  • 🔌 API — Anthropic made Claude Sonnet 5's introductory pricing permanent on August 10–11, 2026 — the $2 / $10 per MTok launch price was scheduled to jump to $3 / $15 on September 1, and that increase will not happen. Same model ID (claude-sonnet-5), same 1M context, same 128k output — just no price hike. What it means: budgets, evals, and cost forecasts you built assuming a September price jump can stand down. If you deferred a Sonnet-5 migration because of the impending increase, there's no longer a September cliff to plan around. The Current Models & Pricing page keeps pointing to Anthropic's official pricing page as authoritative — a stale price on our site is worse than none.

  • 🔌 API (cross-AI) — Cloudflare shipped Kitesurf on August 6, 2026 — a stateless, agent-first browser runtime that runs entirely in V8 isolates on Workers, discarding the Chromium engine that has underpinned nearly every headless browser tool for the past decade. Cloudflare's own benchmarks: 3.1× less CPU and 4.7× less memory than Chromium on screenshots, 3.8× less CPU and 7.0× less memory on HTML extraction — traded for about 1.7–1.8× more wall-clock time per task (Boa interprets JS instead of V8-JIT-ing it). Kitesurf speaks the Chrome DevTools Protocol, so Puppeteer, Playwright, chrome-remote-interface, and chrome-devtools-mcp connect unchanged via a single --wsEndpoint swap. Rendering uses Firefox's CSS engine (Stylo) and the Rust Blitz engine — that's how a 12-week-old project already passes 235,000+ Web Platform Test subtests. Free public beta today; open-source release planned. Four things it cannot do yet: video, WebGL, TLS-fingerprint bot-challenge negotiation, persistent authenticated sessions. What it means: the browser stack for agents and the browser stack for humans are diverging into two products. If you run any bursty, short, HTML-shaped browsing workload on per-CPU-second billing, Kitesurf changes the math — see the full practical read at Cloudflare Kitesurf: The First Browser Runtime Built for AI Agents.

  • 🛠️ Claude Code — Auto mode becomes the default permission mode on August 14, 2026 for new sessions on Pro, Max, and Team plans (Week 32 digest, v2.1.220–v2.1.224). Instead of stopping to ask on every non-read action, Claude Code proceeds unless a separate classifier judges the action irreversible, destructive, or aimed outside your environment (curl | bash, force pushes, prod deploys, rm -rf on unresolved variables, transcript tampering, destructive git that discards uncommitted work, secret exfiltration). Anthropic's own justification: in a study of over 1,000 paid users, the auto-mode classifier caught 89% of harmful actions vs 13.6% for manual review — because habituated users approved about 97% of prompts without reading them. Two carve-outs preserve intent: if you already set permissions.defaultMode in your user settings, it stays put unless you accept a one-time in-app switch prompt; if your organization manages the default (Team/Enterprise managed settings), nothing changes automatically. Related change already in effect: classifier calls made by auto mode no longer count against your usage limits. What it means: if you want to keep the old prompting behavior on Aug 14, set "permissions": {"defaultMode": "default"} in ~/.claude/settings.json before then (or "auto" to opt in early). The updated deep-dive — what auto mode blocks, how to opt in / opt out, and how it composes with bypassPermissions and hardened autonomous runs — is at Permissions & Permission Modes.

  • 🛠️ Claude Code — Cross-session messaging shipped in v2.1.224 (Week 32, Aug 3–7, 2026): on macOS and Linux, two open Claude Code sessions on the same machine can now message each other without you being the copy-paste bridge. Claude discovers other sessions with the ListAgents tool and sends with SendMessage, either when you ask ("tell the session working on the payments API that users.name is now users.display_name") or on its own after a change in one session affects what another is doing. The recipient shows a Message from row you expand with Ctrl+O; /list-agents prints the reachable set. What travels is text Claude writes for the other session — not your conversation history or files. What it means: this is Anthropic's first native answer to the interdependent-project pain that community projects (file inbox, WebSocket bus, MCP channels) have been solving for months — see the still-relevant trade-off matrix at Inter-Session Messaging if you need multi-machine, richer artifacts, or debuggable transport.

  • 🧠 Models — Claude Opus 4.1 (claude-opus-4-1-20250805) was retired on August 5, 2026 as scheduled — API calls to that ID now return an error. Recommended replacement is claude-opus-4-8 (or straight to claude-opus-5). What it means: if anything in your codebase, CI, gateway config, .env, or eval harness still pins the Opus 4.1 ID, it's failing right now — grep for claude-opus-4-1 and flip it. The Deprecation & Migration Watch tracks the current retirement schedule; see the Opus 5 field guide for the contract changes to watch when jumping straight to the current flagship (adaptive thinking on by default, sampling knobs return 400, tokenizer counts ~30% more tokens).

  • 🛠️ Claude Code — Sandbox credential masking got teeth across three August releases (v2.1.221 on August 4, v2.1.223 on August 6, v2.1.224 on August 7) — the sandbox proxy can now let gh, npm, aws, and any HTTP client authenticate without the sandboxed command ever holding the real secret. Environment variables (v2.1.199+) and files (v2.1.221+) with "mode": "mask" show the sandboxed process a per-session sentinel; the proxy substitutes the real value on outbound requests to hosts you allow. v2.1.224 landed the meaningful additions: extract to mask one field inside a structured value (e.g. the password inside DATABASE_URL), decode: "jwt" with maskClaims to swap in a structurally valid fake JWT so in-sandbox decoders keep working, and credentials.awsPairs + credentials.sigv4 so the proxy can re-sign SigV4 requests when your AWS credentials live in non-standard variable names. Two gotchas that catch every first integration: network.tlsTerminate is mandatory (without it the sentinel goes over the wire and auth fails), and mask / tlsTerminate / awsPairs / sigv4 are silently ignored from a repo's .claude/settings.json — they only work from user, managed, or --settings scopes (a repo you cloned can't order the proxy to forward your real token). Also that week: VSCode Focus view (Ctrl+Alt+F, v2.1.221) hides tool activity behind an expandable per-turn summary, archive plugin source (v2.1.224) installs plugins from a zip over HTTPS with optional SHA-256 pinning (no git/npm needed), and the 200-subagent-per-session spawn cap was removed (v2.1.224). What it means: the full practitioner's guide — mask vs deny, all four modes with copy-paste JSON, the Linux/WSL vs macOS matrix, the settings-source rule, and a recommended user-settings starter — is at Sandbox Credential Masking: keep tokens working, keep them secret.

  • 🛠️ Claude Code — Self-hosted environments shipped August 7, 2026 in beta (Claude Code v2.1.224) on Team and Enterprise plans — a first-party way to execute Claude Code cloud sessions (web, mobile, desktop, claude --cloud, scheduled routines) on your own hosts while orchestration and inference stay on api.anthropic.com. Three moving parts, same shape as GitHub Actions: an environment (a named destination created on the Cloud environments admin page, ID ccpool_...), one or more runners (long-lived claude self-hosted-runner processes on your Linux or macOS hosts), and sessions (spawned child claude processes that clone the repo and stream events back). Every connection is outbound HTTPS — Anthropic never opens a port into your network. The operational surprise: a runner locks to the first user that lands on it and only serves that user until it drains, so minimum fleet size = concurrent active users, not concurrent sessions. Not available under ZDR; inference can't be routed off Anthropic (no Bedrock, Vertex, Foundry, or LLM gateway); GitHub-only checkouts today; Claude Tag, Claude Security, and Code Review sessions don't route yet. What it means: the full practitioner guide — the four-command quickstart, the --drain-grace-sec / --retire-at lifecycle, the network shape, the production checklist, and the six gotchas (including the show-once environment secret and the 5-minute clock-skew auth failure) — is at Self-Hosted Environments: run cloud sessions on your own boxes.

  • 🔌 API — Managed Agents got four upgrades on August 7, 2026 — the headline is session budgets, a hard dollar cap you set at session creation. Sessions pause with stop_reason: "budget_reached" when their consumed list cost (public list rates, not your contracted rate) reaches the cap; raise the cap to resume, or set budget: null to remove it (one-way). Amounts are whole US cents as strings ("2500" = $25.00; "25.00" is rejected). Deployments accept the same object and copy it onto each run, so a $20 daily cron budgets $20 per run, not $20 per month. The one gotcha to size around: enforcement is between requests, so a $0.50-capped session can pause at $0.53 (bounded to one request per thread). Same release: advisors as a roster entry ({"type": "advisor", "model": "..."}, one per roster; runs as an invisible anthropic.advisor thread the primary can consult mid-turn; the coordinator's list_agents and send_to_agent can't see it) — the roster form of the same advisor server tool. Also: inference_geo on the model config or as a session override for data residency, and skills auto-discovered from a mounted GitHub repo — any file in the repo's root .claude/skills/ is available to the session at start, no separate registration. What it means: the full session-budget deep-dive — the four-step event sequence at the cap, the "raise by usage.list_cost + 1 cent, never by old max_list_cost" rule, the multiagent shared-cap semantics, and the ops checklist — is at Managed Agents Session Budgets.

  • 🔌 API — Inference Hooks shipped August 5, 2026 in beta for Claude Enterprise — a first-party, HTTPS webhook (not a WebSocket, despite some coverage) that lets your DLP or in-house AI security server allow-or-deny every governed prompt on claude.ai, Claude Code, and Cowork before the model sees it. One config covers all three surfaces. Every request is signed per Standard Webhooks (HMAC-SHA256 over {webhook-id}.{webhook-timestamp}.{raw body} with your whsec_ secret), the verdict is a small JSON object ({"action": "allow"} or {"action": "deny", "deny_reason": "..."} — deliberately no redact today), and the transcript your server sees is what the user sees (text, tool calls, extracted attachment text) — never system prompts, hidden reasoning, or raw file bytes. What it means: the biggest ops levers are the verdict timeout (1–10 000 ms, 5 s default), failure handling (block vs allow uninspected), and the circuit breaker that stops enforcement on sustained failures — get the deep-dive with the two signing bugs that catch every first integration and the shadow → percentage → role-exclusion → enforce rollout playbook at Inference Hooks: inline DLP for Claude Enterprise.

  • 🔌 API (cross-AI) — MCP Apps, the first official Model Context Protocol extension, is now covered in depth on AILmanac. Finalized January 26, 2026 and folded into the 2026-07-28 stateless core spec, MCP Apps lets a server ship an HTML UI that any MCP client renders in a sandboxed iframe, with the iframe speaking JSON-RPC 2.0 over postMessage back to the host. Extension identifier io.modelcontextprotocol/ui, MIME text/html;profile=mcp-app, resources at ui://<server>/<name>, tools link via _meta.ui.resourceUri. Default CSP is connect-src 'none' — a UI cannot fetch anywhere until the resource declares connectDomains. What it means: every UI-initiated write is still a normal tool call the host mediates — Apps can render and propose, they cannot silently execute. The full deep-dive on when it beats a plain result, the wire shapes, and the security model: MCP Apps: Interactive UIs Inside a Tool Call.

  • 🗣️ Apps — Claude Cowork now runs on web + mobile with scheduled tasks — launched July 7, 2026 (Max first, other paid plans rolling in over the following weeks). The architectural shift: Cowork sessions now execute on Anthropic's servers, not your machine, so scheduled tasks run on their cadence with the laptop closed and no device online. Frequency options are hourly / daily / weekdays / weekly / manual (no cron), each run spawns a fresh session with your connectors + skills + plugins, and approval prompts get pushed to your phone mid-run. Local file / browser / computer use stay desktop-only — audit any scheduled prompt for local-machine actions or it'll silently skip them. What it means: the practical playbook (capability-by-surface matrix, the Dispatch-vs-Scheduled-vs-Interactive distinction, and the four gotchas that break silent runs — including OAuth drift and the "if I'm asleep" timeout hole) is at Cowork Scheduled Tasks: Agents That Run With No Device On.

  • 🧠 Models (cross-AI) — OpenAI previewed its "next major model" Astra on August 1, 2026 — not with a keynote, but by pushing ten Lean-4 formalized proofs of previously unsolved problems (sphere packing, Connes rigidity, non-sofic groups, quantum parallel repetition, Ramsey lower bounds, etc.) to openai/ten-proofs. OpenAI described Astra as a multi-agent, long-horizon system that "coordinates multiple agents working together on long-running tasks over hours or days." What it means: there is no API, no pricing, no ChatGPT surface, and no release date — Astra is internal-only and heading into the new U.S. federal review process. The widely-quoted "$2,000" figure is the token cost at Sol's API rates, not Astra's price. Your Claude vs GPT-5.6 vs Gemini decision this month does not change; keep shipping. Full "confirmed vs unknown" breakdown, the ten problems, and a should-I-wait rule of thumb: OpenAI Astra: The Preview Field Note.

  • 🔌 API — Enterprise user-management endpoints entered beta on July 13, 2026 — the Admin API's members and invites endpoints are now callable on Claude Enterprise organizations (in addition to Console), and a new set of RBAC group and custom-role endpoints ships alongside them. Groups and custom-role routes require anthropic-beta: ce-user-management-2026-07-13 and DROP the anthropic-version header; members and invites take neither. Scopes are granular (read:members, write:members, read:rbac_groups, write:rbac_groups, read:org_audit). What it means: you can now automate offboarding, quarterly group audits, and JIT hire onboarding entirely from CI — see the full playbook and the three gotchas at The Admin API: automate your Claude org.

  • 🔌 API — Managed Agents Memory Stores entered public beta on July 22, 2026 — a first-party, server-side persistent-memory primitive for Managed Agents. Stores mount into the session sandbox at /mnt/memory/<slug>/ and the agent reads/writes them with its standard file tools. Every write creates an immutable memory version (30-day retention minimum), you can redact history for compliance, and content_sha256 preconditions give you optimistic concurrency. Limits: 8 stores per session, 2,000 memories per store, 100 kB per memory. What it means: the biggest header gotcha — memory-store endpoints use agent-memory-2026-07-22; session endpoints (including attaching a store) still use managed-agents-2026-04-01, and sending both on the same request returns 400. Full walkthrough: Managed Agents Memory Stores.

  • 🧠 Models — Claude Opus 5 (claude-opus-5) shipped July 24, 2026 — Anthropic's fourth model in two months. Same $5 in / $25 out per MTok pricing as Opus 4.8, same 1M context and 128k output, but materially better numbers: 44.4% on Frontier-Bench v0.1 (vs Opus 4.8's 18.7%), 96.0% on SWE-bench Verified, 30.16% on ARC-AGI-3. Now the default on Claude Max and strongest available on Claude Pro. Two contract changes will break naive migrations: adaptive thinking is on by default and shares your max_tokens budget, and thinking: {"type": "disabled"} now returns 400 at the new xhigh or max effort tiers. What it means: if you pin claude-opus-4-8, read Claude Opus 5: The Field Guide before flipping the ID, and plan the Opus 4.1 → Opus 5 migration before the 5 August 2026 retirement.

  • 🛠️ Claude Code — Screen reader mode shipped July 14, 2026. Turn it on with claude --ax-screen-reader, CLAUDE_AX_SCREEN_READER=1, or "axScreenReader": true in settings: it plain-texts the transcript, hides decorative glyphs, flattens nested tables into Header: value. lines, and announces permission-mode changes aloud when you cycle with Shift+Tab. The same release added vimInsertModeRemaps (map jj → Escape) and mouse-click support in fullscreen menus. What it means: the CLI is now usable with assistive tech and lower-strain input — see Claude Code Accessibility.

  • 🛠️ Claude Code — In-app browser on Desktop (Week 28, July 6–10, 2026): Claude Code on desktop gets a built-in browser, so Claude can pull up docs, designs, or any site and interact with pages the way it already does with local dev-server previews. Also that week: /doctor (alias /checkup) is a full setup checkup that diagnoses and can fix issues, and auto mode now blocks transcript tampering and asks before rm -rf on unresolved variables. What it means: Claude can verify against real web pages without leaving the session, and setup problems get a one-command diagnosis.

  • 🧠 Models — Claude Sonnet 5 shipped June 30, 2026 and is now the default model in Claude Code, with a native 1M-token context window and introductory pricing through August 31, 2026. It's the new balanced "start here" Sonnet tier, superseding Claude Sonnet 4.6 (now a legacy model). What it means: if you pin a model, migrate to claude-sonnet-5 — but read Claude Sonnet 5: The Field Guide first, because non-default temperature/top_p/top_k now returns 400, manual extended thinking returns 400, adaptive thinking is on by default, and the new tokenizer produces ~30% more tokens for the same text. Also check the Current Models & Pricing table for exact IDs and live pricing before relying on a number from a blog post.

  • 🛠️ Claude Code — Dynamic workflows are generally available: ask for one (or set /effort ultracode) and Claude writes a JavaScript script that orchestrates tens to hundreds of subagents in the background — for codebase-wide audits, large migrations, and cross-checked research. Run /deep-research to see the bundled one, or /workflows to watch runs. What it means: you can now take on fleet-scale tasks one conversation could never coordinate, with the orchestration saved as a rerunnable command. See Dynamic Workflows & ultracode.

  • 🧠 Models — A new top-tier model, Claude Fable 5 (claude-fable-5) and its Glasswing-only sibling Mythos 5 (claude-mythos-5) shipped June 9, 2026 on Claude API, Amazon Bedrock, Claude Platform on AWS, Google Cloud and Microsoft Foundry — Anthropic's first "Mythos-class" models, sitting above Opus. They share a 1M-token context, up to 128K output, and $10 / $50 per MTok pricing. What it means: Fable 5 is NOT a drop-in for Opus 4.8 — it refuses in-band as HTTP 200 with stop_reason: "refusal", adaptive thinking is the only mode, raw chain-of-thought is never returned, and Anthropic added a new fallbacks parameter + SDK middleware + fallback-credit billing specifically for retries on Opus 4.8. It also carries mandatory 30-day retention (no ZDR). See the full field guide — Claude Fable 5 & Mythos 5: The Flagship Field Guide.

  • 🛠️ Claude Code — Subagents can now spawn their own subagents (up to 5 levels deep), and /code-review --fix applies review findings to your working tree. What it means: delegation composes deeper, and review can close the loop instead of just reporting. Cross-check the official changelog for exact behavior.

  • 🔌 API — Capabilities like structured output, extended thinking, and prompt caching evolve. What it means: re-check the API section before relying on exact parameters.

Want the firehose?​

This is a digest, not a complete log. For everything:

Next​