Anthropic Debuts Continuous Coding Agents to Slash Enterprise Software Cycles

Code with Claude London 2026: Opening Keynote — Claude

Claude

The rapid expansion of AI capabilities is shifting software engineering from manual prompting to fully asynchronous, self-correcting agent networks that eliminate routine developer maintenance.

AI-assisted summary of Code with Claude London 2026: Opening Keynote — original source. Check the original for full context.

Source published:

Detailed notes

## Background Published on May 19, 2026, by the Claude channel on YouTube, this video captures the Code with Claude London 2026 opening keynote. The page description indicates that the event features Anthropic's engineering and product leaders sharing the latest platform and product updates.

## TL;DR The opening keynote highlights how modern AI is collapsing development time and returning programming to a state of pure, accessible tinkering. Leaders from Anthropic showcase massive enterprise efficiency gains from companies like Spotify and Mercado Libre, alongside profound humanitarian impacts in foster care routing via Binty. The presentation outlines the rapid trajectory toward autonomous, continuous agents and details major platform updates, including self-hosted sandboxes, secure MCP tunnels, and advanced Claude Code automation features like routines and CI autofix. Ultimately, the session demonstrates a fundamental shift from manual, synchronous coding to an asynchronous reality where AI routinely prompts and verifies itself to bridge the gap between human ideas and shipped code.

## Atmosphere & style The presentation carries an optimistic, high-energy vibe that blends personal nostalgia with cutting-edge technical ambition, kicking off with a warm crowd selfie and fond memories of childhood calculator programming. It balances corporate scale with a deeply human emotional arc, drawing a moving connection between software efficiency metrics and the real-world speed of placing foster children with families. The delivery feels forward-looking yet grounded, shifting fluidly from visionary architectural concepts to practical, live developer console demonstrations. Watching the keynote feels inspiring and fast-paced, capturing the 'magical' excitement of an industry moving at an exponential curve where long-standing software limitations are actively dissolving.

## Key takeaways - [00:11](https://www.youtube.com/watch?v=6amLO7I9xdg&t=11s) The Code with Claude 2026 event in London marks the first time this keynote has been hosted outside of San Francisco. - [00:11](https://www.youtube.com/watch?v=6amLO7I9xdg&t=11s) Programming has shifted from early pure tinkering to extreme complexity, but modern AI is collapsing that distance once again, allowing developers to simply describe a problem to generate programs. - [05:00](https://www.youtube.com/watch?v=6amLO7I9xdg&t=300s) Major organizations are using Claude to solve real-world challenges, such as Spotify automating thousands of repository migrations and Binty reducing foster care family licensing times by 20 days. - [06:33](https://www.youtube.com/watch?v=6amLO7I9xdg&t=393s) AI capabilities are growing at an exponential speed, creating an adoption gap for organizations that are still adopting the technology along a linear path. - [06:33](https://www.youtube.com/watch?v=6amLO7I9xdg&t=393s) The evolution of Claude has rapidly progressed over the last two years from drafting simple git commits to discovering a 27-year-old vulnerability in the OpenBSD source tree. - [12:06](https://www.youtube.com/watch?v=6amLO7I9xdg&t=726s) Anthropic has shipped eight frontier models in the past 12 months, shifting use cases from simple code autocomplete to fully agentic coding that owns outcomes end-to-end. - [16:29](https://www.youtube.com/watch?v=6amLO7I9xdg&t=989s) Future updates to Claude models will bring higher judgment, code taste, effectively infinite context windows, and multi-agent coordination running continuously as always-on agents. - [16:29](https://www.youtube.com/watch?v=6amLO7I9xdg&t=989s) As models become smarter, heavy developer scaffolding can hold them back; future-proof systems should rely on generalized primitives and automated testing. - [20:57](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1257s) The 'advisor strategy' balances cost and performance for high-volume agentic workloads by using a smaller model for bulk execution and a larger model like Opus for complex guidance. - [22:49](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1369s) Claude Managed Agents provides production-grade infrastructure that compresses the timeline to build a production agent from months down to days. - [24:35](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1475s) Anthropic introduced self-hosted sandboxes and secure MCP tunnels to allow Claude Managed Agents to execute code on customer servers and access private internal data sources without public exposure. - [31:13](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1873s) Claude Code bridges the developer workflow gap, allowing engineers to transition from reviewing every edit to running the tool in 'auto mode' to test, verify, and prepare green PRs autonomously. - [31:13](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1873s) Claude Code supports 'multi-clotting'—juggling multiple active instances—across interfaces including a CLI, IDE extension, a Desktop application, and an Agents View panel. - [34:53](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2093s) Enterprise adoption of Claude Code has led to massive productivity boosts, including a 200% increase in merged PRs per engineer at scaled organizations. - [34:53](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2093s) Major automation primitives launched for Claude Code include Code Review, Remote Control via mobile, Autofix for CI test failures, Routines, and Claude Security. - [37:54](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2274s) Shopify and Mercado Libre have deployed Claude Code wall-to-wall, enabling autonomous coding loops and allowing non-coding technical leaders to actively ship code again. - [41:57](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2517s) Software engineering is shifting fundamentally from synchronous coding to asynchronous and parallel engineering, where developers manage multiple background tasks simultaneously. - [42:51](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2571s) Routines represent a higher-order prompting mechanism that enables Claude Code to be triggered asynchronously by schedules, webhooks, or API requests to handle tasks while the developer is away. - [43:50](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2630s) CI Autofix acts as an automated system to babysit PRs to production by resolving review comments, fixing CI failures, and handling merge conflicts entirely in the background.

## Detailed walkthrough ### [00:11](https://www.youtube.com/watch?v=6amLO7I9xdg&t=11s) The Magic of Tinkering and the Evolution of Coding

The event opens with a warm welcome in London, marking the first time the "Code with Claude" event has been hosted outside of San Francisco. After taking a quick selfie with the audience, the speaker shares a personal story about how he first got into coding. He did not learn from a textbook; instead, he taught himself on a TI-83 scientific calculator (noting that in the UK, students typically use Casios). By writing small programs in TI Basic, he was able to reference formulas and pass his math tests and homework. He eventually taught his classmates how to do the same and even published an online guide on programming scientific calculators at the age of 13.

Shortly after, he learned HTML not to launch a startup, but to make his eBay listings stand out so he could sell holographic Pokémon cards. He recalls successfully selling three legendary birds for 99 cents each using tables and blinking text—though, in hindsight, he jokes that he wishes he had held onto them. This era of programming was defined by the "giddy feeling" of pure tinkering, where the distance between having an idea and seeing it run was incredibly short.

Over time, however, programming became highly complex. The introduction of compilers, type checkers, build systems, package managers, and "12 config files before you could write a single line of code" lengthened the distance between concept and execution. Today, that distance is collapsing once again. With modern AI, developers can simply describe a problem and watch the program appear. It brings back that original "calculator feeling," except today's calculator is capable of writing a distributed system.

[05:00](https://www.youtube.com/watch?v=6amLO7I9xdg&t=300s) Real-World Impact: From Spotify to Foster Care

The speaker highlights how this rapid collapse in development time is being leveraged by major companies and organizations to solve significant, real-world challenges. For example, Spotify uses Claude to migrate thousands of repositories. Led by Nicholas Gustavsson, the Spotify team built a background agent on Claude that reads migration instructions written in plain English, runs them across a fleet of agents, and opens pull requests (PRs).

Beyond corporate efficiency, speed can also deliver on deeply human missions. The speaker introduces Felicia Curcuru, the co-founder and CEO of Binty, a software platform used by social workers to place children in foster care. Binty manages the extensive paperwork, home visits, and licensing processes required for foster families. By integrating the Claude API, Binty gave social workers back hours of their day and cut 20 days off the foster family licensing process. As the speaker notes, "20 days. It's not just an efficiency metric. That's a kid connecting with a family."

- **Spotify Migration Agent:** Merges over 1,000 PRs a month into production and cuts migration time by over 90%. - **Binty Foster Care Software:** Reduced the licensing process for foster families by 20 days using the Claude API.

[06:33](https://www.youtube.com/watch?v=6amLO7I9xdg&t=393s) Riding the Exponential Curve of AI Capabilities

Reflecting on the rapid pace of AI development, the speaker notes that the industry is moving at an exponential speed, while most organizations are still adopting AI on a linear path. This creates a growing gap between what AI is capable of doing and what it is actually doing for people. Developers are the ones closing this gap, as evidenced by the fact that API volume is up nearly 17x on the Claude platform, and the average developer on Claude Code now spends over 20 hours a week running Claude.

The speaker traces the rapid evolution of Claude's capabilities over the last few years to illustrate this exponential growth: - **Two years ago:** Claude was at a stage where it could draft a "pretty good git commit." - **One year ago:** At the first Code with Claude event, Opus 4 was introduced, and the idea of Claude running for a few minutes to build an entire feature without human intervention felt "crazy." - **Six months ago:** Agents began running end-to-end overnight, allowing developers to wake up to finished work. - **One month ago:** Mythos read the entire OpenBSD source tree and discovered a 27-year-old vulnerability that had survived three decades of human code reviews, fuzzers, and static analyzers.

The presentation outlines the morning's agenda: Lisa will discuss the foundation model layer; Angela and Caitlyn will explain how to securely build and deploy agents at scale on the Claude platform; and finally, the speaker and Cat will demonstrate the latest Claude Code features, including the new agent view and "routines" that allow Claude to prompt itself while the developer is away from the computer. Ultimately, the speaker emphasizes that most people will never call the Claude API directly; they will experience AI through the tools developers build, whether that is a designer using Canva or a lawyer drafting a brief with Lora.

[12:06](https://www.youtube.com/watch?v=6amLO7I9xdg&t=726s) The Journey of Claude Models and the Shift to Continuous Agents

Lisa from the Research Product Management team takes the stage, sharing that she joined Anthropic in 2023 and has been involved in launching 17 different versions of Claude since Claude 3. She reflects on how far the model family has come: Opus 3 was the first model proficient at writing long-form code; Sonnet 3.5 and 3.6 introduced safe computer use; Sonnet 3.7 introduced thinking before answering; Opus 4 excelled at complex Excel and PowerPoint generation; and the latest models, Opus 4.7 and Mythos preview, can own outcomes end-to-end and apply judgment to highly ambiguous tasks. Anthropic has shipped eight frontier models in the past 12 months alone.

Lisa explains that as model intelligence increases, the value of use cases increases exponentially—shifting from simple code autocomplete to fully agentic coding. Anthropic pioneered key areas like tool use, computer use, adaptive thinking, long context windows, and agentic loops that can hold a plan over hundreds of steps. Today, these capabilities allow Claude to perform diverse tasks across verticals, such as redlining legal documents, building financial forecasts, and analyzing genomic sequencing data.

- **AMP (Coding Agent):** Moved its "smart mode" to Opus 4.7 after it outperformed internal benchmarks, allowing them to simplify their scaffolding. - **Rakuten:** Found that Opus 4.7 resolved three times more production engineering tasks than previous models on their internal benchmarks. - **Intuit:** Observed Opus 4.7 catching its own logical faults during the planning phase, accelerating execution. - **Claude Design:** Powered by Opus 4.7, allowing users to build production interfaces in a single sitting.

[16:29](https://www.youtube.com/watch?v=6amLO7I9xdg&t=989s) Designing for the Next Generation of AI

While acknowledging that models are still imperfect—retaining verbal tics, occasionally failing common-sense questions, or over-delivering on instructions—Lisa outlines what developers should expect next. Future updates will bring higher judgment, code taste, effectively infinite context windows, and multi-agent coordination. She introduces the concept of "task horizon"—the length of time a model can work before losing the thread. While models last year worked for minutes, and today's agents run for hours, future generations of Claude will run continuously as proactive, "always-on" agents. Instead of asking Claude to write a project update, developers will ask it to "keep the project on track this week."

To prepare for this future, Lisa advises developers to build for emerging capabilities rather than what works today. She warns that as models get smarter, complex "scaffolding" (the loops, instructions, and tools built around the model) can actually hold Claude back. Smarter models often perform better with generalized primitives like a file system and a sandboxed computing environment. She encourages developers to automate their evaluation and testing processes to make model upgrades seamless, treating every upgrade as a direct business opportunity.

[20:57](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1257s) Overcoming the Adoption Gap with the Claude Platform

Caitlyn and Angela take the stage to discuss how the Claude platform helps businesses bridge the gap between linear adoption and exponential model capabilities. They identify two primary roadblocks for businesses: the difficulty of engineering high-quality agentic outcomes (which requires prompt optimization, tool construction, and harness engineering) and the challenge of scaling prototypes securely in production. The Claude platform addresses these by providing API primitives tuned to Claude models, infrastructure to scale agentic systems, and operational controls.

To address the common business need for frontier-level intelligence at a lower cost, they introduce the "advisor strategy." This strategy is easy to implement by updating the tools array on the Messages API. Behind the scenes, the platform splits execution from advising: a smaller, cheaper model (such as a Haiku or Sonnet class model) handles the bulk of the execution, and when it encounters a difficult step, it reaches out to a larger model (like Opus) for advice.

[22:49](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1369s) The Advisor Strategy and Claude Managed Agents

The "advisor strategy" represents a major breakthrough in balancing cost and performance for agentic workloads. By pairing Claude 3.5 Sonnet as the "executor" with Claude 3 Opus as the "advisor," developers can achieve remarkable results. In testing, this combination allowed Sonnet to perform significantly better and even more cheaply than it would on its own, because Opus successfully guided it to complete its work more efficiently. A real-world example of this is Eve Legal, which implemented the advisor strategy to achieve frontier-model quality at a five-times lower cost. This approach is ideal for premium products where putting your best foot forward is critical, but budget and ROI must be carefully managed across high-volume agentic workloads.

To address the simultaneous demands of speed and scale, Anthropic recently introduced Claude Managed Agents. This production-grade infrastructure and agentic harness allows teams to ship "literally 10 times faster," compressing the timeline to build a production-grade agent from months down to mere days. Asana is a prime example of a customer leveraging this technology; they built AI teammates that allow humans to collaborate directly within Asana projects, delegating tasks seamlessly. Claude Managed Agents recently received major upgrades, including: * **Multi-agent orchestration:** Allows developers to build entire fleets of coordinated agents. * **Outcomes:** Allows developers to specify what success looks like so Claude can iterate autonomously until it is achieved. * **Dreaming:** Enables Claude to introspect on its previous execution transcripts to learn and self-improve.

[24:35](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1475s) Introducing Self-Hosted Sandboxes and MCP Tunnels

Anthropic is introducing two powerful new features for Claude Managed Agents: self-hosted sandboxes and Model Context Protocol (MCP) tunnels. While Claude Managed Agents automatically spawn sandboxes to execute tasks like editing files, developers are no longer restricted to Anthropic's default environment. With self-hosted sandboxes, Claude can execute code directly on a customer's own servers. This feature launches with first-class, easy-to-integrate support for Daytona, Cloudflare, Vercel, and Modal.

Complementing this is the release of MCP tunnels, which solves a major security hurdle for enterprise developers building internal agents. Previously, accessing internal data sources required exposing them to the public internet. With MCP tunnels, companies can host their MCP servers securely behind their private firewalls. Claude Managed Agents can then access these internal resources securely without exposing them publicly.

[25:34](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1534s) Live Demo: Building a Growth Agent for "Counter"

To demonstrate these features in action, a live walkthrough features a fictional e-commerce platform enablement company called "Counter." Counter helps small businesses build digital storefronts and wants to become an AI-native business. One of their most frequent workflows is running growth experiments to optimize merchant onboarding. Using Claude Managed Agents, a growth agent was built to monitor these experiments.

In Counter's Slack workspace, the newly deployed growth bot proactively posts an update announcing a clear winner in the latest onboarding experiment. The data shows that a simpler onboarding flow is vastly outperforming the older, longer version where merchants frequently dropped off. The agent proactively "calls" the experiment and announces it is starting to clean up the old code variant.

A look behind the scenes via the Claude API CLI and the developer console reveals the agent's configuration: * **Slack MCP Server:** A public MCP URL allowing the bot to communicate in Slack. * **Data Warehouse & Feature Flags MCP Servers:** These are configured with URLs pointing to `tunnel.anthropic.com`. Because they are behind Counter's firewall, they are only accessible via the secure MCP tunnel. * **Self-Hosted Sandbox:** Configured via Vercel. When the agent needs to write or execute code, it places a work item in a queue, prompting Vercel to spin up a secure sandbox inside Counter's own Vercel account.

The developer console's rich observability tools confirm the agent successfully called the `set_flag_winner` tool through the secure tunnel and checked out a Git branch to clean up the code inside the self-hosted Vercel sandbox. Back in Slack, the growth bot remains highly collaborative. It posts a pull request (PR) to default the simplified onboarding flow, shares a visual screenshot comparing the messy old flow with the clean new one, and identifies a further 46% drop-off bottleneck in the onboarding flow by querying the secure data warehouse.

[31:13](https://www.youtube.com/watch?v=6amLO7I9xdg&t=1873s) Claude Code: Bridging the Developer Gap

While the Claude platform bridges the gap between models and business agents, Claude Code focuses on bridging the gap between model capabilities and the daily workflow of developers. The Anthropic team expresses deep gratitude to the early builders who trusted their production codebases to Claude Code back when Claude 3.5 Sonnet was the frontier model and the product was still "rough around the edges." The core mission of Claude Code is to help builders close the gap between a great idea and a shipped product by making frontier intelligence highly accessible. The team views themselves not as creators of a rigid roadmap, but as "mountaineers" climbing alongside developers in unmapped terrain.

The developer experience has evolved rapidly. In the early days, developers had to read every single edit and permission prompt, providing highly detailed guidance. Today, most developers run Claude Code in "auto mode," delegating permissions to Claude and checking back only after the agent has tested, verified its changes, and prepared a green PR.

Claude Code is accessible across multiple interfaces to support "multi-clotting"—the practice of juggling multiple active Claude Code instances: * **The CLI:** The original terminal interface, ideal for power users who want minimal text and maximum customization. * **The IDE Extension:** A VS Code extension that allows developers to follow along visually with code changes in real time. * **Claude Code on Desktop:** A full-screen graphical interface featuring built-in previews, a sidebar control plane, and rich image rendering. It provides a unified view of both local and cloud sessions, showing which agents are running, blocked, or waiting for input. * **Claude Agents View in the CLI:** A terminal-based dashboard that lets developers see running, waiting, and completed tasks at a glance, allowing them to reply inline to unblock agents without losing their place.

[34:53](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2093s) Enterprise Adoption and New Automation Primitives

Enterprise adoption of Claude Code has yielded massive productivity gains. Organizations deploying Claude Code wall-to-wall have seen a 200% increase in the number of PRs merged per engineer, even as their engineering organizations scaled. To support this scale, Anthropic has rolled out several powerful primitives based on community feedback: * **Code Review:** Deploys a team of agents to traverse code changes and auxiliary files to catch critical bugs. This is used daily by thousands of companies, including every internal team at Anthropic. * **Remote Control (iOS & Android):** Allows developers to fire off coding tasks from their phones, letting them "go to a park, touch grass, and still get tasks done." * **Autofix:** Automatically listens for flaky CI test failures, code review comments, and merge conflicts, proactively fixing them to keep PRs green. * **Routines:** Allows developers to configure Claude Code to run on a schedule or in response to webhooks and API requests, automating ticket and bug report handling. * **Claude Security:** Scans codebases overnight, flags vulnerabilities by severity, and allows developers to trigger Claude Code to fix them immediately.

[37:54](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2274s) Real-World Impact: Shopify and Mercado Libre

The real-world impact of these tools is highlighted through two major enterprise success stories. Shopify, which powers e-commerce for millions of merchants, has integrated Claude Code across its entire company. It is used not just by engineers, but also by product managers, designers, and data scientists to stand up internal tools at scale. Andrew McNamara, Director of Applied AI at Shopify, notes that "the speed is just crazy" and has completely transformed how they build.

Mercado Libre, Latin America's leading e-commerce platform with over 100 million buyers, runs its 23,000-engineer organization on Claude Code. The tool has reviewed over 500,000 PRs with human oversight and modernized more than 9,000 legacy applications. Oscar Mowen, tech lead at Mercado Libre, is aiming for 90% autonomous coding in a fully agent-driven PR loop by Q3 of this year. Beyond the raw numbers, the most exciting cultural shift is that VPs and managers who haven't written code in years are now actively shipping code again. Claude Code is putting development back into the hands of leaders who previously spent their time stuck in roadmapping sessions.

To transition into a live demonstration of these capabilities, the creator of Claude Code, Boris Cherny, is welcomed to the stage. Cherny shares that even as the creator, the technology "still feels magical" and evokes the same excitement he felt when programming his very first calculator.

[40:37](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2437s) Claude Code in Action: The Acme Pay Demo

To demonstrate the "magic" of Claude Code, the presenter introduces a real-world scenario where the audience is asked to imagine being an engineer at Acme Pay, a payment infrastructure company. Working inside the Claude Code desktop application, the engineer assigns Claude a single, complex task: adding a full refunds implementation to Acme's merchant dashboard. This is not a simple code-generation task; Claude must handle several critical engineering requirements to make the feature production-ready:

* **Idempotency:** Ensuring that a duplicate webhook does not result in double-refunding a merchant. * **Multi-currency handling:** Managing transactions across all the global regions that Acme serves. * **Audit logging:** Creating detailed logs to satisfy the compliance team's requirements.

Claude writes the implementation and immediately begins verifying its own work. It pulls up the merchant dashboard in a browser and triggers a refund. During this live test, a subtle edge case occurs: the modal closes before the success toast can appear. Claude detects this failure, traces it back to a race condition in the optimistic update, fixes the bug, and verifies the fix in the browser before marking the task as complete.

[41:57](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2517s) The Shift to Asynchronous and Parallel Engineering

Zooming out from a single task, the presenter reveals that Claude Code is not restricted to running just one session at a time. The Claude desktop app provides a centralized view of multiple parallel sessions, showing which ones are actively running, which require human input, and which have already resulted in merged and closed Pull Requests (PRs).

This represents a fundamental shift in how software is built. "Synchronous coding is now just a slice of what's happening at any given moment," as the industry moves toward an asynchronous model. Because Claude can verify its own work, developers can let multiple complex tasks run in the background while they focus on other priorities, returning later to fully working results.

[42:51](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2571s) Higher-Order Prompting with Routines

The presenter explains that much of their own code is now written by "routines" rather than direct, manual prompting. For engineers, routines can be thought of as a "higher-order function" or a "higher-order prompt." In the Acme Pay example, a teammate might find a GitHub issue overnight. A routine monitoring the repository automatically picks up the issue asynchronously and kicks off Claude to start working on it.

* **Triggering Mechanisms:** Routines can be scheduled, kicked off by webhooks, or triggered by arbitrary API calls. * **Execution Environments:** They can run locally on a developer's machine or on remote cloud compute. * **Developer Workflow:** Developers can set up these asynchronous automations and simply wake up to PRs that are ready to merge.

[43:50](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2630s) CI Autofix and the New Default

The desktop app also features "CI autofix," a tool designed to "babysit the PR to production." It monitors the PR opened by a session and automatically resolves issues that arise during the shipping process. It fixes comments from code and security reviews, resolves CI failures, and automatically rebases the branch if merge conflicts occur.

During the demo, a network timeout causes a CI check to fail. The routine immediately wakes up, diagnoses the failure as a known infrastructure issue, and retries the job. The presenter notes that in their own Claude Code codebase, they actually instruct the tool to fix the root cause of such issues rather than just retrying. Because CI turns green automatically, the engineer who owns the PR never even sees the "red X," completely removing that maintenance burden from their plate. This highlights the ultimate shift in development: "The default isn't I'm going to prompt Claude code. The default is now I'm going to have Claude prompt Claude Code."

[45:01](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2701s) Closing the Gap Between Ideas and Shipping

All the features shown, including routines and the latest updates to the Claude Desktop app, are available today. The presenter connects these tools back to the overarching themes of the event: Lisa's capability curve, Angela and Caitlyn's infrastructure-controlled agents, and the developer workflows enabled by Claude Code. These represent "three layers of one story," demonstrating that the capability is already here, and the only remaining gap is how quickly teams put it to work. Attendees are encouraged to explore the research talks, platform sessions, and hands-on workshops to start building.

## Notable quotes > [05:00](https://www.youtube.com/watch?v=6amLO7I9xdg&t=300s) 20 days. It's not just an efficiency metric. That's a kid connecting with a family.

> [16:29](https://www.youtube.com/watch?v=6amLO7I9xdg&t=989s) keep the project on track this week. — Lisa

> [37:54](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2274s) the speed is just crazy — Andrew McNamara

> [41:57](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2517s) Synchronous coding is now just a slice of what's happening at any given moment

> [43:50](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2630s) The default isn't I'm going to prompt Claude code. The default is now I'm going to have Claude prompt Claude Code.

> [45:01](https://www.youtube.com/watch?v=6amLO7I9xdg&t=2701s) three layers of one story

## Mentioned London, San Francisco, TI-83, Casio, TI Basic, HTML, eBay, Pokémon, Spotify, Nicholas Gustavsson, Claude, Felicia Curcuru, Binty, Claude API, Claude Code, Opus 4, Mythos, OpenBSD, Lisa, Angela, Caitlyn, Cat, Canva, Lora, Anthropic, Opus 3, Sonnet 3.5, Sonnet 3.6, Sonnet 3.7, Opus 4.7, AMP, Rakuten, Intuit, Claude Design, Claude platform, Haiku, Sonnet, Opus, Messages API, Eve Legal, Claude Managed Agents, Asana, Daytona, Cloudflare, Vercel, Modal, Model Context Protocol, MCP, Counter, Slack, Vercel sandbox, Git, VS Code, Claude Desktop app, Shopify, Andrew McNamara, Mercado Libre, Oscar Mowen, Boris Cherny, Acme Pay, GitHub

[Source](https://www.youtube.com/watch?v=6amLO7I9xdg)

中文简报

Anthropic推出持续编程智能体,大幅缩减企业软件周期 AI能力的迅猛扩展正在推动软件工程从人工提示词交互转向完全异步且具备自我纠错能力的智能体网络,从而免除开发人员的日常维护工作。 开幕主题演讲强调了现代AI如何大幅压缩开发时间,并让编程重回纯粹且易上手的探索状态。Anthropic高管展示了Spotify和Mercado Libre等公司获得的巨大企业效率提升,以及Binty在寄养家庭分配上所产生的深远人道主义影响。演讲概述了向自主、持续智能体迈进的快速演进路径,并详述了多项重大平台更新,包括自托管沙箱、安全MCP隧道,以及诸如例行任务(routines)和CI自动修复等先进Claude Code自动化功能。最终,该环节展示了从人工同步编程向异步现实的根本性转变——在这一模式下,AI能够常规化地自行提示与验证,从而弥合人类创意与上线代码之间的鸿沟。 “Code with Claude 2026” 首次走出旧金山在伦敦举行,大会指出现代 AI 正在迅速消除构建与配置的繁琐链路,让编程重回只需描述问题即可直接生成并运行系统的极简时代。 (0:11) AI 模型能力正以指数级演进,Anthropic 在过去 12 个月内发布了 8 款前沿模型,使 Claude 从两年前撰写简单 git 提交,跃升至能够端到端交付功能并挖掘出 OpenBSD 中长达 27 年的历史漏洞。 (6:33) 为弥合企业的落地差距,Claude 平台推出了 Managed Agents、自托管沙箱(Self-Hosted Sandboxes)与 MCP 隧道,结合将 Opus 与 Sonnet 搭配的“顾问策略”,帮助企业在私有防火墙内安全且低成本地扩展 Agent 方案。 (24:35) Claude Code 迎来重大更新,推出全屏桌面应用、Agent 集中视图、自动化 Routines 以及自动排查 CI 故障的 Autofix,推动软件工程从手动提示词转向多 Agent 并行执行的异步开发模式。 (34:53)

Reading summary

At the Code with Claude London 2026 keynote, Anthropic presenters argued that rapid advancements in AI models are shifting software development from manual instruction to autonomous, continuous agent execution. The presentation highlighted that while model capabilities are expanding exponentially, organizations face a structural adoption gap that requires new operational architectures, security primitives, and asynchronous developer workflows. Advancing Model Capabilities Toward Continuous Execution (12:06) Anthropic's research product team described a trajectory moving from basic code autocompletion to end-to-end outcome ownership. Research Product Manager Lisa reported that Anthropic launched eight frontier models within 12 months, progressing from Opus 3's long-form code writing to Opus 4.7 and a preview of Mythos, which reportedly detected a 27-year-old vulnerability in the OpenBSD source tree that had survived decades of manual reviews and static analyzers. Lisa introduced the concept of an expanding 'task horizon'—the duration an agent can operate without losing context. While early implementations ran for minutes, presenters forecast that future systems will operate as 'always-on,' proactive agents managing continuous objectives over extended periods. Developers were advised to avoid brittle, over-engineered prompt scaffolding, as smarter models perform more reliably when paired with generalized primitives such as sandboxed execution environments and file systems. Infrastructure Primitives for Enterprise Agent Deployment (20:57) To address the cost and security barriers slowing enterprise adoption, Anthropic introduced several platform-level mechanisms. Caitlyn and Angela detailed the 'advisor strategy,' which splits execution between model tiers: a lower-cost model like Claude 3.5 Sonnet conducts bulk tasks and consults Claude 3 Opus only when handling ambiguous steps. Legal technology firm Eve Legal reportedly leveraged this pattern to achieve frontier-level accuracy at an 80% reduction in operating cost. For enterprise infrastructure integration, Anthropic announced Model Context Protocol (MCP) tunnels and self-hosted sandboxes. MCP tunnels permit agents to access internal corporate data sources located behind corporate firewalls without exposing endpoints to the public internet. Simultaneously, self-hosted sandbox integrations with platforms including Daytona, Cloudflare, Modal, and Vercel permit agents to execute and test code directly within a company's internal cloud environments. The Evolution Toward Asynchronous Developer Workflows (31:13) Claude Code creator Boris Cherny and colleagues argued that developer interaction is pivoting from synchronous pair programming to managing parallel, background agent fleets ('multi-clotting'). Developers increasingly run environments in autonomous modes where agents write implementations, test changes, and resolve subtle failures in browser sessions—such as diagnosing race conditions during UI updates—before opening pull requests. This shift relies on higher-order automation primitives called 'routines,' which initiate agent runs via scheduled triggers, webhooks, or issue-tracker events. Presenters showcased 'CI autofix,' a mechanism that monitors opened pull requests, interprets continuous integration test failures or review comments, rebases branches, and pushes corrective code without direct engineer intervention. Enterprise Productivity Metrics and Operational Velocity (5:00) The keynote presented case studies to illustrate how autonomous agents affect development throughput. Presenters cited Spotify's deployment of background migration agents that merge over 1,000 pull requests per month while reducing migration duration by more than 90%. In public-sector software, platform provider Binty reportedly shortened the foster family licensing process by 20 days by automating administrative documentation. At larger organizational scale, Latin American e-commerce platform Mercado Libre deployed Claude Code across 23,000 engineers, reviewing 500,000 pull requests and modernizing over 9,000 legacy applications. Mercado Libre tech lead Oscar Mowen stated an operational objective of achieving a 90% autonomous coding loop by Q3 2026. Across broad enterprise deployments, presenters claimed organizations realized a 200% increase in merged pull requests per engineer. While presenters illustrated marked efficiency gains across early enterprise deployments, speakers acknowledged that current models remain imperfect, occasionally failing basic common-sense checks, retaining verbal tics, or over-executing simple instructions. Anthropic maintained that realizing the value of exponential capability curves depends on how effectively development teams replace legacy workflows with continuous, automated harnesses.

精炼阅读摘要

在伦敦举行的Code with Claude 2026主题演讲中,Anthropic团队指出人工智能模型能力正呈指数级演化,而企业采用仍普遍处于线性节奏;缩小这一鸿沟的关键在于推动软件工程从手动编码与复杂脚手架向持续运行的自主智能体(Autonomous Agents)迁移。通过底层模型推理演化、Claude平台的基础设施安全控制以及Claude Code的异步自动化工作流,团队展示了前沿AI如何在企业生产系统与关键社会事务中实现规模化落地。 基础模型演进与长周期智能体 (12:06) 演讲回顾了Claude系列模型的快速升级,指出代码生成正在从单点补全质变为端到端自主交付。Anthropic研究产品管理团队的Lisa表示,公司在过去12个月内发布了8款前沿模型;从具备长代码编写能力的Opus 3、引入安全计算机操控的Sonnet 3.5与3.6,到具备思考能力的Sonnet 3.7,以及近期的Opus 4.7和Mythos预览版,模型对复杂模糊任务的处理能力显著提升。例如,Mythos在发布前一个月通过通读OpenBSD全量源码树,检测出潜藏27年的安全漏洞。基准测试中,乐天(Rakuten)发现Opus 4.7解决的生产工程任务数量达到以往模型的3倍;Intuit亦观察到该模型能在规划阶段自主纠正逻辑缺陷。 Lisa进一步提出了“任务周期”(Task Horizon)概念,即模型在失去上下文连贯性之前可持续自主运行的时长。当前智能体已可连续执行数小时,未来的研发方向则是构建无需人工唤醒、可主动推进项目的连续型智能体。Lisa向开发者提示,随着模型推理能力提高,外部过于复杂的控制脚手架(Scaffolding)反而可能束缚模型表现;未来的工程设计应倾向于文件系统与沙箱计算等通用原语,并通过自动化评测体系确保应用能够随模型升级无缝收益。 平台架构控制与成本平衡策略 (20:57) 针对企业在部署前沿AI时面临的成本与安全规模化难题,Claude平台推出了“顾问策略”(Advisor Strategy)与托管智能体(Claude Managed Agents)体系。Caitlyn与Angela说明,顾问策略通过在API中分离“执行”与“指导”职责:由成本较低的模型(如Sonnet)负责海量常规执行,遇阻时再向高阶模型(如Opus)请求建议。测试显示该机制能帮助Sonnet以更低成本取得更高表现,例如法律科技机构Eve Legal借此将前沿模型的使用成本降低了5倍。 为缩短企业智能体的研发交付周期,Claude Managed Agents提供了多智能体协同编排、目标导向迭代(Outcomes)及基于执行转录自我改进的“做梦机制”(Dreaming)。同时,针对企业内网数据安全,平台推出了自托管沙箱(适配Daytona、Cloudflare、Vercel及Modal)与MCP隧道(MCP Tunnels)。在电商赋能企业Counter的演示中,智能体在无需公网暴露内部资产的情况下,通过安全隧道访问私有防火墙内的数据仓库与特性标记,并在自托管的Vercel沙箱中独立完成代码清理与分支合并。 开发工作流重构与异步自动化 (31:13) Claude Code专注于将AI能力沉淀为工程师的日常工作范式。演讲指出,早期开发者必须逐条审查模型的修改与权限请求,而目前多数用户已转向“自动模式”(Auto Mode),仅在智能体完成测试、自检并生成拉取请求(PR)后进行确认。为支持开发者同时管理多个并发会话(Multi-clotting),Claude Code提供了涵盖CLI、VS Code插件、桌面端图形界面及CLI智能体看板的控制矩阵,让工程师能全局监控运行状态并即时解除阻碍。 在工程自动化方面,平台引入了代码审查团队、移动端远程控制、持续集成自动修复(Autofix)、例程(Routines)及安全漏洞扫描。在Acme Pay退款系统的演示中,Claude Code不仅处理了幂等性、多币种与合规审计日志等工程边界,还在实时浏览器自测中自主捕获并修复了乐观更新引起的竞态条件。演讲者强调,“例程”充当了事件驱动的高阶提示词,能够监听仓库Issue并自动启动编码修复;配合自动消解CI超时与合并冲突的Autofix,软件工程的核心范式正从“人类向工具提示”转变为“由例程驱使智能体持续协作”。 企业规模化落地与跨领域成效 (5:00) 多项生产数据验证了智能体编程带来的效率跃迁与实用价值。在基础设施迁移方面,Spotify基于Claude构建的后台智能体能够解析自然语言规范并协同编排,每月向生产环境合并超过1,000个PR,使仓库迁移时长削减超90%;拉美电商平台Mercado Libre在2.3万名工程师体系中全面接入Claude Code,完成了超50万次代码审查并重构逾9,000个遗留应用,其技术团队设定了在年内第三季度实现90%自主闭环编码的目标。全面部署该工具的企业,其平均每名工程师合并的PR数量实现了200%的增长。 除了技术提效,该技术在非纯技术职能与社会民生领域也产生了直接影响。儿童寄养服务平台Binty接入Claude API处理繁琐的文书与资格审批流程,将寄养家庭的审批周期缩短了20天,加速了儿童与收养家庭的对接。在组织文化层面,Shopify已将工具普及至产品经理、设计师与数据科学家,而Mercado Libre则观察到多年脱离编码的管理层及副总裁重新开始借助智能体直接交付软件功能,大幅降低了构思到上线的转化阻力。 尽管演讲对智能体的发展前景持乐观预期,但Lisa等演讲者同时承认当前模型仍存在固有局限,包括偶尔的语言习惯偏差、常识问答失误以及对提示词的过度执行等问题。Anthropic团队强调,要应对指数级模型演化与线性组织采纳之间的矛盾,核心在于开发者与企业应尽早告别脆弱繁复的人工脚手架,依托通用计算沙箱与自愈型例程构建异步自治系统,从而承接下一代全天候自适应智能体的技术红利。

Source quotes

[5:00] 20 days. It's not just an efficiency metric. That's a kid connecting with a family. [16:29] Lisa: keep the project on track this week. [37:54] Andrew McNamara: the speed is just crazy [41:57] Synchronous coding is now just a slice of what's happening at any given moment [43:50] The default isn't I'm going to prompt Claude code. The default is now I'm going to have Claude prompt Claude Code. [45:01] three layers of one story

Original transcript

[0:11] Heat. [0:15] Heat. [0:22] Heat. [0:42] Heat. [0:47] Morning [0:58] London. [1:00] >> Hello. [1:02] >> This is uh this is the first time that [1:04] we've taken Claude uh Code with Claude [1:06] outside of San Francisco and uh I'm very [1:09] excited to be here with everyone. Um [1:12] before we jump in, can I take a quick [1:15] selfie? [1:16] >> Is that okay? [1:17] All right. [1:19] Ready? [1:26] All right. I think we got it. [1:30] I um I want to start today by telling [1:33] you how I originally got into coding. [1:39] I actually learned on a scientific [1:41] calculator [1:43] and uh I found out that I could program [1:46] my calculator to help me pass math tests [1:50] and do well on homework. [1:53] I was using a TI 83 calculator. I think [1:56] in the UK use Casios uh Casios for this. [2:00] And I found out that you could write [2:02] little programs in TI basic. This is [2:04] like the basic dialect for for TI [2:06] calculators. [2:09] And um I could reference the little [2:11] programs when I couldn't remember what [2:13] to do. [2:15] It worked beautifully. [2:17] I got great scores on my math tests and [2:19] my homework. [2:21] And then I taught my classmates how to [2:23] program their calculators [2:26] and they also got great scores on their [2:29] math tests and their homework. [2:34] At some point I even published a guide [2:36] on the internet for how to program [2:38] scientific calculators. [2:40] I was uh I was 13 when I wrote this. [2:46] That was my introduction to software. It [2:48] was very practical and um as as a kid it [2:53] just it felt like magic. [2:58] Around the same age, I figured out HTML, [3:02] not to build a startup, but to make my [3:05] eBay listings look better than everyone [3:06] else's so I could sell Pokémon cards. [3:10] There were tables, blinking text, the [3:13] whole thing. And uh and it worked. [3:18] I sold three legendary birds for 99 [3:22] cents each. [3:26] They were all holographic [3:29] and uh in hindsight I wish I would have [3:31] held on to those. [3:36] There was a whole generation of us like [3:38] that, right? We didn't learn to program [3:41] from a textbook. We learned from [3:43] tinkering. [3:44] And I still remember the giddy feeling [3:47] that I got when one of my calculator [3:49] programs ran. You made the thing and it [3:53] did what you wanted. [3:57] And then somewhere along the way, [4:00] programming got complicated. Uh, [4:03] compilers, type checkers, build systems, [4:07] package managers, [4:09] 12 config files before you could write a [4:12] single line of code. The distance [4:14] between I have an idea and it runs just [4:18] kept getting longer. [4:22] What's happening now is that distance is [4:27] collapsing again. [4:29] You describe a problem [4:32] and the program shows up. [4:35] It's the calculator feeling except the [4:38] calculator can write a distributed [4:40] system. [4:42] Now I get to watch people experience the [4:45] same feeling of bringing ideas to life [4:48] and it's happening on a scale none of us [4:51] imagined even a year ago. [4:54] It's so gratifying to talk to people [4:57] experiencing this every day from [5:00] individual indie devs to our biggest [5:03] customers that are taking on significant [5:06] challenges. For instance, Spotify uses [5:10] cloud code to migrate thousands of [5:12] repos. The team led by Nicholas [5:15] Gustiffson built a background agent on [5:17] cloud. It reads a migration that's [5:20] described in plain English and it runs [5:23] it across a fleet of agents opening PRs. [5:28] It's now merging over a thousand PRs a [5:30] month into production and it's cutting [5:33] migration time by over 90%. [5:36] That's real engineering hours back. [5:41] And sometimes speed isn't just about [5:44] efficiency. [5:45] It's about delivering on a mission. [5:50] Felicia Coruru is the co-founder and CEO [5:53] of Binty. Her software runs the systems [5:56] that case workers use to place kids in [5:59] foster care. [6:01] the paperwork, the home visits, the [6:03] licensing process. And this year, her [6:06] team used the Quad API to give case [6:09] workers back hours that they used to [6:12] spend on paperwork. [6:16] And they took 20 days off the process of [6:19] licensing a foster family. [6:22] 20 days. [6:24] It's not just an efficiency metric. [6:26] That's a kid connecting with a family. [6:33] That excitement of solving problems is [6:37] something I hear from people all the [6:39] time. And I'm going to guess that [6:42] everyone here experiences this [6:44] differently. [6:46] Some of you are living on the frontier. [6:51] Some of you are bringing along the [6:53] people around you. [6:57] Many of you can feel the ground shifting [6:59] under us and you want a view of maybe [7:03] what's coming next [7:05] and all of us at Anthropic can feel that [7:07] shifting happening too. The industry is [7:10] moving at incredible speed [7:16] and that makes sense when you look at [7:18] the exponential and how fast these [7:20] models are getting better. [7:23] Remember a couple years ago, the [7:26] frontier of model development was so [7:28] good that Quad could draft a pretty good [7:31] git commit. [7:35] A year ago, we were sitting on stage at [7:37] our first ever code with quad event in [7:39] San Francisco. Opus 4 was the headline. [7:43] And the idea that Cloud could run for a [7:45] few minutes and build an entire feature [7:48] without a human checking in, that was [7:51] crazy. [7:55] Six months ago, agents started running [7:57] end to end overnight and I started being [8:01] able to wake up to finished work. [8:09] Then uh last month, Mythos read the [8:13] entire open BSD source tree and it found [8:16] a 27y old vulnerability that survived [8:20] every human reviewer, every fuzzer, [8:23] every static analyzer that was thrown at [8:25] it for almost three decades. [8:30] The jumps keep getting bigger and the [8:33] intervals keep getting shorter. [8:40] But even though model capabilities are [8:43] improving on an exponential, [8:45] most organizations are still adopting AI [8:49] on a linear path. [8:52] That means there's a growing gap between [8:55] what AI can do and what it's actually [9:00] doing for people. [9:02] Closing [9:04] that gap and translating model [9:07] capability into something that people [9:08] can actually use is what you all as [9:12] developers do. And you're doing it [9:15] year-over-year. API volume is up nearly [9:18] 17x on the cloud platform. And on cloud [9:22] code, the average developer is now [9:23] spending over 20 hours a week running [9:26] cloud. [9:30] Like you, we've been shipping a lot [9:32] lately [9:34] and we want you to walk away today with [9:36] a clear picture of where we're headed. [9:40] So you can plan for it and you can ride [9:42] the exponential with us. [9:45] This event is how is about how we're [9:48] making our products work better for all [9:50] of you. [9:54] And this morning we're going to show you [9:57] what that looks like. [10:00] First, Lisa is going to talk about our [10:02] foundation. That's the model layer. And [10:05] she'll explore more about what what [10:09] going on with our frontier models and [10:11] what's coming next. On the cloud [10:13] platform, we're shifting updates to [10:16] cloud managed agents. And Angela and [10:18] Caitlyn are going to walk you through [10:20] how you can securely build and deploy [10:22] agents at scale. And then finally on [10:24] cloud code, CAD and I will walk you [10:26] through the latest features like uh the [10:28] new agent view and then important new [10:30] primitives like routines to let flood [10:33] prompt itself even when you're away from [10:36] your computer. [10:41] All of it comes back to you [10:44] and what you're going to build [10:47] because most people are never going to [10:49] call the cloud API. Most people are [10:52] never going to run Claude in a terminal. [10:55] They're gonna experience AI through [10:57] something one of you built on the cloud [11:00] platform. [11:03] A designer exploring new directions with [11:06] Canva. [11:09] A lawyer getting a brief out the door [11:11] faster with Lora. [11:14] Or a developer using any one of the [11:16] world's best coding agents. [11:19] You all shape what AI feels like for [11:22] everyone else. [11:24] We'd never be able to build something [11:27] build everything that people need to [11:29] solve their problems. This is only [11:32] something that you all can do. [11:36] So, uh, thanks for being here today. [11:40] Thanks for partnering with us to shape [11:42] what AI looks like for the world and for [11:45] joining us as we all reexperience those [11:48] feelings of learning to code and solve [11:51] problems again. Up next, Lisa from the [11:54] research PM team. [12:06] Hi. So I joined Enthropic in 2023 and [12:10] have been a part of every model launch [12:13] since Claude 3. That means I've been [12:15] involved in bringing 17 different [12:17] versions of Claude to end users and [12:19] developers. [12:21] Claude has come a long way. Opus 3 [12:24] launched just over 2 years ago and was [12:26] our first model that was proficient at [12:28] writing long form code. [12:31] Sonnet 3.5 new sonnet 3.6 six really was [12:35] the first model that could use a [12:37] computer safely. [12:39] Sonnet 3.7 was our first model that [12:41] would think before giving answers. And [12:44] last year at this event, I introduced [12:46] developers to Opus 4. Opus 4, we didn't [12:50] know it really at the time, but it was [12:52] our first model that could write complex [12:54] Excel files and PowerPoint documents. [12:58] And now with our most recent models, [13:00] Opus 4.7 and Mythos preview, we're [13:03] seeing Claude is able to own outcomes [13:05] end to end and apply judgment to [13:08] complete tasks with high ambiguity. [13:12] So we haven't slowed down. In fact, [13:14] we've been accelerating. [13:16] We shipped eight Frontier models in the [13:19] past 12 months. [13:21] Each one builds on the last, helping you [13:23] write better code and deliver more [13:26] advanced experiences to your end users. [13:30] Claude's behaviors and capabilities [13:32] underpin everything else you're going to [13:34] hear about today. As Cloud gets [13:37] stronger, your starting line moves [13:40] forward. [13:43] Like Boris mentioned, we talk a lot [13:45] about the exponential adanthropic. [13:48] We believe as model intelligence [13:50] increases the value of use cases [13:53] increases exponentially. [13:55] So consider coding agentic coding is far [13:59] more impactful than code autocomplete. [14:03] In this way incremental intelligence [14:05] creates new markets and grows the pie. [14:10] As we build better versions of cloud we [14:12] are excited to see benchmarks improve. [14:15] But what's really exciting is when [14:17] Claude can do something that it couldn't [14:19] do before. [14:21] Tool use, computer use, thinking that [14:25] adapts to the task at hand, agentic [14:28] plans that hold agentic loops that hold [14:31] a plan over hundreds of steps, [14:34] long context windows. [14:36] We pioneered these areas. So when you're [14:39] building on cloud, you're building on [14:41] the model family that shipped these [14:42] capabilities first. and has had the [14:45] longest to make them reliable. [14:48] These capabilities are essential for [14:50] code, but the foundations of model [14:53] intelligence have gotten strong enough [14:54] to support a diversity of tasks in a [14:57] range of domain verticals. [14:59] So Claude can iterate on designs for [15:02] marketing presentations, can redline [15:04] legal documents, can build financial [15:07] forecasts, and even analyze genomic [15:10] sequencing data. [15:12] Let me share some examples of how [15:15] customers are using our latest model, [15:16] Opus 4.7. [15:20] AMP, the coding agent, moved their smart [15:23] mode to Opus 4.7 after it outperformed [15:26] on their internal benchmarks. [15:29] They also simplified their tooling since [15:31] the model no longer needed as much help. [15:35] Rakutin ran the model on their internal [15:37] benchmark and found it resolved three [15:39] times more production engineering tasks [15:41] than the previous model. [15:44] In it saw opus 4.7 catching its own [15:47] logical faults during the planning phase [15:49] and accelerating execution far beyond [15:52] previous cloud models. We also recently [15:54] launched cloud design by anthropics labs [15:56] powered by Opus 4.7. [15:59] Customers are using claw design to build [16:02] production interfaces in a single [16:03] sitting and we've heard that Opus 4.7 [16:06] has a taste for visual design. [16:09] Developers building on the model [16:10] directly are seeing the same. We [16:12] continue to hear from everyday users [16:15] that Claude understands the assignment. [16:19] Users view Claude as a valued thought [16:21] partner since it's willing to challenge [16:23] their beliefs and push back when they're [16:26] wrong. [16:29] So, we've made tremendous progress, but [16:32] models are still imperfect. [16:35] Claude absolutely still has verbal [16:37] ticks, can be stumped by viral common [16:40] sense questions, and sometimes does more [16:42] than you asked for. [16:45] Watching Claude improve is what makes [16:47] this industry, this moment, and my job [16:51] exciting. [16:52] So, here's what to look forward to from [16:55] here. [16:58] Higher judgment and code taste. This [17:01] means models you can trust with complex [17:04] autonomous engineering. [17:07] Context windows that feel effectively [17:09] infinite as models take on longer [17:12] continuous work without losing their [17:15] core intent. [17:18] and multi-agent coordination, powering [17:21] teams of agents that can collaborate on [17:23] goals too big for any one agent or [17:26] model. [17:29] One metric I look to to make sense to [17:32] all of this change is task horizon. So [17:35] how long can a model work before losing [17:38] the thread? [17:40] Last year at this time, models could [17:42] reliably work for minutes. And today, [17:45] most users have agents that run for [17:47] hours. [17:49] We expect future generations of Claude [17:51] to run continuously. [17:53] So, we will have agents that are [17:55] proactive, that are always on, that know [17:58] what to do without being told. These [18:01] agents will be responsible for highle [18:03] goals that require judgment and [18:05] collaboration. [18:06] So, let me give you some examples. [18:09] Instead of asking Claude to write a [18:11] project update, you would ask Claude [18:14] keep the project on track this week. [18:17] Instead of asking Claude to produce a [18:19] financial forecast, Claude would own and [18:22] update the forecast to keep it accurate [18:24] over time. [18:27] So what should you as developers do with [18:30] all of this change? [18:32] Since the exponential keeps moving, [18:34] cloud models, future cloud models will [18:37] be more capable than Opus 4.7 and even [18:40] Mythos preview. [18:42] You need to build for emerging [18:44] capabilities, not just what works today. [18:48] That means designing for the next [18:50] version of Cloud, not the current one. [18:54] We've seen countless times that the [18:56] developers who win are the ones whose [18:58] architecture is ready to absorb the next [19:00] big jump. [19:02] Scaffolding is what we call the parts of [19:04] the agent that aren't Claude. So the [19:06] loops, the instructions, the tools. [19:09] We're seeing that as models get smarter, [19:11] the scaffolding that used to help can [19:13] hold Claude back. [19:15] Claude is intelligent and resourceful [19:18] and more intelligent models can al often [19:20] get further with generalized primitives [19:23] like a file system and sandbox computing [19:25] environment. [19:29] As models get more intelligent, you will [19:31] also need to keep making harder evals [19:33] and product prototypes. [19:35] They were they are how you will notice [19:37] that the exponential is moving [19:39] underneath you. [19:41] When a task that used to fail starts [19:43] passing, that's your sign to ship [19:45] something that you couldn't ship before. [19:50] And finally, as the pace continues to [19:52] accelerate, the teams who are getting [19:55] the most out of Claude are the ones who [19:56] treat model upgrades as a business [19:58] opportunity. [20:00] You should make the upgrades easy by [20:02] testing by automating your evaluations [20:05] and testing processes. And you should [20:07] test models hands-on to better touch and [20:09] feel how the improved intelligence and [20:12] capabilities will help your end users. [20:17] We are seeing the exponential continue, [20:20] which means Claude will keep getting [20:22] smarter and keep picking up new [20:23] capabilities. [20:26] You as developers are the first to feel [20:28] that you're the first to experiment, [20:32] the first to build new products, and the [20:35] first to find markets that nobody else [20:37] sees yet. [20:40] Now, Caitlyn and Angela are going to [20:41] show you how the Claude platform can [20:43] make this reality come to life. [20:57] So model capabilities are on this [20:59] exponential, but most businesses are [21:01] still on the linear. It's never been [21:04] more important to take advantage of [21:06] growing model intelligence to drive true [21:08] business impact. But what's preventing [21:10] these businesses from snapping to this [21:12] exponential themselves? [21:14] Well, it boils down to two key problems. [21:17] The first one is just getting the right [21:18] outcomes can be too difficult to build [21:21] an agent that does exactly what you need [21:23] to do. You need to do things like prompt [21:25] optimization, tool construction, [21:27] hardness engineering. There's just so [21:29] much you have to do to get it just [21:30] right. That's right. And the second [21:32] problem is you need to ship fast, but [21:34] you need to ship scalably at the same [21:36] time. Everybody is moving insanely fast [21:39] right now, and you've got to keep up. [21:40] But to win, you need quality, too. It's [21:43] really easy to build prototypes, but [21:45] it's hard to scale in production. [21:48] So, we've built the cloud platform to [21:50] give you everything you need to ship to [21:52] get the right outcomes quickly and for [21:55] scale. The platform gives you API [21:57] primitives that are tuned to cloud [21:59] models. It gives you infrastructure to [22:01] build and scale agentic systems and it [22:04] gives you controls to operate those [22:05] systems. That's right. Now, let's go [22:08] back to one of the most common problems [22:10] that Caitlyn and I hear all the time [22:12] from businesses. Businesses need [22:14] frontier level intelligence, but at [22:16] lower costs. [22:19] One of the ways that we're solving this [22:20] is with the advisor strategy. So, this [22:22] is really easy to implement. All you [22:24] have to do is update your tools and your [22:26] tools array on the messages API. And [22:29] what we're doing behind the scenes is [22:30] that we're splitting execution from [22:32] advising. So, in execution, you can use [22:35] a smaller model. This will make it a bit [22:36] cheaper. But when that small model needs [22:38] help, it can reach out to a larger model [22:40] for advice. Yeah. So in practice, this [22:42] means you can have a haiku or sonnet [22:45] class model do your executing and use [22:47] opus as an adviser. So we used the [22:49] adviser strategy. We ran this with [22:51] sonnet as an executor and opus as an [22:53] adviser. We found that sonnet performed [22:56] way better than sonnet alone. And [22:58] actually we found that sonnet performed [22:59] even more cheaply than on its own [23:01] because opus advised it to get its work [23:03] done better. [23:06] Eve Legal, for example, used the advisor [23:08] strategy and they told us they got [23:10] frontier model quality at five times [23:12] lower cost. And that's awesome. This is [23:15] a perfect situation where you can apply [23:16] it to a premium model. For example, [23:19] you'd want to put your best foot forward [23:20] with your product, but you'd have to be [23:21] conscious of your costs. It's also [23:23] really great in situations where you [23:24] have a extremely high volume of agentic [23:27] workloads. So, you have to keep an eye [23:28] out on your ROI. [23:31] All right, now let's talk about speed [23:33] and scale. those two things that Caitlyn [23:34] was saying that you have to do at the [23:35] exact same time. Recently, we introduced [23:38] Claude Manage agents. Claude manage [23:40] agents is an agentic harness paired with [23:42] production grade infrastructure. It [23:45] allows teams to ship literally 10 times [23:47] faster. You can now build a production [23:49] grade agent in days, not months. One of [23:52] our favorite examples of a customer who [23:54] built on cloud managed agents was Asana. [23:57] Asana built AI teammates so that humans [24:00] can collaborate directly with agents [24:03] within Asauna projects delegating tasks [24:05] and things like that. And Asana wanted [24:07] to build for speed and scale at the same [24:09] time. So they built on cloud managed [24:11] agents. And recently we introduced a [24:13] couple of key features that were [24:15] upgraded for cloud managed agents. [24:17] Multi- aent orchestration which allows [24:19] you to build fleets of agents. outcomes [24:22] that allow you to specify what success [24:24] looks like for Claude and Claude just [24:25] iterates to get it done and dreaming [24:28] where Claude can basically introspect on [24:30] its previous transcripts and learn and [24:32] self-improve. And today we're [24:35] introducing two more new features. The [24:37] first one is self-hosted sandboxes. So [24:40] this means that you can now have Claude [24:42] execute work on your own server. The [24:44] other thing is MCP tunnels. And for many [24:47] people who build internal agents, being [24:49] able to access your internal MCP servers [24:51] securely is now possible on Cloud Manage [24:53] agents through MCP tunnels. Cloud manage [24:57] agents spawn sandboxes when it's time to [24:59] execute work like editing files. And you [25:02] can still choose to use our sandboxes to [25:04] do that work, but starting today you can [25:06] also use your own. And we're introducing [25:08] this with first class support for [25:10] Daytona, Cloudflare, Verscell, and Modal [25:13] Sandboxes with super easy integration. [25:16] So, it's easy to get started with any of [25:17] these providers. With MCP tunnels, you [25:20] can have your MCP servers hosted behind [25:23] your firewall on your private network so [25:25] that Cloud Manage agents can access them [25:28] without exposing them over the public [25:29] internet. Should we check them out? [25:32] Let's do it. [25:34] So, Caitlyn and I have been working with [25:35] a fictional company called Counter. [25:38] Counter offers software for small [25:40] businesses to be able to build up a [25:42] digital storefront. Encounter really [25:44] wants to become an AI native business [25:47] and one of its most common workflows is [25:49] that it's constantly running growth [25:50] experiments to optimize its merchant [25:52] onboarding. Kalin has graciously offered [25:55] to help build a growth agent on cloud [25:57] manage agents for counter. [26:00] So here we are in counter slack [26:02] workspace. I'm in here with my colleague [26:05] Gabe. We're wearing our super cool [26:06] counter hats and we're ready to go. So, [26:08] we're really excited to see how our [26:10] latest growth experiment on our [26:11] onboarding flow has performed. And you [26:14] can see that our new growthbot came into [26:16] the Slack channel and it told us there's [26:18] actually a really clear winner in our [26:19] most recent experiment. The simpler [26:22] version of the onboarding flow is way [26:24] outperforming the older, longer version [26:26] of the flow where merchants were kind of [26:28] dropping off before they ever finished [26:29] signing up for counter. The agent is [26:32] proactively telling us it's calling the [26:34] experiment and it's going to get started [26:35] on cleaning up the old variant. which is [26:38] awesome. So, let's take a look at how [26:40] this agent actually is set up. And to do [26:42] that, I'm going to use the cloud API CLI [26:45] and the cloud developer console. [26:48] So, first let's check out the agents [26:49] configuration. You see here we've got [26:52] our system prompt, our skills, our [26:54] tools. Well, let's take a look at the [26:55] MCP servers. First, we've got Slack. [26:58] Makes sense, right? That bot was talking [27:00] to us in Slack. Then we've got our data [27:02] warehouse so that the bot can go and [27:04] read data about the experiments and be [27:06] able to determine what might be winning. [27:08] We've got our feature flags MCP server [27:10] so that the bot can call experiments or [27:12] start new ones and and take actions like [27:14] that. But let's look at these URLs. So [27:17] for Slack, regular public MCP URL, but [27:21] for the data warehouse and features flag [27:22] services, you might notice something [27:24] different here. We've got these URLs [27:26] that are behind tunnel.anthropic.com. [27:28] And what this means is both of these MCP [27:30] servers are behind counter's firewall [27:33] and only accessible via the tunnel so [27:36] that counter can kind of meet those [27:37] requirements of making sure that its MCP [27:39] servers stay on its private network. And [27:42] so let's pop into the cloud developer [27:44] console and see how this is set up. So [27:46] for counter, they set up a gateway in [27:48] their own private network. Then they [27:51] establish a secure connection to [27:52] Anthropic. As a result, any agent that [27:55] Caitlyn builds that uses the MCP tunnel [27:57] is now able to securely access internal [27:59] MCP servers. [28:02] You can go ahead and create these MCP [28:03] tunnels directly in the cloud developer [28:05] console. And we give you a couple of [28:07] different configuration options so you [28:08] can adjust them accordingly. [28:10] So counter's next big requirement is [28:12] that agent when it goes to do things [28:14] like write code and execute code, it it [28:17] wants us to do those things on a [28:19] self-hosted sandbox. it doesn't want to [28:21] run these things on public [28:22] infrastructure. So what we do is for our [28:26] cloud manage agents, we can set up our [28:28] environment to make sure that we're [28:29] using a self-hosted sandbox. So with the [28:32] self-hosted sandbox, now what's going to [28:35] happen is when the agent actually needs [28:36] to execute work, it's going to put a [28:38] work item in a queue. And here counter [28:40] is actually using Verscell's uh [28:42] self-hosted sandbox. And so what will [28:44] happen is that Verscell will actually [28:46] pick up that work item and then they [28:48] will actually spin up a sandbox in [28:50] counter's versell account in order to [28:51] execute the work. So one of the cool [28:54] things about cloud manage agents is that [28:56] we've got a whole bunch of really rich [28:57] observability within the console [28:59] experience. And so let's actually go [29:00] check out the session that ran that [29:02] resulted in that Slack thread that we [29:04] saw earlier. And so you can see here [29:06] that this agent is running a whole bunch [29:08] of different tools. But we can briefly [29:10] take a look and make sure that some of [29:11] the things that we cared about around [29:12] MCP tunnels and self-hosted sandboxing [29:15] are working the way we want. So first [29:16] we've got this set flag winner tool [29:18] call, which means that the agent was [29:19] able to work through the MCP tunnel to [29:21] call that MCP server for the feature [29:23] flag service. And then you can see here [29:26] too when the agent decides it's time to [29:28] write the code to clean up the old [29:30] variant, it checks out a new git branch [29:32] and it's doing this work on our Versell [29:34] self-hosted sandbox. Awesome. Let's head [29:37] back to Slack and take a look at what [29:39] this Growthbot agent has been doing. So, [29:42] first off, Growthbot is very proactive. [29:44] Not only has it figured out that it [29:46] should default the uh simplify variant, [29:48] but it also put together a PR in order [29:51] to actually do that defaulting and clean [29:52] it up. And when that work gets executed, [29:55] it's done on counter servers via the [29:57] self-hosted sandbox. Another great thing [29:59] in its productivity, you can see it also [30:01] gave us a little screenshot. So you can [30:03] see the old variant, which is a bit [30:04] messy, and the new one, and that [30:06] definitely looks cleaner. [30:08] Not only is this agent proactive, but [30:10] it's also collaborative. You can see [30:12] here, Caitlyn asked, "What next?" And [30:15] Growthbot was actually able to detect [30:16] that another great opportunity could be [30:19] to solve this 46% drop off that it found [30:21] in the onboarding flow. Now, Growthbot [30:24] was able to calculate that because it [30:25] was able to query the data warehouse [30:27] securely through an MCP tunnel. and we [30:30] love that it ended up by asking us, do [30:32] you want me to get started on that? [30:34] Thank you very much, Claude. All right, [30:36] let's wrap up. [30:39] So, today we introduced two big upgrades [30:41] to Cloud Manage agents with self-hosted [30:43] sandboxes and MCP tunnels. With this [30:46] collection of feature upgrades, it's now [30:48] easier than ever to become an AI native [30:50] business yourself and build agents for [30:52] all of your workflows and ultimately [30:54] accelerate whatever you are building. [30:57] And now Kad and Boris are going to come [30:59] and talk to you about how Cloud Code is [31:01] making it even more fun to ship as a [31:03] developer. [31:13] Thanks. Angela and Caitlyn just showed [31:16] you how the Quad platform bridges the [31:18] gap between what models can do and what [31:21] agents businesses ship. We see a related [31:23] challenge on cloud code to bridge the [31:25] gap between model capabilities and how [31:28] every developer can benefit from them. [31:31] First, I want to take some time to just [31:33] thank all of the builders in the room [31:35] with us today and watching online. Thank [31:38] you for trusting us and your production [31:40] codebase back when Sonnet 37 was our [31:43] frontier model and back when our product [31:45] was rough around the edges. Your support [31:49] is what makes the team so excited to [31:50] come in every day and make Cloud Code [31:53] better. [31:55] Let's back up to why Cloud Code exists. [31:59] Our mission is to help every builder [32:01] close the gap between having a great [32:03] idea and having a shipped product. The [32:07] way that we enable this is by building [32:09] tools that elicit the frontier [32:10] intelligence from our models and making [32:13] these tools accessible to every builder. [32:17] And we don't think of ourselves as [32:18] having a finished road map to hand to [32:20] you. We think of ourselves more like [32:23] mountaineers [32:24] just climbing alongside you in terrain [32:27] that none of us has mapped before, [32:29] figuring things out as we go. And we're [32:32] growing with you with increasing AI [32:34] capabilities and helping you manage [32:36] these new challenges as they emerge. [32:40] I remember looking back to last year [32:42] when I would give quad code a task and I [32:44] would read every single edit it tried to [32:46] make every permission prompt. I would [32:49] give it superdetailed guidance about [32:51] what to do and what not to do. Just [32:53] walking it through the details of the [32:55] change. [32:57] Now most of us are running in auto mode [32:59] to delegate permissions to Claude and [33:02] we're checking in after Quad has already [33:04] tested, verified its changes and has a [33:06] PR ready for us. [33:10] Looking back, Quad Code started in the [33:12] CLI and the terminal is still the [33:15] interface for power users who want a [33:17] minimal text interface and the most [33:19] control and customizations. [33:23] Then we added the IDE. This gives you [33:25] the same powerful agent, but you also [33:29] have the ability to follow along with [33:31] all the code changes as the agent is [33:33] working. [33:35] And we heard from you that many of you [33:37] are now juggling multiple cloud code [33:40] instances which we've affectionately [33:42] been calling multi-clotting. [33:46] We've added two new interfaces to help [33:48] you manage more agents. [33:51] One that I use frequently is quad code [33:53] on desktop. [33:55] It's a full screen graphical interface. [33:58] It has built-in previews, a sidebar [34:00] control plane, and the ability to render [34:03] images and rich outputs. [34:06] We've built desktop to be a single view [34:08] across both local sessions and your [34:10] cloud sessions with visual indicators of [34:13] which agents are running, which ones are [34:15] blocked, and which ones need your input. [34:19] Next is our newest surface, cloud agents [34:22] view in the CLI for people who actually [34:25] just prefer to stay in the terminal. [34:28] In this view, you can also see what's [34:30] running, what's waiting for you, and [34:32] what's done in one glance. You can reply [34:35] in line to unblock. You can jump in and [34:38] out of sessions, all without losing your [34:40] place. [34:42] The VS Code IDE extension and desktop [34:44] app are both built on the Cloud Agent [34:47] SDK, the same one that many of you are [34:50] building on as well. [34:53] And many enterprises have now adopted [34:55] quad code wallto-wall anthropic. We've [34:59] seen that this has driven a 200% [35:01] increase in the number of PRs per [35:03] engineer even as our engineering org has [35:07] scaled substantially. [35:10] Together with all of you, we're [35:12] redefining and discovering what the [35:15] future of engineering looks like by [35:17] embracing these new challenges that [35:18] we're encountering and building [35:21] automations powered by Quad to tackle [35:24] each. [35:26] Here's some of the feedback that we've [35:27] heard from our users and what we've [35:29] built with the help of everyone in this [35:31] community. [35:33] We heard from you that you want to spend [35:35] less time on code review. So, we shipped [35:38] a code review product that deploys a [35:41] team of agents to traverse all your code [35:44] changes and auxiliary files to catch [35:47] critical bugs. Thousands of companies [35:49] use this every day, including every [35:52] internal anthropic team. [35:54] We heard from you that you want to code [35:57] on the go. So, we launched remote [36:00] control and quad code in iOS and Android [36:03] so that you can fire off a task no [36:05] matter where you are. You're no longer [36:08] needing to walk around with this open [36:10] laptop or you're no longer stuck at your [36:13] desk. You can now go to a park, touch [36:16] grass, and still get your tasks done. [36:20] We heard from you that you're also [36:22] spending a lot of time babysitting your [36:24] PRs, fixing flaky CI tests, addressing [36:28] code review comments, and resolving [36:30] merge conflicts. [36:32] So, we added autofix. It listens for [36:36] these events and proactively fixes each [36:39] one so that your PR is always green. [36:44] And we heard from you that you want to [36:46] run cloud code on new tickets and on new [36:50] customer bug reports that are coming in. [36:52] So we built routines. Configure once and [36:56] cloud code can run on a schedule or in [36:59] response to a web hook or API request. [37:03] The work that used to require you to [37:05] manually kick off now just happens on a [37:08] schedule. [37:10] And last, we heard from you that you're [37:12] landing so much code that security teams [37:16] are struggling to keep up. So, we built [37:19] Cloud Security. It scans your codebase [37:21] overnight, flags vulnerabilities ranked [37:24] by severity, and lets you kick off cloud [37:26] code to address each one. [37:30] Each of these primitives that we've [37:32] built composes together so that we can [37:35] together [37:36] easily adapt to the future of [37:39] engineering. [37:41] Everything I've covered is something an [37:43] individual can pick up today, but it's [37:46] especially exciting to see how a range [37:48] of companies have adopted cloud code at [37:50] the scale of their entire engineering [37:52] orgs. [37:54] First, Shopify powers e-commerce for [37:58] millions of merchants worldwide and has [38:00] built AI use into its entire engineering [38:03] culture. [38:05] They use quad code across the entire [38:07] company, both across the engineering [38:09] org, but also non-engineers, so product [38:12] managers, designers, data scientists, [38:15] and they're bringing it directly into [38:17] their platform to stand up tools at [38:19] scale. [38:21] Andrew McNamera is the director of [38:23] applied AI at Shopify and in his words, [38:26] the speed is just crazy and quad code [38:29] has transformed how they build their [38:31] internal tools. [38:33] Another example is Marcato Libre. [38:36] They're Latin America's most popular [38:38] e-commerce site with over 100 million [38:42] buyers. [38:43] They have a team of 23,000 engineers and [38:47] their org runs on cloud code. When that [38:51] happens across an org, the work itself [38:53] changes. Engineers are pointing agents [38:55] at debt, tech debt that people haven't [38:58] had the time to fix themselves. It's [39:01] reviewed more than 500,000 PRs with [39:04] human oversight and modernized more than [39:07] 9,000 of their apps. [39:10] Oscar Mowen leads technology and is [39:12] aiming for 90% autonomous coding in a [39:15] fully agent-driven PR loop by Q3 of this [39:18] year. [39:20] But the detail I love the most isn't [39:22] just the number. It's that managers and [39:24] VPs who haven't committed code in years [39:27] are now shipping again. [39:30] Quad code is putting coding back in the [39:32] hands of people who've spent the last [39:34] decade in reviews and roadmap sessions [39:37] instead of in their codebase. [39:40] And we see this across the entire [39:41] industry. Millions of developers are [39:44] getting more products shipped at higher [39:47] quality and at faster speeds. [39:50] Now let's see what this actually looks [39:52] like in practice. To take you through [39:54] it, please welcome the creator of Quad [39:57] Code, Boris Churnney. [40:08] I just realized we're matching. [40:12] Thanks, Cat. Um, I'm going to jump into [40:14] the demo in a sec, but um, first I just [40:18] want to say everything that we're [40:20] showing still feels magical to me. [40:25] using cloud code, I still get those same [40:27] feelings that I got when I programmed my [40:29] first calculator. And even inside [40:32] Anthropic in Slack, all day we're [40:34] trading screenshots of things that [40:37] engineers are doing in the wild with [40:39] Cloud Code. It's it's just so exciting [40:41] to see. [40:43] Um, and so today I'm excited to share [40:45] some examples of Cloud Code's magic with [40:48] uh with all of you. For this demo, let's [40:50] imagine that we're an engineer at Acme [40:52] Pay. It's a payment infrastructure [40:54] company. We're gonna start in the Cloud [40:57] Code desktop app. And we're gonna start [40:58] by working on just one single task. And [41:02] in this session, Claude is working on [41:05] adding refunds to Acme's merchant [41:07] dashboard. It's working on a full [41:09] implementation. Item potency so a [41:13] duplicate web hook doesn't double refund [41:14] a merchant. multicurrency handling [41:17] across all the regions that Acme serves [41:20] and uh audit logging for the compliance [41:22] team. [41:24] It writes the implementation and it's [41:26] going to verify its own work. Quad pulls [41:29] up the merchant dashboard in the [41:30] browser, triggers a refund, [41:33] and the modal closes before the success [41:36] toast appears. [41:38] It's a real edge case. [41:41] Claude sees the failure. It traces it [41:44] back to a race condition in the [41:46] optimistic update. It fixes it and it [41:49] verifies it actually works in the [41:51] browser before calling the task done. [41:57] Now let's zoom out. [42:02] Cloud code isn't running just one [42:04] session here. It's one of many sessions [42:08] all running and being managed in [42:11] parallel. [42:12] In the cloud desktop app, you can now [42:14] see all your cloud code sessions. Which [42:17] ones are running, which need your input, [42:20] which have PRs that have already been [42:22] merged and closed. [42:25] Synchronous coding is now just a slice [42:29] of what's happening at any given moment. [42:32] And we think that going forward more [42:34] code is going to be written in an async [42:36] way. And this is why we keep talking [42:39] about verification. If cla can check its [42:42] work, you can just let it run while you [42:44] work on something else and you can come [42:46] back to a fully working result. [42:51] A lot of my code these days is written [42:53] by routines. I'm not the one doing the [42:56] prompting. I'm the one that creates a [42:59] routine that does the prompting. [43:01] For the engineers in the room, think of [43:03] it like a higher order function. [43:05] Routines are a higher order prompt. For [43:07] example, let's go back to the refund [43:09] session we just looked at. A teammate [43:11] found a GitHub issue overnight. A [43:13] routine watching the repo picked it up [43:15] async and then it kicked off the working [43:18] clock. [43:21] With routines, developers can set up [43:24] async automations and wake up to PRs [43:27] that are ready to merge. Here's [43:31] our routines view. [43:34] Routines can be run on a schedule. They [43:36] can get kicked off by web hooks or even [43:38] kicked off by arbitrary API calls. And [43:41] you can run them locally on your machine [43:43] or on remote cloud compute. [43:50] Let's look at one more feature in [43:51] desktop. [43:56] This is CI autofix. [43:59] What it does is it watches the PR that [44:01] the last session just opened and its job [44:05] is to babysit the PR to production. It's [44:08] going to autofix any comments from code [44:10] review and security review, autofix CI, [44:13] auto rebase if there's any merge [44:15] conflicts. [44:17] And look at what just happened. CI [44:19] flicked on a network timeout. The [44:21] routine woke up, diagnosed it as a known [44:24] infra issue, and retried the job. [44:28] And actually in the cloud code code base [44:30] we we tell it to fix the root cause [44:32] instead, not just retry. [44:36] And CI is green. The engineer that owns [44:39] the PR is never going to see the red X [44:42] and that work is off their plate. [44:49] That's the shift. The default isn't I'm [44:52] going to prompt Claude code. The default [44:55] is now I'm going to have Claude prompt [44:58] Cloud Code. [45:01] Everything you just saw is available [45:03] today, uh, including routines and all [45:06] the latest updates to the Cloud Desktop [45:08] app. We're excited for you to try them [45:10] out and let us know what you think. We [45:14] hope these features continue to let you [45:16] close the gap between your ideas and [45:20] shipping products. [45:25] And that's really what every talk today [45:28] was pointing at. Lisa's capability [45:31] curve, Angela and Caitlyn's agents that [45:34] run on infrastructure that you control. [45:37] What Cat and I just showed you. [45:40] These are three layers of one story. [45:44] The capability is already here and the [45:47] remaining gap is how fast we put it to [45:49] work. [45:52] I encourage you to spend the rest of [45:53] today exploring these layers, research [45:56] talks if you're evaluating the models, [45:58] uh cloud platform sessions if you're [46:01] building for your users, [46:03] and cloud code workshops if you want to [46:06] learn more ways to bring cloud into your [46:08] day-to-day development workflow. [46:12] Dive in, go deep, and start building [46:15] with us. Thank you.