Kleiner Perkins · Published 2026-08-25

Inside Anthropic's 200-Person Platform Team | Katelyn Lesse and Angela Jiang

Open on YouTube ↗

Summary

Overview

  • Speaker: Josh Coyne and Leigh Marie Braswell with guests Angela Jiang and Katelyn Lesse
  • Channel: Kleiner Perkins
  • Main topic: Shipping AI Agents at Scale
  • Purpose: Provide founders and operators building AI products with deep insights into model infrastructure, agent architecture, trust, and organizational dynamics from Anthropic's perspective. An in-depth discussion with Anthropic's platform team members Angela Jiang and Katelyn Lesse, exploring the evolution of AI models, agent infrastructure, autonomy, trust, reliability, and how a 200-person team builds products that define the next decade of technology.

Topic Map

From Model APIs to Agent Infrastructure

  • Explanation: How the AI industry shifted from basic model wrappers to robust agent infrastructure where models run longer, execute tasks, and recover from errors.
  • Key claims:
    • Models have gotten significantly better at working for longer periods.
    • Infrastructure around models has become critical to enable long-running agent workflows.
    • Engineering challenges shifted from simply getting the model to output text to handling error recovery and security.
  • Examples:
    • Moving from manual cell-by-cell spreadsheet editing to automated DCF valuation agents.
  • Terminology:
    • model APIs
    • agent infrastructure
    • DCF
    • prompt caching
  • Why it matters: Understanding infrastructure needs helps engineers build reliable, production-grade AI agents rather than simple chat demos.

Autonomy and What It Costs

  • Explanation: Evaluating the trade-offs of giving AI agents greater autonomy and the engineering systems required to support it safely.
  • Key claims:
    • Autonomy requires robust error recovery and sandboxing to prevent catastrophic failures.
    • Unsupervised agents need guardrails and observability layers to ensure compliance.
  • Examples:
    • Agents opening spreadsheets, calculating values, verifying their own work, and retrying upon errors.
  • Terminology:
    • autonomy
    • sandboxing
    • error recovery
  • Why it matters: Balancing autonomy with safety is the central challenge of deploying production AI agents.

Trust, Reliability, and Production

  • Explanation: Building trust in agentic systems through architecture, sandboxing, and rigorous observability.
  • Key claims:
    • Trust relies on architectural bounds and robust observability layers.
    • Agent failures must be caught and handled within security bounds.
  • Examples:
    • Injecting credentials securely without exposing them directly to the agent.
  • Terminology:
    • observability
    • sandboxing
    • credentials
  • Why it matters: Without trust and reliability, enterprises cannot deploy agents into production systems.

Key Points

Models can now work longer and smarter

  • Explanation: A year ago, interactions were human-in-the-loop chat sessions. Today, models execute long-running tasks autonomously.
  • Evidence: Observed transition from simple prompt-response chatbots to multi-step agents executing financial workflows.
  • Practical implication: Engineers must build infrastructure that supports long-running, fault-tolerant agent execution.

Infrastructure replaces prompt engineering hacks

  • Explanation: Rather than forcing models down rigid paths with extensive prompting, proper infrastructure allows models to operate naturally over extended periods.
  • Evidence: Discussion on moving from constrained cell editing to autonomous financial analysis.
  • Practical implication: Invest in infrastructure layers rather than over-engineering prompt constraints.

Two layers of trust in agents

  • Explanation: Trust is built through architectural security bounds and agent observability.
  • Evidence: Anthropic's approach to sandboxing and output verification.
  • Practical implication: Enterprise adoption requires strict security boundaries and clear auditing tools.

Frameworks, Models & Processes

Cloud Managed Agents Harness Architecture

  • How it works: Provides a robust, generic harness that handles foundational execution, error recovery, and system prompting while exposing higher-level customization.
  • Components:
    • Base execution harness
    • System prompt tuning
    • Skill configuration
    • MCP (Model Context Protocol) connections
  • When to use: When building production-ready AI agents without rewriting low-level infrastructure.

Examples & Case Studies

A customer integrated a new API by dragging documentation into cursor and getting 70% accuracy.

  • Illustrates: The power of model capabilities combined with context windows in knowledge work.
  • Lesson: AI significantly accelerates developer onboarding and integration tasks.

Actionable Takeaways

  • Immediate:
    • Utilize cloud managed agents for robust infrastructure.
    • Implement prompt caching and context management.
  • Strategic:
    • Focus engineering efforts on high-level agent architecture rather than low-level harness tinkering.
    • Design products for agentic workflows where agents act as primary collaborators.
  • Questions to investigate:
    • How do token economics impact long-running agent workflows?
    • What is the optimal form factor for human-agent collaboration?

Claims Worth Verifying

  • Anthropic's platform team operates efficiently with around 200 people. (organizational claim)

Notable Quotes

"We have to be a team that's really ready to get punched in the face." (at 0:02) "Welcome back to season two of Builders, a video series from Kleiner Perkins." (at 0:31)

Compressed Summary

  • AI agents have evolved from chat interfaces to long-running autonomous workers.
  • Infrastructure is now the primary bottleneck and value driver for agent deployment.
  • Trust requires robust sandboxing, security bounds, and agent observability.
  • Cloud managed agents simplify enterprise adoption by abstracting low-level harness engineering.
  • Keywords: ai agents, infrastructure, anthropic, cloud managed agents, autonomy
  • Core insight: Building successful AI agents requires robust infrastructure and architectural trust layers that allow models to operate autonomously and reliably at scale.

Core insights

5
Architecturemedium noveltystrong evidence

The binding constraint for agent engineering has moved from getting a model to emit good text to building the reliability and security infrastructure around long-running model execution.

Why it matters

Teams that dedicate engineering effort to prompt hacks are optimizing the wrong layer; the model already handles text, while failures, retries, and credential safety dominate production outcomes.

Generalization

As model generation capability improves, marginal engineering advantage shifts to execution lifecycle, error handling, and permissioning.

Engineering challenges shifted from simply getting the model to output text to handling error recovery and security.
Open source video
Models have gotten significantly better at working for longer periods.
Open source video
Architecturehigh noveltystrong evidence

Production agents do not achieve trust by making the model more conservative; trust comes from two architectural layers: external security bounds and observability of agent behavior.

Why it matters

This reframes enterprise trust as an infrastructure and auditing problem rather than a prompt or model-alignment problem.

Generalization

For any high-stakes agent deployment, define a security perimeter and an audit trail before tuning behavior.

Trust relies on architectural bounds and robust observability layers.
Open source video
Enterprise adoption requires strict security boundaries and clear auditing tools.
Open source video
Injecting credentials securely without exposing them directly to the agent.
Open source video
Architecturemedium noveltymoderate evidence

Managed agent harnesses are an abstraction boundary: base execution, error recovery, and system prompting become provider-owned, while customization happens as skills and MCP connections.

Why it matters

This lets builders stop rewriting low-level harness code and differentiate at tool, skill, and workflow level.

Generalization

When a platform offers a robust generic execution harness, the highest-value engineering investment is configuring skills and connections, not reinventing runtime plumbing.

Provides a robust, generic harness that handles foundational execution, error recovery, and system prompting while exposing higher-level customization.
Open source video
Base execution harness
Open source video
System prompt tuning
Open source video
Skill configuration
Open source video
MCP (Model Context Protocol) connections
Open source video
Tradeoffmedium noveltystrong evidence

Autonomous agents create a direct cost: they require error recovery and sandboxing to contain failures and require guardrails and observability to maintain compliance.

Why it matters

Choosing an autonomy level is not a binary product decision; it changes the engineering burden and compliance requirements.

Generalization

Every increase in unsupervised runtime must be paired with a matching investment in containment and inspectability.

Autonomy requires robust error recovery and sandboxing to prevent catastrophic failures.
Open source video
Unsupervised agents need guardrails and observability layers to ensure compliance.
Open source video
Mental Modelmedium noveltymoderate evidence

Rather than constraining models with elaborate prompts, modern agent infrastructure should let the model operate naturally over long periods while infrastructure handles faults, so agents can verify their own work and retry.

Why it matters

Engineers used to treat prompts as the control plane; this says the control plane should be the runtime, with caching and tool-aware execution.

Generalization

Capability gains in models mean engineering effort should shift from brittle prompt constraints to platform features like error recovery and context/caching management.

Rather than forcing models down rigid paths with extensive prompting, proper infrastructure allows models to operate naturally over extended periods.
Open source video
Agents opening spreadsheets, calculating values, verifying their own work, and retrying upon errors.
Open source video

Deep dives

5

Error Recovery as the Core Engineering Discipline for Long-Running Agents

Research question

Which error categories emerge when language-model agents run unattended over minutes-to-hours, and which recovery primitives (automatic retry, verification, human escalation) produce the largest reliability gain?

Why

The pass-1 insight says the hard engineering part moved from generating text to handling error recovery and security. A taxonomy of agent errors and recovery strategies will guide teams toward building platforms rather than prompts.

Engineering challenges shifted from simply getting the model to output text to handling error recovery and security.
Open source video
Models have gotten significantly better at working for longer periods.
Open source video
Source video

Architectural Trust: Security Bounds and Observability as the Contract for Enterprise Agents

Research question

What is the minimal set of architectural mechanisms (sandboxing, credential injection, event logs) that an agent platform must provide before an enterprise will treat an autonomous agent as auditable and deployable?

Why

The source claims trust comes from bounds and observability, not conservative model behavior; this needs to be operationalized into concrete platform requirements.

Trust relies on architectural bounds and robust observability layers.
Open source video
Injecting credentials securely without exposing them directly to the agent.
Open source video
Source video

Observability Grain Size for Agent Incident Reconstruction

Research question

At what event granularity should an agent platform log actions so that operators can reconstruct any failure or security incident quickly without drowning in routine token-level noise?

Why

Pass-1 names observability as a trust pillar but leaves its required resolution unspecified; this deep dive would turn it into a measurable engineering spec.

Unsupervised agents need guardrails and observability layers to ensure compliance.
Open source video
Trust relies on architectural bounds and robust observability layers.
Open source video
Source video

Interaction Design for Human Oversight of Autonomous Agents

Research question

Does approving an agent's summarized plan and status deliver acceptable safety and task quality compared with approving every action, and where are the failure points?

Why

The source underscores that autonomous agents need guardrails, but the product form factor of human supervision is unknown; this determines whether 'human-in-the-loop' can scale beyond a demo.

Unsupervised agents need guardrails and observability layers to ensure compliance.
Open source video
Agents opening spreadsheets, calculating values, verifying their own work, and retrying upon errors.
Open source video
Source video

Token Cost Economics of Agentic Retry and Self-Verification

Research question

What is the token-cost multiplier of adding error recovery (retry, self-verification) to long-horizon agent workflows, and can prompt caching offset the additional cost enough to be viable?

Why

Token economics was flagged as an unresolved constraint; without a cost model for retries and verification, autonomy decisions are made without a P&L.

Models have gotten significantly better at working for longer periods.
Open source video
Moving from manual cell-by-cell spreadsheet editing to automated DCF valuation agents.
Open source video
Source video

Article ideas

4

Stop Prompt-Hacking Your Agents: The Control Plane Is Now the Runtime

Modern model quality means long-horizon behavior is best controlled with infrastructure—error recovery, caching, and observability—not with brittle prompt constraints; teams that pour effort into clever system prompts are investing in the wrong layer.

Angle

A polemic aimed at engineering leaders who measure agent quality by prompt length rather than runtime reliability, grounded in Anthropic's platform-team shift.

Source video

Enterprise Trust Is a Security Perimeter, Not a Model Attitude

No prompt can make an agent safe enough for production; enterprises should demand sandbox boundaries, credential injection, and audit logs because trust in agents is an architectural property.

Angle

Advisory piece for enterprise platform buyers and internal platform teams deciding how to evaluate agent vendors.

Source video

The Managed Agent Harness Is the New Managed Database

Just as teams stopped self-hosting databases once managed services matured, builders of AI agents should treat the execution harness (error recovery, sysprompting, routing) as provider-owned commodity and compete on skills, MCP connections, and workflow design.

Angle

Infrastructure-shift analogy; argues that the platform layer, not the model, is becoming the primary differentiator.

Source video

Autonomy Is an Engineering Budget, Not a Feature Flag

Deciding to let an agent run unattended is deciding to spend on error recovery, sandboxing, guardrails, and observability; teams that treat autonomy as a binary product checkbox will find the cost in compliance failures and hard-to-debug incidents.

Angle

Cost/tradeoff framework for product managers choosing autonomy levels.

Source video

Project ideas

3

Secret-Safe Tool Gateway

gatehouse

Interposing a credential-injection gateway between an agent and its tools — so secrets are bound to tool calls and never appear in the model context — reduces secret leakage to zero on an adversarial prompt-injection suite, whereas baseline prompt-injected credentials leak in at least one case.

Proof of concept

Wrap a sample API tool with a gateway that reads credentials from an environment secret store, injects them only when making the tool call, and scrubs the model-visible context; run 50 adversarial prompt-injection attempts against both baseline and gateway.

Measurement

Secret leak rate (%) in tool calls, responses, and logs; median time to first leak.

Source video

Self-Verification Agent Cost Benchmark

beyond-evals

A spreadsheet-valuation agent that verifies its own work and retries on error will cut task failure rate by more than 50%, while total token cost per successful task stays below 1.5x the no-verification baseline when prompt caching is enabled.

Proof of concept

Build a controlled DCF/spreadsheet task where an agent fetches cells, performs calculations, verifies totals, and retries on inconsistency; run 50 trials in four modes: no verification, verification only, verification+retry, verification+retry+prompt caching.

Measurement

Task success rate, tokens per successful task, wall-clock time per task.

Source video

Oversight Mode A/B Test for Agent Supervision

new

For a routine multi-step data-entry agent, summary-gated supervision will match step-by-step approval on final task quality while consuming less than 50% of the operator's time and maintaining equal operator trust.

Proof of concept

Implement the same agent behind two UIs: one asking approval for every write/action, the other presenting a plan and post-run summary for approval. Run a within-subject operator study with 10 operators and 40 tasks.

Measurement

Task error rate, operator time per task, intervention count, self-reported trust score.

Source video

Architectural implications

3

Trust is an explicit architectural layer, not emergent model behavior.

Before

In traditional chatbots, user reviews model output before any consequential action.

After

In agent systems, sandboxes and credential injection bound what an agent can do, and observability records what it did.

Consequence

Agent products must begin with permission boundaries and audit trails as first-class components rather than adding them after deployment.

Source video

Cloud managed agents place the execution harness at a platform layer, above model APIs and below skills/MCP.

Before

Teams built custom runtimes and battle-tested error recovery themselves.

After

Teams configure system prompts, skills, and MCP connections atop a provider-backed harness.

Consequence

Development effort shifts from infrastructure plumbing to the semantics of tools, skills, and workflow orchestration.

Source video

Successful agent behavior is increasingly enabled by infrastructure rather than prompt constraints.

Before

Developers constrained the model with rigid prompting and multi-step chain-of-thought hacks.

After

Model runs longer, retries on errors, and validates intermediate outputs because the harness provides context, caching, and recovery.

Consequence

Retain engineers for building observability and execution control rather than for prompt iteration.

Source video

Tradeoffs and failure modes

3

Autonomy vs safety

Benefit

Agents execute long-running tasks and recover without waiting for human instruction.

Cost or risk

Without sandboxing, catastrophic failures; without guardrails and observability, compliance is breached.

Autonomy requires robust error recovery and sandboxing to prevent catastrophic failures.
Open source video
Source video

Trust through containment vs trust through behavior

Benefit

Architectural bounds define what can go wrong and make agent actions auditable for enterprise adoption.

Cost or risk

An over-tightened security layer can block valuable agent capabilities; an overly permissive one makes auditing impossible.

Trust relies on architectural bounds and robust observability layers.
Open source video
Source video

Managed harness vs bespoke runtime

Benefit

Avoids rewriting low-level infrastructure for execution, error recovery, and system prompting.

Cost or risk

Provider-managed harness may not allow the full customization a highly differentiated agent needs.

Provides a robust, generic harness that handles foundational execution, error recovery, and system prompting while exposing higher-level customization.
Open source video
Source video

Open questions

3

How do token economics impact long-running agent workflows?

Why unresolved

Summary identifies token economics as important but provides no cost model for multi-step, retrying agents.

Research direction

Measure total token cost as a function of task length, retry rate, prompt caching, and observability overhead.

Source video

What is the optimal form factor for human-agent collaboration?

Why unresolved

The summary discusses autonomy and guardrails but does not specify whether humans approve steps, review outcomes, or intervene on exceptions.

Research direction

Prototype and compare supervision interfaces: per-action approval, summary-based approval, and post-hoc auditing.

Source video

How granular must observability be to establish trust without drowning operators in logs?

Why unresolved

The summary treats observability as a requirement but never characterizes required grain size or overhead.

Research direction

Design observability layers that capture security-relevant actions and outcomes while suppressing routine step noise, then benchmark operator trust and effectiveness.

Source video

Key claims

7
comparativeVerification needed

Models have gotten significantly better at working for longer periods.

Evidence

Models have gotten significantly better at working for longer periods.

Question

Which evals or industry evidence show the improvement in long-horizon task completion over the past year?

Source video
causalVerification needed

Engineering challenges shifted from simply getting the model to output text to handling error recovery and security.

Evidence

Engineering challenges shifted from simply getting the model to output text to handling error recovery and security.

Question

Can we quantify the distribution of engineering effort across model generation, error recovery, and security in real production agents?

Source video
causalVerification needed

Trust relies on architectural bounds and robust observability layers.

Evidence

Trust relies on architectural bounds and robust observability layers.

Question

Which production agent incidents are prevented by architectural containment vs. detected by observability?

Source video
causalVerification needed

Autonomy requires robust error recovery and sandboxing to prevent catastrophic failures.

Evidence

Autonomy requires robust error recovery and sandboxing to prevent catastrophic failures.

Question

How does the rate of unhandled failures change when agents are given autonomous retry vs. human-in-the-loop?

Source video
factualVerification needed

Cloud managed agents provide a robust, generic harness that handles foundational execution, error recovery, and system prompting.

Evidence

Provides a robust, generic harness that handles foundational execution, error recovery, and system prompting while exposing higher-level customization.

Question

Does Anthropic's cloud-managed agent harness actually deliver these features robustly at production scale?

Source video
factualVerification needed

A customer integrated a new API by dragging documentation into Cursor and getting 70% accuracy.

Evidence

A customer integrated a new API by dragging documentation into cursor and getting 70% accuracy.

Question

Can this be reproduced in a controlled evaluation and compared against baseline API integration approaches?

Source video
factualVerification needed

Anthropic's platform team operates efficiently with around 200 people.

Evidence

Anthropic's platform team operates efficiently with around 200 people. (organizational claim)

Question

What is the actual headcount of Anthropic's platform team and how does that correlate with product output?

Source video

Connections

5

ObservabilityTrust

Observability provides the audit trail that makes an agent's actions inspectable, which is required for enterprises to trust autonomous behavior.

Source video