Anthropic Rejects AI Walled Gardens to Push Industry Standards

Anthropic拒绝AI围墙花园，力推行业标准 Anthropic将其AI生态战略押注于MCP等开放协议及模块化执行框架上，认为企业的长期采用取决于标准化的互操作性，而非封闭的垂直技术栈。 Katelyn Lesse与Angela Jiang概述了Anthropic的平台架构，该架构兼顾了内部产品开发的快速推进与面向外部开发者的灵活原语支持。她们详细介绍了涵盖知识、执行和协同策略的三层技术栈，重点阐述了模型上下文协议（MCP）等开放标准以及托管智能体基础设施。讨论强调了Token用量的合理优化而非暴力消耗、针对特定任务的执行框架，以及一种能让企业工作流与非Claude智能体实现无缝互操作的开放生态路线。 Anthropic 开发者平台确立了内部研发提速与外部跨云通用原语两颗“北极星”，通过内部试用（dogfooding）保持内外 API 能力对等，避免将开发者绑定在单一交互模式中。 (1:49) 平台架构被拆解为知识层（MCP 与技能）、执行层（沙箱与执行 Harness）以及协调层（Meta-Harness 策略）三层栈，致力于将复杂的运行基础设施封装为 Managed Agents 等高级抽象。 (9:07) Anthropic 坚持构建开放生态而非封闭的“围墙花园”，与 Modal、Vercel 等伙伴合作支持自托管沙箱，并推动 Model Context Protocol (MCP) 成为跨模型与跨系统互联的通用标准。 (15:39) 如 Claude Tag 所示，类似 Slack 的前端界面仅是冰山一角，其核心壁垒在于底层组织级 Harness 对企业级上下文工程、主动任务生成与安全工具路由的深度整合。 (22:26) 行业正从“Token 暴力消耗”迈向“Token 成本合理化”，Anthropic 提出“让每个 Token 承担专门角色”（如执行、反思或顾问），并主张针对 Claude 模型家族精细调优 Harness 而非提供泛化的跨模型路由。 (38:13)

Anthropic platform leaders Katelyn Lesse and Angela Jiang argue that scalable AI development requires an open, modular ecosystem rather than a walled garden, supported by standardized protocols and specialized execution harnesses. They assert that developer value is shifting from brute-force token usage toward multi-layer coordination architectures where individual tokens perform dedicated operational roles. The Three-Layer Agent Architecture (9:07) Angela Jiang outlines Anthropic's platform roadmap across three architectural tiers: knowledge, execution, and coordination. The baseline knowledge layer encompasses core model capabilities, structured prompt parameters, tool calling, and context integration through protocols like the Model Context Protocol (MCP). The execution layer provides managed sandboxes and infrastructure—exemplified by Claude Managed Agents—that allow models to execute code, edit files, and interact with external systems without requiring builders to manually engineer state persistence, safety sandboxing, or context caching. The coordination layer occupies the top tier, managing multi-agent strategies and meta-harnesses. Because tokens are non-fungible, this layer orchestrates specialized workflows by directing specific tokens to advise, execute, reflect, or review. While early-stage startups and low-level builders continue to prefer direct access to raw primitives to fine-tune performance, Lesse and Jiang note that enterprises increasingly favor higher-level managed abstractions to operationalize multi-step business workflows. Modular Infrastructure Over Walled Gardens (13:06) Rather than requiring developers to run code strictly within Anthropic-controlled sandboxes or proprietary storage, the platform emphasizes modular execution. Comparing the current phase of AI to the early electrification era, the speakers contend that AI utility relies on universal interoperability rather than single-vendor ownership. The platform natively supports self-hosted environments via providers such as Modal, Vercel, Cloudflare, and AWS Firecracker microVMs, utilizing MCP tunnels to safely query tools behind corporate firewalls. Anthropic separates standardization into two levels: a technical builder layer centered on MCP specifications to enable programmatic interoperability, and a higher-order layer focused on collective infrastructure defense against fraud and cyber threats. Jiang argues that achieving multi-agent trans-actability—where autonomous agents collaborate across different organizational boundaries—depends on these industry-wide safety and technical baselines. Harness Engineering and Domain Verification (126:09) As underlying models have become more steerable through system prompts, harness engineering has transitioned from rigid scaffolding toward context hygiene and execution management. Lesse highlights that low-level harness performance depends on systematic hygiene: aggressive prompt caching, programmatic tool calling to prevent context bloat, context clearing, and structured evaluation frameworks. Anthropic references Claude Tag—an internal tool embedded in Slack and Teams—to demonstrate that user interfaces are secondary to the underlying organizational harness managing context and cross-system tool routing. For high-stakes domains like finance, legal review, and healthcare, Jiang and Lesse state that generic execution loops fall short due to low error tolerance. Instead, task-specific verification logic, structured retry mechanisms, and hand-offs between execution and verification agents form the core technical moat for production-grade vertical applications. Shifting from Token Maxing to Coordination (218:13) The speakers identify an enterprise transition from 'token maxing'—consuming raw token volume to maximize brute intelligence—to 'token rationalization,' focused on balancing cost, speed, and latency. Drawing parallels to historical cloud computing optimization at firms like Stripe, Lesse cautions against blunt usage bans that stifle organic adoption. Instead, Anthropic recommends task-complexity routing, delegating routine tasks to smaller models while escalating complex problems to larger models within the Claude family. Under this 'token has a job' paradigm, workflows allocate distinct tokens to planning, executing, reflecting, and grading. To overcome performance ceilings in single-agent execution, Jiang points to multi-agent coordination and 'best-of-N' sampling as more effective alternatives to simply increasing model size or loop duration, noting Anthropic's plan to package these coordination patterns into turn-key platform primitives. While Anthropic champions open specifications and modular execution over closed walled gardens, its planned coordination harnesses and routing primitives remain intentionally optimized for the Claude model family rather than functioning as cross-vendor model routers.

Anthropic 开发者平台负责人 Katelyn Lesse 与 Angela Jiang 指出，该平台致力于在内部工程提速与外部构建者赋能之间保持能力对等，坚决不建封闭的“围墙花园”。她们提出了涵盖知识、执行与协调的三层架构，主张通过模型上下文协议（MCP）等开放规范以及让“每个 Token 各司其职”的策略，推动行业从盲目堆砌计算力转向精细化编排。 双轮驱动平台与模块化开放生态 (1:49) Lesse 与 Jiang 将平台的职责概括为两个平行的核心目标：对内最大限度提升工程团队研发前沿产品的杠杆与迭代速度；对外向各类开发者提供构建工具，并通过深度集成 AWS 和 Google Cloud 融入企业现有技术栈。Anthropic 秉持严格的平台对等哲学，内部自测验证（Dogfooding）与外部早期访问计划同步推行，避免将前沿核心技术私有化或滞留在内部体系中。 在生态策略上，Anthropic 明确反对打造封闭的控制栈，不强制开发者将其执行沙箱或数据存储绑定于 Anthropic 的专有环境。团队通过支持 Modal、Vercel、Cloudflare 以及 AWS Firecracker 微虚拟机（microVMs），允许企业自托管沙箱环境，并借助 MCP 隧道（MCP Tunnels）安全穿透企业防火墙连接私有服务。引用电力网络普及的历史类比，团队强调统一的技术互操作性与跨行业安全防护标准才是 AI 规模化扩展的前提，单靠一家厂商无法独自构建未来的底层网络。 从消息接口到三层代理架构演进 (9:07) 伴随 Claude 上下文窗口的扩大和执行周期的延长，平台从最初的无状态 Messages API 逐步进化为高阶代理基础设施。Anthropic 将其长期平台路线图划分为三层技术栈：一是专注模型能力、结构化提示参数、工具调用与上下文注入（MCP 和 Agent Skills）的“知识层”；二是提供底层执行 Harness 与托管环境（如 Claude Managed Agents），支持文件编辑和跨系统代码运行的“执行层”；三是处于顶层的“协调层”，旨在通过元 Harness 将不同角色（建议、执行、反思等）串联为连贯的多代理工作流。 在底层 Harness 工程中，团队强调维持严格的上下文卫生（Context Hygiene），包括主动实施提示词缓存（Prompt Caching）以削减开销、以程序化方式按需调用工具以避免冗余数据污染上下文，以及依托评估框架（Evals）持续追踪性能基准。Jiang 观察到，得益于现代模型指令遵循能力的提升，过去用于强行纠偏的笨重脚手架正被逐步剥离，Harness 的重心转向长期执行与更高维度的预算分配。 从蛮力消耗迈向 Token 理性编排 随着代理工作流走向常态化，市场正从不计成本堆砌计算力的“蛮力期”（Token Maxing）跨入兼顾成本、速度与延迟的“理性期”（Token Rationalization）。Lesse 结合其在 Stripe 监控 AWS 云计算账单的经历指出，企业对 AI 开销的治理正在经历类似的成熟周期。简单粗暴的封禁或预算封顶不仅会扼杀创新，还会滋生以非官方工具为代表的“影子 IT”，合理的路径应是在保障治理可见性的同时引入结构化调度。 Anthropic 的核心设计理念是“每个 Token 皆有分工”（The token has a job）。团队摒弃无差别的单模型彻夜循环，转而依据任务复杂性实施分级路由——将简单日常任务分配给轻量且廉价的模型（如 Haiku），仅在面对高难度推理时动态升级至高智力模型（如 Opus）。此外，面对单代理执行收益递减的瓶颈，Anthropic 正在将多代理协作、“N 取最佳”（Best-of-N）采样等高阶元协调机制封装为开箱即用的平台原语，以替代脆弱的定制开发。 流动交互形态与组织级 Harness 实践 (17:12) 在应用形态层面，Anthropic 提倡拥抱“流动交互”视角，鼓励团队打破静态产品形态，甚至定期淘汰旧范式。团队优先聚焦具有高反馈频率与迭代特性的“消耗型”垂直领域（Token-Hungry Workflows），如软件工程、金融与法律行业。这类场景的特征在于单轮交互不仅不会终结任务，反而会激发下一轮更深度的生产力飞轮；而在容错率极低的垂直领域，定制化的执行与验证逻辑（Verification Loops）正成为关键的竞争护城河。 以内部工具 Claude Tag 为例，该工具常被外界误解为简单的聊天机器人，但其本质是 Andrej Karpathy 所定义的“组织级 Harness”（Org-level Harness）。表层的 Slack、Teams 或邮件交互仅是浮出水面的冰山一角，水面之下则是支撑上下文工程、前瞻性主动建议（Proactive Assistance）以及跨企业系统调用的复杂工程架构。此外，针对医疗等缺乏现代 API 的传统行业，企业开发者正结合 Claude 的计算机使用能力（Computer Use）搭建适配层，打通传统孤岛软件。 Lesse 与 Jiang 认为，AI 平台竞争的终局并非比拼封闭生态的掌控度，而在于能否为不同类型开发者——从追求严格合规的大型企业到灵活实验的独立开发者——提供高度可组合的原语支持。随着单模型性能逼近边际，行业尚未完全解决的问题在于如何在多代理元编排、跨平台互操作协议与跨企业网络安全标准之间建立稳固的协同防线。

## Background 本期视频由红杉资本（Sequoia Capital）于 2026 年 7 月 14 日在 YouTube 平台发布，由 Sonya Huang 与 Lauren Reeder 联合主持。简介指出，访谈深入探讨了 Anthropic 开发者平台负责人 Katelyn Lesse 与 Angela Jiang 的核心构建哲学——通过知识、执行与协调的“三层架构”、MCP 等开放标准以及生态沙箱合作，打造一个如电力般互联互通的开放生态，而非封闭的围墙花园。 ## TL;DR 访谈系统阐述了 Anthropic 开发者平台的演进路径与战略考量：技术栈正从底层的知识层、执行层逐步迈向由“策略”与元测试载具（Meta-Harness）主导的协调层，赋予不同 Token 规划、执行与反思等明确角色分工。团队坚持内外部共用同一套底层原语的“双北极星”原则，既快速孵化内部顶级产品，又通过自托管沙箱与 MCP 协议向全行业输出开放标准以实现跨智能体协作。面对企业在 AI 规模化落地过程中的开销与治理挑战，Anthropic 主张避免一刀切关停，而是倡导利用同模型家族内的智能路由策略与 Best-of-N 等架构手段来最大化“每美元智能”。 ## Atmosphere & style 整场对谈兼具硅谷前沿技术洞察的宏大愿景与一线系统工程实践的冷静务实，节奏明快且信息密度极高。红杉主持人的提问直切架构边界与商业化痛点，两位女性工程领袖则配合默契，在“AGI-pilled”的幽默调侃中坦率解构技术神话与工程细节。整场对话呈现出一种深入系统内核的通透感与对生态共建的坚定信念，既有拆解复杂基建时的严谨自律，又洋溢着如同早期电气化时代铺设电网般的笃定与极客兴奋感。 ## Bulletin - [00:00](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=0s) Anthropic 提出开发者平台的“三层蛋糕”架构（知识层、执行层与协调层），演进重心正由底层上下文交付跃迁至顶层“策略编排”，强调将 Token 划分为顾问、执行、反思与记忆等专属职责。 - [15:39](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=939s) 在平台生态上，Anthropic 坚持打造开放生态而非围墙花园，已将沙箱执行解耦并与 Modal、Vercel、Cloudflare 及 AWS 微虚拟机深度集成，支持通过 MCP 隧道穿透内网调用私有服务，不执着于底层硬件锁定。 - [39:23](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2363s) 针对模型路由，Anthropic 拒绝构建跨厂商通用路由层，强调 Harness 必须与特定模型家族深度绑定调优，其官方路由专注于在 Claude 家族内部按任务复杂度在 Opus 与 Haiku 之间智能分流以优化成本效益。 - [43:31](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2611s) 针对“堆大模型”与“死耗运行时间”面临边际效益递减的瓶颈，Anthropic 押注 Best-of-N 采样验证与多路径策略编排，致力于将原本极难落地的论文级架构沉淀为开箱即用的高阶原语。 ## Key takeaways - [00:00](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=0s) 平台架构“三层蛋糕”模型：涵盖底层的知识层（Messages API、工具调用、Skills）、中间的执行层（底层测试载具、托管沙箱）以及顶层的协调层（策略调度），技术路线图正自底向上持续演进。 - [01:49](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=109s) 平台坚持内外部统一的“双北极星”哲学：对内支撑产品团队以极限速度交付面向 AGI 的产品，对外输出通用原语赋能开发者；因底层模型演进剧烈导致形态极难预测，坚持内外使用同一套构建块。 - [06:00](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=360s) 从无状态 Messages API 跨入长程自主 Agent：针对缺乏人类实时介入的长程任务，平台推出 Claude Managed Agents，统筹沙箱动态编排、会话快照存储与工程级 Harness 缓存管理。 - [08:07](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=487s) 开发者诉求呈现阶梯分化：AI 原生初创公司倾向于在底层原语上自由修补与拼接，而业务驱动型企业则倾向直接采用全托管 Agent 方案以聚焦于端到端工作流的交付。 - [12:13](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=733s) 以“电力普及”类比生态建设：Anthropic 认为没有任何单一家公司能独立铺设整张 AI 电网，必须通过开源开放 MCP 协议与 Skills 规范，促进 Claude 与非 Claude 等异构 Agent 间的互联互通与安全防护共识。 - [15:39](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=939s) 基础设施全面解耦与内网穿透：Anthropic 不强制工作负载运行在自研硬件上，而是通过自托管沙箱对接多元算力伙伴，并依托 MCP 隧道穿透防火墙，支持企业安全接入私有数据与服务。 - [17:12](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1032s) 保持“好用一年就扔掉”的敏捷实验精神：产品形态随模型智能跃升而剧烈重塑，如 Claude Design 验证了抛弃传统所见即所得系统、纯靠代码生成驱动视觉表达的崭新交互可能。 - [19:56](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1196s) 商业化重点瞄准“Token 饥渴型”正向飞轮：优先布局编程辅助、金融与法律等高频且交互后能激发用户探索更多任务的垂直领域，并配套发布行业技能包与参考指南。 - [23:28](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1408s) 组织级 Harness 的冰山隐喻：类似 Claude Tag 等嵌入 Slack 的应用，水面之上的交互入口极为平淡，真正构筑壁垒的是水面之下庞大的上下文工程、主动性意向理解与多系统协同底座。 - [28:53](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1733s) 模型指令遵循能力吃掉死板脚手架，垂直领域转向极限校验：尽管模型进化让硬编码引导逐步精简，但在法律与金融等高合规场景中，针对工具报错捕获与极限验证的专用 Harness 仍不可或缺。 - [31:30](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1890s) 上下文塞入已沦为平庸能力，胜负手在于验证与预算调度：单纯堆砌上下文不再构成核心护城河，真正的系统壁垒在于模型与运行环境之间的验证闭环以及工作流中的 Token 预算精细分配。 - [34:07](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2047s) 真实前沿场景拓展认知边界：一线开发者正利用计算机使用（Computer Use）技术绕过 API 缺失的限制强行联通老旧医疗系统，同时以制造业为代表的实体工业正在展现出极强的 AI 改造诉求。 - [39:23](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2363s) 从无脑堆算力走向 Token 理性化治理：面对 AI 支出暴涨，粗暴叫停只会引发影子 IT 泛滥，正确策略是搭建类似云资源管理的监控审计，并在 Claude 家族内依据任务复杂度在旗舰大模型与轻量小模型间动态分流。 - [41:11](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2471s) 解耦通用路由不可行，Harness 需与模型家族深度绑定：业界实践表明跨模型通用路由器往往导致性能折损，Agent 执行层必须针对特定模型家族细致调优才能发挥极限智力。 - [43:31](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2611s) 超越大模型与长时间推理的“第三杠杆”：单纯扩大参数量或死耗时间边际收益递减，Anthropic 押注 Best-of-N 多路验证策略与 Token 专属职责化分工（顾问、执行、反思等），沉淀高 Alpha 收益。 - [46:10](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2770s) 平台能力深度模块化以提升“每美元智能”：既要满足大企业私有网络合规下的按需插拔集成，又要保持基础开发体验的高可魔改性，以同时赋能严肃企业级落地与周末极客社区创新。 ## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=0s) 协调层与“三层蛋糕”愿景：从底层 Harness 到策略编排 Angela Jiang 从 Anthropic 平台宏观的抽象分层切入，提出了平台的三层架构模型：最底层是知识层（Knowledge Layer），中间是执行层（Execution Layer），而顶层则是协调层（Coordination Layer）。在这套体系中，顶层正在孕育一种被称为“策略”（Strategies）的机制，它本质上是一种元套具（Meta-Harness）。低阶的 Harness 专注于具体的执行环节，而协调层则着眼于更高维度的调度：Tokens 本身并非同质或完全可替代的，它们在整个任务中承担着截然不同的分工——有的 Token 负责提供建议与规划（Advising），有的负责实际执行（Executing），有的则负责反思与记忆。 为了让复杂系统高效运转，必须将这些协调策略编排组合起来，并统一置于知识与执行之上。毕竟所有系统最终都要落到具体执行，而执行又依赖于具体的上下文知识，整套技术栈在逻辑上必须层层递进。Angela 指出，若展望 Anthropic 未来的平台路线图，团队的演进路径将非常清晰：从最开始深耕知识层，逐步向上推进至执行层，最终走向协调层，向外输出更高级别的抽象能力。 ```mermaid flowchart TD accTitle: Anthropic 平台的三层架构 accDescr: 展现知识层、执行层到协调层的自底向上抽象关系 subgraph Coordination["顶层：协调层 (Coordination Layer)"] direction LR S1["策略调度 (Strategies)"] S2["Token 分工 (Advising vs Executing)"] S1 --> S2 end subgraph Execution["中层：执行层 (Execution Layer)"] direction LR H1["低阶 Harness"] H2["环境沙箱与执行"] H1 --> H2 end subgraph Knowledge["底层：知识层 (Knowledge Layer)"] direction LR K1["上下文与状态"] K2["MCP 与外部数据"] K1 --> K2 end Knowledge --> Execution Execution --> Coordination ``` --- ### [01:04](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=64s) 平台的“双北极星”：对内赋能极速，对外输出原语 红杉资本（Sequoia Capital）的 Sonya Huang 与 Lauren Reeder 正式开场，欢迎 Anthropic 平台工程团队的两位核心负责人 Katelyn Lesse 与 Angela Jiang。Sonya 称 Anthropic 正在构建当今全球最关键的开发者平台之一。Katelyn 随后阐述了平台团队在公司内部的定位：他们不仅负责承载外部生态的开发者 API 和平台系统，让外部开发者能够调用 Claude 的智能来构建应用；同时，他们也是 Anthropic 内部的产品基础设施团队，支撑着公司自身所有面向用户的上层应用。 当被问及团队的“北极星指标”（North Star）时，Angela 风趣地表示，普通团队可能只有一个北极星，但他们由于同时兼顾对内与对外，实际上拥有两颗北极星，如同“两个不同的行星系统”： - **内部北极星**：为内部团队提供尽可能大的杠杆（Leverage），让他们能以极快的速度推出具备 AGI 思维的顶级产品（"AGI-pilled products"）。内部对交付速度、系统可靠性有着极其严苛的要求。 - **外部北极星**：赋予所有构建者利用 Claude 创造一切所需的能力。为实现这一点，平台主动贴近客户的实际业务环境，与 AWS、Google Cloud 等超大规模云厂商（Hyperscalers）展开深度原生集成；同时打造基础原语（Primitives），赋能定制软件开发。过去在经济上极不可行、成本高昂的“最后一公里定制软件”，在 AI 时代变得触手可及。 此外，Anthropic 将 Skills 和 MCP（Model Context Protocol，模型上下文协议）等能力直接确立为开放标准，不仅让 Claude 受益，也毫无保留地赋能整个行业生态。 --- ### [03:54](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=234s) 拒绝内外部割裂：基于不可预测的形态演化打造通用原语 在决定哪些能力沉淀进平台、哪些对外开放时，Anthropic 坚持内外部一致的底层哲学。许多平台型企业往往会将内部专有架构与外部商业产品完全割裂开来，但 Anthropic 刻意让两者保持统一。尽管内部产品团队可能存在细微的特殊场景需求，但 Anthropic 坚持让内部和外部开发者使用同一套底层原语。 这一策略背后的核心假设是：底层基础模型的演进速度是指数级的，这导致应用形态（Form Factors）处于剧烈变动中，极其难以预测。两年前全行业都坚信“一切应用的终局是对话聊天（Chat）”，而如今行业共识已经迅速转向了智能体（Agents），未来注定还会涌现出更多截然不同的形态。既然 Anthropic 并不自负地认为自己是唯一能摸索出终极形态的人，那么最佳解法就是将底层构建块充分民主化，让全市场的开发者共同实验，从而自然筛选出最佳的产品形态。 Katelyn 补充说明了团队在实践中的平衡机制： - 团队在尝试将原语封装为更高阶形态时，会时刻警惕避免陷入“过度契合内部需求”的认知陷阱。 - 典型的演进节奏是：在内部全面吃狗粮（Dogfooding）的同时，同步向外部客户开放早期尝鲜访问（Early Access）。 - 结合内部极速迭代的反馈与外部复杂多样化的实际诉求，将两端经验统一沉淀回通用平台。 --- ### [06:00](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=360s) 从无状态 Messages API 跨越到长程 Managed Agents 回顾平台的演化历史，Katelyn 提到在一年前她刚加入 Anthropic 时，开发者平台的核心形态基本上只有一个无状态的 Messages API。当时虽然已经探索了 MCP 规范，并配备了基础的 SDK、文档与开发控制台，但整体交互仍然停留在一次性的请求与响应上。 然而，随着底层模型在长上下文处理能力以及长时间持续推理能力上的突破，大量外部客户与 Anthropic 内部团队同时撞上了完全一致的工程壁垒：如何在缺乏人类实时介入（Human-in-the-loop）的情况下，稳定构建支持长时间运行、甚至处于远程环境中的自主智能体。为此，Anthropic 开始将内部打磨的成熟基建打包为开箱即用的高阶抽象，重点解决两大维度的核心痛点： 1. **复杂基础设施管理**： - 动态沙箱编排：具备严格权限隔离与安全治理的执行沙箱，能够根据任务需求毫秒级拉起并在任务结束时自动销毁。 - 对话与执行快照存储：自动保存多轮交互的会话转录（Transcripts），支持智能体在中断后随时恢复状态继续执行。 2. **Harness 工程化难题**： - 智能提示词缓存（Prompt Caching）与上下文窗口管理。 - 提升模型智能上限并同时有效控制 Token 调用成本。 ### [08:07](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=487s) 开发者群体的分层选择：底层原语与全托管 Agent 探讨平台设计理念时，Anthropic 团队强调其初衷是让开发者更加专注于自身真正想解决的核心问题；如果他们愿意将某些复杂环节外包给 Anthropic，平台随时可以接管。针对主持人关于客户是倾向于“在工具箱中自由挑选各种底层原语”还是“直接选择 Claude Managed Agents 等一揽子全托管服务”的提问，团队指出这在不同的用户群体之间存在明显的分化。 对于那些高度 AI 原生（AI-native）的初创企业而言，团队成员热衷于在极低层级进行修补和技术实验，他们会毫不犹豫地直接选择底层原语（primitives）。但对于其他更偏向经典企业级应用、或业务重心不在于底层算法“爬山调优（hill climbing）”的团队来说，其核心使命是将多种工作流串联起来为最终用户提供独特价值。在这些场景中，管理底层基建和编写低级 Agent 循环并不是他们的核心竞争力，因此他们更愿意直接调用更高阶、打包完备的托管产品，从而把有限的时间和工程资源集中在业务交付上。 - **AI 原生初创团队**：倾向于直接使用底层原语，在更低的抽象层级灵活拼接、极客实验。 - **工作流驱动型企业与初创团队**：核心在于串联业务流与创造终端用户价值，偏好开箱即用的高阶打包方案（如 Managed Agents）。 --- ### [09:07](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=547s) 平台的三层架构模型：从知识、执行到协调 为了系统阐释过去数月及未来规划的底层原语，Angela 提出了一个“三层蛋糕”（Three Layer Cake）的抽象架构：知识层（Knowledge）、执行层（Execution）和协调层（Coordination）。过去一年多里，Anthropic 的大量精力集中在最底层的**知识层**。这一层解决的是让模型“知道”如何与系统交互，包括打磨成型的 Messages API 规范与参数、工具调用（tool calls）标准，以及后续标准化的上下文注入机制，具体体现为技能（Skills）与记忆（Memory）。 ```mermaid flowchart TD accTitle: 三层 Agent 架构模型 accDescr: 展现从底层知识层、中间执行层到顶层协调层的技术栈递进关系 subgraph CoordinationLayer ["3. 协调层 (Coordination Layer)"] direction TB Strategies["编排策略 (Strategies)"] TokenRoles["Token 角色分工: 咨询 / 执行 / 思考"] end subgraph ExecutionLayer ["2. 执行层 (Execution Layer)"] direction TB LowHarness["底层测试载具 (Low-level Harness)"] ManagedInfra["托管基础设施 (Managed Agents)"] MultiSys["多系统文件编辑与状态维护"] end subgraph KnowledgeLayer ["1. 知识层 (Knowledge Layer)"] direction TB MsgAPI["Messages API & 参数设计"] ToolCall["工具调用标准 (Tool Calls)"] ContextExt["上下文机制: Skills & Memory"] end CoordinationLayer --> ExecutionLayer ExecutionLayer --> KnowledgeLayer ``` 随着模型能力的跃升，Anthropic 正将重心逐步上移至**执行层**。Angela 强调，“知道某件事”与“真正去执行工作”之间存在巨大的鸿沟：单纯的问答可以通过字符串拼接完成，但一旦需要让 Claude 真正替用户干活（例如在多套系统间穿梭、读取并修改复杂文件、返回确定的运行结果），事情就变得极为繁琐，必须依赖专门的基础设施来兜底。这一层本质上是“底层测试载具（low-level harness）结合托管基础设施”，其高阶产品形式正是 Claude Managed Agents。 而在执行层之上，团队正在探索并逐渐勾勒出顶层的**协调层**。在这一层，核心概念被称为“策略（Strategies）”，它扮演着元级载具（meta-harness）的角色。其核心逻辑在于：**Token 本身并非同质且可随意替代的（tokens aren't really fungible）**，每个 Token 应当被赋予不同的职责——有的负责“提供建议”（advising），有的负责“落地执行”（executing），有的负责“深度发散或反思”（dreaming/reflecting）。协调层负责编排这些多元策略，使之层层向下锚定到执行层与知识层。Anthropic 未来的产品演化路线图，将清晰地呈现出“从知识层迈向执行层，再从执行层向协调层持续攀升”的轨迹。 --- ### [12:13](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=733s) 开放生态、标准制定与安全底线 当被问及这套架构如何融入更广泛的外部生态时，团队表示 Anthropic 绝无意打造封闭的花园。无论是在知识、执行还是协调层，他们希望将尽可能多的基础原语开放给全行业，让所有构建者都能在其上自由组合与创新。即便 Anthropic 自身也在构建第一方终端产品，他们依然通过基于开放协议（如基于 MCP，即 Model Context Protocol 规范）的 Connectors，确保任何外部开发者和系统都能以原生方式嵌入进来。 更深层的生态愿景在于**跨 Agent 的可交易性与互操作性（trans-actability）**。团队期望实现这样一个世界：不同企业能够天马行空地打造各自独立的 Agent，并且这些 Agent 能够无缝协作——无论它是 Claude Agent，还是其他技术栈驱动的非 Claude Agent。 为了让这种互联互通成为可能，生态建设必须伴随两个层面的标准制定（standard setting）： 1. **构建者层面的技术互操作标准**：类似 Skills 和 MCP，规范系统之间如何传递上下文和调用功能。 2. **更高维度的安全共识标准（Safety & Security）**：任何企业都不希望 AI 在自己的系统上做出破坏性举动。在网络安全（cybersecurity）与反欺诈等关乎关键基础设施的核心领域，整个行业必须协同制定防护标准，防范恶意行为者（bad actors），共同维护底层系统的稳定性与安全性。 ### [15:03](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=903s) 电力比喻：没有一家公司能独自铺设整张电网 Angela 用“电力”（Electricity）的发展历史对 Anthropic 的生态哲学进行了总结。在电力出现之前，人类只能依赖烛光，能做的事情极其有限。而电力之所以能够成为颠覆全人类社会的基础公用事业，核心原因并不在于发电技术本身有多神秘，而在于它能够被布线接入到世间万物（wired into everything），让每个人都能触手可及。 电力的普及建立在统一的电压标准、通用的插头插座规范以及紧密的网络协作之上。“这绝非任何单一家公司能够单打独斗完成的伟业”，它必须依赖全行业的深度协同、制定共同准则并携手生态伙伴共同拓荒。AI 技术正处于类似的范式转变时刻，唯有通过开放标准与互信生态，才能让这种变革性力量真正通达每一个角落。 ### [15:39](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=939s) 开放生态还是围墙花园：不执着于掌控整个技术栈 关于 Anthropic 是倾向于构建开放生态还是封闭的“围墙花园”（walled garden），以及如何界定自研产品与生态集成的边界，团队有着非常务实的理念。结合之前提出的“三层蛋糕”架构（知识层、执行层与协调层），在执行层（例如托管智能体 Claude Managed Agents）上，Anthropic 并不执着于“所有任务都必须运行在我们自己的基础设施上”。团队完全不介意底层沙箱（sandboxes）或存储层是否由 Anthropic 绝对掌控，核心目标是让系统架构更加模块化。 为了实现这一目标，Anthropic 推出了自托管沙箱方案，并与 Modal、Vercel、Cloudflare 等生态伙伴乃至亚马逊最新的微虚拟机（microVMs）深度合作，提供第一方级别的原生集成能力。同时，他们上线了 MCP 隧道（MCP tunnels），允许开发者直接穿透企业防火墙，安全调用内网的 MCP 服务器。对 Anthropic 而言，工作负载到底是在自有集群还是第三方基础设施上跑，并没有那么重要；真正重要的是构建智能体的底层架构是否强大、可靠且具备扩展性。只要开发者遵循开放的接口规范，就可以自由拼装各种组件。 ```mermaid flowchart TD accTitle: Anthropic 开放生态集成架构 accDescr: 展示 Claude 平台如何通过 MCP 隧道与标准接口与第三方沙箱及内网基础设施解耦协作 subgraph AnthropicCore["Anthropic 架构核心"] Spec["标准化接口与协议规范"] Coord["智能体协调策略"] end subgraph ExecutionLayer["模块化执行与沙箱环境"] Modal["Modal 沙箱"] Vercel["Vercel 运行时"] Cloudflare["Cloudflare Workers"] AWSVM["Amazon microVMs"] end subgraph EnterpriseInfra["企业内网环境"] MCPTunnel["MCP 隧道 (穿透防火墙)"] PrivateMCP["私有 MCP 服务器与数据"] end AnthropicCore --> ExecutionLayer AnthropicCore --> MCPTunnel MCPTunnel --> PrivateMCP ``` - **基础设施解耦**：自托管沙箱已支持 Modal、Vercel、Cloudflare 及 AWS 微虚拟机，开发者可灵活插拔计算环境。 - **防火墙穿透**：通过 MCP 隧道打通企业内网，实现对私有数据和服务（MCP servers behind firewalls）的安全调用。 - **核心哲学**：不靠硬件绑定或封闭壁垒盈利，只输出具备高可靠性与扩展性的智能体架构接口与标准。 --- ### [17:12](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1032s) 动态的产品形态与实验哲学：以 Claude Design 为例 在垂类产品开发与形态（form factor）探索上，Anthropic 内部持有极其动态的视角——他们坚信产品形态绝非一成不变，而是随着底层模型能力剧烈演进的。“适合某一年 AI 水平的产品形态，到了下一年大概率就不适用了。”在 Anthropic 内部，工程师和产品经理们经常互相调侃：“这个设计够不够 AGI pilled？”（是否足够面向 AGI 的终局思考）。团队保持着随时可以推倒重来的心态：做出来的东西哪怕过去一年里非常惊艳，只要它不再符合下一个技术阶段的需求，就要毫不犹豫地扔掉换新，他们也建议平台开发者采纳同样的迭代思维。 这种探索催生了两种截然不同的产品路径。第一种纯粹是为了探索全新的交互形态，而不是为了追求最大的市场规模（TAM）。以 Claude Design 为例，外界可能会将其视作 Anthropic 杀入设计垂类领域的信号，但其实内部的核心假设只有两个：第一，能否让用户将更多工作毫无保留地“卸载”给模型，让用户直接用自然语言与 Claude 沟通，弱化甚至不鼓励传统的直接微调；第二，传统生成式幻灯片或设计工具往往基于固定设计系统（Design System）和所见即所得（WYSIWYG）的模式，而 Claude Design 则大胆验证“纯粹依靠代码来表达设计”的可行性。实验证明 Claude 直接生成代码驱动视觉的效果出奇得好。Anthropic 的 Labs 团队经常孵化这类项目，在内部让大家把玩两周、觉得“太酷了”之后便迅速转向下一项实验，很多成果甚至从未对外公开发布。 - **快速淘汰机制**：拒绝将产品形态固化，保持“好用一年就扔掉重来”的敏捷实验精神。 - **颠覆所见即所得**：Claude Design 证明了无需受限于传统设计系统的框架，通过大模型端到端直接编写代码同样能完成高保真设计表达。 - **Labs 实验室文化**：大量产品实验纯粹为了验证模型能力的表达上限，许多极具创意的项目仅在内部运行两周即完成使命。 --- ### [19:56](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1196s) 评估市场潜力：押注“高 Token 消耗”与垂直行业赋能 除了探索形态的 Labs 实验，Anthropic 的另一条路径则是严谨评估商业市场潜能（TAM）。作为一家商业公司，在布局具有商业价值的智能体场景时，团队格外青睐那些“Token 饥渴型”（token-hungry / token-heavy）的工作流。所谓“Token 饥渴”，核心衡量标准在于：当用户与智能体完成一轮交互（turn）后，是觉得“任务搞定了我可以走了”，还是会惊叹于“这太不可思议了，彻底打通了我的卡点，我想立刻做更多事情”？ 软件编码（coding）就是最典型的正向飞轮：用户完成一次代码生成或调试后，不仅不会离开，反而会产生更强烈的意愿去构建更多功能、编写更多代码，形成深度的连续迭代。相反，那些一次性解决完即可关掉页面的低频任务，就不是 Anthropic 优先考虑的重构方向。 在面向金融（Financial Services）和法律（Legal）等高价值垂直领域的布局中，Anthropic 致力于展示“实现这些商业目标的所有可能性”，并为不同深度的客户提供多层接入路径： 1. **底层调用**：客户可以直接使用 Messages API 获取原生 Token，在其上自主搭建全部业务逻辑； 2. **开箱即用托管**：借助 Claude Managed Agents 获得开箱即用的高阶智能体调度能力； 3. **生态连接器与技能包**：构建 MCP 连接器或插件，直接嵌入官方产品与形态中。 近期发布的“Claude for Financial Services”便打包了特定领域的技能组合（packages of skills），同时配套推出了应用指南（cookbooks），手把手指导企业如何结合托管智能体完成金融级工作流。Anthropic 期望通过模块化组件将可能性全面展现给行业，观察市场会跑出怎样的创新形态。 - **飞轮效应指标**：优先切入能激发用户“继续产出更多（do more）”的重度迭代流，而非单次交付即结束的任务。 - **垂直深耕领域**：以金融与法律为代表，将领域知识上下文与工具深度封装。 - **多层次交付模式**：从底层的 Messages API，到全托管的 Claude Managed Agents，再到开箱即用的特定行业技能包（Skills）与 MCP 插件，满足不同技术深度开发者的需求。 --- ### [22:26](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1346s) 内部沉淀的产品化：Claude Tag 与“不只是一只 Slack 机器人” 有时，Anthropic 的垂类产品其实就是将内部验证成熟的最佳实践打包开放。整个行业此前已有类似的前哨探索：例如 Shopify 内部孵化了智能体平台“River”，Square（Block）近期推出了“Builder Bot”，它们都致力于在公司内部搭建统一的智能体平台，注入充分的企业上下文，并将其无缝接入 Slack 等高频协作工具中。 Claude Tag 正是这一趋势下的产物，它是 Anthropic 将自身内部日常使用的高效工作模式对外封装的成果。当市场传出质疑、吐槽“搞了半天这不就是个 Slack 机器人吗”时，两位负责人笑着表示，这种看法完全低估了其背后的架构变革。Claude Tag 并不是简单挂载在聊天框上的对话接口，它的真正魔力在于底层对上下文的精准组装、企业级工具链的打通，以及多智能体在企业协作中枢里的隐性协作方式，这恰恰折射出了未来软件交互形态的演进方向。 ### [23:28](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1408s) 组织级 Harness 与冰山之下的上下文工程 在探讨 Agent 的形态时，很多人往往过度执着于外在的形式或 UI 交互界面，觉得某个界面看起来炫酷就代表产品很酷。然而，以 Claude 的协同应用（如 Claude Tag）为例，用户与其交互的方式非常简单——直接在 Slack 里 @ 它。界面的形式虽然直接，但这绝非核心所在。真正关键的是 Anthropic 在底层构建的庞大“上下文工程”（Context Engineering）与系统架构，正是这些底座使得整个体验无缝运转。 它的终极目标是让 AI 感觉就像一个活生生的同事。当你入职一家新公司，这位“同事”加入你的频道，能够与你对话、主动捕捉有价值的信息、搞清楚什么是有用的，并把事情切实搞定。对于非技术受众而言，这是一个巨大的门槛跨越：过去如果你想提销报销、搞清某个业务流程，你得四处找人，问主管、找入职导师（Spin buddy），流程极其繁琐；而现在，只需建个频道 @ 一下 Claude，它就能直接帮你解决。 ```mermaid flowchart TD accTitle: 组织级 Agent 冰山模型 accDescr: 描述 Agent 用户可见的交互表面与底层庞大的上下文工程及执行架构 subgraph Surface ["水面之上：多变的人机交互界面"] UI["多渠道交互入口<br/>(Slack / Teams / WhatsApp / Email)"] end subgraph UnderIceberg ["水面之下：底层组织级架构 (Org-level Harness)"] CE["上下文工程与管理<br/>(Context Engineering)"] ACT["主动性与意向理解<br/>(Proactivity Engine)"] EXEC["底层执行环境与模型调度<br/>(Execution Layer)"] end UI --> CE CE --> ACT ACT --> EXEC ``` 这正如 Andrej Karpathy 所精准概括的——它是一个“组织级 Harness”（Org-level harness）。虽然开发者完全可以使用 Anthropic 提供的公开 API 自己搭建实验系统，但 Claude Tag 展现了 Anthropic 内部对“如何为整家公司打造一个始终在线（Always-on）的高性能 Agent”所持有的鲜明见解与最佳实践。 - **冰山隐喻**：水面上的交互入口只是极小的一部分，且未来随时可以替换；真正困难、最具价值的工程全部隐藏在水面之下。 - **形态的“平淡即前沿”**：今天大家在 Slack 协作，明天可能是 Microsoft Teams、WhatsApp 群组、短信甚至传统邮件。AI Agent 采用人类已经在使用的沟通载体，这种看似平淡的形态实际上最前沿，因为它让高智商、强上下文理解能力的 AI 以最自然的人类形态融入工作流。 --- ### [26:04](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1564s) 基础 Harness 的繁重细节与向“Meta-Harness / 策略”的演进 当谈到构建卓越 Agent 的秘诀时，Sonya 提问团队对于 Harness 与上下文工程有哪些关键的最佳实践与建议。Katelyn 指出，Anthropic 推出“Claude 托管 Agents”（Claude Managed Agents）的初衷，正是为了提供一个通用但极高性能的执行框架。这个底层框架里充满了大量枯燥但极其繁琐的工程细节： 1. **Prompt 缓存（Prompt Caching）**：务必开启，这是大幅削减 Token 开销与延迟的核心手段。 2. **上下文窗口管理（Context Management）**：及时清除无用、陈旧的历史信息，保持上下文窗口干净。 3. **程序化调用工具**：通过代码精准触发工具，避免将海量原始数据一股脑塞进上下文窗口。 4. **评测体系（Evals）**：必须尽早搭建严密的评估机制，确保 Agent 执行流程的效果可量化且具备稳定性。 然而，Katelyn 强调，底层 Harness 虽然重要，但继续在这一层死磕所能压榨出的边际价值正在减少，未来的真正创新爆发点在于**策略（Strategies）**或**元 Harness（Meta-harnesses）**。核心区别在于“你如何分配手中的每一个 Token”： - **单纯执行**：把 Token 纯粹花在推进任务的工具调用上。 - **反思与沉淀**：把 Token 用于复盘上一轮 Agent 执行会话，将学到的经验写入长期记忆，让下一个 Agent 表现更好。 - **顾问-执行架构**：使用推理能力更强的大模型（如 Opus）提供高层建议与拆解，指导更轻量快速的小模型去执行落地。 - **评估反馈循环**：在执行多步后引入“打分器”（Grader）审查是否达标，未达标则打回重试。 这种将 Token 赋予不同“工种”的 Meta-level 架构调度，正成为 Anthropic 团队内部最兴奋的探索方向，也是行业拉开代差的关键。 --- ### [28:53](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1733s) 模型代际跃迁与垂直领域定制 Harness Angela 进一步剖析了从“脚手架”向“策略”转变背后的模型代际演进逻辑。两年前，模型的指令遵循能力很弱，开发者必须构建密集的硬编码管道，如同在左右两边各砌一堵墙，强行逼着模型走出直线。而现在的模型具备极强的可控性（Steerability），很多原本写在 Harness 里的死板引导完全可以精简为一行清晰的 Prompt。 行业里常说的“模型正在吃掉脚手架”（Model will consume some scaffolding），正是指这部分强行纠正方向的代码应当果断删除。现在的 Harness 不应再聚焦于微观转向控制，而应专注于**支持模型长时间、多步骤自主运行**。当模型自主从 A 走到 B 之后，能够依据宏观策略自主向 C、F、Z 推进，并匹配模型前沿智力的跃升。 针对 Sonya 提出的“是否存在任务专属或垂直领域的专用 Harness”这一争议话题，Angela 给出了明确的肯定回答： - **通用能力基底**：编程（Coding）等基础能力是高度通用的杠杆，能够贯穿绝大多数工作流。 - **垂直领域的定制必要性**：并不存在一套通用的万能 Harness。在对准确性要求极高的垂直领域，Harness 必须在特定逻辑上进行定制。 - **错误处理与极限校验机制**：在法律（Legal）或金融（Finance）等强合规行业，工具调用报错时、任务向模型交接时的错误捕获与极限验证逻辑（Extreme verification）至关重要。在这类关键节点上针对领域特性进行微调与打磨，能够释放出巨大的商业与技术成效，这也是很多垂直领域开发者坚持自主掌控 Harness 的根本原因。 ### [31:30](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1890s) 领域特异性与 Harness 的多层抽象 在探讨构建垂直产品与通用基座的边界时，Angela Jiang 指出，决定一个产品能否在竞争中胜出的核心，往往在于“出错的后果严重程度”。如果某个领域的容错率极低，哪怕出现一点差错都会产生严重后果，那么这种领域特异性（Domain Specificity）就是决定用户最终选择你的产品还是竞品的胜负手；反之，若某些领域可以通过模型基础能力的提升被逐步压缩，领域特异性的重要性就会大幅下降。在真正需要深度垂直优化的场景中，关键往往不是简单地往上下文里塞数据，而在于两点：一是模型与执行环境之间的具体验证逻辑（Verification Logic），二是高阶调度策略——即如何在整个工作流中精打细算地分配 Token 预算。Angela 坦言，外界对上下文窗口的炒作有些过头了，“往里面塞上下文这事其实人人都能做，任何 Harness 都能吞下海量上下文”。拥有独特的数据固然让你具备独特资格，但光有数据绝非核心壁垒。 Katelyn Lesse 顺着这一逻辑进一步解构了大家口中经常含义含混的“Harness”。在最基础的定义中，Harness 仅仅是一个循环（Loop）——用户输入、模型推理、工具调用，周而复始。再往上一层，它还打包了与该运行环境绑定的所有工具。Katelyn 强调，底层那些较为通用的逻辑——比如调优 Prompt Caching、从上下文窗口中清理过期的历史工具调用（Tool Calls）记录——虽然繁琐，但并不值得开发者自己花大把精力去“占有并维护”。 真正值得开发者去掌控的，是更高抽象层级的能力。目前 Anthropic 推出的 Claude 托管代理（Claude Managed Agents）虽然定位为高阶抽象，但依然保留了极大的自主度：开发者可以自定义接入的所有工具、编写技能（Skills）、调整系统提示词（System Prompts），并配置 MCP 服务器。但 Anthropic 的终极愿景是实现更高维度的“端到端托管”——用户只需要告诉 Agent “这是我要的结果，这是我的预算，预备、开始”，底层的循环、上下文裁剪、工具调度细节完全无需操心。不同层级的开发者可以根据自身需求选择在不同的深度切入并进行差异化优化。 ```mermaid flowchart TD accTitle: Harness 抽象层级演进 accDescr: 展示从底层管道机制到最终基于目标与预算的高层愿景架构 subgraph LowLevel["底层通用机械层（平台托管与自动化）"] A["基础循环 (User - Model - Tool)"] B["Prompt Caching 调优"] C["上下文清理 (修剪历史 Tool Calls)"] end subgraph MidLevel["中层定制层（当前 Claude Managed Agents）"] D["自定义工具接入 (Custom Tools)"] E["Skills 与 System Prompts 定义"] F["MCP 服务器标准连接"] end subgraph HighLevel["高阶终极目标（结果与预算驱动）"] G["目标声明 (Outcome Goal)"] H["Token 预算约束 (Budget Allocation)"] I["自动验证与策略执行"] end LowLevel --> MidLevel MidLevel --> HighLevel ``` --- ### [34:07](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2047s) 前沿客户的真实创新：上下文工程与老旧系统连接 当被问及平台团队从全球最前沿的开发者身上看到了哪些意想不到的创新时，Angela Jiang 指出，许多团队并没有在“界面交互形式”上做惊天动地的颠覆，而是在“上下文工程”（Context Engineering）和“系统连接”（Connectivity）层面做出了极其巧妙的设计。最典型的创新往往并非来自面向公众的消费级产品，而是来自正在成为“AI 原生”（AI-native）的企业的内部场景。例如： - 有些企业自主搭建了高度创新的定制化软件开发生命周期（SDLC）系统； - 有些企业将 Agent 深度嵌入口径极其复杂的后台运营（Back Office）体系； - 这些团队能够跨多个孤岛系统主动抓取上下文、动态穿透并组合不同系统的权限，并以极度平滑的方式流式注入 Agent 中，创造出了惊人的实用价值。 另一个让 Anthropic 团队极为振奋的创新领域，是应对“完全没有 API”的古董级老旧软件（Old-school Software）。例如在医疗健康（Healthcare）行业中，许多核心系统甚至根本不提供任何现代 API 接口，这在以往是自动化集成的绝壁。面对这种情况，许多开发者脑洞大开，直接利用 Claude 的计算机使用（Computer Use）能力——甚至有人把一台实体笔记本电脑挂在系统上，让 Agent 模拟屏幕点击、自动生成后续流程所需的一整套操作数据，强行在老旧软件上打通连接。Anthropic 正致力于为这些硬核场景提供更标准化的规范（Spec），让 Claude 能够原生遵从标准，将不可连接的系统有机地串联起来。 --- ### [36:49](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2209s) MCP 驱动的 Agent 互联与非共识行业的爆发 Katelyn Lesse 分享了一个令团队印象深刻的“脑洞大开”（Galaxy Brain）真实客户案例：该客户的一部分 Agent 运行在 Claude 托管代理平台上，另一部分 Agent 则基于其他模型或平台构建，各自针对特定垂类任务做了极致调优。客户希望让这些异构的 Agent 能够紧密协作，最终想出了一个极其漂亮的架构——直接在每个 Agent 外面暴露一个 MCP（Model Context Protocol）服务器接口，把每一个独立的 Agent 包装成一个标准化工具供其他 Agent 调用。Anthropic 团队与该客户共同打磨并落地了这套模块化架构，验证了 MCP 在实现跨平台、跨模型 Agent 互联上的巨大威力。 除了技术架构的突破，行业落地趋势也正在打破硅谷原有的固有认知： - 编程辅助（Coding）作为 AI 最早爆发的品类，目前依然在飞速演进； - 但非传统的实体产业正呈现出极强的爆发力，特别是**制造业（Manufacturing）**； - 制造业客户对 AI 接入的需求激增，以至于 Anthropic 的产品经理（PM）需要专程买机票飞往底特律（Detroit），现场调研工厂与传统制造业客户对智能化改造的具体诉求。 --- ### [38:13](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2293s) 从“Token 狂欢”到“Token 理性化”：企业开支的治理反思 随着行业逐渐从前期的无脑堆算力（Token Maxing）进入更加务实的“Token 理性化”（Token Rationalization）阶段，企业对待 AI 账单的态度发生了深刻变化。Angela Jiang 对这一趋势表示高度认同：当基础模型的智力水平到达某个阈值并实现“智力拉满”（Intelligence Maxing）后，评估任务的核心维度必然会转向**成本（Cost）**或**速度（Speed）**。 在应对这一转型期时，Angela 告诫企业千万不要“因噎废食”： - 最糟糕的应对策略就是因为成本压力或失控风险而“全面叫停 AI 使用”； - 现实中，许多企业内部的 AI 支出之所以突然爆发式增长，往往源自“影子 IT”（Shadow IT）——员工因为工作刚需无法被满足，便绕过官方采购流程自行购买并接入 AI 工具； - 等管理层回过神来，往往发现半个组织都已经在私下使用各种 AI 工具办公，从而引发治理与合规的恐慌。如何在满足一线生产力需求的同时，通过清晰的预算治理和平台化架构实现理性降本，成了当下所有企业面临的核心课题。 ### [39:23](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2363s) Token 消耗管理与模型路由策略 随着企业团队内部广泛接入 Claude Code，工程主管们很快就会面临一个现实挑战：这类 Agent 系统本质上是“非常饥渴的 Token 吞噬者”（"very token hungry"）。面对客户对开销骤增的顾虑，Angela Jiang 明确建议不要为了省钱而粗暴遏制创新。如果接入模型后团队的交付速度突破以往、运营效率显著提高，那么这些收益本身就是实打实的价值。Anthropic 鼓励客户采取的应对思路是搭建一套更聪明的“策略架构”（Strategy Architecture）：当一个任务进入系统时，先动态评估其复杂度级别；高难度、复杂的任务分流给最强、最聪明的旗舰大模型，而相对简单的日常任务则路由给更便宜、更敏捷的小模型。 当被问及 Anthropic 官方是否会推出专门的模型路由器（Router）时，Angela 表示在 Claude 模型家族内部推出此类能力完全顺理成章，这也正是团队当前正在设计的协调策略之一。当今 AI 领域的技术风向几乎“每个月都进入一个全新时代”，面对这种日新月异的变化，Anthropic 的设计哲学是将底层基语（Primitives）做得高度可复用、可重组，以便任何新范式出现时都能迅速调整适配。不过，在模型路由的边界上，Anthropic 的态度十分鲜明：平台的一切能力都是专门为 Claude 量身打磨的，目标是让 Claude 成为解决问题的极致工具。他们无意去开发那种跨越不同厂商底层模型的通用外部路由层。 ```mermaid flowchart TD accTitle: Claude模型家族内部策略路由流程 accDescr: 展示任务根据复杂度被分配至旗舰模型或经济型模型的内部路由策略 Task["输入任务 / 代码工单"] --> Eval["复杂度评估策略 (Router)"] subgraph Routing ["Claude 家族内部动态调度"] Eval -->|"高难度 / 深度推理"| Opus["高阶模型 (如 Claude 3.5 Opus)"] Eval -->|"轻量 / 确定性任务"| Haiku["高性价比模型 (如 Claude 3.5 Haiku)"] end Opus --> Output["高质量交付成果"] Haiku --> Output ``` - **业务创新的权衡**：与其一味缩减模型预算，不如将精力放在评估真实回报率上；只要生产力提速带来的增益覆盖了计算成本，创新就不该被叫停。 - **动态分流原则**：通过规则引擎或轻量判别机制识别任务难度等级，将难啃的架构重构或 Bug 追踪派发给大模型，机械性脚本编写分流给小模型。 - **生态定位聚焦**：Anthropic 坚守“为 Claude 优化”的产品边界，拒绝做无差异化的跨厂商模型路由，专注于在自家模型家族内部最大化性价比。 --- ### [41:11](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2471s) Harness 与模型家族的深度绑定及成本治理周期 Katelyn Lesse 进一步阐释了为何路由层应当限制在同类模型家族内部。业界曾经历过一段狂热期，许多开发者天真地认为“我只要搭一个执行工具箱（Harness）和 Agent 框架，底下随便插拔哪家模型都一样”，并将希望寄托在通用路由器上。然而近期的行业演进（例如 Vercel 推出的 Harness Agent）证明，抽象层正在向上跃迁——业内玩家逐渐意识到，完整的 Harness 架构与 Agent 执行层必须与特定的模型家族深度协同与微调，才能激发出最佳能力。因此，平台真正需要提供的价值，是在该模型家族内部以更智能的方式混合搭配合适规格的模型。 谈到业内对“Token 暴增”（Token maxing）与开销失控的焦虑，Katelyn 认为这只是企业在接纳新技术时必然经历的常规生命周期。她以自己在加入 Anthropic 之前在 Stripe 工作的经历类比：当年工程团队极其严密地监控 AWS 账单，一旦有工程师写了个配置不当的后台任务在服务器上死循环空转、疯狂消耗 CPU 并拉高账单，监控报警就会迅速触发，团队会礼貌地要求工程师“立刻关停那个不合理的后台脚本”。如今的生成式 AI 正在迈向同样的治理阶段。粗暴设置一个硬性预算上限（Cap）并警告员工“花超就停机”是极其危险且扼杀生产力的做法；真正的解法是保留创新的空间，同时从架构层面寻找更经济的解题路径——与其让最顶级的 Opus 模型整夜跑暴力搜索，不如设计更优雅的策略组合，以更低成本换取同等甚至更好的交付成果。 - **深度绑定的必要性**：Agent 的上下文感知、工具调用习惯与提示词容错率均因模型而异，解耦模型与 Harness 往往会导致系统性能与稳定性全面下滑。 - **云基础设施的既视感**：AI 支出的管控轨迹正在重演当年的云资源管理（FinOps），核心在于建立细粒度的监控护栏与资源审计，而非全面叫停试验。 - **聪明的策略替代暴力计算**：依靠精细编排的调度策略替代低效的“暴力长时间推理”，是降低实际生产环境推理成本的下一代核心思维。 --- ### [43:31](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2611s) 协调层的未来：策略组合、Best-of-N 与“Token 各司其职” 在被问及团队未来数月最令人振奋的技术蓝图时，Angela 直言不讳地指出重心依然是“策略编排”（Composing Strategies）与协调层（Coordination Layer）的演进。为了获取最高投资回报，开发者必须洞察所解决问题的本质特征。例如在构建一个用于“缺陷排查”（Bug Hunting）的 Agent 时，行业初期的普遍思路只有两个杠杆：要么换一个参数量更大的模型，要么给它更长的推理运行时间，但这两者很快就会撞上边际效益递减的墙。 通过大量一线实验，Anthropic 发现了能够产生巨大超额收益（Alpha）的“第三个杠杆”：**Best-of-N 采样与多路验证策略**。尽管学术界对此已有海量论文背书，但在实际生产系统中将 Best-of-N 稳健落地、供真实用户大规模测试却是一件“难上加难的事情”（"really really freaking hard"），开发者往往被迫编写大量混乱复杂的定制 Harness。Anthropic 的哲学正是将这些高收益却极难构建的模式沉淀为开箱即用的底座。这种模式让人联想到一年前火热的“Agent 蜂群”（Agent Swarms）概念，但 Angela 从更底层的逻辑重新定义了它——**“每一个 Token 都有其专属职责”**（"the token has a job"）。在实际工作流中，不同阶段的 Token 承担着顾问、执行者、反思校验或记忆维护等不同职能。Anthropic 内部已经提炼出 5 种核心职责抽象，当把这些组合基元赋能给外部生态时，开发者将能衍生出数十万种令人惊叹的全新架构模式。 ```mermaid flowchart LR accTitle: 复杂任务的三种提升杠杆及策略组合 accDescr: 对比传统提升杠杆与第三种高Alpha收益的Best-of-N职责组合策略 subgraph Traditional ["传统杠杆 (收益递减)"] L1["杠杆 1: 升级更大模型"] L2["杠杆 2: 延长单次运行时间"] end subgraph StrategyLever ["第三个杠杆: Token 职责编排 (高 Alpha)"] direction TB GenA["分支 A: 生成方案"] GenB["分支 B: 生成方案"] Eval["反思/裁决 Token (Best-of-N)"] GenA --> Eval GenB --> Eval end Traditional -.->|"进阶演化"| StrategyLever StrategyLever --> Result["高可靠产出 (Bug 修复/复杂决策)"] ``` - **打破双重杠杆困局**：摆脱“堆大模型”和“死耗运行时间”的单维竞争，通过分流采样与互验逻辑实现质量跨越。 - **降低工程实现壁垒**：将论文级的并行多路径生成与评分机制封装成高阶 API，消除开发者手动拼装 Harness 的痛苦。 - **Token 职责化概念**：不再将上下文一视同仁，而是赋予不同批次 Token 明确的角色分工（例如规划、试错、复核），从而使协同效率呈指数级放大。 --- ### [46:10](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2770s) 企业级落地与平台模块化：提升“每美元智能” 在持续向外释放更强技术杠杆的同时，Katelyn 强调平台演进的另一条生命线是“持续攀登每美元智能（Intelligence per dollar）的峰值”，并切实扫清企业在组织与系统内部署 AI 的现实障碍。无论模型核心推理能力有多么先进，如果企业无法将其平滑植入现有生产环境与业务产品中，价值就会大打折扣。这就要求平台必须兼备严格的企业级安全规范、合规审计控制能力，以及极高水准的开发者体验（DX）。 为此，Anthropic 正在全面推进平台能力的“模块化”（Modularity）。企业级用户通常拥有戒备森严的内部系统与私有网络（Walled Garden），他们并不一定希望全盘接收一整套黑盒解决方案，而是需要高度灵活的可插拔组件——比如单纯调用 Anthropic 封装的长期记忆模块（Memory），或是按需挂载其执行沙箱。团队内部目前保持着清晰的双轨推进态势：一部分工程力量在协调层最前沿大举探索 Agent 策略编排与 Token 角色分工，另一部分团队则深耕底层工程接口的解耦与安全合规加固，确保各行业客户既能跟上最先进的 Agent 架构演进，又能将技术安全稳固地集成到自身的专有基础设施之中。 - **每美元智能（Intelligence per Dollar）**：Anthropic 衡量子代架构与调度策略的核心指标，追求在给定算力预算下榨取最大化的逻辑推理质量。 - **深度模块化与解耦**：允许大型企业根据合规要求自由拆分功能，按需将记忆管理、工具执行或特定模型能力嵌入其私有化护栏体系内。 - **敏捷探索与合规落地双轨并行**：既在协调策略层开拓最前沿的工程范式，又在企业级基础设施上提供坚如磐石的合规支撑。 ### [47:05](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2825s) 平衡企业落地障碍与周末极客的“可魔改”需求 Anthropic 在构建开发者平台时，需要同时关照两类截然不同但同等重要的开发者群体。第一类开发者虽然惊叹于团队为最大化模型智能所做的一切创新，却常因为各种企业合规、架构约束或实际业务限制（"XYZ reasons"）而无奈表示“东西很酷，但我根本用不了”。针对这一群体，平台的重心必须放在切实扫清这些现实落地障碍上。与此同时，另一类群体则是极富创造力的“周末开发者”（weekend developers）——他们只想利用业余时间为自己搭建一些实用的小工具。这类极客开发者不仅活跃在 Anthropic 的平台上，也穿梭于整个开源社区的各种开发者基础设施之间。 对于这些独立开发者，平台需要提供更开放、更具“可魔改性”（hackable）的解决方案，让他们能够基于 Anthropic 提供的组件随心所欲地自由发挥，并享受到极致顺畅的开发者体验（developer experience）。这类看似基础、甚至属于“入场券”（table stakes）的基础体验建设，实际上具有巨大的杠杆效应：只有把这些底层的基本功做好，开发者才能毫无阻碍地说“这套东西确实契合我的工作流”，进而顺理成章地接入 Anthropic 那些最具前沿创新性的功能，在获取更强模型智能的同时有效降低 Token 消耗成本。 - **严肃企业开发者困境**：对前沿智能成果感兴趣，但常受制于现实架构或合规限制，急需平台消除实际集成摩擦。 - **周末极客生态**：热衷于用业余时间打造工具，高度依赖更加开放、自由度更高且易于 Hack 的组件。 - **底层基础功能（Table Stakes）的战略意义**：打磨好基础开发者体验是建立信任的起点，唯有基本盘稳固，外部开发者才会进一步采纳更深度的智能优化与成本节省策略。 ```mermaid flowchart TD accTitle: Anthropic 开发者平台的双轮驱动战略 accDescr: 展示平台如何通过完善基础体验（Table Stakes）同时赋能企业开发者和周末极客，进而解锁前沿智能与降本创新。 subgraph Users["核心开发者画像"] A["企业开发者<br/>(面临落地合规/架构壁垒)"] B["周末极客开发者<br/>(追求开放、可魔改与顺畅 DX)"] end subgraph Foundation["底层基础支撑 (Table Stakes)"] C["消除集成障碍<br/>(解除各类实际限制)"] D["开放与可定制组件<br/>(让极客自由发挥)"] end subgraph Value["高阶价值转化"] E["顺畅接入前沿创新能力"] F["实现更高智能输出并降低 Token 成本"] end A --> C B --> D C --> E D --> E E --> F ``` ### [48:01](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2881s) 寄语 Anthropic：生态理念与未来展望 访谈在对 Anthropic 开发者平台未来发展的共识与期许中落下帷幕。红杉资本的主持人 Lauren Reeder 和 Sonya Huang 总结道，Katelyn Lesse 与 Angela Jiang 正在主导打造全球最重要的开发者平台之一。通过多次深入的对话与交流，可以真切感受到这个平台掌握在极其严谨、深思熟虑且由衷珍视整个生态体系建设的团队手中，这让人对未来的技术演进充满了乐观与期待。主持人对两位嘉宾分享的深度架构理念表示感谢，Katelyn 与 Angela 也表达了对主持人的谢意，整场对谈在对未来 AI 开放生态的憧憬中圆满结束。 ## Notable quotes > [09:07](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=547s) tokens aren't really fungible — Angela Jiang > [01:04](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=64s) AGI-pilled products — Angela Jiang > [17:12](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1032s) 适合某一年 AI 水平的产品形态，到了下一年大概率就不适用了。 — Angela Jiang > [31:30](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1890s) 往里面塞上下文这事其实人人都能做，任何 Harness 都能吞下海量上下文 — Angela Jiang > [31:30](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1890s) 这是我要的结果，这是我的预算，预备、开始 — Katelyn Lesse > [39:23](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2363s) very token hungry — Angela Jiang > [39:23](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2363s) 每个月都进入一个全新时代 — Angela Jiang > [28:53](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=1733s) Model will consume some scaffolding — Angela Jiang > [43:31](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2611s) really really freaking hard — Angela Jiang > [43:31](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2611s) the token has a job — Angela Jiang > [46:10](https://www.youtube.com/watch?v=vPnVTHYplrQ&t=2770s) 每美元智能（Intelligence per dollar） — Katelyn Lesse ## Mentioned Katelyn Lesse, Angela Jiang, Sonya Huang, Lauren Reeder, Anthropic, Sequoia Capital, Claude, Claude Code, Claude Design, Claude Tag, Claude Managed Agents, Messages API, MCP (Model Context Protocol), Opus, Haiku, AWS, Google Cloud, Modal, Vercel, Cloudflare, Amazon microVMs, Shopify, River, Square (Block), Builder Bot, Slack, Microsoft Teams, WhatsApp, Andrej Karpathy, Stripe ## Video description Katelyn Lesse and Angela Jiang lead the team building Anthropic's developer platform - the layer that both outside builders and Anthropic's own products run on top of. Angela frames the platform as a three-layer stack: knowledge, execution, and coordination. She argues the real leverage is what’s at the top: "strategies," or meta-harnesses that give each token a different job, from advising to executing to reflecting to memory. On the question of open ecosystem vs. walled garden, they say they aren't precious about owning the stack. Katelyn points to Anthropic's self-hosted sandboxes with partners like Modal, Vercel, and Cloudflare. Whether the work runs on Anthropic's infrastructure or someone else's, what really matters to them is that the architecture is sound. The deeper bet is standards: they hand skills and MCP to the whole industry, build connectors on the MCP spec, and help agents (Claude and non-Claude) work together. The one place they stay closed is model routing: they argue harnesses should be tuned to a model family, so they're designing for Claude rather than routing across models. Angela's frame for the ecosystem bet is electricity: transformative only because everyone could plug in, and no company wired it alone. Hosted by Sonya Huang and Lauren Reeder, Sequoia Capital 00:00 Introduction 01:49 Two North Stars 02:27 External Builders And Primitives 03:54 What To Externalize 06:00 From Messages To Agents 08:19 Managed Agents Adoption 09:07 Three Layer Cake 10:22 Execution Harnesses Explained 11:09 Coordination Strategies Roadmap 12:13 Ecosystem Standards And Safety 15:39 Open Ecosystem Not Walled 17:12 Vertical Products And Form Factors 22:26 Claude Tag Under The Hood 26:04 Harness Best Practices 38:13 Token Costs And Whats Next [Source](https://www.youtube.com/watch?v=vPnVTHYplrQ)

[9:07] Angela Jiang: tokens aren't really fungible [1:04] Angela Jiang: AGI-pilled products [17:12] Angela Jiang: 适合某一年 AI 水平的产品形态，到了下一年大概率就不适用了。 [31:30] Angela Jiang: 往里面塞上下文这事其实人人都能做，任何 Harness 都能吞下海量上下文 [31:30] Katelyn Lesse: 这是我要的结果，这是我的预算，预备、开始 [39:23] Angela Jiang: very token hungry [39:23] Angela Jiang: 每个月都进入一个全新时代 [28:53] Angela Jiang: Model will consume some scaffolding [43:31] Angela Jiang: really really freaking hard [43:31] Angela Jiang: the token has a job [46:10] Katelyn Lesse: 每美元智能（Intelligence per dollar）

[0:00] Angela Jiang: strategies [17:12] Once you spend a... call it like one turn, you look at the end of that turn, and you say like, 'Am I done, or am I actually so glad that I did that thing, I want to do more of that thing?' We like industries where... the answer to that question, you say, 'I want to do more of that thing.' [22:26] just a Slack bot [126:09] Katelyn Lesse: nitty-gritty [43:31] best-of-$N$ [45:24] the token has a job

[0:00] The last layer of abstraction on top of [0:01] this is probably the coordination layer. [0:03] So, you have knowledge, and you have [0:04] execution, and you have coordination. [0:05] And at the coordination layer, we're [0:07] beginning to think of these things [0:08] called like strategies, where basically [0:10] it's almost like a meta harness. The [0:12] true low-level harness is designed for [0:13] execution, but the next one is about, [0:15] okay, if tokens aren't really fungible, [0:17] and you need to give them different [0:18] jobs, like maybe some this token is [0:20] advising versus this token is executing, [0:22] you want to start composing these like [0:24] these kind of orchestrated strategies [0:25] that go together, and they should sit on [0:27] top of all these things because at the [0:28] end of the day you still need to execute [0:29] and the execution still needs to know [0:30] what to do. So, everything in theory [0:32] should kind of like ladder together. And [0:34] so, I think, you know, if you were to [0:35] look at our road map and the maybe kind [0:36] of project forward a little bit where [0:37] you kind of expect us to go, we'll move [0:39] more and more from the knowledge layer [0:41] to the execution layer and from the [0:42] execution layer to the kind of [0:44] coordination layer in terms of the [0:45] abstractions that you [music] can see us [0:46] put out. [0:53] >> [music] [1:04] >> Caitlin and Angela, thank you so much [1:06] for joining us today. Lauren and I are [1:07] thrilled to have you here. You are [1:09] responsible for building Anthropic's [1:10] platform, and so you're responsible for [1:13] building what I think is one of the most [1:14] important, if not the most important [1:16] developer platform in the world. And we [1:18] are really excited to interview you [1:20] today to understand more about what's [1:21] ahead. And so, maybe just to get [1:23] started, can you give us the context of, [1:25] you know, what is Anthropic platform and [1:26] where do you sit within Anthropic? [1:28] >> Yeah, so platform is both our externally [1:31] facing APIs, our developer platform that [1:33] people build on top of when they want to [1:34] build applications and system that [1:36] systems that access Claude's [1:38] intelligence, as well as internally, um [1:41] we run our product infrastructure, and [1:43] basically we're the layer that our apps [1:46] build on top of uh internally as well. [1:49] >> Awesome. What's your North Star as a [1:50] team? [1:51] >> It's a great question. We actually, [1:52] because we have both internal and [1:53] external, we actually kind of have like [1:55] two North Stars, which is probably like, [1:57] you know, you'd be like, "What? You [1:58] shouldn't have one North Star." But, um [2:00] no, we we can [2:01] >> planetary system. [2:01] >> Yes, exactly. There's separate solar [2:03] systems, so it's fine. Um but, uh on the [2:05] internal side, like we really want to [2:07] provide is like literally as much [2:08] leverage as possible for our internal [2:10] teams to be able to ship like AGI-pilled [2:14] products. [2:15] Um and we want them to be able to move [2:16] fast, be able to have reliable, like [2:18] great, like uh platform uh to be able to [2:21] build on top of. But, I think that key [2:22] bit about speed is like really [2:24] intentional for us, and we really really [2:26] care about that internally. Externally, [2:28] um we actually have a lot more like [2:29] complicated set of things. Um but, one [2:31] of the true Norths that we have there is [2:33] to be able to basically give any builder [2:35] the tools to be able to work with Claude [2:37] to build whatever they want to build. [2:39] And so, it's a bit of a broad statement, [2:41] but as a result of that, uh boils its [2:43] itself down into, you know, being [2:45] wherever that business is. Like, we [2:46] really care about like bringing our [2:48] platform really really close to that [2:49] business. This is why we spend a lot of [2:51] time with the hyperscalers, integrating [2:52] really closely uh directly with them, [2:54] like AWS, Google, so on and so forth. Um [2:57] and it is a lot of like primitives that [2:59] we end up creating. We want people to be [3:01] able to express what they think their [3:03] product should be. We want them to be [3:04] able to almost do like custom software [3:07] in their own way, you know, like in this [3:08] new world with AI, uh what used to be [3:11] probably economically impossible was [3:13] that last mile of of custom software. [3:15] Now, in theory, should be like very very [3:18] achievable. Um and we want to give them [3:19] all the tools and all the capabilities [3:21] to go and do that. And so, sometimes [3:22] that comes in form of primitives and [3:24] APIs and higher-order abstractions, and [3:26] sometimes that comes in the form of just [3:27] like [3:29] standards. Uh so, for example, like [3:30] skills and MCP, um those are things just [3:33] like Claude needs them to be useful, and [3:35] we can just give them out to the rest of [3:36] the ecosystem, work with everyone to [3:38] help you create those things, and get [3:40] the best out of Claude. So, um I would [3:42] say externally, you know, we really are [3:43] oriented around just helping you just be [3:45] able to build, but internally, that [3:47] orientation, while still existing, is [3:49] probably more, you know, sp- specified [3:51] towards speed and being able to move [3:53] really quickly. [3:54] >> How do you decide what goes into the [3:56] platform, what gets externalized, and [3:58] what doesn't to decide what products [4:00] should be available? [4:01] >> Yeah, I mean, we generally try to have a [4:02] philosophy that we try to be consistent [4:05] across the board. It's actually one of [4:06] the reasons why we do internal and [4:08] external. [4:10] There's plenty of other, you know, [4:11] platform businesses and constructs where [4:13] you actually like bifurcate these two [4:14] things. [4:15] For us, we kind of try to intentionally [4:16] keep it equal and then as a result we [4:18] try to hold this philosophy as much as [4:20] we can around like, you know, for any [4:22] builder internal or external, even [4:24] though if our internal builders might [4:24] have some slightly different [4:26] requirements in the same way any user [4:27] would have slightly different [4:27] requirements. [4:29] We want to have the same primitives that [4:30] are available to everyone. And one of [4:32] the maybe the overarching thesis for [4:33] that is that we've just seen like the [4:36] capabilities of these models just grow [4:37] and that's just exponential. It's really [4:39] hard to figure out like a long-lasting [4:41] form factor. I think two years ago we [4:42] were all like everything's chat and now [4:44] everyone's like forget chat. Now you [4:45] just like agents. And like there's going [4:46] to be another form factor, another form [4:48] factor. [4:49] And we kind of imagine that like [4:51] constantly evolving. And so the best way [4:53] for us to kind of enable that for [4:55] everyone and also ourselves is to [4:56] actually build a really robust platform [4:58] that gives people those kinds of like [4:59] tools to figure out what those form [5:01] factors are. And I don't think we by any [5:03] means feel like we're the only ones [5:04] capable of figuring out that form [5:05] factor, like not at all. In fact, the [5:07] more democratization we can do on that [5:08] and help people and allow people to [5:10] experiment, I think the the more those [5:12] form factors will actually kind of [5:13] naturally come out of the market. [5:15] >> Yeah, and I think within our team we've [5:17] we've had moments where we're [5:18] experimenting even with just like a [5:20] packaging up of our primitives in a [5:22] different sort of higher order way and [5:24] we've thought about, okay, cool, we've [5:26] solved this exact type of problem with [5:28] this product that we built into the [5:30] world. And so we can go and dog food it [5:32] for ourselves, but we never want to fall [5:33] into this trap of like we're over [5:35] indexed on the problem as it needs to be [5:37] solved for an internal user like because [5:40] exactly what Angela said, internal users [5:42] have very specific requirements, [5:43] external users have very specific [5:45] requirements. And so if you over index [5:46] on one or the other, you fall into a [5:48] trap. So, a lot of the time what we'll [5:50] do is dog food something internally at [5:52] the same time that we open up early [5:54] access of some sort with external [5:56] customers so that we can kind of get a [5:57] range of feedback and bring those things [5:59] back into the platform. [6:00] >> I'd love to talk about the higher levels [6:02] of abstraction that you discussed. So, I [6:04] guess at the base level, this is just, [6:05] you know, raw access to Claude, Opus, or [6:08] whatever tokens. [6:10] How do you think about the I guess the [6:11] layer cake of abstractions above that? [6:14] >> Yeah, if you look back, um so when I [6:16] joined Anthropic around a year ago, um [6:19] the platform was basically just the [6:21] Messages API. There was a Messages API, [6:23] um you know, we had come out with [6:25] standards like MCP. We obviously have [6:27] developer tooling around our SDKs and [6:29] our docs and our console and things like [6:31] this, but for the most part it was a [6:32] stateless API. Um and what's interesting [6:35] to Angela's point on foreign factors [6:37] evolving over time is we found a lot of [6:40] our customers solving the same problems [6:42] over and over again that we also were [6:43] solving over and over again around as [6:46] the models got better at running for [6:47] longer and working with more context at [6:49] a given time, you want to build agents [6:52] that can succeed in a kind of [6:54] long-running context and even a remote [6:56] context that doesn't necessarily have a [6:58] human in the loop. And so, we found that [7:01] we could piece together our primitives [7:03] and stand up all the same infrastructure [7:05] that we're finding ourselves standing up [7:06] internally to power our own products and [7:08] arrive at some higher-order abstractions [7:10] that let you do more agentic work out of [7:13] the box. And the problems that we're [7:14] solving for you are, you know, [7:16] infrastructure being kind of a hard [7:18] thing to deal with. Like, how do you [7:20] figure out spawning sandboxes that are [7:22] going to have the right governance and [7:23] security and like, you know, spin them [7:25] up and spin them down when you need to [7:27] or the storage around transcript [7:30] sessions so that you can resume a [7:31] session if you stop it and pick it back [7:33] up later. Um so, that infrastructure is [7:35] a big thing that we wanted to be able to [7:36] provide more of out of the box and we do [7:38] more of that today. Um and then the [7:40] second thing just being harnesses and [7:42] harness engineering. There's a lot of [7:44] thought and energy going into how do I [7:46] do my prompt caching and how do I manage [7:48] my context window as well as how do I [7:50] actually just get more intelligence out [7:52] of the model, um, and how do I manage my [7:54] costs and things like that. So, [7:57] we've kind of packaged up our primitives [7:58] a bit more in tune with the problems [8:01] that we found ourselves solving to [8:02] provide more of these things out of the [8:04] box for people so that they can, if [8:07] they're building systems for them [8:08] themselves internally, if they're [8:09] building products, they can just be more [8:11] focused on the problems that they want [8:12] to be solving and if they want to [8:14] offload some aspects of those problems [8:16] to us, they can. Um, and that's kind of [8:19] the ethos. [8:19] >> And are your customers generally [8:20] choosing to opt from the grab bag of [8:22] stuff that you offer or are they like [8:24] how how often are they opting into the [8:25] just the the managed agents offering, I [8:27] guess, just take care of it all for me? [8:29] >> Um, it varies by like the the user [8:32] group. So, like for I would say, you [8:34] know, like really AI native startups, [8:36] like the ones who are like tinkering and [8:38] like experimenting at a really low [8:39] layer, they're just going to go for the [8:40] primitives. [8:41] Um, and then for everyone else, uh, [8:43] these are kind of classic, like more [8:44] like enterprises or areas where it's [8:46] like the purpose of the startup or the [8:48] philosophy behind the startup isn't [8:49] necessarily to optimize on, um, some [8:51] kind of hill climbing piece, it's more [8:52] like stringing together a bunch of [8:53] workflows and, you know, providing [8:55] unique user value at, uh, to that user. [8:57] For those people, um, you know, it's [8:59] just kind of not their core competency. [9:01] It's not what they want to focus their [9:02] time and resources and they reach much [9:03] more for these kind of like [9:04] higher-ordered like package offerings. [9:07] >> What are some examples of the primitives [9:08] you've released at different layers in [9:10] the last few months? We've seen a few of [9:11] them. Would love to hear. [9:13] >> Yeah, I think maybe one framing I would [9:14] give, um, for some of the constructs [9:16] that Cayden was talking about is like, [9:18] and this is a bit of an [9:19] oversimplification, but effectively [9:21] there's approximately like three like [9:23] layers of this cake. At the very bottom [9:25] is just kind of like like knowledge. And [9:28] so at this layer, like in many ways it's [9:30] it's knowledge about the model, it's [9:31] knowledge about the things that the [9:32] model needs, and it's just like the [9:33] ability to know how to actually do [9:35] something with Claude is maybe the way [9:36] I'd phrase that. And so there, the [9:38] primitives that we have spent more and [9:40] more time on have been actually things [9:42] of the past. Cuz like we still evolve [9:44] them, but they tend to be a little bit [9:45] more baked. Like for example, there's [9:47] very specific shapes and parameters we [9:48] put on the messages API, and it's more [9:51] like trying to expressly like showcase [9:54] Claude's like design. [9:57] Like Claude the model's actual design, [9:59] the way it thinks, the way it respects [10:00] certain parameters, the way it kind of [10:02] like [10:03] will do tool calls. Like all of those [10:05] different pieces. And then we started to [10:07] standardizing like tools, and then we [10:08] started standardizing bits and pieces of [10:09] like context that you could put in at [10:11] different moments in time, which is [10:13] concretely like skills and like memory. [10:15] And so those are like the kind of like [10:16] knowledge layer type of abstractions [10:18] that we've put out over the past I guess [10:20] like year plus plus a bit. [10:22] Um the next layer of abstraction that [10:24] we've actually started to spend more and [10:26] more of our time on is like once you [10:27] kind of know stuff, you then need to [10:29] like execute. And so at the execution [10:31] layer, that level of abstraction is the [10:33] part that Kaylin was talking about [10:34] around like we're doing these like [10:35] higher order pieces, but like what are [10:36] we putting higher order there? It really [10:38] is because you're now getting Claude to [10:40] execute work. It's not just to know [10:42] something, right? I can give it a [10:43] question, it'll give me an answer. You [10:45] can push string a lot of that stuff [10:46] together. [10:47] But now if you need to execute, like do [10:49] work, give me the output, edit files in [10:51] a bunch of different systems, that [10:53] becomes a lot more complicated and [10:54] requires infrastructure to handle. And [10:56] so that layer is basically I would say a [10:58] low-level harness plus managed [10:59] infrastructure as like the set of [11:01] abstractions. Today we just like our [11:03] high-level product for that is called [11:04] Claude managed agents. [11:06] And so that's like a piece, but we [11:07] started to wrap more and more pieces in [11:08] that. Um I think there's going to be a [11:10] layer like on top of that. We have like [11:12] some inklings of it if we started to [11:13] build towards, but the last layer of [11:15] abstraction on top of this is probably [11:16] the coordination layer. So you have [11:18] knowledge, and you have execution, and [11:19] you have coordination. And at the [11:20] coordination layer [11:22] we've started to expose some of these in [11:23] ways that like aren't very obvious, but [11:25] we're beginning to think of these things [11:27] called like strategies, where basically [11:29] it's almost like a a harness. Right, the [11:31] harness, the true low-level harness is [11:33] designed for execution. [11:34] But the next one is about, okay, if [11:36] tokens aren't really fungible, and you [11:38] need to give them different jobs, like [11:39] maybe some this token is advising versus [11:41] this token is executing, this token is [11:43] dreaming versus this token's executing, [11:44] so on and so forth. You want to start [11:46] composing these like these kind of [11:48] orchestrated strategies that go [11:49] together, and they should sit on top of [11:51] all these things because at the end of [11:52] the day you still need to execute, and [11:53] the execution still needs to know what [11:54] to do. So, everything in theory should [11:56] kind of like lad- ladder together. And [11:58] so, I think, you know, if you were to [11:59] look at our road map and the maybe kind [12:00] of project forward a little bit where [12:01] you kind of expect us to go, we'll move [12:03] more and more from the knowledge layer [12:06] to the execution layer, and from the [12:07] execution layer to the kind of [12:08] coordination layer in terms of the [12:09] abstractions that you can see us put [12:11] out. [12:11] >> That's a really cool road map. [12:13] >> How do you think this all comes together [12:15] into a broader ecosystem beyond just the [12:17] things that you guys are building? How [12:19] do you help support people building [12:21] products on top of it, and how do you [12:22] help them get the most out of all these [12:24] pieces? [12:25] >> Yeah, I think this is like super top of [12:27] mind for us. Like, we really want to [12:28] find a way to be [12:30] to support as many people in doing this [12:32] as we can. I think we're still like [12:34] learning. Like, a lot of the industry [12:35] like has evolved, we've seen, you know, [12:37] a lot of different pieces um get spun up [12:40] and spun down. And I think the the [12:43] operative part for for Caitlin and I has [12:45] been in the category of like making [12:47] sure, at least at the base layer, that [12:49] we provide as many primitives across the [12:51] board as possible. So, you know, this [12:53] kind of like yeah, like knowledge, [12:55] execution, coordination layer, we want [12:56] to give all of that out to everyone so [12:58] that people can start to compose and [13:00] create on top of that. Um and that's [13:02] just from a I think pure builder kind of [13:03] point of view. Then there's a point of [13:05] view around like, how do you kind of [13:06] like plug in with us? Right? Like, we're [13:08] also building first-party products of [13:10] our own. We've also created some ways to [13:12] embed natively with us, like for [13:13] example, connectors which are built on [13:15] top of the MCP spec. Um and we try to be [13:18] more open about those types of things. [13:19] And we're starting to figure out like [13:21] what are the right bits and pieces, but [13:22] I mean, what we're really trying to do [13:24] is get to a place where, you know, in a [13:26] a company is able to get creative and [13:28] build on uh they can build whatever [13:30] products that they want. They can build [13:31] agents if they need to and then those [13:33] agents and those products could be [13:34] things that could plug into other [13:36] agents. Some of those agents could be [13:37] cloud agents, some of those agents could [13:38] be other people's agents. [13:40] But we want to be able to enable that [13:41] kind of like trans-actability across the [13:43] board. And then I think in order for all [13:45] of that to kind of ultimately be true, [13:47] there is a bit around like standard [13:49] setting. And I think there's the [13:51] traditional standard setting which is [13:52] around, you know, how do systems [13:53] interoperate? Um and that's uh you know, [13:56] things that you've kind of seen us do [13:56] with like skills and MCP. [13:59] But they're at again like the builder [14:00] layer. I think at a higher order layer, [14:01] there's also a bit around [14:02] interoperability and standard setting [14:04] around how do we all kind of like treat [14:06] safety together? And you know, we've [14:08] talked to a lot of these companies and [14:09] this is less from, you know, [14:11] philosophies aside, just more like no [14:13] one really wants to have technology [14:15] that's like, for example, like doing [14:17] negative things on on their service, [14:20] right? Uh so cyber I think is a great [14:21] example of this. You want to protect [14:23] your own systems from like negative [14:25] actors or bad actors. And so like these [14:28] kinds of like standard settings of like [14:30] how can we find ways to partner with [14:32] more and more people to be like, yeah, [14:34] we all kind of want to make sure our [14:36] critical infrastructure is good. We all [14:37] want to prevent like fraud or any of [14:40] those things from happening and how can [14:41] we work better with each of these [14:43] members? I think on the last layer, [14:44] we're still kind of like we're still [14:46] evolving and I think we're still very [14:47] much like trying to find ways that we [14:49] can be better and work with the rest of [14:50] the industry to bring people along and [14:53] and work with them. [14:54] Um but those are kind of like, you know, [14:55] the higher order primitives or pieces [14:57] that we wish to kind of like be in [14:59] place. Um so they can work with folks to [15:01] to ultimately solve this. I think if I [15:03] would like take a step back at the end [15:04] of the day on on all of these things, [15:06] um [15:06] you know, like this technology is so [15:08] transformative [15:10] and if it's a little bit like [15:11] electricity in the sense like before [15:13] electricity, there was just like, you [15:14] know, you had to like have a candle and [15:16] it was like you can only do so many [15:17] things. [15:18] Um [15:19] but with electricity, the reason why [15:21] it's such a transformative technology [15:22] for all of us and so greatly of a [15:24] utility is because you can actually like [15:26] wire it into everything. Everyone is [15:28] able to actually access it. We also have [15:29] like standards and ways to plug in and [15:31] do all the pieces that we need. And [15:33] that's not something that anybody can do [15:34] by themselves. They always have to work [15:36] with the ecosystem and work with [15:37] partners um to figure out a path [15:38] forward. [15:39] >> How do you think about the philosophy of [15:41] building an open ecosystem [15:43] uh versus a walled garden? And you know, [15:46] how do you think about what products are [15:47] really important for you to own first [15:49] party versus [15:50] where you're perfectly happy to plug [15:52] into other components of the ecosystem? [15:54] >> Yeah, there's So, maybe in using [15:57] Angela's kind of layered cake that we [15:59] talked about a little bit earlier, [16:00] you'll see that on some pieces of this [16:02] like execution for example, um what [16:05] we've done within something like Cloud [16:06] Managed Regions. And I think over time [16:08] you'll see us try to make this a little [16:09] bit more modular. We actually aren't [16:11] precious about you should run these [16:13] things on our infrastructure. Like it [16:15] should be sandboxes that we control or [16:17] it should be a storage layer that we [16:18] control. Um Well, we actually like for [16:21] example, we launched self-hosted [16:23] sandboxes and we partnered with Moodle [16:25] and Vercel and Cloudflare and a bunch of [16:27] other folks um even like Amazon's new [16:30] micro VMs um to have a first-class [16:33] offering where you can go plug any of [16:34] those things in. Um [16:37] We launched MCP tunnels so that you can [16:38] call out to your MCP servers that are [16:40] behind your firewall, right? And um be [16:43] able to punch through there. And so, for [16:45] some of these things, we you know, the [16:47] weather whether it runs on our [16:48] infrastructure versus somebody else's [16:50] infrastructure is actually not important [16:51] to us cuz the thing that's important to [16:53] us is more that the architecture of how [16:55] you put together these agents in a way [16:57] that will be powerful, in a way that [16:59] will be reliable and scalable. Um We [17:02] have strong opinions on that, and you [17:04] can kind of just conform to the [17:05] interfaces that we put out there and [17:07] plug those things in. Um And we think [17:09] that that generally is a thing that [17:11] works really well. [17:12] >> Yeah, I think on the the kind of like [17:14] verticals where we we build products, um [17:17] you know, I think we we kind of have [17:19] like two frames here. The first one is [17:21] we are always trying to figure out a [17:22] form factor, like an evolving form [17:24] factor. We, by the way, don't think form [17:26] factors are like static. It's like a [17:27] dynamic thing. So, what might be awesome [17:29] for 1 year's worth of AI development [17:31] will probably not be awesome for the [17:33] next year's worth. And we just kind of [17:34] try to have that mentality. We tell the [17:36] team uh just overall like around [17:38] Anthropic, everyone's always trying to [17:39] be like, "Is this AGI pilled enough?" Um [17:41] and then we always have this mentality [17:43] of like, you know, we build something, [17:44] it works. It was cool for a a year and [17:46] maybe it's not the right next thing. And [17:48] so, throw it away, try again. Um and we [17:50] we tell like platform users the same [17:52] thing. Um [17:53] We just think that's probably just like, [17:54] you know, attached to the technology. [17:56] But so, yeah, one one principle is like [17:57] trying to always constantly find this [17:58] new form factor. So, sometimes we'll [18:00] like launch products in certain areas to [18:01] try to showcase a new type of form [18:03] factor. Um it's not necessarily cuz we [18:05] think it's like the biggest TAM or the [18:07] most important thing to go after, but [18:09] sometimes like, "Okay, this is like [18:10] always been a really difficult thing and [18:11] people have always communicated this way [18:13] or tried something this way." And so, [18:15] can we show that maybe there's a [18:16] slightly different way? Um and because [18:18] the model capabilities are are so [18:20] advanced now, can we try to express it a [18:22] bit differently? Um [18:23] >> What's an example of that? [18:25] >> Yeah, you know, like uh [18:27] Claude design is a little bit of of that [18:29] way. I think depending on how you [18:30] squint, you might see it as like a way [18:32] that we kind of are going into design as [18:34] as as like, you know, one of the [18:35] verticals. But more often than not, it's [18:37] like if you take a look at what we're [18:39] trying to do with that product, there's [18:40] a couple of like decisions that were [18:42] made in there. The first one is that [18:43] like you can actually try to offload [18:45] more and more and more to Claude. [18:47] Um and so, it tries to be kind of [18:49] opinionated on like, you know, just just [18:50] like talk to it and like let it really [18:52] try to figure out. And yes, you can [18:53] still edit it and then do these kinds of [18:55] things, but kind of like discourage a [18:56] little of that and more just like let [18:58] just talk to Claude to go figure it out. [19:00] Um the second thing was it was really [19:02] trying to express that actually like [19:04] code is a is a a way to solve for things [19:07] that you wouldn't normally think would [19:08] be the way. So, a lot of people who have [19:10] built kind of generative um you know, [19:12] like slide decks or designs or whatever, [19:14] um, we'll pick uh the way of like they [19:16] have like some kind of design system, [19:18] you integrate against design system. [19:19] It's almost in the traditional like a [19:20] classic WYSIWYG style of designing [19:22] something. And with like cloud design, [19:25] it was like, "Okay, can we try to just [19:27] like use code purely, but have Cloud [19:30] generate that code, and would it like do [19:32] a good job?" And we found through some [19:34] experiments early on, it's like, [19:35] "Actually, it looks like it can kind of [19:37] do that. And how can we kind of showcase [19:38] that uh to the world?" So, that's like [19:41] an example. We have a lot of other [19:42] internal projects, and this kind of [19:43] falls in the category of like expressing [19:45] form factor. We'll all try it out [19:46] internally. It'll be super cool for like [19:48] 2 weeks, and then we move on to the next [19:50] thing. Um, we never even ship the thing, [19:51] frankly. But yeah, we actually do a lot [19:53] of product experimentation in that area, [19:54] and that's like our labs team. And then [19:56] there's like the second category, which [19:57] is that we actually do look at TAM. [19:59] Like, we're a business, we do look at [20:00] TAM, we do look at areas that we think, [20:02] uh, you know, there'd be reasonable [20:04] agentic like operations that would [20:06] happen. [20:07] In those areas, [20:09] uh, we do tend to have an orientation [20:10] towards things that are more token [20:12] heavy. And by token heavy or token [20:13] hungry, maybe is the way I would say [20:14] that, is like what we mean is like, you [20:16] know, you for spending once you spend a, [20:19] like call it like one turn, you look at [20:21] the end of that turn, and you say like, [20:23] "Am I done, or am I actually so glad [20:25] that I did that thing, I want to do more [20:26] of that thing?" We like industries where [20:28] it's like the answer to that question, [20:30] you say, "I want to do more of that [20:31] thing." So, coding is obviously the one [20:32] that we all know. And the great thing [20:33] about coding is that what it's actually [20:35] doing is that like once you finish a [20:37] turn, you look at that, and you're like, [20:39] "That was incredible. I'm like unlocked. [20:41] I'm going to do like more. I'm going to [20:42] build more, I can do more." And there's [20:44] other services where it's like actually [20:45] when you finish that turn, you completed [20:47] the job, and you just move on. You know [20:48] what I mean? Um, and so we tend to like [20:51] go into the ones that are a bit more [20:52] like there's this kind of like iterative [20:53] flow, you're going to build more, [20:55] generate more together. [20:56] Um, and then the last angle that we kind [20:58] of take a look at is just sort of like, [20:59] you know, there's going to be certain [21:01] business functions that were like they [21:03] are the buyer that we like to go to. We [21:04] want to help them optimize their [21:06] workflows, help them create better [21:07] products there. And I think we've been [21:09] pretty transparent with some of the [21:10] verticalization like we've done like [21:11] finance, we've done like legal. [21:13] Um and we've tried to kind of like [21:15] narrow on into specific areas where we [21:17] feel like by having the right context [21:19] and the right tools and putting it [21:20] together in a good form factor is [21:22] probably useful um for us to to be able [21:24] to do. And in each of those areas, we do [21:28] we're trying to do a bit of like showing [21:29] the art of the possible across all the [21:31] different ways that you would accomplish [21:33] those outcomes. And so for you know, [21:35] like finance for example is a good one. [21:38] Um you know, we you could be a company [21:41] that solves problems in finance and you [21:43] could build directly on the messages API [21:45] and you can just get some tokens and you [21:46] can build everything else on top. Or you [21:49] could be someone who builds on Claude [21:50] managed agents, you can get a lot more [21:52] out of the box. Or you could say, "I'm [21:54] going to build a plugin that or like a [21:56] connector, right?" That's going to sit [21:58] within one of our products and within [22:00] those form factors. And we did recently, [22:02] we launched like Claude for financial [22:03] services is like, "Okay, cool. We've got [22:06] packages of skills and things like this [22:08] that you could choose to use within our [22:10] product, within other people's [22:11] products." We even launched like [22:12] cookbooks on, "Here's how you would use [22:14] Claude managed agents to go and do these [22:16] things." And so I think for us, it's all [22:19] kind of an experimentation around like, [22:21] you know, we provide people all these [22:23] different pieces and see kind of where [22:25] they run with it. And then sometimes we [22:26] put together products that are just [22:28] packaging of all of these things like [22:30] Claude Tag, I think, is a really good [22:32] example. Like we had been seeing people [22:34] in the industry go into like Shopify did [22:37] this with River, um Square Block [22:39] recently did this with Builder Bot. Um [22:41] there's like a few of these examples [22:43] where people said, "I'm going to I'm [22:44] going to build like an agentic platform [22:46] internal to my company and I'm going to [22:48] try to give it all the right context and [22:49] I'm going to make it accessible from [22:51] Slack or from various other um you know, [22:54] platforms that you'd want it to be [22:55] accessible at." And I think Claude Tag [22:58] was very much a [22:59] packaging of all those same things that [23:01] anybody could choose to build something [23:03] similar, but this is how we're kind of [23:06] like, well, this is how we're doing it [23:07] internally, and if you would like to [23:09] just kind of plug in and go, here's what [23:11] that looks like. [23:11] >> you think people misunderstood about [23:13] Claude Tag? Cuz there's all this like [23:14] ruckus about, oh my god, it's just a [23:16] Slack bot. Like, tell tell us [laughter] [23:17] what what the magic of Tag is. [23:19] >> Yeah, I think it's a great question. Um [23:21] and I I do think it actually showcases a [23:22] little bit of where maybe the future [23:24] could be going. [23:25] Um yeah, I think like the I think if you [23:27] look at products in the past, people are [23:28] like, oh, you really attached to like [23:30] the form or the the UI almost, right? [23:32] Like, it looks like this, so it's like [23:34] super cool. [23:35] Um and I think when you look at like [23:36] Tag, uh it like, yeah, like the way you [23:39] interact with it is that you like [23:40] literally tag it in Slack. Uh and so [23:42] yeah, that is like the interface. But [23:44] that's not really the important part. [23:46] The important part um is all the kind of [23:49] like context engineering and like [23:52] architecture that we put underneath the [23:54] hood so that Tag just works. It really [23:57] should just like just feel like a [23:58] coworker. Like a co- you know, if you go [24:00] to a company and you onboard to the the [24:02] coworker comes into your channel and [24:03] then you can chat with it. It's [24:05] proactive, it's figured out like what's [24:07] like useful, you could and um it just [24:09] gets stuff like done for you. And so, if [24:11] you think about, you know, especially [24:13] like non-technical audiences, this is [24:15] like it's a huge unlock. You just you [24:17] literally create a channel and then you [24:18] @ Claude or sometimes you don't even @ [24:19] Claude and you're like, "Hey, I want to [24:20] be able to do this and do that, and I [24:22] can't figure out this, and how do I [24:23] actually like submit an expense report [24:25] again?" And traditionally, do you think [24:27] about how to solve that workflow, you [24:28] are going all over the place, and you're [24:30] talking to your manager, and you're [24:31] talking to your spin buddy, and it's [24:32] like really really complicated. [24:34] And uh today, now you just like go talk [24:36] to Claude Tag, and we do a lot of the [24:38] hard work on doing the context [24:40] engineering, the proactivity, a lot of [24:42] the harness pieces. I think Andre [24:44] Kaparthy said it really well, he's like, [24:45] it's an org-level harness. There's a lot [24:46] of like complexity baked into that. Like [24:48] Kaylee mentioned, like you can use our [24:50] APIs to go and construct that. You can [24:51] do a lot of the experimentation [24:52] yourself, obviously, but this is like an [24:54] opinionated take from Anthropic on like [24:56] how you can have this really awesome [24:58] always on kind of agent for your entire [25:01] entire company. And the bit that's like [25:04] futuristic I guess is like a lot of that [25:07] complexity is actually like it's like an [25:09] iceberg. It's like all the stuff [25:11] underneath it. That's actually becoming [25:13] the harder and harder and like useful [25:14] part that we're trying to like push [25:16] through. And I think we'll see more and [25:18] more like that kind of like tip bit [25:20] that's like outside in the water. It's [25:22] just like the interface can actually [25:24] constantly swap. Like today right like [25:26] Slack is a place where a lot of people [25:28] collaborate. A lot of business [25:29] collaborate. But also a lot of people [25:30] collaborate in Teams. And some people [25:31] collaborate by a WhatsApp group or they [25:34] text each other or they may some people [25:36] still email each other. And like those [25:38] could be the form factors that actually [25:39] completely you can imagine agents just [25:41] going there and being. And they're [25:42] almost taking up the same form factors [25:44] as humans have taken up. It was almost [25:46] like a very almost like boring take but [25:48] it's actually like I feel like the most [25:50] like forward one because you want the [25:52] agent and you want AI to basically be [25:55] like another person and it's helping [25:57] you. But like it's like you know very [25:58] intelligent can figure out all the [26:00] context and you can always have it to be [26:02] a really helpful assistant. [26:03] >> Totally. You talked about context and [26:05] then harnesses quite a bit and so your [26:08] team is just you know has such an [26:09] opinion and point of view on like what [26:11] it takes to build an exceptional agent. [26:12] I imagine a lot of that comes down to [26:14] the context engineering and the [26:15] harnesses. [26:15] >> Totally. [26:16] >> Maybe like what best practices of or [26:18] advice would you would you share with [26:20] people about what you need to get right [26:21] on the harness and what you need to get [26:22] right on the context? [26:24] >> Yeah, I think so it's interesting [26:26] because we've kind of talked about you [26:28] know we launched Claude managed agents [26:30] as this like very generic but high [26:33] performing harness because we've done [26:35] all the nitty-gritty work that's [26:37] actually like really boring and not [26:39] super interesting around how do you deal [26:41] with prompt caching? How do you deal [26:42] with context management? You like clear [26:44] old stuff out of the window. Sometimes [26:46] you like call tools programmatically so [26:48] you don't pull everything into the [26:49] context window and you can keep it [26:50] clean. There's a lot of those sort of [26:52] details on the lower level harness [26:54] layer. [26:55] Um [26:56] and I think honestly like best practices [26:58] are just stuff like [27:00] prompt caching, do it. Save a lot of [27:02] money and and token costs. Um obviously [27:05] like try to keep your context window [27:06] clear and then putting those things [27:08] together in [27:10] uh a harness that will be performant is [27:12] is you know sometimes specific to the [27:15] task that you're trying to accomplish, [27:17] right? And then of course evals. Um I'm [27:20] surprised we got this far into this [27:22] thing before one of us said the word [27:23] evals. But like you need evals um to [27:25] make sure that what you're trying to [27:26] accomplish is performant. Um [27:29] but I think we're we're starting to go [27:31] and Angela mentioned this a little bit [27:32] earlier is more of a concept of [27:34] strategies or meta harnesses. Because I [27:37] do think that yes, you can again make [27:39] this lower level harness that's going to [27:41] be performant and maybe that's [27:42] interesting for you to do yourself or [27:43] maybe not and you offload it to us. But [27:46] this concept that [27:48] you can take any given token and spend [27:49] that token on just executing or you [27:52] could take that same token and choose to [27:54] actually reflect on your past agentic [27:57] sessions and write learnings to memory [27:59] so that the next agent does a good job. [28:01] Or you could take that token and advise [28:03] with a bigger model so that a smaller [28:05] model can execute and do a better job. [28:07] Um or you can say execute execute and [28:09] then like a grader comes in and is like, [28:11] "Did you do a good job? No, you didn't. [28:13] Try again." right? And so I think the [28:15] the like interesting innovation is going [28:18] to come more at that higher level on [28:20] like the meta level, right? And I think [28:23] optimizing within those strategies is [28:25] something that our team is really [28:26] excited about and we're starting to do a [28:28] lot of work there. Um and I think a lot [28:30] of other people are starting to feel [28:31] really excited about this concept of [28:33] strategies and like the jobs you give to [28:34] tokens. [28:36] Because again like yes, there's best [28:37] practices on stuff like your prompt [28:39] caching and exactly how you clear stuff [28:41] out of your context window and how you [28:42] write your evals and like a lot of [28:43] things like this. But I I don't know [28:46] that there's necessarily so much juice [28:47] to squeeze in a lot of cases out of that [28:50] layer as compared to a layer higher than [28:52] that. [28:53] >> Yeah, and one of the reasons for that I [28:54] think is it has to do with the [28:55] generations of the the models. I if you [28:57] look like 2 years ago, a lot of the [28:59] harness was like a scaffold to kind of [29:01] like [29:02] tell the model to go from point A to [29:03] point B. And you had to like you really [29:05] had to like build in a lot you had to [29:07] practically build one wall here and one [29:08] wall here so that like the thing would [29:09] go in a straight line. And now the [29:11] models are actually very very steerable. [29:14] Um and so a lot of that steering you can [29:16] just put it in the prompt, right? You're [29:17] like go do go from point A to point B. [29:20] And the model like will go from point A [29:22] to point B. So a lot of if you have [29:24] harnesses um that are like designed to [29:27] kind of do that kind of like steering, [29:29] you can delete that part. Like that part [29:31] we actually frequently encourage like [29:32] you can delete part of those harnesses. [29:33] I think various people have said things [29:34] along those lines. And that's I think [29:36] what people oftentimes mean when they're [29:38] like you know the model will kind of [29:39] consume some of the scaffolding. And [29:40] like in that sense like for sure if your [29:42] scaffolding is telling it to go in [29:43] direction, um that it can just [29:45] intelligently figure out. Like that I [29:47] think will increasingly continue to to [29:48] be so. [29:49] But as a result of of this, what the [29:51] harness needs to start doing is more [29:53] allow it to run longer. And so that's [29:55] where like that execution bit tends to [29:57] be I think like it sounds like a maybe [29:59] somewhat silly point, but I do think it [30:00] results in a lot of differences. Because [30:02] because it you can go in the direction [30:04] that you tell it to go, you obviously [30:05] don't want it to stop at B. You don't be [30:06] like okay now go from B to C and then go [30:08] to F and then go to Z and then come back [30:10] to me on A. You know, something funky [30:12] like that. In order to be able to do a [30:14] lot of those things, the kinds of [30:16] harnesses that you do are less the [30:17] steering harness and it's more like [30:19] these kind of strategy harnesses that [30:20] Caitlyn's mentioning, which allows you [30:22] to operate at a slightly higher level of [30:24] thinking, which matches I think a lot of [30:26] the intelligence gains that we're [30:27] starting to see with the model. [30:27] >> Do you think task-specific harnesses [30:30] make sense? Or a vertical-specific or [30:32] task-specific harnesses? [30:33] >> I think people have different opinions [30:34] on this. Like our opinion is yes. I [30:36] don't think there's like a general [30:37] harness. I think there are some [30:39] capabilities that are obviously very [30:40] general and they tend to like be very [30:43] useful. Like coding is a capability that [30:45] like is very useful cuz you use it [30:47] across so many things and software as [30:50] you know it's just like eating so much [30:51] of of what is capable. So our ability to [30:53] like write software is therefore useful. [30:55] I think when you think about like very [30:57] very specific types of domains that were [30:59] going to require like a couple of pieces [31:01] of the harness to be sort of like [31:03] customized. One of that I do think is [31:06] how you choose to kind of like handle [31:08] sort of like errors between when you do [31:11] something and you hand something off to [31:12] the model. [31:13] So in like domains where you require [31:15] like an extreme level of verification, [31:17] that logic of how you handle that like [31:19] it again I think it sounds small but [31:21] like I totally understand why some [31:22] people feel like they really want to own [31:24] the harness because tweaking that last [31:25] bit will give you a ton of juice. And [31:27] especially domains like like legal and [31:29] finance where there's a lot of [31:30] consequences to you know not getting it [31:33] perfectly correct, like it's really [31:34] going to matter and that's going to be [31:35] the difference between your product and [31:36] someone else's product being the thing [31:38] that the user ultimately uses. And then [31:41] there are other domains for which like I [31:43] would say it's not going to matter as [31:45] much because you're able to compress it [31:47] into like a general model capability. So [31:49] the tweaks that I guess like you know [31:51] where where we feel like the domain [31:52] specificity is really going to matter is [31:54] the specific like verification logic [31:56] between the model [31:58] and your execution and then [32:00] I think it's going to be about like some [32:02] of these kind of like higher order [32:04] strategies on how well you're able to [32:07] actually like allocate your token [32:08] budget. I think the context is actually [32:12] a little like over done. Like yes you're [32:13] going to like throw in context and like [32:15] that's but any harness can actually [32:17] handle a lot of context and so that's [32:19] just more like you have the data and if [32:20] you have the data then obviously you're [32:21] you're uniquely qualified to do [32:23] something useful. [32:24] >> Yeah and I think when people say [32:25] harnesses they often mean a lot of [32:27] different things and I think this is why [32:29] in part there's so many different [32:31] opinions on this. Like you can think of [32:32] a harness is literally just like a loop [32:35] Um, like okay cool like user model, user [32:38] model tool, you know, like that sort of [32:40] thing. Um, then you could think of the [32:42] harness as also all of the tools that [32:45] are packaged up with the harness, right? [32:47] And and there's just like a lot of [32:48] different definitions of these things, [32:49] and I think the stuff that can be pretty [32:52] generic and like less interesting to own [32:55] and and deal with what I was kind of [32:56] saying earlier is like getting your [32:58] prompt caching right, right? Like, maybe [33:00] that is not the world's most interesting [33:02] thing. Choosing to clear out old tool [33:05] calls from the context window and and [33:07] things like that, right? Are like maybe [33:08] a little bit less interesting. [33:10] And you like go a layer higher into some [33:12] of the stuff Angela was talking about, [33:13] and then you get into like, okay, yeah, [33:15] these are things that I might want to [33:16] own and control. And so, it's [33:18] interesting with cloud managed agents, [33:20] like, the thing that we built today, we [33:22] call it higher order, but it's not [33:24] really like that high order in the sense [33:26] that you can choose to define all of the [33:29] tools that you want to bring in as [33:31] custom tools with the harness, right? [33:32] And like, we give you a lot of knobs to [33:35] control. You can define skills, you can [33:36] do your system prompts, you can do a [33:37] whole bunch of different things, MCP [33:39] servers and things like this. And I [33:41] think where, you know, we want to get to [33:43] is a point where you can literally just [33:45] tell an agent, here's the outcome I [33:46] want, and here's the budget that I want [33:47] to spend, like, ready, set, go. And you [33:49] maybe like don't think about any of [33:51] those things underneath. And so, I think [33:53] there's just a few different layers of [33:55] this, right? That for certain things, [33:57] like, you might want to sit at a [33:58] different layer of what you actually go [34:00] and control, um, and you can probably [34:02] get better outcomes within some of those [34:04] layers by doing a little bit more [34:06] optimization work. [34:07] >> Very cool. One of the things I'm curious [34:09] about, and then what that I love about [34:11] infrastructure and platform teams, is [34:12] that you get to see what the most [34:13] advanced users in the world are using [34:15] and learn from them. I'm curious, what [34:17] are some things that you're seeing and [34:18] learning from from the people building [34:19] on your platform? [34:21] >> There's some people who've been doing [34:22] some really funky ways of like handling [34:25] context. [34:26] Um, we ourselves explored this a lot. [34:28] This is actually like one of the reasons [34:29] why tag is like uh such a great product [34:31] is like there's a lot of really awesome [34:33] like context kind of engineering that [34:34] that's happening. [34:36] Um we've seen some teams be really [34:38] clever about like how they do that and [34:40] they are able to kind of think through [34:42] like, "Okay, if I have all these [34:43] contacts in a bunch of different places, [34:44] how can I proactively go reach out to [34:46] them? How can I try to generate enough [34:48] like um permissions across each of them [34:51] so and then feed that all into like an [34:53] agent?" And it's interesting that like [34:55] um I guess like this is kind of the [34:56] level of innovation that like we're [34:58] actually like very excited by. It [34:59] doesn't express itself as like a [35:00] completely different form factor, um but [35:03] what it actually does express itself as [35:04] is like maximally useful to users and [35:07] we've been seeing this more and more [35:08] with like inter- actually like internal [35:09] use cases [35:10] instead of like external ones. So like [35:12] companies who are becoming more AI [35:14] native basically, they're the ones we're [35:15] seeing increasingly more and more [35:17] innovation out of and so you know, we've [35:19] had like customers try to do this for [35:21] their like they've built their own like [35:22] custom SDLC kind of setup in very very [35:25] innovative ways. We've had uh ones who [35:27] do that for like in their entire back [35:29] office. And just like the kind of [35:30] nuances of how they like stream in [35:32] context, I think it's been like actually [35:34] really interesting in terms of like how [35:35] they've been putting together the [35:36] pieces. So that's been like one category [35:38] that's been like really really like [35:39] fascinating. Uh another category that's [35:42] been like really interesting has [35:44] actually been with companies that are [35:45] dealing with like really old-school [35:47] software. And so there's a lot of like [35:48] healthcare companies um that we kind of [35:49] engage with and you know, like they're [35:52] like the the systems I'm working with, [35:53] they don't even have APIs. Like that's [35:55] that's a a dream. Um and so you know, [35:58] how can they use computer use uh and [36:01] things like this to be able to start to [36:03] kind of automate and create more [36:04] connectivity with our systems. Um and [36:07] that area of innovation I think has been [36:08] really exciting. It's been really [36:09] interesting to see people try all sorts [36:11] of crazy stuff from like taking a laptop [36:12] and trying to like run a bunch of things [36:13] on it to auto-generate a bunch of things [36:15] that then their agents can go and use. [36:17] Um and this has actually been probably [36:18] like an area of um I think a lot of [36:20] innovation coming from a lot of our [36:22] customers that we want to find ways to [36:23] like support better and see like, "Okay, [36:25] maybe there are like how can we make [36:27] this easier for you? How can we help you [36:29] with some standardization? How can we [36:31] get it so that, you know, like you can [36:32] just have a spec and then Claude can [36:34] then respect it. And so it's much easier [36:36] for you to organically connect a lot of [36:38] these things. But yeah, maybe the the [36:39] general theme I would just give you is [36:40] like interestingly, a lot of the [36:42] innovation that's most exciting out [36:44] there right now has been uh this kind of [36:46] like context and connectivity layer, [36:48] which has been really fascinating. [36:49] >> Yeah, like a good one in that um we were [36:52] working with a customer who they built [36:54] some agents on Claude managed agents. [36:56] They also have some agents that they [36:57] built on other models and other [36:59] platforms and they've kind of optimized [37:01] each of these agents to be good at the [37:03] things that they want. They want these [37:04] agents to all be able to work well [37:06] together. Um and they kind of were like [37:08] wow, galaxy brain, like what if I expose [37:10] an MCP server on top of this agent so [37:12] that I can then go and like have this [37:14] other agent call a tool on that agent, [37:17] right? And and have these things just be [37:18] more modular and be able to work [37:20] together. And we're like We sat down [37:22] with them and worked through it and and [37:24] it worked perfectly. And it was pretty [37:25] cool. And so we're seeing a lot of again [37:27] that connectivity layer that I think is [37:29] one of the cooler areas where people are [37:31] innovating, but [37:33] outside of that, one thing that has been [37:34] cool is just seeing the shift in I guess [37:37] like industry trends of where we're [37:39] seeing a lot of our usage come from. [37:40] Like talked a lot about coding, like [37:42] coding as a category, like of course [37:44] absolutely exploded. There's so much [37:45] going on there. And we're starting to [37:47] see some of these emerging trends like [37:48] more recently. [37:50] Um we're starting to see manufacturing [37:52] really pick up as just a category where [37:55] people are building with AI and like one [37:56] of our PMs like getting on a flight to [37:58] Detroit to go like figure out with these [38:01] customers like what they need and what's [38:03] going on. And so I think we're going to [38:04] start to see a lot more just kind of [38:07] like outside of the box of what people [38:09] think about today sort of use cases, [38:11] which we're really excited about. [38:13] >> It seems like there's no there's a we [38:15] went through a token maxing moments of [38:16] history and now there's like the token [38:19] rationalization moments of history. [38:21] [laughter] [38:21] What are your thoughts on that and like [38:23] what what should companies be doing and [38:24] then how it how does the platform team [38:26] think about enabling that? [38:28] >> Yeah, I mean it it makes sense. [38:30] It makes sense from the high you start [38:32] to rationalize. I really like that [38:34] framing. And I think there's like a [38:36] couple things that that are like top of [38:37] mind for us on this front. I think like [38:39] again it makes sense and as these models [38:40] get more and more capable you're going [38:41] to hit like levels of intelligence [38:43] maxing that are like there that then you [38:45] want to do the next kind of dimension [38:47] and the next dimension after [38:48] intelligence will either be cost or it [38:50] will be speed. [38:52] And you just kind of like you know go [38:53] through that across all possible task [38:54] complexities in the distribution. And as [38:57] we kind of see that like happen you know [38:59] something that's like really top of mind [39:00] for us that we kind of try to spend some [39:01] time with users on is like what you [39:03] don't want to do is like stop AI usage. [39:06] Right like that's kind of the wrong [39:07] move. And we do actually see some of our [39:09] our customers do that. So often times [39:11] the way that AI spend has erupted inside [39:13] their company has been through some kind [39:14] of like shadow IT. You know like their [39:16] employees just like want to use it they [39:18] find a way they end up procuring it [39:19] themselves and before you know it like [39:21] half your org has like found some way to [39:23] have installed cloud code. And in that [39:25] world it is kind of hard to to manage [39:26] because these things are again like [39:27] they're very token hungry ultimately. [39:29] And so what we try to kind of encourage [39:30] our customers is like okay you don't [39:31] want to like stop the innovation. Like [39:33] if you are getting returns on top of [39:34] this you are shipping faster than ever [39:36] before you can like run more [39:37] operationally like efficient then those [39:40] are gains. And so the area that we [39:42] actually try to encourage people is like [39:44] if there is a way for you to kind of [39:46] construct again like a strategy that [39:48] allows you to design an architecture [39:50] that says like given a task assesses [39:52] level of complexity. I mean I'm [39:53] effectively [39:54] describing a router but like there are [39:56] ways to do this that are like I think a [39:57] bit better now. And so like this task [39:59] comes in has a certain level of [40:00] complexity for that level of complexity [40:02] like you can define some rules but for [40:03] the most part right if it's like a hard [40:05] task you should probably route that to [40:06] like a big super smart model. And if [40:09] it's not a hard task you can route that [40:10] to like cheaper models. [40:11] Designing that I think has a little bit [40:13] of like there's a lot of technical [40:14] complexity in that but it's like very [40:16] very doable. And we actually like, [40:17] encourage people to try those kinds of [40:19] things. I think ultimately [40:20] >> offer a router? [40:21] >> I I think within the Claude space, it [40:24] will like make sense. It's actually one [40:25] of the strategies we imagine like [40:26] designing, cuz the way that we are kind [40:28] of thinking a lot of these things is [40:29] like, it almost feels like every month [40:31] there's a new era of something. [40:33] Um, and if we just take a step back and [40:34] go, "Okay, and it they seems to be like [40:36] really fast." And so, what are the [40:37] different ways that are re-composable so [40:39] we can redesign very quickly for any new [40:42] whatever the cool thing is that month [40:44] kind of like [40:45] Um, and so this is like in that category [40:47] of things where we feel like we can [40:48] actually just like re-compose a lot of [40:49] our primitives and then design it. I [40:51] think the bit that we do feel really [40:53] strongly about on the model routing [40:55] front is like, we are designing our [40:58] platform for Claude and we want to make [40:59] sure that Claude is great at like [41:01] solving all these things. So, we'll like [41:03] restrict to that space [41:05] um, rather than you know, I don't think [41:06] we're that interested in saying like, [41:08] "Okay, and then you know, you should [41:09] route to a different model or whatever." [41:10] >> Makes sense. [41:11] >> Yeah, and and well, some of that too is [41:13] just like, I think we have a strong [41:14] belief that harnesses and and just like [41:17] the agentic layer should be tuned to the [41:19] model family that you use it with. And [41:21] so, I think there was a period where [41:23] people were kind of like, "Yeah, cool. I [41:24] can like build a harness and build an [41:25] agent and then just like plug in a [41:27] different model underneath." And they [41:29] were excited about routers from that [41:31] perspective. And I think we've started [41:33] to see um, like Vercel just did this [41:35] with harness agent for example. Like, [41:37] some of these players in the space like [41:38] come up a layer of abstraction and say, [41:40] "Actually like, plug in the whole [41:42] harness and the whole agent that's tied [41:44] to a model family." Which makes a lot of [41:45] sense. And so, what we could provide is [41:47] a little bit better, smarter like, how [41:49] do you mix and match the right models [41:50] within the model family underneath that [41:52] thing if that makes sense. But, yeah, on [41:54] the general question of token maxing, [41:56] costs, and these sorts of things, [41:58] I think we're just kind of going through [42:00] what feels like a normal, natural cycle [42:02] for companies in figuring out how to [42:04] make the best use of this technology and [42:07] run their businesses really well and [42:09] really effectively. And um, it's [42:11] interesting like before working at [42:12] Anthropic, I was at Stripe and we were [42:14] kind of in the very reasonable era of [42:16] like we paid a lot of attention to our [42:18] AWS bill. And so, you know, if someone [42:21] were to have built some background job [42:23] and they like didn't quite configure it [42:25] correctly and this thing's like burning [42:27] through like CPU or whatever it is, [42:29] right? Like at any given moment and [42:32] causing, you know, big increase in span [42:34] that's not actually worth it, right? [42:35] Like we have put in place the guardrails [42:38] to find that and then go ask that [42:40] engineer very nicely to please turn off [42:41] their background job that's not like [42:43] within the bounds of of what they should [42:45] be spending for the thing they're trying [42:46] to accomplish. I think those are the [42:48] things with AI that people are going to [42:50] start to go and figure out and I think [42:52] to Angela's point, I think that gets [42:54] dangerous is when you're kind of just [42:56] like, here's a cap and you're stuck [42:58] within your cap like ready, set, go. But [43:01] I do think that encouraging innovation, [43:03] encouraging people to, you know, create [43:06] really excellent outcomes with this [43:07] stuff and then coming in from the side [43:09] and looking and saying like, okay, well, [43:11] there are few different ways we probably [43:13] could have accomplished that outcome, [43:15] right? And one is like you take Opus and [43:18] you run it all night and you do [43:19] something crazy and another is maybe to [43:21] get a little bit smarter with the [43:23] strategies that you put together in [43:24] order to create that same outcome within [43:26] a lower cost and I think that's the like [43:29] next layer of thinking that everyone's [43:30] going to start to do. [43:31] >> Very cool. Is there anything that you [43:33] guys are excited about building over the [43:34] next two months that you can share hints [43:35] at what might come next? [43:37] >> Uh, yeah, I mean, I know we said this [43:38] word like 20 million times, so I [43:40] apologize, but like we really are trying [43:41] to build ways for you to compose [43:43] strategies. [43:44] Um, and so, uh, that is an area that [43:47] that we're like trying to move into that [43:48] kind of like, yeah, uh, coordination [43:50] layer of the abstraction. Um, and we [43:52] want to start at at this front because [43:53] the types of problems that we see people [43:55] building, they are at a layer where it's [43:58] like in order to get the most return on [44:00] this, you have to be a little clever [44:02] about like what is the nature of the [44:03] problem that you're solving. So, to give [44:05] you something like concrete, like if [44:06] when you try to solve for like let's say [44:08] you want to build an agent that's like [44:10] trying to [44:11] do bug hunting. And you could just send [44:14] one off to go and do that. And it's [44:16] going to give you a certain type of [44:17] return, a level of return possibility. [44:20] And then people kind of get stuck at [44:21] that and they're like, "Okay, my next [44:22] options are I can like [44:24] make a bigger I can just like swap the [44:26] model for a different probably bigger [44:28] model [44:29] or I could like let it run like longer. [44:31] And that's what pretty much like the [44:32] only two like levers that you have to [44:34] like try to make this like bug hunting [44:35] agent. [44:36] From a lot of experimentation, when we [44:37] do these kinds of things it's like [44:39] actually the thing like those two those [44:41] two things are still true. But you [44:42] actually have a third lever and tends to [44:44] actually do a lot more than you think it [44:45] does. Which is that actually if you were [44:47] to like best of end the thing, it would [44:49] like give you a lot more returns. But [44:50] like just to be just saying those words [44:52] are fine. There's plenty of papers and [44:54] people have published it to actually [44:55] build that thing and put it into [44:56] production so you can actually test it [44:58] on users and see the results for [44:59] yourself. That's like really really [45:01] freaking hard. And you end up building [45:02] all these like custom harnesses and so [45:04] on and so forth. So like you know, all [45:05] that stuff. [45:06] But we're seeing like this is where the [45:07] alpha is and it's hard. And so like in [45:10] the same very simple philosophy that we [45:12] talked about at the beginning, like if [45:13] it's like gives you the return that you [45:14] want and it's hard, we're going to go [45:15] try to just make it easy for you. So [45:17] then you can use it to then run the [45:19] experiments that you actually need to [45:20] run. It reminds me of when people were [45:21] talking about agent swarms a year ago. [45:23] It's some version of that. [45:25] >> Yeah. Has it been a whole year? [45:26] >> Yeah. [45:27] I know. We're finally there. [45:28] >> Yes. [45:29] Yeah. No, I think that that's like [45:31] that's a type of strategy. Exactly. In [45:33] the same way that you have like you [45:34] know, one big one that separates a bunch [45:35] that's another type of strategy. I think [45:37] people have thought about this maybe the [45:38] in the way of like human organization. I [45:41] guess it could be similar. But if you [45:42] take it to the kind of its end state, [45:43] it's actually more just like the token [45:44] has a job. And I think it's this job [45:46] piece that we're we're really indexed on [45:48] and [45:50] we see a lot of returns to you. And [45:52] that's the thing that we want to spend [45:53] time with users and the rest of the [45:55] ecosystem on on like how can we just [45:56] make that easier for folks to then [45:57] experiment? Like we can give you like [45:59] five jobs off the top of our head and [46:01] we'll probably "That's what we have [46:02] internally. [46:04] Um and if we give this out to the rest [46:05] of the ecosystem, there's probably going [46:06] to be like 100,000, 200,000, who knows [46:08] what other combinations of people could [46:09] put together." [46:10] >> Yeah. We want to be able to keep doing [46:11] this hill climbing on like, how do you [46:13] get the most value, the most [46:14] intelligence per dollar, and just put [46:16] that power in people's hands. But around [46:19] the edges of that, we have these [46:21] personas that have kind of just like [46:23] things they have to work through in [46:24] order to be able to like really deploy [46:26] AI either within their companies or [46:29] within their products. And um that's [46:31] like the sort of enterprise-ready [46:34] security and compliance controls and [46:36] things like this. But really even just [46:38] like making the platform more modular in [46:41] the right ways, like being able to plug [46:42] in different pieces of the solutions [46:44] that we're building, like I want to use [46:45] memory for this thing over here, right? [46:47] Or whatever else it is, and having a [46:50] truly excellent developer experience [46:51] around that, because we spend a lot of [46:53] time with enterprises who are like, [46:55] "Okay, I have this like walled garden, [46:58] and I need to figure out exactly how I [47:00] can plug these in." And so, we're We've [47:02] got a part of our team that's innovating [47:04] on things like strategies and jobs and [47:05] trying to help you maximize [47:06] intelligence. And they're like, "That's [47:07] really cool, but I can't actually use [47:09] any of that for XYZ reasons." So, I [47:11] think solving those problems is really, [47:13] really important to us. But then the [47:14] other persona is, you know, the like [47:16] weekend developer who's like, "I want to [47:18] go and build something useful for [47:20] myself, right?" And they're often doing [47:22] that on top of our platform and on top [47:24] of many other just pieces of developer [47:26] platforms in the community. And I think [47:28] for some of those folks, there's more [47:30] that we can do to be provide solutions [47:32] that are maybe more open or more [47:33] hackable or whatever it may be for those [47:35] folks to kind of just like go wild with [47:38] what we can offer them and have this [47:40] really excellent developer experience. [47:41] And so, I think there's a lot of stuff [47:43] that maybe I would put in the the [47:45] category of table stakes that I'm really [47:47] excited about, because I think those are [47:49] the things that then unlock getting [47:51] people to say, "Okay, yes, this thing [47:53] works for me, and now I can plug in on [47:55] some of the stuff that you guys are [47:56] doing that's really innovative and help [47:58] line me to get more intelligence and [47:59] save costs and things like that. [48:01] >> Wonderful. [48:02] >> Caitlin and Angela, I feel I mean you [48:04] were building one of the most important [48:06] developer platforms in the world and [48:08] talking to the two of you over time I [48:09] just feel really optimistic that that [48:12] platform is in very thoughtful [48:15] hands that that care about the [48:16] ecosystem. So thank you for taking the [48:18] time today to share what you're up to [48:19] and we look forward to what's ahead. [48:21] >> Thanks for having us. [48:22] >> Thank you guys. [48:33] >> [music] [48:49] [music]