Everyone spent April arguing about reasoning benchmarks and OpenAI demo reels. No one was paying attention to Anthropic. Over 90 days they shipped eight separate production releases that together form the first complete, usable platform for running LLM agents in production.

This is not a collection of random feature drops. Every release lines up. There is a clear architecture here. And if you are building anything on top of commercial LLMs right now, this changes almost everything.

The quiet platform shift no one is talking about

Until last month, every production agent worked the same way. You called an LLM API. You wrote a loop. You handled tool execution. You built state management. You wrote context compaction logic. You handled retries. You built sandboxing. You added observability. You tuned the harness every time the model got an update.

90% of the code in every production agent deployment had nothing to do with the actual task the agent was supposed to perform. It was boilerplate. Every team built exactly the same thing, badly, over and over.

Anthropic just killed all of that.

They did not announce this shift. They did not put out a big press release. They just shipped one component after another, week after week, until the entire stack existed.

1M context at standard pricing: the end of context gymnastics

Start with the foundation. 1M token context is now generally available for both Opus 4.6 and Sonnet 4.6.

The important part is not the number. It is the pricing. There is no long context premium. A 900k token request costs exactly the same per token as a 9k one. No multipliers. No hidden fees.

This was the single most requested feature from production users for two years. No other provider has done this.

Opus 4.6 scores 78.3% on MRCR v2 at full context length. That is the highest score of any generally available frontier model. You can load an entire 100k line codebase, 600 page PDF, or full 8 hour agent trace and the model will correctly recall details anywhere in that window.

You no longer need to write context window management code. You no longer need to run recursive summarization. You no longer need to throw away half the conversation every ten turns. The context window is now just memory. Use it.

Artifacts are not a UI toy. They are a new output primitive.

Artifacts went GA for all users at the end of April. Most coverage wrote this off as a nice UI improvement for chat users.

That is missing the point.

Artifacts are the first standard output format for LLM agents that is not plain text. Before artifacts, every agent had to implement its own logic for rendering code, diagrams, tables, interactive controls and previews. Every team built the same iframe sandbox, the same edit controls, the same version history.

Now that is a primitive. Agents can emit an artifact once, and it will render correctly across the Claude web interface, mobile apps, API responses, and third party integrations. Users can edit it, fork it, share it, and the agent will see all changes.

Tens of millions of artifacts have already been created. This is already the most widely deployed agent output interface in the world.

Opus 4.7 and the end of fixed effort prompting

Opus 4.7 is the first model that does not have a fixed reasoning budget.

Instead of forcing you to pick a thinking token limit up front, Opus 4.7 uses adaptive thinking. It will skip thinking entirely for simple queries. It will spend thousands of tokens on hard problems. It will adjust how much it thinks on every turn based on what it sees.

This breaks almost every existing prompt. If you just swapped Opus 4.6 for 4.7 you probably got worse results and higher token usage. That is not a bug. That is the model working as intended.

The default effort level is now xhigh, a new setting between high and max. Use this for almost everything. Max effort is almost never worth it. It produces diminishing returns and will reliably overthink trivial problems.

Stop treating the model like a dumb autocomplete. Treat it like an engineer you are delegating work to. Give it the goal. Get out of the way.

Managed Agents: decoupling brain from hands

Managed Agents is the most important release of the last three years. No one has written about it properly.

This is not another agent framework. This is production infrastructure.

Every agent implementation before this ran the model harness, tool execution and credentials all in the same container. You paid container startup latency before the model could even start thinking. Prompt injection could leak all your secrets. If the container died the entire run vanished.

Managed Agents fixes this by splitting the agent into three separate components:

1. The harness and model control plane, run by Anthropic
2. An isolated disposable sandbox for code execution
3. An append only session log that connects the two

Credentials never enter the sandbox. The model starts reasoning immediately while the sandbox spins up in parallel. Sessions can be paused, resumed, inspected and replayed at any time.

This architecture cut time to first token by 60% at p50 and over 90% at p95. That is not a minor optimization. That is the difference between an agent that feels responsive and one that feels broken.

You do not have to write the loop anymore. You do not have to write retry logic. You do not have to build sandboxing. You define the agent, the tools and the guardrails. Anthropic runs everything else.

Memory, dreaming and agents that actually improve

Memory for Managed Agents launched in public beta. It is not a vector database.

Memory mounts as a normal filesystem inside the agent sandbox. Agents read and write memory using the same bash and code execution tools they already use for everything else. There is no special retrieval API. There is no embedding step.

This works. Rakuten reported a 97% reduction in first pass errors after enabling cross session memory. Wisedocs saw verification speed improve by 30%.

On top of memory sits dreaming. Dreaming is a scheduled background process that reviews all completed agent sessions, extracts patterns, fixes recurring mistakes and cleans up memory. It runs when your agents are idle. It learns across every run.

This is the first implementation of agent self improvement that actually works in production. No one else has anything close.

Code Review: the first production agent people actually trust

Code Review is the first agent that is routinely trusted to do work that humans used to do.

Anthropic runs this on every internal PR. Before deployment 16% of PRs received substantive review comments. After deployment that number went up to 54%. Less than 1% of findings are marked incorrect by engineers.

It does not approve PRs. It does not make the final call. It just finds bugs. And it finds bugs that humans miss.

On PRs over 1000 lines, 84% get findings, averaging 7.5 issues per review. A typical review costs $15-$25. That is cheaper than paying a senior engineer 20 minutes to read the diff.

This is not a demo. This is already replacing real work.

Routines: agents that work while you sleep

Routines are scheduled, headless Claude Code sessions that run on Anthropic's infrastructure.

You define a prompt, a schedule and a trigger. You can run them nightly, on webhooks, or from API calls. They have full access to your repos, connectors and tools. They do not require your laptop to be open.

This is the end of the custom cron job, the random lambda running an agent loop, the script on some engineer's desktop.

You can have an agent that wakes up every night, pulls the top open bug from Linear, attempts a fix and opens a draft PR. You can have one that runs on every PR, audits authentication changes and posts alerts to Slack. You can have one that gets paged by your monitoring system and starts triaging outages before you even get the alert.

Microsoft 365 integration: context that follows your work

Claude now runs natively inside Excel, Word, PowerPoint and Outlook. It maintains a single conversation across all four applications.

This is the first time an LLM has properly integrated into the tools where most actual work happens. You can triage an email, draft the memo, run the analysis and build the deck without ever re-explaining what you are doing.

All activity logs can be exported via OpenTelemetry. Enterprise admins have full audit and control. This is not a demo. This is rolling out to millions of users right now.

What this actually means for engineers building right now

If you are building agents today, you have three options:

1. Continue building and maintaining your own harness, sandbox, state management and observability stack.
2. Use an open source agent framework that will be obsolete in 6 months when model behaviour changes.
3. Build on top of Managed Agents and spend 100% of your time on the actual problem you are trying to solve.

For almost everyone, option 3 is now the correct choice.

The game changed. Most people have not caught up yet.

The unspoken tradeoffs

This platform is not perfect. There are real tradeoffs.

You are locking yourself into Anthropic. There is no standard for agents right now. Everything you build on Managed Agents will not port to any other provider.

Pricing is opaque for long running agent jobs. It is very easy to run up large bills very quickly if you do not set hard limits.

Many features are still in beta. Breaking changes will happen. Documentation is incomplete. Support is still thin.

None of these are deal breakers for most teams. They are just facts you should know going in.

---

All releases covered in this article are available today on the Claude Platform. Original announcement links are listed in the article sources.