Photo by Igor Omilaev on Unsplash
In a recent conversation hosted by Anthropic, Alex Albert (Cloud Relations), Brad Abrams (Product), and Katelyn Lesse (Engineering) laid out how the Claude Developer Platform is evolving to power a new generation of AI agents. The discussion covered everything from why the platform name changed, to concrete tools available today (web search, web fetch, code execution), to best practices for getting started and what’s on the roadmap—observability, memory, and even giving Claude a persistent "computer" to work with.
What is the Claude Developer Platform? 🧭
The team opened by explaining the rebrand from the Anthropic API to the Claude Developer Platform. That change reflects a bigger reality: the product is no longer just a simple model endpoint, it’s a full developer platform that bundles APIs, SDKs, documentation, console experiences, and more. As Katelyn put it, the platform “really encompasses our APIs, our SDKs, our documentation, all of our experiences within the console, and really everything that a developer needs to actually build on top of Claude.”
That larger vision matters because internal Anthropic products (like Cloud Code) are built directly on the public platform—proof that the platform is designed for production usage and internal scaling, not only experimentation. Over the past year the platform added key features like prompt caching, a batch API, web search and web fetch tools, context management support, and code execution. Brad summarized the arc neatly: “We added prompt caching... web search... code executions. All these tools...we feel like yeah, it's aspirationally a platform now.”
Defining an "agent" 🔎
The term “agent” is everywhere, but the team clarified what it means at Anthropic. In short: an agent is when the model takes autonomy—choosing which tools to call, executing those calls, handling the results, and deciding the next action. Brad described it as the model “taking some autonomy to be able to choose what tools to call, to call those tools, to handle the results and kind of choose the next step.”
That autonomy is the defining element. It contrasts with heavily scaffolded workflows where developers predefine every step. Those workflows can be useful, but they risk constraining the model and preventing it from leveraging future improvements in intelligence. As Brad said, “with a true agentic pattern... those services are just going to get better” with each model release.
Why "unhobbling" models matters 🐎
One recurring idea in the discussion is that developers should "unhobble" their models—give Claude the right tools and freedom rather than micro-managing its every move. The intuition is simple: models have latent capabilities that are often underutilized by heavy scaffolding.
“If you just give the model like the tools it needs, and set it free, let it be able to use those in the right way, you'll get great results.” — Brad Abrams
The team emphasized that scaffolding can become a liability. Heavy frameworks or opinionated agent runtimes sometimes mask the model’s inherent reasoning power. Instead, lightweight, opinionated tools that don’t obfuscate the model’s decision-making are preferred. As Katelyn explained, the industry trend is moving away from overly complex wrappers—sometimes “it’s just a while loop”—toward tooling that helps the model shine without getting in its way.
Tools that make agents work 🔧
Practical tooling is where unhobbling meets engineering. Anthropic highlighted several platform features that turn Claude into an effective agent without excessive developer effort:
- Server-side web search and web fetch: Let Claude research the web autonomously—performing searches, following promising links, and fetching page content to extract facts.
- Code execution on a VM: Claude can write and run code, analyze images, process spreadsheets, and return results—an early step toward a persistent computing environment.
- Context management: Tools to manage the model’s context window (which can be large—default 200K tokens, with a 1M-token beta on SANA) and selectively remove or summarize older context to declutter prompts.
- Agentic memory (notes): The model can take internal memory notes during multi-step tasks and consult them later, enabling iterative improvement across runs.
- Prompt caching and batch APIs: Infrastructure features to reduce latency and cost when using the platform at scale.
Brad gave a concrete example: enabling web search turned complex research tasks into something the model could complete almost end-to-end. The model calls the search tool, polls results, fetches a promising link, digests it, and iterates—autonomously.
Getting started: Agent SDK (formerly Cloud Code) 🚀
If you’re a developer wondering where to begin, the team recommended starting with the Agent SDK (formerly Cloud Code SDK). Katelyn explained that the SDK provides an out-of-the-box agent harness to run the agentic loop—handling tool calling, orchestration, and runtime concerns so you can prototype faster.
Importantly, the SDK isn’t just for code-related workflows. Brad pointed out that once they stripped code-specific scaffolding from Cloud Code, what remained was an agentic loop that solves many general-purpose problems. That makes the SDK a great starting point even if you’re not building a coding assistant.
Practically, the SDK is built on top of the messages API and exposes the same tools described above, but packaged as a usable runtime you can deploy wherever you like. For teams ready to deploy, it’s production-capable; for experimental developers, it’s a fast hackable baseline.
Best practices: choose the right use case and manage context/memory 📚
Not every problem needs a fully agentic approach. The team stressed the importance of selecting use cases where agents deliver clear business value:
- Estimate engineering hours saved or manual work reduced.
- Define the outcome you expect from the agentic project before you build.
- Start small, measure impact, then expand scope as the agent proves value.
On context and memory: long agent runs can create heavy context windows with dozens or hundreds of tool calls. Anthropic is rolling out features to declutter context and to add “tombstoning” when older tool results are removed. Tombstoning preserves a short note in the prompt that indicates that a tool’s results were previously present but have been archived—so Claude won’t be completely oblivious when older context is pruned.
“If you declutter the prompt... the model can actually focus a little bit better.” — Brad Abrams
For memory, the idea is to provide Claude with an internal note-taking capability. Humans naturally improve over repeated tasks; the model’s outputs can improve similarly if it can record and consult notes about what worked and what didn’t. Anthropic currently exposes the memory capability and lets developers decide how and where to persist those notes (cloud storage, databases, etc.), giving teams control over privacy and lifecycle policies.
Observability, auditing, and the road ahead 🔭
As agents gain autonomy and run for longer periods, observability becomes critical. Enterprises need ways to audit what an agent did, how it made decisions, and whether it performed acceptable actions. Katelyn highlighted observability as a core area of investment: dashboards, logs, and tooling that let engineers inspect long-running tasks, see when an agent made a particular tool call, and tune prompts or tool behavior.
Security and auditing go hand-in-hand with observability. If an agent is allowed to act inside other applications, teams must be able to trace steps, apply constraints, and intervene if the agent drifts from desired behavior. The platform roadmap includes features to support these needs at scale.
Another big-picture roadmap item is the idea of giving Claude a persistent computing environment—a “computer” that stays available across sessions. Early work is already visible in the code execution tool, but the team imagined a future where Claude has persistent storage, file organization, and a personalized toolset, enabling more sophisticated, stateful workflows over time.
“We’re in the early stages of giving Claude a computer...What if I had a persistent computer that was always there and it could organize the files in there the way it needed...there's a lot of headroom to that scenario.” — Brad Abrams
Conclusion: Where this is headed 🏁
Anthropic’s take on agents is pragmatic and developer-focused. Rather than prescribe a single heavy agent framework, the Claude Developer Platform prefers lightweight, composable tools that unlock the model’s reasoning while preserving observability and control. The priority is clear: give the model the tools it needs, avoid unnecessary scaffolding, and provide developers with SDKs and platform features that scale from prototype to production.
For teams and individual developers exploring agentic systems today, the practical advice is to start with the Agent SDK, pick a business-focused use case, and make use of web search, code execution, and memory features to accelerate outcomes. Watch context usage, use tombstoning and memory notes to manage the prompt, and instrument long-running tasks for observability.
As models improve and Anthropic rolls out higher-order abstractions, expect agents to become more autonomous and more useful. The combination of better models, smarter tooling, and practical observability could enable self-improving, continuously improving agents that deliver material business value. In short: unhobble the model, give it the right tools, and let it get to work.
Quick starter checklist
- Try the Agent SDK (Cloud Code reimagined) to prototype an agentic loop.
- Enable server-side web search and web fetch for research-based tasks.
- Use code execution for heavyweight transformations (data analysis, image processing).
- Manage context with tombstoning and selective pruning to keep prompts focused.
- Implement memory notes and decide where to persist them for long-term improvement.
- Instrument long-running agents with logs and dashboards to support observability and auditing.
If you want to dive deeper, Anthropic provides documentation and SDKs on the Claude Developer Platform to help you start building agents today.
