Building Production-Ready Agentic Systems with the Claude Developer Platform

anthropic · Tech · 2024 · source Agentic: yes · promotional bias: high · source-backed · extracted with prompt 0.5.5 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Developer platform for production agentic applications on Claude

Anthropic needed the Claude Developer Platform to support production agentic systems, not just single API calls: developers need reusable agent loops, tools, SDKs, context management, prompt caching, code execution, web search/fetch, memory, deployment paths, observability, and business-value scoping for long-running autonomous workflows.

Constraints:

Architecture

The Claude Developer Platform bundles APIs, SDKs, documentation, console experiences, prompt caching, batch API, web search/fetch, context management, code execution, and higher-order agentic abstractions. The Claude Code SDK serves as a general-purpose agentic harness: it runs the tool-calling loop on top of the Messages API, gives Claude access to generic capabilities such as a file system, Linux command-line tools, and code execution, and can be deployed as an agentic loop runtime. Server-side web search/fetch and code execution are exposed as tools with minimal prompting so Claude can decide how to use them. Context-management features remove older tool calls with guardrails and tombstones, while agentic memory lets Claude take notes and later review them. The roadmap pairs these abstractions with observability for long-running tasks and self-improving outcomes.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  claude-developer-platform[Claude Developer Platform] --> messages-api[Messages API]
  claude-developer-platform --> claude-code-sdk[Claude Code SDK]
  claude-developer-platform --> prompt-caching[Prompt caching]
  claude-developer-platform --> batch-api[Batch API]
  claude-developer-platform --> web-search-and-web-fetch[Web search and web fetch]
  claude-developer-platform --> context-management-tools[Context management tools]
  claude-developer-platform --> code-execution-vm[Code execution VM]
  claude-developer-platform --> observability-layer[Observability layer]
  messages-api --> claude-code-sdk[Claude Code SDK]
  claude-code-sdk --> agentic-loop-runtime[Agentic loop runtime]
  agentic-loop-runtime --> tool-set[Tool set]
  tool-set --> web-search-and-web-fetch[Web search and web fetch]
  tool-set --> code-execution-vm[Code execution VM]
  tool-set --> agentic-memory[Agentic memory]
  agentic-loop-runtime --> context-management-tools[Context management tools]
  context-management-tools --> agentic-memory[Agentic memory]
  agentic-loop-runtime --> observability-layer[Observability layer]
  business-value-scoping[Business-value scoping] --> claude-developer-platform[Claude Developer Platform]
Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component Role Interacts with
Claude Developer Platform Public platform surface including APIs, SDKs, documentation, console experiences, and production tooling. Messages API, Claude Code SDK, Prompt caching, Batch API, Web search and web fetch, Context management tools, Code execution VM, Observability layer
Messages API Underlying API used by the Claude Code SDK and agentic tool-calling loop. Claude Code SDK
Claude Code SDK General-purpose agentic harness and deployable runtime for the tool-calling loop. Agentic loop runtime, Messages API
Agentic loop runtime Runtime that lets Claude choose tools, call them, handle results, and pick next steps. Tool set, Context management tools, Observability layer
Tool set Generic capabilities such as web search, web fetch, file-system access, Linux command-line tools, and code execution. Web search and web fetch, Code execution VM, Agentic memory
Web search and web fetch Server-side tools that Claude can autonomously invoke for research and retrieval. Agentic loop runtime
Code execution VM Virtual machine environment where Claude can write code, execute it, inspect results, and perform data analysis. Tool set
Prompt caching Optimization for repeated calls and agentic workflows that reuse similar context. Claude Developer Platform
Batch API Separate API for batch processing workloads. Claude Developer Platform
Context management tools Remove older tool calls, preserve recent critical calls, and tombstone removed results so the model retains awareness. Agentic loop runtime, Agentic memory
Agentic memory Tool that lets Claude write notes during tasks and review them in later runs, with storage managed by developers. Agentic loop runtime
Observability layer Platform capability for auditing, monitoring, steering, prompt tuning, and tool-calling analysis for long-running tasks. Agentic loop runtime
Business-value scoping Use-case selection process defining expected saved hours, removed manual work, and business outcomes before building. Claude Developer Platform

Data flow

A developer builds on the Claude Developer Platform using APIs, SDKs, docs, and console workflows. For agentic systems, the developer can start with the Claude Code SDK, which supplies the runtime agent loop over the Messages API and tool-calling infrastructure. The model receives tools such as web search, web fetch, code execution, command-line access, and file-system access. During execution, Claude chooses which tools to call, handles tool results, and chooses next steps. Prompt caching and batch APIs support production efficiency. Context-management features prune older tool calls while tombstoning what was removed; agentic memory lets Claude write and later read notes. Observability is intended to let developers audit long-running tasks, steer behavior, tune prompts, and adjust tool-calling strategy.

6 supporting quotes
“the Claude Developer Platform really encompasses our APIs, our SDKs, our documentation, all of our experiences within the console”transcript, stated
“we essentially built an agent harness an agentic harness around the model to run that loop, right? And automate a lot of that tool calling and otherwise feature use. And obviously originally was built for coding purposes. And what the team really quickly”transcript, stated
“what the SDK does is it gives people a perfect out-of-the-box solution to actually just start prototyping agents”transcript, stated
“the loop with all the tool calling and otherwise. It's built on top of the messages API and all those same tools that we're mentioning. But it kind of gives you that really great starting place right out-of-the-box. - Right, I feel like this is a pretty common misconception, at least when I talk”transcript, stated
“We just give it the web search tool and all of a sudden deep research tasks are almost completely done with just turning on that switch on the API”transcript, stated
“this cool feature that lets the model actually remove some of the older tool calls that are not needed anymore.”transcript, stated

Why this architecture

Anthropic's platform architecture follows its 'unhobbling' philosophy: keep infrastructure lightweight enough that Claude can use its reasoning, while still giving developers reusable runtime machinery for loops, tools, context, memory, observability, and production deployment. The SDK exists because every team should not rebuild prompt caching and tool-loop handling from scratch.

5 supporting quotes
“what we really think about agent is where the model is taking some autonomy to be able to choose what tools to call”transcript, stated
“necessarily placing the bumper spawn the model itself? - Yeah, we think about it as like, how do you unhobble the model? The model already has a lot of capabilities. In fact, I'm convinced that even if you take your current generation of models, there's way more intelligence in there than”transcript, stated
“we wanna be lightweight in the way that we're doing that and make sure that the real thing we're doing is helping you get the most out of the model”transcript, stated
“everybody's implementing some form of managing prompt caching or some form of managing their tool calls and that loop.”transcript, stated
“prompt caching or some form of managing their tool calls and that loop. And now it's like, oh, just start at this base point, and then build from there. - You start a little bit higher up. - Yeah. - Yeah, yeah, yeah. - So it's like a further level abstraction. I think that's”transcript, stated

Models used: Claude · Claude Code SDK · Claude Developer Platform · Messages API · Claude Sonnet · Web search · Web fetch · Code execution · Prompt caching · Batch API

Scale

Alternatives considered (roads not taken)

Heavy scaffolding and predefined workflows

Rejected because: The team argues that heavy scaffolding can bound the model and hide improvements from newer models.

“if you build a workflow with a lot of scaffolding in it, you kind of put bounds on the model, which is maybe okay in some use cases, but that means that you may not take advantage of the next level of intelligence that a next model release gets. - Yeah, so”transcript, stated
“they were constraining it in ways that makes it harder for them to see the intelligence of the model. - Ah, does this match what we see in the field with our customers where they're also following these same trends? I know at the limit we have customers”transcript, stated

Every developer implements their own agent loop

Rejected because: The Claude Code SDK gives a higher starting point so teams do not have to rebuild tool-loop and prompt-caching management.

“before the Claude Code SDK, everybody's implementing some form of managing prompt caching or some form of managing their tool calls and that loop.”transcript, stated
“prompt caching or some form of managing their tool calls and that loop. And now it's like, oh, just start at this base point, and then build from there. - You start a little bit higher up. - Yeah. - Yeah, yeah, yeah. - So it's like a further level abstraction. I think that's”transcript, stated

Coding-only interpretation of Claude Code SDK

Rejected because: After removing coding-specific scaffolding, the team found a general agentic loop with generic computer capabilities.

“once we got done removing things from Claude Code to really unhobble the model, it turns out there was nothing coding left.”transcript, stated
“then it's just agentic loop and you're really a minimalistic thing to give Claude access to a file system, to a set of Linux command line tools to the ability to, you know, write code and execute that code. So those are all very generic kind of capabilities”transcript, stated

Keeping all old tool calls in context

Rejected because: The team says decluttering context helps the model focus, while preserving recent calls and tombstoning removals.

“if you declutter the prompt actually, the model can actually focus a little bit better. - Ah, interesting. So okay, we're moving unnecessary context. Is there a risk that we remove necessary context? - Yeah. - How does that work? - Yeah, yeah, yeah. So we”transcript, stated
“yeah. - But yeah, so generally we have put some bounds on that, because of that experience. So we do preserve the most recent set of tools. - I see, okay. - And then the other cool thing we do is tombstone it. So by that we mean when we remove the tool calls,”transcript, stated

Platform-managed memory storage only

Rejected because: Anthropic exposes the memory tool but lets developers decide where to store memory for control and deployment flexibility.

“to say. - Yeah, yeah, well, we're giving the model this core capability to do memory, and right now we're letting the developer manage the memory. So, because, you know, different developers, they might wanna store it in some cloud storage or they might wanna store it”transcript, stated
“somewhere else. So we're letting developers figure out exactly where to store the memory. That way they have more control over that. - But exposing the tool. - But expose the tool. Yeah, we expose the tool. - So going back again to a roadmap question here.”transcript, stated

Patterns

tool-use-orchestration (agent-runtime)

The platform and SDK let Claude choose tools, call them, handle their outputs, and decide the next step without every developer writing that loop.

“the model is 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.”transcript, stated
“And automate a lot of that tool calling and otherwise feature use. And obviously originally was built for coding purposes.”transcript, stated

semantic-caching (cost-latency)

Prompt caching is part of the platform and is explicitly called out as something developers were otherwise managing themselves.

“We added prompt caching, we added a whole separate batch of API”transcript, stated
“I feel like something I've been running up to in my own side projects and also seeing with projects within Anthropic is before the Claude Code SDK, everybody's implementing some form of managing prompt caching or some form of managing their tool calls and that loop.”transcript, stated

batch-offline-processing (throughput)

The platform includes a separate Batch API for production workloads that do not need immediate interactive execution.

“We added prompt caching, we added a whole separate batch of API, we added web search, web fetch, we have this context management support, the code execution.”transcript, stated

context-compaction (context-management)

Claude can remove older tool calls from context, preserve recent calls, and leave tombstones so the model knows what was removed.

“lets the model actually remove some of the older tool calls that are not needed anymore.”transcript, stated
“when we remove the tool calls, we put a note in there to the model that say, oh, the tool results for the search call were here.”transcript, stated

agent-memory (learning)

The memory tool lets Claude write notes during execution and review those notes on later runs so repeated tasks can improve.

“we've given this memory tool to the model now, so that the model can actually take some notes while it's going”transcript, stated
“when it's stumped, it can actually go back and review its notes”transcript, stated

observability-tracing (operations)

The platform roadmap prioritizes observability for long-running tasks so developers can audit, monitor, steer, tune prompts, and adjust tool strategy.

“another big problem that our users we know are gonna keep trying to solve is observability within those longer running tasks.”transcript, stated
“there needs to be a way to audit it and make sure the right things are happening”transcript, stated

cost-aware-routing (efficiency)

Prompt caching, batch API, and context removal reduce repeated work and context bloat in tool-heavy agentic loops.

“We added prompt caching, we added a whole separate batch of API”transcript, stated
“10, 15, 100 tool calls and you edit this file or look up data in this database or you know, send this email and each of those tool calls takes up 100, 200, 1,000 tokens. And so we have this cool feature that lets the model actually remove some of the older tool calls that are not needed anymore. -”transcript, stated

eval-driven-development (business-scoping)

The team advises customers to define expected business outcomes such as saved engineering hours or reduced manual work before selecting an agent project.

“what's the business value of this? Will it actually save this many engineering hours or will it help us remove this much manual work”transcript, stated
“being able to articulate what you expect the outcome of the agent project to be, I think is really helpful in defining the scope of the agent.”transcript, stated

Tradeoffs

Reduce scaffolding around Claude

Chose Lightweight tools and runtime support over Super-heavy opinionated agent frameworks.

Rationale: The team wants infrastructure that helps developers use Claude's capabilities without constraining the model's reasoning and future improvements.

“And I think what the industry is maybe kind of circling around is a lot of that has become maybe too heavy and maybe too opinionated and which is why you kind of get the people coming back to like, "It's just a wild loop and that is all you need.”transcript, stated
“it's not this super-heavy framework that really to Brad's point gets in the way of what the model's ultimately trying to do.”transcript, stated

Expose web search/fetch with minimal prompting

Chose Let Claude decide when and how to use server-side tools over Developer-orchestrated research steps.

Rationale: The team believes the model can autonomously inspect results, choose promising links, fetch content, and continue research with minimal tool-specific orchestration.

“fetch tools. And it's been interesting to watch customers use those. And you know, all we did really, I mean it's a very minimal prompt that we have. We just give it the web search tool and all of a sudden deep research tasks are almost completely done with just turning on that switch on the API,”transcript, stated
“the model will call that tool, it'll look at its results, it'll say, consider it and say, okay, maybe I need to call”transcript, stated

Use Claude Code SDK beyond coding

Chose General-purpose agentic harness over Treating Claude Code SDK as coding-only infrastructure.

Rationale: After removing coding-specific scaffolding, the remaining loop and computer access were generic enough for many agentic applications.

“scaffolding on the model. It's like once we got done removing things from Claude Code to really unhobble the model, it turns out there was nothing coding left. When you remove everything else, then it's just agentic loop and you're really a minimalistic thing to give Claude access to a file system,”transcript, stated
“those are all very generic kind of capabilities it turns out could solve a wide variety of problems.”transcript, stated

Prune context while preserving awareness

Chose Remove old tool calls with tombstones over Either keeping all context or deleting without explanation.

Rationale: Decluttering helps focus, but the model performs better if it knows results were removed and recent tool calls remain available.

“if you declutter the prompt actually, the model can actually focus a little bit better.”transcript, stated
“we put a note in there to the model that say, oh, the tool results for the search call were here.”transcript, stated

Expose memory but leave storage to developers

Chose Developer-managed memory persistence over One platform-mandated memory store.

Rationale: Different deployment contexts need different storage choices, and developer-managed memory gives production teams control.

“- Yeah, yeah, well, we're giving the model this core capability to do memory, and right now we're letting the developer manage the memory. So, because, you know, different developers, they might wanna store it in some cloud storage or they might wanna store it somewhere else.”transcript, stated
“That way they have more control over that. - But exposing the tool. - But expose the tool. Yeah, we expose the tool.”transcript, stated

Gotchas (what bit them)

Heavy scaffolding can suppress model improvements.

Root cause: Predefined workflows and framework constraints put bounds on the model, making newer models look only marginally better.

Resolution: Use lightweight platform tools that unhobble the model while still providing reusable production support.

“scaffolding the model needs to be able to accomplish tasks is it's needing less as the level of intelligence of the model goes up.”transcript, stated
“those guardrails in some cases become some like a liability to have.”transcript, stated

Teams waste effort reimplementing common agent-loop machinery.

Root cause: Before a shared harness, developers had to manage prompt caching, tool calls, and loop logic themselves.

Resolution: Start from the Claude Code SDK's agentic loop runtime and build project-specific logic on top.

“everybody's implementing some form of managing prompt caching or some form of managing their tool calls and that loop.”transcript, stated
“And now it's like, oh, just start at this base point, and then build from there. - You start a little bit higher up.”transcript, stated

Context size alone does not guarantee better output.

Root cause: Even with 200K or 1M-token windows, too much old tool context can distract the model.

Resolution: Prune older tool calls with guardrails, preserve recent calls, and tombstone removals so the model keeps situational awareness.

3 supporting quotes
“We have a million token available now in beta on Sonnet, which is great, but even a million, there's a limit there. And what many customers have told us is that they get better outputs, higher intelligence if they even use a smaller part of the context.”transcript, stated
“many customers have told us is that they get better outputs, higher intelligence if they even use a smaller part of the context.”transcript, stated
“we put a note in there to the model that say, oh, the tool results for the search call were here.”transcript, stated

Removing tool results too aggressively breaks the model's immediate task state.

Root cause: The model can become confused if very recent tool results disappear before it has used them.

Resolution: Keep bounds around removal and preserve the most recent tool calls.

“I removed the tools that it was just called and it's, oh, my tool results are gone, I don't know what to do.”transcript, stated
“So we do preserve the most recent set of tools. - I see, okay. - And then the other cool thing we do is tombstone it.”transcript, stated

Autonomy without observability is hard to trust.

Root cause: Long-running agents may work in the background, and developers need to know whether they are doing the right thing.

Resolution: Build platform observability so developers can audit behavior, tune prompts, and adjust tool-calling strategies.

“as you trust them to go work in some, you know, other application in the background, how do you make sure they're actually doing the right thing”transcript, stated
“there needs to be a way to audit it and make sure the right things are happening”transcript, stated

Memory storage remains a production responsibility for developers.

Root cause: Different teams may want to store memory in cloud storage or elsewhere, so the platform exposes a memory tool but does not fully own persistence.

Resolution: Expose the tool while letting developers decide memory storage and control boundaries.

“different developers, they might wanna store it in some cloud storage or they might wanna store it somewhere else.”transcript, stated
“So we're letting developers figure out exactly where to store the memory.”transcript, stated

Evaluation

The conversation does not present a formal benchmark. It frames production evaluation as business-value scoping and platform observability: define the expected outcome of an agent project, audit long-running autonomous behavior, observe whether the agent is doing the right thing, tune prompts, and adjust tool-calling strategies. Self-improvement and memory are positioned as future directions that also require observability to validate improvements.

Metrics: Engineering hours saved · Manual work removed · Expected business outcome of the agent project · Auditability of long-running autonomous tasks · Prompt-tuning signals · Tool-calling strategy observations · Context-management effectiveness · Self-improving outcome validation

5 supporting quotes
“Will it actually save this many engineering hours or will it help us remove this much manual work”transcript, stated
“articulate what you expect the outcome of the agent project to be”transcript, stated
“there needs to be a way to audit it and make sure the right things are happening”transcript, stated
“I might need to tune my prompt, or I might need to think about tool calling a little differently.”transcript, stated
“see the data and take those insights from those longer running tasks.”transcript, stated

Outcomes

The case gives platform-scale signals rather than external customer metrics: over the last year the platform added many features; Claude has 200K context by default and 1M-token Sonnet context in beta; agentic loops may include 10, 15, or 100 tool calls, each adding 100, 200, or 1,000 tokens; and the roadmap looks 6-12 months toward higher-order abstractions and observability.

6 supporting quotes
“- It used to be called the Anthropic API. - Yeah. - We just went through a big name change. Can you walk me through why we made that change and also what this new platform is and what it encompasses?”transcript, stated
“Claude Code, for example, is actually built directly on our public platform.”transcript, stated
“We added prompt caching, we added a whole separate batch of API, we added web search, web fetch”transcript, stated
“originally was built for coding purposes. And what the team really quickly figured out was like, actually this is an excellent general purpose agentic harness. And so what the SDK does is it gives people a perfect out-of-the-box solution to actually just start prototyping agents without having to”transcript, stated
“Wikipedia site is better than this other site or whatever. They learn which thing, so they get better over time. So we've given this memory tool to the model now, so that the model can actually take some notes while it's going and say, oh, I realize that this website maybe isn't the right one, or if”transcript, stated
“we can help you get self-improving and continuously improving outcomes out of Claude.”transcript, stated