# The Evolution of Agentic Surfaces

Gagan Bhat & Isabella Kai He, Anthropic | AI Engineer World's Fair 2026 | 31:24

Source: https://www.youtube.com/watch?v=K0X9QDRkIdg
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/the-evolution-of-agentic-surfaces
Published: 2026-08-11
Tags: agents, context-engineering, memory, reliability

## TL;DR
- Agent harnesses encode assumptions about model limitations, so they need frequent updates as models improve.
- Separating the agent loop from its execution environment lets reasoning begin earlier and makes failures recoverable.
- Durable session logs provide observability, context recovery, and input for memory improvements through dreaming.

## Summary
Gagan Bhat and Isabella Kai He trace the progression from Anthropic's Messages API to hand-built agent loops, the Claude Agent SDK, and managed agents. As models moved from answering questions to owning outcomes, teams had to build session management, sandboxing, credential handling, hosting, and observability around them. The speakers argue that these harnesses can become liabilities when they preserve assumptions about older models. Sonnet 4.5's context anxiety led Anthropic to add context resets, but Opus 4.5 no longer needed them, so the resets added latency and discarded useful cache. Managed agents separate the reasoning loop from tool execution, allowing parallel startup and recovery when either component fails. Their durable session log supports retries, observability, context retrieval, and memory updates through dreaming. The talk also covers secure credential vaults, self-hosted sandboxes, MCP tunnels, and outcome graders that retry work against a defined rubric.

## Key ideas
### Agent surfaces grew as models moved from answering questions to owning outcomes
[01:24](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=84s)
Gagan Bhat describes three stages in agent development. The Messages API began as tokens in and tokens out for simple question answering. As tasks became longer and required information gathering, customers manually built agentic loops that called Claude, ran tools, and managed context. The Claude Agent SDK then packaged a built-in loop with file-system access and sandboxing. Managed agents moves further by providing the production infrastructure around the agent. Teams still own the product, task, context, and domain knowledge, while Anthropic runs the agent loop, sandbox, credentials, sessions, observability, and hosting.

### A harness can become harmful when its model assumptions go stale
[07:02](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=422s)
Isabella Kai He says harnesses encode assumptions about what Claude cannot do without help, including context resets and compaction. Sonnet 4.5 showed what Anthropic called context anxiety: near its context limit, it ended work early even though room remained. Anthropic added context resets to compensate. Opus 4.5 did not show the behavior, so the fix became overhead. It added latency and sometimes discarded cache incorrectly. Her conclusion is direct: when the model changes and the harness does not, the harness can degrade the agent. A useful harness therefore needs components that can be changed quickly as model abilities evolve.

### Long-running agents need context engineering, secure environments, reliability, and parallel work
[09:59](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=599s)
Managed agents is designed for agents that work asynchronously on complex tasks over hours or days. Isabella Kai He says such agents need to handle context that accumulates over long work, operate inside a secure sandbox, recover from failures, and parallelize parts of a task. The architecture uses a small set of independent primitives so individual components can be swapped without changing the whole system. This design responds to a shift in products such as Claude Code and other enterprise agents, where the agent increasingly owns a complete outcome instead of producing a single response.

### Separating the reasoning loop from tool execution improves startup and recovery
[11:16](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=676s)
Anthropic first placed the agent loop and tool execution in the same container. That made tool access simple, but the model could not start reasoning until container setup finished. A failure in either part also took down the whole agent. Managed agents separates the brain, the agent loop, from the hands, the tool execution environment. The brain can begin work while a sandbox starts, or skip sandbox setup when a task does not need it. If a sandbox dies, the brain can create another and retry. If the brain dies, it can resume from the durable session log.

### Agent, environment, and session form the managed-agent model
[12:59](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=779s)
The system is organized around three primitives. The agent defines the model, prompts, tools, skills, and other behavior for a use case. The environment defines the container where execution occurs. Multiple sessions can use one environment definition while each receives an isolated container instance. Combining an agent with an environment creates a session. A session is a durable cloud resource that persists every interaction with the agent. That persistence supports long-running execution, observability, and recovery. Sessions also have four states: idle, running, rescheduling after an error, and terminated when recovery is not possible.

### The session log lets the harness recover context that Claude discarded
[15:32](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=932s)
Traditional harnesses often treat the context window and the session as the same thing. If Claude discards or edits part of its current context, the harness may have no way to bring that material back. Managed agents writes the user message, model response, tool calls, and tool results to a durable session log. The harness can read selected slices back into the current context window when needed. The same log gives developers a play-by-play trace for debugging and observability. The developer still controls context management and domain expertise, including the prompts, skills, and tools that make a coding, legal, or go-to-market agent different.

### Decoupling the brain and hands produced large time-to-first-token improvements
[23:15](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=1395s)
In the coupled design, model reasoning and the first output token waited for the execution container to finish setting up. After separating the agent loop from the sandbox, reasoning could start immediately while container setup ran in parallel. The system could also avoid starting a container when the task did not require one. Anthropic measured 60% faster time to first token for P50 use cases and more than 90% improvement for P95 use cases. The architectural change therefore affected the user-visible start of a task, rather than only the internal organization of the service.

### Dreaming turns past sessions into updates to the agent's memory
[27:28](https://www.youtube.com/watch?v=K0X9QDRkIdg&t=1648s)
Dreaming is a periodic batch process that takes an agent's session transcripts and current memory state, extracts new insights and organized structures, and edits the memory for future sessions. Isabella Kai He says this can make the next day's sessions more intelligent as the agent executes over time. She describes memory as holding user-specific information, while dreaming enables self-improvement. The speakers also see organizational memory emerging, where an agent stores team runbooks and other shared details. This makes the session log useful beyond debugging: it becomes raw material for improving how the agent works later.

## Notable quotes
- "Harnesses encode assumptions about what Claude cannot do on its own." (07:37)
- "When the model moves and the harness doesn't, it degrades the agent." (08:52)
- "The session log essentially contains events of everything that happened during an agent execution." (24:17)
- "We saw 60% faster time to first token for P50 use cases and over 90% improvements in latency for time to first token in P95 use cases." (23:51)
- "Harnesses have become the limiting factor to what models can achieve." (30:22)

## Tools & references mentioned
- Anthropic
- Claude
- Claude 3
- Sonnet 4.5
- Opus 4.5
- Messages API
- Claude Agent SDK
- Claude Code
- Claude Cowork
- Atlas
- MCP
- dreaming
- outcomes

## Who should watch
- You are building an agent from a prototype and are deciding which infrastructure to own yourself.
- Your agent runs for long periods, uses tools or sandboxes, and needs recovery when a component fails.
- You need to understand how credentials, private MCP servers, session history, and model upgrades affect a production agent.