How Anthropic Builds Claude With Claude: The Brain-and-Hands Architecture Explained
Latent Space's deep-dive with Anthropic's engineering and product heads reveals the brain-and-hands architecture behind Claude's Managed Agents, explaining why separating session state from code execution improves both reliability and security. The episode also contextualises Anthropic's dramatic efficiency gains and is honest about what remains on the roadmap versus what is already shipped.
Anthropic Just Explained How It Ships Its Own AI — Using That Same AI
Most conversations about Claude focus on what it can do for you. A far rarer conversation is how Anthropic builds, tests, and deploys Claude at scale — and what architectural decisions sit underneath the product you actually use. Latent Space’s discussion with Katelyn Lesse and Angela Jiang, Anthropic’s heads of Engineering and Product respectively, surfaces exactly that. The episode, published at latent.space/p/opus55, is one of the most technically candid accounts of how a frontier AI lab structures its platform engineering. Even if you are not a developer, the concepts inside matter for how you think about AI tools and their reliability.
The Model Launch You Saw — and the API Launch You Probably Missed
When Opus 5.5 launched, the public conversation centred on benchmark rankings and cost. Latent Space’s discussion notes that Anthropic positioned the model on both quality and cost efficiency, with the new version costing less to run than its predecessor — though the exact saving depends on the workload and how much cached context it uses.
Beneath that headline, however, was a quieter set of changes to how developers connect to the API. One example the episode highlights is a new requirement around preserved thinking blocks. Anthropic made a deliberate engineering choice to protect the model’s reasoning process from being extracted and used to train competing models — a practice called distillation. Preserving thinking blocks across conversation turns addresses this, but as the episode candidly notes, a new requirement like that can also break an existing customer’s integration. A company that had built a workflow assuming a particular API behaviour suddenly has to update its code. That tension — between protecting the model and not disrupting customers — is a real tradeoff that does not appear in any press release.
The Mental Model That Changes How You Think About AI Agents
The most useful concept in the Latent Space episode is what the guests call the separation of the brain and the hands.
In Claude’s Managed Agents architecture, Anthropic separates two distinct components:
- The session log and harness (the brain): This is the part that holds conversation history, context, and the ongoing state of an agent’s work.
- The sandbox that executes code (the hands): This is the isolated environment where the agent actually runs code, browses files, or calls external tools.
Latent Space’s discussion of this notes that an earlier approach put the entire coding agent inside a single sandbox behind an API. The problem was latency and fragility: starting the environment added delay before the first response, and if the sandbox crashed, the entire agent session — including all its accumulated context — was lost with it.
By separating these two layers, the harness can persist and stay alive even if the execution environment fails or needs to be restarted. The brain survives even when the hands stumble.
Why This Separation Is Also a Security Decision
The brain-and-hands split is not just about reliability. It is also about where sensitive credentials live.
Latent Space’s discussion describes a design where generated code runs in a sandbox that never receives a service credential directly. Instead, credentials are held separately and attached through a proxy, with controls on where sandbox traffic is permitted to go. Anthropic’s containment write-up, referenced in the episode’s show notes, describes the broader set of isolation and network controls used across its products.
The practical implication: if a piece of AI-generated code turns out to be malicious or simply buggy, it cannot read the API keys or database passwords that were never placed in its environment to begin with. The architecture limits the blast radius of failure by design.
For anyone building or evaluating AI tools at their organisation, the Latent Space episode frames this as a useful set of questions to ask any vendor: Which parts of the system need to survive a failure? Which parts execute untrusted or generated work? And which secrets actually need to be present in the environment where code runs?
What This Looks Like for a Non-Technical Team in India
Consider a mid-size wealth management firm in Pune whose operations team uses an AI assistant to process client portfolio queries, generate compliance summaries, and pull data from internal systems. On the surface, the team just sees a chat interface. But underneath, they are running what is effectively a managed agent — the assistant reads documents, runs calculations, and writes outputs.
Under an architecture that does not separate the brain from the hands, a single error in retrieving data from the firm’s internal server could crash the entire session. The relationship manager then has to start the query from scratch, re-enter context, and wait for the environment to restart. At scale, across dozens of concurrent users, that is a meaningful reliability problem.
Under the brain-and-hands model that Latent Space’s discussion attributes to Anthropic’s Managed Agents, the session and its accumulated context survive the execution failure. The hands can be restarted without the brain losing memory. And crucially, the firm’s internal database credentials are never handed directly to the code-execution layer — they are proxied in, reducing the risk that a misbehaving API call can leak sensitive client information.
This is not a hypothetical. It is the architecture Anthropic says it is building into the platform that enterprise customers in India and globally are already integrating.
Memory, Dreaming, and the Limits of What Is Shipped
The episode also describes an experimental capability called Dreaming, which Latent Space’s discussion explains is simply implemented as one agent inspecting another agent’s prior work and writing memories back. It is an example of building a higher-level behaviour — persistent memory across sessions — out of the same underlying managed-agent primitives.
This is worth noting carefully. Memory and multi-agent coordination are described as important on the roadmap, but the episode is explicit that more of the immediate engineering attention has moved toward safety as model launches have become more complex. The guests discuss keeping the base harness relatively simple while letting developers experiment with verifiers, parallel agents, and other strategies on top.
Latent Space appropriately cautions that ideas mentioned for future platform capabilities should be treated as plans, not shipped promises. If your team is making procurement or integration decisions based on anticipated features, that distinction matters.
The Efficiency Story Behind the Architecture
Latent Space’s episode opens with context from Anthropic’s S-1 filings. According to those disclosures, Anthropic reported its first profitable quarter under generally accepted accounting principles — a 19% GAAP profit margin, compared to a loss of over 126% of revenue a year earlier. Revenue per employee reportedly grew from approximately ₹1.19 crore (roughly USD 1.4 million) to approximately ₹5.61 crore (roughly USD 6.6 million) in one year.
The episode attributes this in part to what Anthropic calls two core loops: an improvement loop, where Claude helps build better Claude, and an investment loop, where revenue from adoption funds the capabilities that drive more adoption. The platform architecture discussed throughout the episode is the mechanism by which those loops operate — the engineering infrastructure that makes it possible to ship Claude using Claude.
Over 50% of customers generating more than USD 100,000 in annualised revenue on the Claude Platform reportedly use it directly, according to disclosures referenced in the episode. That is the scale at which these architectural choices — sandbox isolation, brain-and-hands separation, credential proxying — stop being academic and become operational necessities.
Honest Limitations to Keep in Mind
A few important caveats for readers evaluating any of this:
- Managed Agents and the brain-and-hands architecture are described as active development areas, not fully settled products. The episode is candid that the roadmap includes plans, not only shipped capabilities.
- Early access programs involve trade-offs. Latent Space’s discussion describes early access customers discovering surprising model behaviour that Anthropic’s own internal products did not surface. If your team is in such a program, you are contributing to evaluation, not just consuming a finished product.
- The API changes around preserved thinking blocks may affect existing integrations. Teams that have built custom Claude workflows should verify their harnesses are compatible with newer model versions before assuming continuity.
- The episode does not specify which features or architectural capabilities are available in which regions or pricing tiers. Indian teams evaluating Claude Platform for enterprise use should confirm feature availability directly with Anthropic’s sales or developer relations teams.
What to Watch For Next
Latent Space’s discussion flags that evaluations — structured ways of measuring whether a model is actually doing the right thing for real users — are becoming a core discipline, not just a technical nicety. The guests describe using models to help build and analyse evaluations, while retaining human judgment about whether an evaluation reflects a real user’s actual job.
If your organisation is moving from experimenting with Claude to depending on it, that framing is worth internalising. The next layer of capability is not just a smarter model. It is a more thoughtful harness around it — and a clearer sense of which parts of your workflow need to survive, which parts can fail safely, and which secrets should never be handed to the hands.
