The March 2026 Anthropic Instability:
A Cross‑Surface Analysis of the 4.6 Rollout
Embedded Files
Overview
In late March 2026, I experienced a sudden and dramatic spike in usage consumption while working with Claude — a pattern that, at the time, looked like runaway metering. My first instinct wasn’t to assume a bug: I checked my logs, compared behavior across surfaces, and looked for corroborating reports. What I found was a much larger pattern.
Between March 17 and March 23, users across all Anthropic services — Claude.ai, Claude Code, the Claude API, and Cowork — reported the same symptoms I was seeing:
runaway usage
session drift
cache failures
long‑session collapse
usage meters advancing while idle
purchased credits evaporating far faster than expected
At first, most public discussion focused almost exclusively on Claude Code. But when I mapped the reports against Anthropic’s own rollout timeline for the 4.6 model generation, it became clear that the issue was broader. This wasn’t a single product malfunctioning. It was a shared backend under stress during a period of rapid evolution.
Naturally, I investigated further.
1. Anthropic’s Products Share a Common Backend
Anthropic’s own documentation makes this explicit:
Claude.ai, the Claude API, Claude Code, and Cowork are distinct interfaces built on top of the same underlying model backend.
The Sonnet 4.6 System Card describes Computer Use as embedded directly into the foundation model.
Agent Skills work identically across all products.
The Enterprise tier bundles all services under a single seat because they share the same system logic.
The March 31 source‑code exposure (“Kairos leak”) briefly revealed Claude Code’s routing and fallback logic, confirming that it uses the same cloud‑hosted models as the API.
In other words: these products are different doors into the same building.
This matters because backend‑layer instability will surface across all of them.
2. The 4.6 Rollout Timeline
The instability window aligns almost perfectly with Anthropic’s staggered rollout of the 4.6 generation:
Date
Feb 5
Feb 17
Mar 13
Mar 23
Mar 31
Event
Opus 4.6 released
Sonnet 4.6 released (became default for Claude Code)
1M context window GA
Computer Use GA
Claude Code v2.1.88 exposure incident
During this period, Anthropic pushed dozens of releases across the ecosystem — exactly what a shared backend looks like when it’s undergoing rapid, dependency‑ordered evolution.
3. The Claude Code Narrative Has
Drowned Out the Real Story
Much of the public conversation has centered on Claude Code — and for understandable reasons. It had:
visible regressions
reproducible failures
agentic loops
cache‑key mismatches
Bun runtime quirks
--resume bugs
MCP schema explosions
These issues were real, and they deserved attention.
But the volume of Claude Code complaints created a false impression:
that the instability was isolated to the CLI or to developer workflows.
It wasn’t.
The same symptoms appeared across:
Claude.ai
the Claude API
Cowork
Enterprise analytics
These surfaces do not share Claude Code’s front‑end logic.
They do share the backend.
The result is simple:
Claude Code was the loudest failure, not the only one.
The underlying issue was systemic, not surface‑specific.
And the root cause was architectural, not model‑specific.
4. What My Own Logs Revealed
Before I ever looked at Reddit, GitHub, or news reports, I had already seen the pattern emerging in my own logs.
Across multiple sessions and multiple product surfaces, I observed:
usage meters advancing even when idle
multi‑minute gaps followed by sudden usage spikes
cache churn where previously cached prompts were re‑billed
context drift in long sessions
metering anomalies where usage jumped in discrete, unexplained blocks
session resets that didn’t correspond to user actions
compaction storms
recount triggers appearing in clusters
negative deltas followed by large positive corrections
These were not front‑end artifacts.
They were backend behaviors.
And they were consistent.
5. Technical Log Analysis Performed by Claude
When I provided these logs to Claude, it performed structured, technical analysis — not agreement, not validation, but forensic parsing of raw data.
Claude identified:
double API call patterns (two backend calls for every one user-visible response)
cache‑expiry cycling (cache rebuilt, expiring within minutes, then rebuilt again)
delta‑counter resets (accumulated usage dropping from ~100k to ~4k mid‑session)
timestamped overbilling events, including a documented case where a nine‑word prompt was billed at ~79,000 tokens due to a premature cache expiry
These findings aligned with what I was already seeing in the logs.
They were not interpretations — they were artifacts.
6. Cross‑Service Failure Timeline (Feb–Mar 2026)
Google Search’s AI‑generated summaries — which compile public reports, forum discussions, and news coverage — show a clear pattern:
Claude Code
Feb 6: Idle session progress failures
Mar 23: Runaway usage, cache failures, agentic loops
Claude API
Mar 19: 120‑second heavy‑request timeouts
Claude.ai
Feb 25: Elevated error rates
Cowork
Mar 23: Session caps (10–15 minutes)
Enterprise
Mar 24–26: Analytics anomalies and usage spikes
Every service shows failures within the same six‑week window.
7. Symptom Clusters and Their Likely Causes
A. Post‑Opus 4.6 (Feb 5–25)
Idle sessions
Elevated error rates
Backend saturation
B. Post‑1M Context GA (Mar 13–22)
Context drift
Cache failures
Long‑session degradation
120‑second API wall
C. Post‑Computer Use GA (Mar 23–31)
Recursive self‑prompting
Session grafting
Usage meters advancing while idle
Cowork session caps
Authentication drift
D. The “Kairos” Leak (Mar 31)
A brief exposure of Claude Code’s source files revealed internal routing and fallback logic, including session‑management behavior consistent with the failures users were reporting.
8. Independent Corroboration:
The March 17–23 Spike
Public reports during this window included:
Pro users burning weekly limits in under 24 hours
Max 20x users jumping from 21% → 100% on a single prompt
Max 5x users losing 5‑hour sessions in 70–90 minutes
One‑sentence replies consuming 40% of a quota
Developers burning hundreds of dollars in extra usage on a handful of prompts
Technical factors identified in these reports included:
prompt‑cache inflation
peak‑hour multipliers
agentic loops
post‑promotion regressions
My logs showed the same behaviors.
9. What This Means
The evidence points to a simple, grounded conclusion:
The March 2026 instability was not a Claude Code bug.
It was a system‑wide backend disruption during the 4.6 rollout.
Claude Code had its own regressions — and those were real — but they do not explain:
runaway usage in Claude.ai
120‑second API timeouts
Cowork session caps
authentication drift
diminishing returns on purchased credits
cross‑surface context drift
usage meters advancing while idle
These are backend‑layer symptoms, and they appeared across every product surface.
This makes the issue architectural, not model‑specific.
10. Why I’m Publishing This
I want to be clear about something that often gets lost in these conversations:
I’m not writing to punish Anthropic.
I’m not trying to embarrass them, pressure them, or score points online.
That’s never been my interest.
What I want is simple:
a stable workflow.
Claude has been — at its best — an extraordinarily effective collaborator for my work. Not a replacement for thought, not a crutch, but more like a research assistant who helps me:
organize complex notes
maintain structure across long projects
keep my reasoning honest
challenge my assumptions
and stay grounded when I’m working at scale
That’s the relationship I value.
That’s the workflow I’m trying to preserve.
When the system is stable, Claude is one of the most productive tools I’ve ever used. When the backend is unstable, that entire workflow collapses — not due to a single bug, but because the underlying architecture is struggling.
My goal isn’t to assign blame.
It’s to understand what happened — to verify that my experience wasn’t an anomaly; to separate front‑end regressions from backend instability. Then I can plan my work accordingly.
Online searches didn’t reveal anything I hadn’t already seen — they simply confirmed that the pattern I was tracking was real, widespread, and overlooked.
This is what happens when a shared backend undergoes rapid evolution.
It's also what happens when you analyze the system instead of reacting to the symptoms.
Page updated
Google Sites
Report abuse