# Evolving Claude APIs for Agents

Katelyn Lesse, Anthropic

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/aqW68Is_Kj4-evolving-claude-apis-agents) · [Video](https://www.youtube.com/watch?v=aqW68Is_Kj4)

## 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.

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?

[0:32](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=32s)

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.**

![Three illustrated cards read: Harness Claude’s capabilities; Manage Claude’s context; Give Claude a computer & let it cook.](https://ai.engineer/api/talk-essay-media/91e90580afd1607fbb2c938435ae9197948cf0a6f435e24b6d73cbea271fa66a)

Three ways the Claude Developer Platform maximizes intelligence.

### Allocate reasoning to the task

[2:08](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=128s)

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](https://platform.claude.com/docs/en/build-with-claude/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.

### Give the model tools it can select

[3:10](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=190s)

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.

![Tool Use slide with a code example listing bash, a text editor, and a run_tests tool with a description and input schema.](https://ai.engineer/api/talk-essay-media/1c7c6054182f21ab89aef4751343e55c2721f34e70a24304c66b3eadb7784fda)

Tool Use: built-in tools alongside a custom test-running tool.

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.

### Bring external context within reach

[3:50](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=230s)

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](https://www.anthropic.com/news/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.

### Store durable information outside active context

[5:12](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=312s)

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.

### Clear old results and preserve room to work

[5:58](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=358s)

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](https://claude.com/blog/context-management) 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**](https://claude.com/blog/1m-context), 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.

![Before and after context-editing diagrams show tool-use and tool-result blocks, with a green Available Context block in the lower row.](https://ai.engineer/api/talk-essay-media/6cd2c44af3e8af969accb0229bb69480ecdcab5ae6d6241b17fbc02ff08f0b57)

Context editing frees space in the context window.

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.

### Where does the agent work when you walk away?

[7:37](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=457s)

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](https://claude.com/blog/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.

### Expose a managed execution environment

[9:15](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=555s)

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.

### Supply expertise through skills

[9:58](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=598s)

Execution becomes more useful when the model also has domain expertise. [Agent Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-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.

![Agent Skills slide shows code specifying a web-design-system skill, a landing-page request, and a code-execution tool.](https://ai.engineer/api/talk-essay-media/729daf39e71984fb152486c3a5ccfd884ed4bdb3b64046e2222f4ec4c4890d18)

Agent Skills example combining a web design skill with code execution.

For a deeper treatment, Lesse points attendees to Barry and Mahesh’s skills talk scheduled for the following day.

### Let the platform evolve with the model

[11:54](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=714s)

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.

## Resources

- [Managing context on the Claude Developer Platform](https://claude.com/blog/context-management) — Launch explanation of memory and context editing, including Anthropic's internal agentic-search results.
- [Equipping agents for the real world with Agent Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills) — Explains skill folders, SKILL.md metadata, progressive disclosure and scripts through a PDF workflow.
- [Claude Code on the web](https://claude.com/blog/claude-code-on-the-web) — The web and iOS preview announcement describes parallel coding sessions on managed cloud infrastructure.
- [Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol) — The original MCP announcement explains connecting AI applications to external data sources and tools.
- [Claude Sonnet 4 now supports 1M tokens of context](https://claude.com/blog/1m-context) — Historical announcement of Sonnet 4's million-token context beta, including initial access conditions.
- [Extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) — Current guidance for manual thinking budgets and migration to model-dependent adaptive thinking.

## Slides

### How the Claude Developer Platform maximizes intelligence

The platform focuses on API access to Claude’s capabilities, managing its context window, and giving it a computer. Keeping the right context in the window is critical to getting the best outcomes, Lesse says.

[1:30](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=90s) [Overview of three approaches: harness Claude's capabilities, manage its context, and give it a computer.](https://assets.ai.engineer/sites/aiecode2025/sha256/6386d75af2b403726ceb2f4c5e7df8d111d869c493fb20d601b87ce1c5c52b3b.webp)

How the Claude Developer Platform maximizes intelligence

Harness Claude's capabilities
Manage Claude's context
Give Claude a computer & let it cook

ANTHROPIC
3

AIE / LEAD
PRESENTED BY
Google DeepMind

EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Harness Claude's capabilities

Katelyn Lesse introduces API features designed to make Claude's capabilities customizable.

[2:05](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=125s) [Orange section slide titled Harness Claude's capabilities, with a lightbulb illustration.](https://assets.ai.engineer/sites/aiecode2025/sha256/d2a88a7e55f12ff4a52b46a6e16c1b82f4fde19675e1c2d9065f3a9786d184ad.webp)

Harness Claude's capabilities

ANTHROPIC
4

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Extended Thinking

The API exposes a token budget for Claude’s reasoning. Claude Code uses the feature to decide whether Claude should think longer.

[2:18](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=138s) [Extended Thinking slide showing an API request with thinking enabled and a token budget.](https://assets.ai.engineer/sites/aiecode2025/sha256/b221bdf2e3eefb25b76ab084a126759e92d890fd5c2c92ec06e4de1df1ef47e5.webp)

Extended Thinking

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=8192,
    thinking={
        "enabled": True,
        "budget_tokens": 20000  # You control the depth
    },
    messages=[{
        "role": "user",
        "content": "Help me debug why this system fails under load"
    }]
)

ANTHROPIC
5

Interface text:
AIE / LEAD
PRESENTED BY Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Tool Use

Claude can call built-in and custom tools. The example defines a test-running tool by name, description and input schema; Claude Code uses tools to work with files and rerun tests.

[3:07](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=187s) [Tool Use slide showing built-in tools and a custom test-running tool with an input schema.](https://assets.ai.engineer/sites/aiecode2025/sha256/fbd17c9eab5f7d44873ca9262167d6395c18aee9fb129295eb0b07fb1647a98e.webp)

Tool Use

# Claude Code can use our tools & add custom ones
tools=[
    {"type": "bash"},
    {"type": "text_editor"},
    {
        "name": "run_tests",
        "description": "Run the project's test suite and return results",
        "input_schema": {
            "type": "object",
            "properties": {
                "test_path": {"type": "string", "description": "Specific test directory"},
                "verbose": {"type": "boolean", "description": "Include full output"}
            }
        }
    }
]

ANTHROPIC
6

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Manage Claude’s context

Lesse says getting the right context into Claude’s window at the right time is key to maximizing performance.

[3:47](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=227s) [Orange section slide titled Manage Claude’s context, with a small context diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/95e97d39bc2fa89df70cdfb57fbf0d5a5e930ef105419475cfc03cabd9899ce3.webp)

Manage Claude's context

ANTHROPIC
7

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Context engineering for agents

Context is curated from documents, tools, instructions and history into the model’s window. The model can respond or call a tool, whose result feeds back into message history.

[4:04](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=244s) [Diagram showing possible context curated into a context window, feeding an assistant and tool-call loop.](https://assets.ai.engineer/sites/aiecode2025/sha256/e7a9df279fc321a445aa10a9a4a2575f7bbbd71aa1684dd8daf216f393c24974.webp)

Context engineering for agents

Possible context to give model
Doc  Doc  Doc
Tool  Tool  Tool
Tool  Memory file
Comprehensive instructions
Domain knowledge
Memory file  Doc
Tool
Message history

Curation

Context window
System prompt
Doc 1  Doc 2
Memory file
Tool 1  Tool 2
User message
Message history

Assistant message
Tool call
Tool result

ANTHROPIC
8

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Memory

Claude's client-side memory stores context outside the window and retrieves it when relevant. The example saves details from a payment-service debugging request.

[5:09](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=309s) [Memory slide showing an API example that enables a memory tool for a debugging request.](https://assets.ai.engineer/sites/aiecode2025/sha256/316d58c77e870be23760cf5075d5bd971ec9062577de60bb0136df221287fb7b.webp)

Memory

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    tools=[{"type": "memory"}],
    messages=[{
        "role": "user",
        "content": "Debug why the payment service is timing out"
    }]
)
# Claude saves: "Payment service uses 30s timeout,
# retry logic in PaymentClient.java,
# team prefers circuit breaker pattern"

ANTHROPIC
10

Interface text:
AI Engineer
Engineering the future of AI

### Context Editing

Context editing clears old tool results from the window, freeing space taken up by results that may no longer be relevant.

[5:55](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=355s) [Context Editing slide showing an API configuration for clearing tool uses.](https://assets.ai.engineer/sites/aiecode2025/sha256/67c350892449a8cd905c31dffba596e2d5faed9a5f20aeaed88d181f9f9b42b2.webp)

Context Editing

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=[...],
    context_management={
        "edits": [
            {"type": "clear_tool_uses_20250919"}
        ]
    }
)

ANTHROPIC
11

Interface text:
AI Engineer
Engineering the future of AI

### Before and after context editing

Context editing reduces the space occupied by earlier tool uses and results, leaving available context while later entries remain in the window.

[6:43](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=403s) [Two context-window timelines compare tool-use and result blocks before and after editing, with available context shown after editing.](https://assets.ai.engineer/sites/aiecode2025/sha256/c10f9733cca0bdd93e994f05e2269cdedd3c26bda37d31d5cf3aa22c442fabb1.webp)

Before context editing
Tool Use 1 | Tool Result 1 | … | Tool Use N | Tool Result N | … | Tool Use N + 1 | Tool Result N + 1 | …

After context editing
Tool Use 1 | Tool Result 1 | … | Tool Use N | Tool Result N | … | Tool Use N + 1 | Tool Result N + 1 | … | Available Context

ANTHROPIC
12

Interface text:
AI Engineer
Engineering the future of AI

### Give Claude a computer and let it cook

The speaker argues that giving Claude access to writing and running code gives it room to work, while infrastructure and expertise remain challenges.

[7:36](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=456s) [Orange slide with the message “Give Claude a computer & let it cook” and a code-window icon.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b290267c5fadf4ba2e62f3e89b9b10a2843ea7af1fa51339f810c695b827001.webp)

Give Claude a computer & let it cook

</>

ANTHROPIC
13

AI Engineer
Engineering the future of AI

### Claude Code on the web

Claude Code’s web interface shows a prompt and active sessions. Supporting sessions after users walk away required secure environments, container orchestration, and session persistence.

[8:19](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=499s) [Slide showing a Claude Code web interface with a prompt box, session list and pixel-art graphic.](https://assets.ai.engineer/sites/aiecode2025/sha256/f61ef02032d800155066abcfa083bb1ce62ee522728e5be1f03103520faf2c24.webp)

Claude Code  Research preview

Ask Claude to write code...

acme/tea-sales    Cloud

Sessions    Active

Tax calculation details
acme/tea-sales    Answered

Add fall welcome banner
acme/mobile-tea    +263 -11    Open

let’s git together and code

ANTHROPIC
14

Interface text:
Claude Code
claude.ai/code
AI Engineer
Engineering the future of AI

### Code Execution

The API example enables code execution for an animation request. Anthropic runs Claude’s code in a sandbox and handles containers and security on its servers.

[9:18](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=558s) [Code Execution slide with an API example enabling a code execution tool for an animation request.](https://assets.ai.engineer/sites/aiecode2025/sha256/7d002ca3cbe69c845f98942f5c49da9d40e63206c77be935eac7c09bb9d8d877.webp)

Code Execution

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=8192,
    tools=[{"type": "code_execution_20250825"}],
    messages=[{
        "role": "user",
        "content": "Make the animation more sparkly"
    }]
)

ANTHROPIC
15

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Agent Skills

The example combines a web design skill with code execution for a landing page request. Claude can select a skill based on the request and its description, then use its instructions and resources.

[9:58](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=598s) [Agent Skills slide with a code example using a web design skill and code execution.](https://assets.ai.engineer/sites/aiecode2025/sha256/4877a4f79350e673bfc998d77654a3f0c953a94d5c6c729236fd18cca55a7836.webp)

Agent Skills

response = client.beta.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    container={
        "skills": [
            {
                "type": "user",
                "skill_id": "web-design-system",
                "version": "latest"
            }
        ]
    },
    messages=[{
        "role": "user",
        "content": "Build a landing page for our new product"
    }],
    tools=[{
        "type": "code_execution_20250825",
        "name": "code_execution"
    }]
)

ANTHROPIC
16

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Three ways to build with Claude

Anthropic is evolving its APIs to expose Claude’s capabilities, help developers keep the right context in the window, and give Claude a computer to work with.

[11:21](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=681s) [Three priorities: harness Claude’s capabilities, manage its context, and give it a computer.](https://assets.ai.engineer/sites/aiecode2025/sha256/c02c23cb7a4c7b0d7aab6deaece5911f3f345384c6a43d5b61567909251fcbee.webp)

1. Harness Claude's capabilities
2. Manage Claude's context
3. Give Claude a computer & let it cook

ANTHROPIC
17

Interface text:
AIE / LEAD
PRESENTED BY
Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Claude Developer Platform

The platform diagram places agent building blocks and model inference above Claude models and deployment options, with Model Context Protocol and developer tools alongside them.

[11:58](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=718s) [Diagram of the Claude Developer Platform, including agent building blocks, model inference, tools, models, and deployment.](https://assets.ai.engineer/sites/aiecode2025/sha256/66db9d89c88f67bfdced8d00b7eecc3f5260b8b2257d44251edb0d0a67596aa7.webp)

The Claude Developer Platform provides a powerful, customizable system to maximize the intelligence of agents.

Model Context Protocol
Agent SDK & Building Blocks
Model Inference
Developer Tools

Models
Claude Opus
Claude Sonnet
Claude Haiku

Deployment
Native
Cloud Partners

ANTHROPIC | Our products
18

Broadcast overlay:
AIE / LEAD
PRESENTED BY Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### Work with Anthropic

Anthropic is hiring across engineering, product, design and DevRel. Lesse invites people excited about Claude and developer products to explore anthropic.com/jobs.

[12:44](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=764s) [Anthropic recruiting slide inviting viewers to work with the company.](https://assets.ai.engineer/sites/aiecode2025/sha256/1ff16998fe64f0ea7a3f1e0fae1f0ffaab284855e19fa6729876ce767e64cf73.webp)

And we’d love to work with you

anthropic.com/jobs

ANTHROPIC

Interface text:
AIE / LEAD
PRESENTED BY Google DeepMind
EVOLVING CLAUDE APIS FOR AGENTS
KATELYN LESSE / Engineering Leader
ANTHROPIC

### AI Engineer Code Summit

[13:07](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=787s) [AI Engineer Code Summit closing card on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/12cdece8aa7f9b5a4a01a40f5a4f80b9b37e62f97f58e98530aed3fd73624be4.webp)

AI Engineer
Code Summit
https://ai.engineer

[13:13](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=793s) [AI Engineer Code Summit logo and website on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/50a05be6696810a36c833a68ac8f1fd5b820c9fab8a3ed8a85ed316ca37d7d59.webp)

AI Engineer
Code Summit
https://ai.engineer

## Full transcript

[0:00](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=0s) [on hold music] Good morning.

[0:22](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=22s) Um, so first, let's give a huge thank you to swyx and the whole AI engineer organizing team for bringing us together. [audience clapping]

[0:32](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=32s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=43s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=54s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=66s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=75s) Um, it's an agentic coding product, we love it a lot, and it's called Claude Code.

[1:22](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=82s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=93s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=102s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=112s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=128s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=140s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=151s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=162s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=180s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=190s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=204s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=215s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=230s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=245s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=257s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=272s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=285s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=302s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=312s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=327s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=343s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=358s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=370s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=387s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=398s) Um, so they take advantage of, um, context management to clear those things out of the window.

[6:46](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=406s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=425s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=439s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=457s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=468s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=483s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=494s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=501s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=510s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=521s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=534s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=550s) wanted to see the results of what Claude did.

[9:15](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=555s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=567s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=582s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=598s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=614s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=632s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=647s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=662s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=673s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=683s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=692s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=708s) And third, giving Claude a computer and just letting it do its thing.

[11:54](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=714s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=730s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=743s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=757s) And so we're gonna keep working, um, to make sure that those are, um, ready for you to take advantage of.

[12:44](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=764s) 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](https://www.youtube.com/watch?v=aqW68Is_Kj4&t=785s) And thank you. [audience applauding] [upbeat music]
