AI Engineer Code 2025
Evolving Claude APIs for Agents
Read the talk
Evolving Claude APIs for Agents
Claude Code illustrates what an agent platform must provide: control over model capabilities, selective context management, and a secure computer on which to work.
From a talk by Katelyn Lesse
Before you start: Familiarity with LLM API requests, tool calling, and context windows will help you follow the platform mechanisms.
What does a coding agent need from its platform?
What does an LLM API need to expose so developers can build a capable coding agent? Katelyn Lesse, who leads Anthropic’s Claude Developer Platform team, frames the problem around developers pushing for the best performance available from Claude. Her recurring example is Claude Code: an agentic coding product that puts those platform capabilities to work.
The platform has three responsibilities. First, expose the capabilities the model is being trained to use. Second, help applications keep the right information in its context window. Third, provide the infrastructure that lets the model use a computer. Agent performance depends on the model’s abilities, the context available to it, and the environment in which it can act.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Allocate reasoning to the task
The first capability is thinking. Lesse describes performance on various tasks as improving with the time Claude spends reasoning through them. An API therefore needs to let the application choose between a quick response and a longer deliberation, rather than imposing the same reasoning effort on every request.
In the API design described here, a thinking token budget gives developers control over how much reasoning to allocate. Claude Code uses that control because complex debugging and a quick coding answer have different needs. The historical manual-budget mechanism remains documented in extended thinking, alongside newer, model-dependent adaptive-thinking configurations; it is not an unchanged contract across every model. The application-level decision remains useful: spend more reasoning where the task warrants it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the model tools it can select
Tool use turns model decisions into requests for action. The API exposes built-in tools, such as web search, and lets developers define custom tools. A custom definition supplies a name, a description, and an input schema. These tell Claude what the tool does and what arguments it accepts, so the model can decide when to call it.
A test-running tool illustrates the shape of that contract. The description explains when it is useful; the schema makes the requested input explicit:
json
{
"name": "run_tests",
"description": "Run the test suite for a file or directory after a code change.",
"input_schema": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "The test file or directory to run."
}
},
"required": ["path"],
"additionalProperties": false
}
}
This definition describes the callable operation; the application supplies its implementation. The slide places a custom run_tests tool alongside bash and a text editor.
Claude Code uses tools throughout a coding session: reading files, searching for files, writing changes, and rerunning tests. Reasoning controls influence how the model works through the problem; tools give it access to the operations needed to investigate and change the codebase.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Bring external context within reach
Once an agent can call tools, selecting its context becomes a continuing engineering problem. A coding session may contain technical designs, code, instructions, and tool calls. Each can be useful, but their usefulness changes as the work progresses. The objective is the right context at the right time, not simply accumulating everything the agent has encountered.
Model Context Protocol, or MCP, standardizes how agents interact with external systems. Lesse describes its introduction as roughly a year before the talk. For Claude Code, GitHub and Sentry are examples of places containing information or tools beyond the agent’s immediate context. Connecting to those systems gives the agent a way to obtain relevant material instead of being limited to what someone placed in its prompt.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Store durable information outside active context
External access helps bring information in. Memory lets the agent retain information outside the active window and retrieve it when needed. The first memory-tool iteration Lesse describes is a client-side file system: the developer controls the data, while Claude decides what is worth saving and when to bring it back into context.
Codebase patterns and Git workflow preferences are useful examples. They can matter across multiple tasks without needing to occupy the window throughout every task. Storing them separately makes them available for later use while allowing active context to focus on the current work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Clear old results and preserve room to work
Memory keeps information available outside the window; context editing removes information that no longer belongs inside it. The initial editing feature clears old tool results. Those results can be large, and material returned earlier in a session may contribute little to the next response. A coding agent that calls hundreds of tools can otherwise fill its context with previously read files and other accumulated output.
Lesse reports a 39% performance improvement from combining memory and context editing on Anthropic’s internal evaluations. The accompanying context-management announcement identifies the evaluation as agentic search involving complex multistep tasks. It does not provide the numerical baseline, exact scoring definition, sample size, or an explicit relative-versus-absolute definition, so the result should not be read as a measured coding-productivity gain.
Larger windows complement this editing process. Lesse notes that some models offer million-token context windows; a historical example is the million-token API beta for Claude Sonnet 4, which initially had access restrictions. More capacity provides room for work, while editing controls what occupies that room. The context-editing diagram makes the immediate effect visible: removing old results creates available context.
The next layer is capacity awareness. Lesse describes work on teaching Claude to recognize whether it has substantial room remaining or is approaching the end of its window, and to adjust its behavior accordingly. Context management then involves both choosing the contents and understanding the space left to continue.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Where does the agent work when you walk away?
Giving Claude a computer changes the question around agent harnesses. Developers debate how much scaffolding to build and how opinionated it should be. Lesse’s position is that a model able to write code gains much broader practical reach when it can also run that code. Producing professional outputs then depends on providing both the execution infrastructure and the expertise needed to use it well.
The launch of Claude Code on the web, which also included an iOS preview, makes the infrastructure requirement concrete. Local Claude Code uses the developer’s machine. When someone starts a web or mobile session and walks away, the work needs another computer on which to continue.
That remote environment has three requirements:
- Secure execution: It must accommodate generated code that the user has not necessarily approved individually.
- Container orchestration: It must support many concurrent sessions at scale.
- Session persistence: Work and results must remain available when users return.
The operational challenge is not merely starting a process. It is keeping many independent coding sessions ready for their users after unattended work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Expose a managed execution environment
The API’s code execution tool provides a primitive for this kind of work: Claude can write code and run it in a secure sandbox on Anthropic’s servers. The platform handles the containers and their security, reducing the execution infrastructure the application developer must operate.
Lesse’s example is a request to make an animation more sparkly. An agent benefits from being able to run the code it changes, rather than stopping at generated source. This is the direction she advocates for agents: allow the model to work with substantial autonomy inside a sandbox, with the platform supplying the environment that makes that work possible.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Supply expertise through skills
Execution becomes more useful when the model also has domain expertise. Agent Skills package scripts, instructions, and resources into folders that Claude can access while working in its sandbox. The request and the skill’s description guide whether Claude loads the skill into context and uses its contents. Skills can be combined with the code execution tool.
Skills also complement MCP. Their roles are distinct:
| Mechanism | What it supplies |
|---|---|
| MCP | Access to external tools and context |
| Skills | Expertise for using tools and context |
Access to a system gives the agent something to work with. A skill supplies the procedures and knowledge for doing that work appropriately.
Consider a team that regularly builds landing pages for product launches. It wants each page to follow its design system and established patterns. A landing-page request is a reason for Claude to load the web-design skill and apply those conventions. The slide’s web-design-system example pairs that skill with a landing-page request and code execution: the skill provides the design guidance, and the execution environment supports the implementation work.
For a deeper treatment, Lesse points attendees to Barry and Mahesh’s skills talk scheduled for the following day.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Let the platform evolve with the model
The platform roadmap follows the model’s development. As Claude acquires new capabilities and improves existing ones, the API needs to expose them so developers can put them to use. For memory and context, Lesse describes a move toward giving Claude more control over what it retrieves, stores for later, and clears from its window.
That direction also requires continued investment in orchestration, secure environments, and sandboxing. Giving an agent a computer creates an infrastructure obligation: the environment must support the work the model can increasingly perform. Lesse closes by inviting people interested in building these developer products to join Anthropic, across engineering, product, design, DevRel, and other functions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Launch explanation of memory and context editing, including Anthropic's internal agentic-search results.
The web and iOS preview announcement describes parallel coding sessions on managed cloud infrastructure.
The original MCP announcement explains connecting AI applications to external data sources and tools.
Historical announcement of Sonnet 4's million-token context beta, including initial access conditions.
Further reading
Explains skill folders, SKILL.md metadata, progressive disclosure and scripts through a PDF workflow.
Updates since the talk
Current guidance for manual thinking budgets and migration to model-dependent adaptive thinking.
Read the complete timestamped transcript
- 0:00
[on hold music] Good morning.
- 0:22
Um, so first, let's give a huge thank you to Swix and the whole AI engineer organizing team for bringing us together. [audience clapping]
- 0:32
I'm Katelyn, and I lead the Claude Developer Platform team at Anthropic. Um, so let's start with a show of hands. Who here is integrated against an LLM API to build agents?
- 0:43
Okay, I'm talking to the right people. Love it. Um, so today I want to share how we're evolving our platform to help you build really powerful agentic systems using Claude.
- 0:54
So we love working with developers who do what we call raising the ceiling of intelligence. They're always trying to be on the frontier, they're always trying to get the best out of our models and build the most high-performing systems.
- 1:06
Um, and so I want to walk you through how we're building a platform that helps you get the best out of Claude, um, and I'm going to do that using a product that you hopefully have all heard of before.
- 1:15
Um, it's an agentic coding product, we love it a lot, and it's called Claude Code.
- 1:22
So when we think about maximizing performance, um, from our models, we think about building a platform that helps you do three things. Um, so first, the platform helps you harness Claude's capabilities.
- 1:33
We're training Claude to get good at a lot of stuff, and we need to give you the tools in our API to use the things that Claude is actually getting good at.
- 1:42
Next, we help you manage Claude's context window. Keeping the right context in the window at any given time is really, really critical to getting the best outcomes from Claude.
- 1:52
And third, we're really excited about this lately, we think you should just give Claude a computer and let it do its thing. So we'll talk about how we're, we're evolving the platform to give you the infrastructure and otherwise that you need to actually let Claude do that.
- 2:08
So starting with harnessing Claude's capabilities. Um, so we're getting Claude really good at a bunch of stuff, and here are the ways that we expose that to you, um, in our API as ideally customizable features.
- 2:20
So here's a first example, um, relatively basic, Claude got good at thinking. Um, and Claude's performance on various tasks, um, scales with the amount of time you give it to reason through those problems.
- 2:31
Um, and so, uh, we expose this to you as an API feature that you can decide, do you want Claude to think longer for something more complex, or do you want Claude to just give you a quick answer?
- 2:42
Um, we also expose this with a budget, um, so you can tell Claude how many tokens to essentially spend on thinking. Um, and so for Claude Code, um, pretty good example, obviously, you're often debugging pretty complex systems with Claude Code or sometimes you just want a quick, um, answer to the thing you're trying to do.
- 3:00
And so, um, Claude Code takes advantage of this feature in our API to decide whether or not to have Claude think longer.
- 3:10
Another basic example is tool use. Claude has gotten really good at reliably calling tools. Um, so we expose this in our API with both our own built-in tools, like our web search tool, um, as well as the ability to create your own custom tools.
- 3:24
You just define a name, a description, and an input schema, um, and Claude is pretty good at reliably knowing when to actually go, um, and call those tools and pass the right arguments.
- 3:35
So this is relevant for Claude Code. Claude Code has many, many, many tools, and it's calling them all the time to do things like read files, search for files, write to files, um, and do stuff like rerun tests and otherwise.
- 3:50
So the next way we're evolving the platform to help you ma-maximize intelligence from Claude, um, is helping you manage Claude's context window. Getting the right context at the right time in the window is one of the most important things that you can do to maximize performance.
- 4:05
But context management is really complex to get right, um, especially for a coding agent like Claude Code. You've got your technical designs, you've got your entire code base, um, you've got instructions, you've got tool calls.
- 4:17
All these things might be in the window at any given time, and so how do you make sure the right set of those things are in the window? Um, so getting that context right and keeping it optimized over time is something that we've thought a lot about.
- 4:32
So let's start with MCP, Model Context Protocol. We introduced this a year ago, and it's been really cool to see the community swarm around adopting, um, MCP as a standardized way for agents to interact with external systems.
- 4:45
Um, and so for Claude Code, you might imagine GitHub or Sentry. There are plenty of places kind of outside of the agent's context where there might be additional information or tools or otherwise that you want your agent to be able to interact with or the Claude Code agent to be able to interact with.
- 5:02
Um, and so this will obviously get you much better performance than an agent that only sees the things that are in its window as a result of your prompting.
- 5:12
Uh, so the next thing is memory. So if you can use tools like MCP to get context into your window, we introduced a memory tool to help you actually keep context outside of the window that Claude knows how to pull back into the window only when it actually needs it.
- 5:27
Um, and so we introduced the first iteration of our memory tool as essentially a client-side file system. So you control your data, but Claude is good at knowing, "Oh, this is like a good thing that I should store away for later," and then s- uh, it knows when to pull that context back in.
- 5:43
So for Claude Code, you could imagine, um, your patterns for your code base or maybe your preferences for your Git workflows. These are all things that Claude can store away in memory and pull back in only when they're actually relevant.
- 5:58
And so the third thing is context editing. If memory helps you keep stuff outside the window and pull it back in when it makes sense, context editing helps you clear stuff out that's not relevant right now and shouldn't be in the window.
- 6:10
Um, so our first iteration of our context editing is just clearing out old tool results. Um, and we did this because tool results can actually just be really large and take up a lot of space in the window, and we found that tool results from past calls are not necessarily super relevant to help Claude get good responses
- 6:27
later on in a session. And so you can think about for Claude Code, Claude Code is calling hundreds of tools. Um, those files that it read otherwise, all these things are taking up space within the window.
- 6:38
Um, so they take advantage of, um, context management to clear those things out of the window.
- 6:46
And so, um, we found that if we combined our memory tool with context editing, we saw a thirty-nine percent bump in performance over, o- over the benchmark on our own internal evals, um, which was really, really huge, and so it just kind of shows you the importance of keeping things in the window that are only relevant at
- 7:05
any given time. And we're expanding on this by giving you larger context windows, so for some of our models, you can have a million-token context window. Combining that larger window with the tools to actually edit what's in your window maximizes your performance.
- 7:19
Um, and over time, we're teaching Claude to get better and better at actually understanding what's in its context window. So maybe it has a lot of room to run, maybe it's almost out of space, um, and Claude will respond accordingly depending on how much time, uh, or how much room it has left in the window.
- 7:37
So here's the third thing. Um, we think you should give Claude a computer and just let it do its thing. We're really excited about this one, [chuckles] um, because there's a lot of discourse right now around agent harnesses.
- 7:48
Um, you know, how much scaffolding should you have? How opinionated should it be? Should it be heavy? Should it be light? Um, and I think at the end of the day, Claude has access to writing code, and if Claude has access to running that same code, it can accomplish anything.
- 8:03
You can get really great professional outputs for the things that you're doing just by giving Claude runway to go and do that. But the challenge for letting you do that is actually the infrastructure, as well as stuff like expertise.
- 8:14
Like, how do you give Claude access to things that, um, when it's using a computer, it will get you better results?
- 8:21
So a fun story is we recently launched Claude Code on web and mobile. Um, and this was a fun project for our team because we had a lot of problems to solve.
- 8:30
When you're running Claude Code locally, Claude Code is essentially using your machine as its computer. But if you're starting a session on the web or on mobile, and then you're walking away, what's happening?
- 8:41
Like, where is that... Where is, um, Claude Code running? Where is it doing its work? Um, and so we had some hard problems to solve. We needed a secure environment for Claude to be able to write and run code that's not necessarily, like, approved code by you.
- 8:54
Um, we needed to solve orc- container orchestration at scale, um, and we needed session persistence, um, because, uh, we launched this, and many of you were excited about it and started many, many sessions and walked away, and we had to make sure that, um, all of these things were ready to go when you came back and, um,
- 9:10
wanted to see the results of what Claude did.
- 9:15
So one key primitive in this is our code execution tool. Um, so we released our code execution tool in the API, um, which allows Claude to run, write code and run that code in a secure sandbox environment.
- 9:27
Um, so our platform handles containers, it handles security, and you don't have to think about these things because they're running on our servers. Um, so you can imagine deciding that, um, you're, you want Claude to write some code, and you want Claude to go and be able to run that code.
- 9:42
And for Claude Code, there's plenty of examples here, um, like make an animation more sparkly, [chuckles] that, uh, you want Claude to actually be able to run that code. Um, so we really think the future of agents is letting the model work pretty autonomously within a sandbox environment, and we're giving you the infrastructure to be able to do
- 9:58
that. And this gets really powerful once you think about giving the model actual domain expertise in the things that you're trying to do. So we recently released agent skills, which you can use in combination with our code execution tool.
- 10:14
Skills are basically just folders of scripts, instructions, and resources that Claude has access to and can decide to run within its sandbox environment. Um, it decides to do that based on the request that you gave it as well as the description of a skill, um, and Claude is really good at knowing, like, this is the right time
- 10:32
to pull this skill into context and go ahead and use it. And you can combine skills with tools like MCP. So MCP gives you access to tools and access to context, um, and then skills give you the expertise to actually make use of those tools and make use of that context.
- 10:47
Um, and so for Claude Code, a good example is web design. Maybe whenever you launch a new product or a new feature, um, you build landing pages, and when you build those landing pages, you want them to follow your design system, and you want them to follow the patterns that you've set out.
- 11:02
Um, and so Claude will know, "Okay, I'm being told to build a landing page. This is a good time to pull in the web design skill, um, and use the right patterns and, and design system for that landing page."
- 11:13
Uh, tomorrow, Barry and Mahesh from our team are giving a talk on skills. They'll go much deeper, and I definitely recommend checking that out.
- 11:23
So these are the ways that we're evolving our platform, um, to help you take advantage of everything that Claude can do to get the absolute best performance for the things that you're building.
- 11:32
First, harnessing Claude's capabilities. So as our research team trains Claude, we give you the API features to take advantage of those things. Next, managing Claude's context. It's really, really important to keep your context window clean with the right context at the right time.
- 11:48
And third, giving Claude a computer and just letting it do its thing.
- 11:54
So we're gonna keep evolving our platform, um, as Claude gets better and has more capabilities and gets better at the capabilities it already has. We'll continue to evolve the API around that so that you can stay on the frontier and take advantage of the best that Claude h- has to offer.
- 12:10
Um, second, as, uh, memory and context evolve, we're gonna up the ante on the tools that we give you in order to let Claude decide what to pull in, what to store away for later, and what to clean out of the context window.
- 12:23
And third, we're really gonna keep leaning into agent infrastructure. Some of the biggest problems with the idea of just let Claude have a computer and do its thing are those problems that I talked about around orchestration, secure environments, and sandboxing.
- 12:37
And so we're gonna keep working, um, to make sure that those are, um, ready for you to take advantage of.
- 12:44
Um, and I'm hiring. [chuckles] We're hiring at Anthropic. We're really growing our team. Um, and so if you're someone who loves, um, building delightful developer products, um, and if you're excited about what we're doing with Claude, we would love to work with you across eng, product, design, um, DevRel, lots of functions, so please reach out to us.
- 13:05
And thank you. [audience applauding] [upbeat music]