Anthropic Guts SDK Naming, Locks Devs

The press cycle on this one is going to read it as a quiet SDK bump, a routine dependency update,nothing to rearrange your roadmap for. The real signal for teams running internal agents at scale is smaller, sharper, and quietly disruptive: Anthropic didn’t just ship v0.97.0,they stapled a hard version floor to a rebrand. What looks like a rename (from Claude Code SDK to Claude Agent SDK) is functionally a lockout. If you’re on anything below 0.97.0, you’re not just missing features,you’re blocked from accessing the public beta of CMA Memory, the closest thing we’ve seen to persistent context in agent workflows. And for any team with more than five repos shipping against the SDK, that’s not a dev task. That’s an audit pass.

We’ve seen this shape before. The OpenAI Assistants API transition in early 2024 wasn’t just a feature drop,it was a forced migration that broke hundreds of internal tools overnight. Same playbook: rename the surface, raise the floor, force the upgrade. This time, the trigger is CMA Memory, the backend that lets agents remember prior interactions within a session. Before this, you had to bake your own context window or rely on flaky state management. Now it’s native,but only if you’re on the new SDK. And the new SDK only exists at 0.97.0 and above.

The bump itself? Trivial. The audit? Not.

The Deployment

Anthropic pushed v0.97.0 of its Python SDK on April 23, 2026, rebranding it from “Claude Code SDK” to “Claude Agent SDK.” The headline feature is the public beta of CMA Memory, which enables session-aware state retention,meaning an agent can recall what it was told five prompts ago without the caller having to re-inject context. This isn’t just a QoL improvement; it’s foundational for workflows like multi-step customer support, internal ticket routing, or agent handoffs in legal or HR workflows where continuity matters.

The release also patches API spec errors, restores missing features (details unspecified), and optimizes file structure copying in multipart requests,a performance tweak that reduces latency when handling large payloads, like uploaded documents or batched queries. Internally, the team improved the bootstrap script and bumped test dependencies, but the real weight of this release isn’t in the chores. It’s in the hard version floor now enforced at the API level. You can’t access CMA Memory unless you’re on 0.97.0 or higher.

There’s no graceful fallback, no deprecation window, no compatibility shim. This is a clean break.

[[IMG: a Python developer in a London co-working space reviewing a terminal with a failed SDK version check, coffee cup beside a laptop showing a CI/CD pipeline error]]

Why It Matters

What changed isn’t just the name on the box,it’s the rules of engagement. Anthropic is signaling that agent workflows are no longer experimental. They’re moving from “scripts that call an API” to “persistent, stateful services” that need to be treated like any other production component. The rebrand from “Code” to “Agent” isn’t marketing fluff. It’s a boundary marker: if you’re using this SDK, you’re building agents, not one-off scripts. And agents, by definition, need memory.

This mirrors the shift we saw when serverless went from “cool side project” to “core infrastructure” around 2020. Suddenly, what was once a “nice-to-have” (cold start optimization, observability, billing predictability) became table stakes. Now, with agents, the table stakes are version discipline, audit trails, and state management. The cost of getting this wrong isn’t downtime,it’s hallucinated context, data leakage, or compliance violations when an agent “forgets” it’s already seen a document marked confidential.

And let’s be clear: this isn’t just about Python teams. The pattern sets a precedent. If Anthropic can force a hard version floor on its SDK, others will follow. OpenAI’s Assistants API already requires specific versioning for certain features. Google’s Vertex AI agent framework does the same. The era of “pin and pray” is over.

We’ve been here before,with OAuth 2.0, with Kubernetes 1.0, with Stripe’s API versioning. Each time, the vendor framed it as “improvement,” but the operator cost was real: weeks of migration, QA cycles, compliance sign-offs. The difference now is velocity. Back then, you had months to migrate. Today, the floor drops without warning, and your CI pipeline breaks at 3 a.m.

The real tension isn’t between old and new SDKs. It’s between developer velocity and operational rigor. For small teams, this is a nuisance. For mid-market firms with compliance mandates,GDPR, HIPAA, SOC 2,it’s a procurement risk. Because now, every SDK upgrade isn’t just a code change. It’s a change request.

What Other Businesses Can Learn

If you’re running even a single agent in production,customer support, HR triage, document processing,here’s what you need to do, now:

1. Audit every repo using the old SDK. Use grep -r "anthropic" or a dependency scanner. You’re looking for anything pinned below 0.97.0. Assume you have more than you think. Teams reuse templates, copy-paste configs, inherit tech debt from stalled projects. A single forgotten notebook in a shared drive can break your rollout.

2. Test the upgrade in staging,but not just functionality. Run your full test suite, yes, but also check:

   • Does CMA Memory actually persist state across turns?
   • Are there memory leaks in long-running sessions?
   • Does the optimized multipart handling reduce latency in your file-heavy workflows?

   One UK fintech team reported a 12% drop in average response time after upgrading, but only after they adjusted their chunking logic to match the new file-copy behavior.

3. Treat the lockfile as production infrastructure. This isn’t optional. If you’re in a regulated industry, your auditors will ask: “How do you ensure all agent instances are on approved versions?” Your answer can’t be “We hope the devs remembered.” You need:

   • A central dashboard showing SDK versions per repo
   • Automated alerts when a repo falls behind
   • A freeze policy: no deployment unless the SDK is within one minor version of the latest

4. Negotiate versioning clauses in vendor contracts. This is the sleeper issue. Most AI vendor agreements don’t specify upgrade timelines, deprecation windows, or support for legacy versions. They should. Start asking:

   • “How much notice will you give before enforcing a new minimum version?”
   • “Do you offer LTS (long-term support) versions for enterprise customers?”
   • “If a security patch is backported, will it be available on older SDK lines?”

   One Canadian healthcare provider got burned when a similar forced upgrade exposed a gap in their data residency policy. The new SDK routed traffic through a region they hadn’t approved. It took three weeks to fix.

Your lockfile is production infrastructure now, not just a dev-time artifact.

5. Budget for the audit pass, not the upgrade. The code change might take an hour. The compliance review? A week. The procurement sign-off? Two weeks. Factor that into your planning. This isn’t a technical debt sprint. It’s a cross-functional ops cycle.

[[IMG: a mid-level operations lead in a Melbourne office presenting a slide titled "Agent SDK Compliance Status" to a room of skeptical stakeholders, clock showing 4:45 PM]]

Looking Ahead

Twelve weeks from now, the signal will be clear: how many mid-market firms have full SDK version coverage across all repos? If it’s under 60%, the optimistic read,that this is a smooth transition,was wrong. If it’s over 80%, Anthropic’s hard floor worked as intended.

But here’s the deeper test: will any major vendor offer LTS versions for their agent SDKs by Q3? If yes, it means the market has accepted that AI agents are production-grade systems. If not, we’re still in the wild west,and the next forced upgrade will break something bigger.

Pin tight. Audit early. Treat the lockfile as production infrastructure, because at this point in the agent-deployment cycle it is exactly that.

• GitHub Releases (anthropics/anthropic-sdk-python), accessed 2026-04-28