Anthropic Automates Agent Memory Upgrades With Dreaming Preview

Scheduled Agents, Dreaming and Q&A: Claude Managed Agents (Part 3 of 4) — Anthropic — AI Engineer

AI Engineer

Anthropic argues that letting Claude dynamically orchestrate its own sub-agents outperforms rigid human-engineered control graphs, using autonomous 'Dreaming' loops to self-correct operational failures from past runs.

AI-assisted summary of Scheduled Agents, Dreaming and Q&A: Claude Managed Agents (Part 3 of 4) — Anthropic — original source. Check the original for full context.

Source published:

Key ideas

  • Claude Managed Agents (CMA) provides a managed API abstraction for running long-lived, multi-agent sessions, featuring automatic backend state compaction that has supported continuous production runs lasting up to 10 hours. (5:59)
  • Anthropic introduced Dreaming, an experimental research preview that audits the past 30 days of execution transcripts to autonomously detect operational gaps and optimize shared memory stores. (2:54)
  • For multi-tenant SaaS applications, Anthropic strongly advises against Bring Your Own Key (BYOK) architectures because they strip developer observability, recommending instead that teams enforce tenancy boundaries using Workspaces. (17:14)
  • CMA completely abstracts infrastructure concerns like Kubernetes pods, replica counts, and horizontal autoscaling, scaling sessions purely on-demand subject only to standard account API rate limits. (20:09)

Detailed notes

## Background Published by the AI Engineer YouTube channel on October 12, 2026, this video documents part three of Anthropic's four-part Claude Managed Agents workshop. It features Anthropic's Gabe Cemaj and Priyanka Phatak demonstrating multi-session fan-out, scheduled deployments, and the experimental Dreaming memory feature, followed by an extensive technical Q&A covering architecture, scaling, and enterprise adoption.

## TL;DR Gabe Cemaj demonstrates how Claude Managed Agents orchestrates parallel runs by fanning out single tasks into independent multi-agent sessions, configures recurring cron-like deployments, and previews Dreaming, an asynchronous research feature that audits historical execution logs to self-improve persistent memory stores. During the audience Q&A, Cemaj and Priyanka Phatak clarify that the platform handles context compaction automatically for multi-hour sessions, operates without infrastructure-level Kubernetes configuration, and uses workspaces rather than 'Bring Your Own Key' setups to preserve observability across tenants. The speakers also address the tension between rigid scaffolding and advancing base models, urging builders to rely on evals and autonomous delegation over brittle visual graph topologies.

## Atmosphere & style The presentation carries the candid, practical energy of an interactive engineering workshop, with speakers working through live demos against the backdrop of conference Wi-Fi hiccups and deadpan stage humor. Gabe Cemaj and Priyanka Phatak maintain a collaborative, grounded dynamic, answering audience questions directly without corporate evasiveness. Watching the session feels intimate and developer-centric, balancing excitement over frontier agent capabilities with honest acknowledgment of scaffolding fatigue and the unglamorous necessity of running rigorous evaluations.

## Bulletin - [05:59](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=359s) Claude Managed Agents (CMA) provides a managed API abstraction for running long-lived, multi-agent sessions, featuring automatic backend state compaction that has supported continuous production runs lasting up to 10 hours. - [02:54](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=174s) Anthropic introduced Dreaming, an experimental research preview that audits the past 30 days of execution transcripts to autonomously detect operational gaps and optimize shared memory stores. - [17:14](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1034s) For multi-tenant SaaS applications, Anthropic strongly advises against Bring Your Own Key (BYOK) architectures because they strip developer observability, recommending instead that teams enforce tenancy boundaries using Workspaces. - [20:09](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1209s) CMA completely abstracts infrastructure concerns like Kubernetes pods, replica counts, and horizontal autoscaling, scaling sessions purely on-demand subject only to standard account API rate limits.

## Key takeaways - [00:01](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1s) Top-level agents can break batch requests into independent parallel runtime sessions via custom dispatch tools rather than executing sequentially. - [01:06](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=66s) Deployments bundle an agent definition, a cron-like schedule, seed messages, and mounted external resources like repositories and persistent memory stores. - [02:54](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=174s) Dreaming operates as an asynchronous meta-agent fleet reviewing 30 days of past logs to update memory stores, with plans to eventually rewrite skills and prompts autonomously. - [04:40](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=280s) Full telemetry and event-level timestamps are exposed out-of-the-box via Console and REST/streaming APIs, allowing custom integrations without imposing an opinionated monitoring framework. - [05:59](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=359s) Anthropic manages backend context compaction automatically, enabling multi-hour agent sessions to run for days without memory explosion. - [06:43](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=403s) Giving Claude dynamic delegation authority consistently outperforms hand-engineered, rigid orchestration graphs and constrained routing topologies. - [07:46](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=466s) Workspaces serve as the primary administrative tenancy boundary today, with fine-grained role-based access control (RBAC) remaining on the product roadmap. - [08:53](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=533s) Memory stores are decoupled from scheduled deployments, persisting accumulated learning across runs without resetting when code definitions change. - [10:01](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=601s) In CMA, the 'harness' refers strictly to the single-session tool-execution loop, leaving higher-level multi-agent orchestration topologies to the developer. - [10:01](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=601s) Defining explicit outcome rubrics and maximum iteration caps enables automated verification loops that guide agents toward desired results. - [11:17](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=677s) Rigid scaffolding and explicit instructions tend to 'melt' away as base model intelligence scales, although multi-agent setups remain durable for complex tasks today. - [12:57](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=777s) While Dreaming demonstrates internal performance gains, builders must validate autonomous memory updates against their own domain-specific evaluation suites. - [15:07](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=907s) CMA drew architectural inspiration from Claude Code's tool loop but was re-engineered as a multi-tenant cloud API for general, non-coding domains. - [17:14](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1034s) CMA is available on Claude Platform for AWS but exclusively runs Anthropic's Claude models, with no support for third-party or open-weight models. - [17:14](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1034s) SaaS architectures should avoid passing end-user API keys (BYOK) to preserve developer tracing and centralized operational telemetry. - [21:09](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1269s) Enterprise production adopters like Notion and Atlassian wrap CMA calls within their own client interfaces and authentication layers rather than exposing raw endpoints. - [23:44](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1424s) Claude Cowork targets individual personal desktop productivity, whereas Claude Managed Agents is engineered for multi-user organizational workflows and customer-facing software products. - [25:18](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1518s) Anthropic is actively evaluating customer demand for on-premises hosting and dedicated enterprise VPC deployments to satisfy strict data governance requirements.

## Detailed walkthrough ### [00:01](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1s) Multi-Session Fan-Out Demo

Gabe Cemaj begins a live demonstration prompting the system to “analyze Google and Microsoft.” Hoping the demo holds together over the venue's spotty Wi-Fi, he explains the intended mechanics: the primary agent first inspects its existing information context and then triggers a custom tool called `dispatch_analysis`. Instead of forcing a single session to handle everything sequentially, this custom tool fans out the workload by provisioning distinct sessions for each individual ticker.

```mermaid flowchart TD accTitle: Multi-Session Fan-Out Architecture accDescr: The main coordinator agent delegates ticker analysis across independent collaborative sessions via a dispatch tool. subgraph Coordination["Main Coordinator"] A["Main Agent Prompt:<br/>'Analyze Google & Microsoft'"] --> B{"Dispatch Analysis<br/>(Custom Tool)"} end subgraph Sessions["Parallel Executions"] B --> C["Session: Google (GOOGL)<br/>Collaborative Sub-Agents"] B --> D["Session: Microsoft (MSFT)<br/>Collaborative Sub-Agents"] end subgraph Persistence["Cross-Session Learning"] C <--> E[("Shared Memory Store")] D <--> E end ```

Each spawned session operates as a multi-agent environment where sub-agents work collaboratively on financial artifacts. These runs include explicit outcome definitions to enable self-supervision, allowing the sub-agents to critique their work and communicate through shared memory stores to learn across runs.

- The primary dispatch pattern allows a top-level agent to break batch prompts into independent runtime sessions. - Sub-agents within those sessions run collaborative loops guided by defined outcome targets and persistent memory stores.

---

[01:06](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=66s) Deployments: Running Sessions on a Schedule

Transitioning to recurring workflows, Gabe Cemaj introduces the concept of deployments to handle scheduled routines, such as scanning an equity watchlist every morning at 9:00 AM or generating summary analyses on the first of every month. While users can inspect and trigger these workflows manually in the Anthropic web console, Gabe Cemaj stresses that Claude Managed Agents is engineered primarily as an API and SDK foundation:

> “Deployments is everything is API based. So we you can obviously interact with our platform via the console. Um but their main way that we intend to you for you to interact with it is via the API and the SDK.”

A deployment record packages four key primitives: an agent definition (such as a "research desk weekly memo" agent), a cron-like execution schedule (e.g., the first day of every month at 1:00 PM), a seed set of initial messages, and external resources such as GitHub repositories, persistent files, or memory stores. Gabe Cemaj demonstrates a custom management dashboard built on top of the API to list, search, and trigger runs on demand. When an ad-hoc trigger fails during the live stage test, he quips with a laugh that he will have to "ask Claude about it later."

---

[02:54](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=174s) Dreaming Research Preview: Autonomous Memory Self-Improvement

Gabe Cemaj shifts to "Dreaming," a research preview aimed at autonomous self-improvement. The system allows an operator to designate a target memory store, pick a base Claude model, supply optional guidance, and unleash an asynchronous analysis pass over the previous 30 days of execution transcripts.

Under the hood, Dreaming uses Claude Managed Agents itself to spin up a fleet of evaluator sub-agents. These workers comb through execution logs where the memory store was mounted, hunting for operational failures, missing context, or repeated mistakes. Gabe Cemaj shows a live artifact where the Dreaming process audited a custom skill:

> “You can see here what it actually did is that it found that the skill that we created actually had a few gaps um on the way that it was written and it updated the memory store to tell it even though there is this skill, you should extend this knowledge with the fact that we've learned from it.”

The roadmap for Dreaming involves expanding past memory store modifications to autonomously rewriting skills, refining top-level prompts, and updating sub-agent system instructions based on observed patterns over time.

---

[04:40](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=280s) Q&A: Telemetry, Observability, and OpenTelemetry Export

Opening the floor to questions, an attendee asks about native telemetry and observability instrumentation, noting they did not see configuration code for monitoring hooks during the walkthrough. Gabe Cemaj clarifies that full observability is enabled out of the box:

> “If you go into the console, you can see it live, but you can also obviously get it from the API where this transcript view is like a nice view, but if you go to debug, it's every event that occurred in that session.”

The underlying log exposes raw event timings—including precise timestamps for when model calls start and terminate—allowing developers to derive custom latency and cost metrics. When the audience member asks about standard enterprise observability stacks such as OpenTelemetry (OTel), Gabe Cemaj explains that because every run artifact is accessible through standard REST and streaming APIs, teams can build custom export pipelines without Anthropic forcing an opinionated monitoring stack onto the platform.

---

[05:59](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=359s) Q&A: Session Lifetimes, Auto-Compaction, and Orchestration Topologies

An attendee asks whether agents can run indefinitely or if state size will eventually explode, requiring offline maintenance. Gabe Cemaj reveals that Anthropic handles compaction automatically on the backend:

> “We are running compaction for you so that you can run these for days. We've seen 10-hour sessions in production uh from some of our users.”

When asked whether the platform supports visual graph builders or rigid topology engines where Agent A explicitly routes work to Agent B and C, Gabe Cemaj pushes back against rigid control architectures:

> “We find that uh there's a desire as humans to constrain what claude does and the way it does it. As cloud gets smarter we have continuously remove those guard rails and let claude just let it cook uh let it do what it thinks it's best.”

He notes that prompting Claude with broad delegation authority and letting it dynamically choose the number of sub-agents consistently outperforms hand-engineered graph constraints, though he hints that additional orchestration UI features might appear in future releases.

---

[07:46](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=466s) Q&A: Workspaces, Multi-Tenancy, and Deployments vs. Memory

The discussion turns to enterprise tenancy and isolation boundaries. Priyanka Phatak and Gabe Cemaj outline the current authorization model, explaining that **Workspaces** serve as the primary administrative boundary. Teams can compartmentalize specific customer deployments, agents, and access privileges into separate workspaces (e.g., Workspace A versus Workspace B). While acknowledging that full fine-grained Role-Based Access Control (RBAC) is on the active roadmap, workspaces currently act as the boundary for tenancy.

Another attendee asks for clarification on the relationship between deployments and persistent memory stores, wondering if a deployment is just a point-in-time snapshot. Priyanka Phatak clarifies the fundamental distinction:

> “Deployment is essentially a way for you to run sessions for a specific agent on a schedule. So you can say like oh research desk agent go research NVIDIA once every quarter and it'll just create a session every quarter to go research and produce you that report.”

Memory stores exist as independent stateful entities. They are not bundled immutably into a deployment; instead, developers choose which memory store to mount to which session, allowing accumulated insights to persist cleanly across scheduled runs without being reset when code definitions change. The conversation then transitions into developer confidence, evaluation strategies, and how Anthropic defines an agent harness.

[10:01](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=601s) Defining a Harness and Driving Agent Outcomes with Evals

Gabe Cemaj addresses the confusion around what a "harness" actually means, distinguishing between Anthropic's internal architecture in Claude Managed Agents (CMA) and how external developers talk about agent systems. In CMA, the harness specifically refers to the underlying tool-execution loop—managing context, handling session state, and ensuring the model can perform its assigned tasks. In contrast, most builders use the term to describe orchestrating multiple sessions and agents across complex topologies to solve larger workflows. Gabe clarifies that CMA delivers a single session as the fundamental primitive of work, intentionally leaving higher-level orchestration harnesses to the builder.

```mermaid flowchart TD accTitle: CMA Single-Session Primitive vs Developer Harness accDescr: Diagram contrasting CMA's single-session tool loop with developer-managed multi-session orchestration topologies.

subgraph CMA["Claude Managed Agents (CMA)"] S["Session (Unit of Work)"] T["Tool Loop Execution"] C["Context & Session State"] S --- T S --- C end

subgraph Builder["Builder Application"] H["Custom Builder Harness"] O["Multi-Agent Topology"] E["Evaluations & Outcomes Rubric"] H --> O O --> S H --> E end ```

When asked how developers can measure whether an agent is performing properly, Priyanka Phatak emphasizes rigorous evaluation across diverse task distributions. She points out that defining concrete outcomes is one of the most effective levers available: developers set an explicit rubric for success along with a maximum iteration cap, enabling an automated verifier loop that nudges the agent to re-try until it meets the target criteria.

- In CMA, the harness is specifically the execution tool loop responsible for session state and context management. - Builders are given a single session as an atomic abstraction so they can assemble custom multi-agent topologies. - Evals against distinct task suites are the primary recommended method for tracking real-world performance. - “Outcomes is a really good way where we steer the agent for you to get you the specific outcome where you can define an exact rubric for like hey this is the exact outcome I want and you can define max iterations and the agent will keep going into it until it gets you that outcome,” Priyanka explains.

[11:17](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=677s) Skills vs. Multi-Agent Topologies and the "Melting" Harness

An attendee asks how to decide between relying on skills versus deploying full multi-agent harnesses, expressing exhaustion over constantly investing in fragile scaffolding around rapidly shifting base models. Gabe responds candidly to the fatigue, acknowledging the debate of "thick harness, thin harness, thick skills" is in constant flux. He observes that as frontier models advance, the rigid guardrails and hand-holding historically imposed by developers naturally begin to dissolve.

While skills serve as a dependable, lightweight abstraction today by feeding the model structured guidance, Gabe anticipates that explicit instructions will steadily become thinner as models gain autonomous competence. Despite the maintenance burden of evaluating every new release, he considers multi-agent systems to be generally more durable and capable for complex objectives today, though actual utility will always hinge on the specific problem space.

- The boundaries and explicit instructions provided to models tend to fade as base model intelligence scales. - Skills supply sufficient procedural context today, but their footprint will likely shrink over time. - “The boring answer is just run evals and evaluate these things,” Gabe remarks, admitting that re-evaluating scaffolding across model generations feels exhausting. - Multi-agent framing remains Gabe's preferred setup for complex tasks, though empirical results vary by domain.

[12:57](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=777s) Dreaming Research Preview and Automated Evaluation

The conversation shifts to Dreaming—a research preview designed to synthesize long-term insights across historical runs—and how developers can validate that these distilled memories actually help rather than mislead the agent. An attendee raises the concern that automated dreaming could latch onto bad runs or take an agent in contradictory directions, asking whether Anthropic provides automated evaluation pipelines to select the best memory iteration.

Priyanka explains that Dreaming functions by analyzing all transcripts over a developer-defined timeframe (such as the past 30 days), identifying what tasks were attempted, and generating an upgraded memory store tailored to those workflows. While Anthropic runs internal benchmark suites that show notable performance lifts from Dreaming, she insists that teams must maintain their own evaluation suites. Gabe underscores that Dreaming is still an early, experimental research preview. When the attendee presses on how to verify divergent paths when nine sessions are broken and only one succeeds, Gabe jokes, “if I tell you just to trust me is that no?” prompting laughter from the audience before reiterating that evals are the only true source of truth.

- Dreaming reviews past session transcripts over a selectable window (e.g., 30 days) to construct an optimized memory store. - Internal tests show measurable performance improvements, but builders are strongly advised to run their own evals before deploying updated memory stores. - The feature is in early research preview, meaning multi-path automated selection and automated eval-guided pruning remain areas of active refinement.

[15:07](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=907s) Architecture Heritage: Claude Code vs. Claude Managed Agents

A developer working with Claude Code notes structural similarities between local session logs and the memory management in CMA, asking whether CMA is essentially an open-source productization of Claude Code and urging Anthropic to keep data formats accessible. Gabe clarifies the architectural lineage: the team drew direct inspiration from Claude Code's terminal harness because of its exceptional performance on programming tasks, but CMA is fundamentally designed as a generalized backend API.

While Claude Code packages an out-of-the-box developer tool tailored to interactive terminal usage, CMA tackles the enterprise infrastructure required to scale across diverse, non-coding domains. Priyanka notes that moving from a client-side CLI to a multi-tenant API required rebuilding the execution plane from the ground up to ensure multi-hour reliability, horizontal scaling, and secure tool execution.

- Claude Code served as a design benchmark for effective agentic tool usage on coding workloads. - CMA is decoupled from the CLI, offering an API for builders who bring their own context, tools, and execution environments. - Priyanka stresses that turning local tool loops into reliable cloud infrastructure required solving core distributed systems problems.

[17:14](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1034s) Deployment on AWS, Model Restrictions, and SaaS Multi-Tenancy

During the closing questions, attendees ask about running CMA across cloud providers and model families, as well as how to architect multi-tenant SaaS products on top of the platform. Gabe confirms that while CMA is not hosted directly on Amazon Bedrock, it is accessible via Claude Platform for AWS, providing a dedicated AWS console interface. Model selection remains strictly limited to Anthropic's Claude models. Addressing SaaS billing and usage, Priyanka points out that end users do not need individual Anthropic Console accounts; developers simply generate API keys within their free Console workspace and pay based on underlying token volume.

The discussion then turns to tenant isolation patterns. Gabe strongly advises against a "Bring Your Own Key" (BYOK) architecture, noting that delegating API keys to end users destroys the developer's centralized observability into agent performance and traces. Instead, Anthropic recommends leveraging workspaces as the foundational tenancy boundary. Priyanka outlines the trade-offs currently available to SaaS architects: teams can either route all customer agents through a single workspace with an application-level mapping layer, or provision a dedicated workspace per customer at the cost of having to duplicate agent definitions. Because granular Role-Based Access Control (RBAC) within workspaces is not yet supported, developers must enforce their own authorization and security layer on top of CMA endpoints.

| Multi-Tenancy Approach | Implementation Mechanism | Trade-Offs & Limitations | |:--- |:--- |:--- | | **Workspace-as-Tenant** | Dedicated workspace created per customer tenant | Clean isolation, but agents and tools must be recreated and maintained across workspaces | | **Shared Workspace + App-Layer Mapping** | Single workspace for all tenants; custom database maps agents to customer IDs | Simpler agent management, but lacks built-in data segregation; relies entirely on custom app security | | **Bring Your Own Key (BYOK)** | End users supply their own Anthropic API keys | Strongly discouraged by Anthropic; strips the developer of telemetry, tracing, and run observability |

- CMA is supported on Claude Platform for AWS, offering a cloud-native console experience distinct from Bedrock. - CMA exclusively supports Claude models; third-party or open-weight models cannot be slotted into the managed agent loop. - “We have seen that the best model for multi-tenancy is not bring your own key because you lose observability because it runs on your end users' API key rather than yours,” Gabe advises. - Workspaces currently enforce a flat permission model where all workspace members access all workspace resources, making application-level RBAC necessary until native fine-grained controls launch.

[20:09](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1209s) Infrastructure Scaling, Rate Limits, and Abstracted Kubernetes Pods

An attendee asks about multi-tenant scaling mechanics and whether developers need to configure infrastructure parameters like minimum pod counts, timeout limits, or Horizontal Pod Autoscaling (HPA) in Kubernetes when scaling agents across multiple tenants.

Priyanka Phatak and Gabe Cemaj explain that Managed Agents is architected entirely as a managed API abstraction, deliberately hiding cluster management and pod orchestration from the developer. Users do not configure replica sets or specify pod counts; instead, they simply spin up as many sessions as their application requires. While Anthropic applies standard API rate limits to customer accounts, there are no infrastructure-level scaling knobs or capacity planning parameters that a developer needs to tune to run thousands of concurrent agents.

As Priyanka succinctly puts it: “You don't need to because we're managing it all for you you're just making API calls that's all.”

- **Infrastructure Abstraction**: Eliminates the need to configure Kubernetes pod autoscalers (HPA), minimum replicas, or cluster nodes manually. - **Session Capacity**: Applications can trigger as many independent agent sessions as needed, bounded only by standard API rate limits rather than managed server instances.

[21:09](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1269s) Production Deployments, UI Integration, and End-Customer Scale

An attendee asks how to transition from local server prototypes to deploying client-facing applications at scale. Using a hypothetical astrology app as a concrete scenario, the attendee describes collecting sensitive birth data through an authentication layer, spinning up an ephemeral sub-agent for 90 seconds to compute a star chart interpretation and generate assets, and cleanly tearing down the session once the task finishes. They wonder how this pattern interacts with tools like Model Context Protocol (MCP) channels and how teams structure production architectures when distributing apps to real customers.

Gabe and Priyanka clarify that Claude Managed Agents is already operating in high-volume production environments, citing enterprise integrations like Notion’s external agents and Atlassian Jira automations. In production architectures, developers do not expose Claude’s underlying infrastructure directly to end users. Instead, teams build and authenticate their own custom frontend interface and backend service, which in turn calls Anthropic’s Managed Agents API to create sessions, dispatch tools, and manage agent lifecycles.

```mermaid flowchart LR accTitle: Client to Managed Agents Production Architecture accDescr: Flow diagram showing an end-user UI interacting with a custom backend before routing to Claude Managed Agents. subgraph ClientLayer["Client Facing"] UI["User Interface"] --> Auth["Auth & Input Filter"] end subgraph AppBackend["Developer Infrastructure"] Auth --> Backend["Application Backend API"] end subgraph AnthropicPlatform["Anthropic Cloud"] Backend -->|"REST API Calls"| CMA["Claude Managed Agents"] CMA --> Agent["Ephemeral Sub-Agent Session"] Agent --> Tools["Tools & Integrations"] end ```

- **Production Proof Points**: The service is actively leveraged at scale by major partner ecosystems, including Notion external agents and Atlassian Jira workflows. - **Architectural Boundary**: Developers maintain their own client application, user authentication, and data governance layers, delegating execution orchestration to Claude Managed Agents strictly via authenticated API calls.

[23:13](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1393s) New Model Support and Claude Sonnet Availability

An audience member asks about recent model announcements, referencing Anthropic's newly released Sonnet model and inquiring about its availability and capabilities within the platform.

The panel responds with brief enthusiasm and humor, confirming immediate compatibility within the platform. When asked what details they can share about the new release, Gabe prompts laughter from the room with a concise recommendation: “It's a great model.” The speakers emphasize that attendees do not have to wait for separate platform rollouts to experiment with Anthropic’s flagship frontier models: “It is supported in Claude Managed Agents. Go give it a try.”

[23:44](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1424s) Positioning Claude Cowork, Claude Code, and Managed Agents

An audience member asks about bridging non-technical business partners who currently use Claude Cowork or Claude Code for custom one-off solutions into Claude Managed Agents. While Managed Agents offers significantly greater power, the console and API interface can appear intimidating to folks who are not traditional software engineers.

Gabe explains that the Console Quickstart lowers this barrier by letting users prompt Claude in plain natural language to generate agent scaffolding. Furthermore, developers working inside Claude Code can use a dedicated Managed Agents skill that interactively guides them through authoring their first agent. Gabe draws a clear line between the products' target use cases: Claude Cowork is designed for personal productivity and individual desktop workflows, whereas Claude Managed Agents is engineered for enterprise-grade applications. When an attendee asks if there is an automated skill to migrate existing Cowork setups directly into Managed Agents, Gabe notes that Claude Code can inspect an existing Cowork workflow and translate it into Managed Agents API calls.

Regarding the target audience and deployment scope, Gabe emphasizes: “With this one, you're trying to build probably an agent that's like available to like your team, your internal organization, or you're building a product that you're shipping to your end customers.”

- **Claude Cowork vs. Managed Agents**: Cowork focuses on single-user, personal productivity tasks, while Managed Agents is built for multi-user organization-wide deployments, team automation, and commercial end-customer applications. - **Onboarding Avenues**: Non-technical builders can use natural language prompts in the Anthropic Console Quickstart, while technical users can leverage the Managed Agents skill in Claude Code to scaffold agents interactively. - **Workflow Translation**: Claude Code can consume existing Cowork instructions or logic and translate them into API configurations for Claude Managed Agents.

[25:18](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1518s) Enterprise On-Premises Requirements and Workshop Wrap-Up

A participant raises enterprise privacy and governance considerations, asking whether Anthropic plans to support on-premises or customer-hosted VPC deployments. Many large enterprises handle sensitive internal datasets that cannot traverse public boundaries, run dedicated secure proxies for model routing, or require dedicated internal compute clusters for strict scaling control.

Priyanka validates that private and on-premises hosting is one of the most frequent requests from enterprise partners. While Anthropic does not yet have an on-premises product ready to announce, the team is actively evaluating options to support these strict governance requirements. Priyanka confirms that customer feedback is directly shaping the roadmap: “It's definitely been a customer ask from a bunch of enterprise customers and we're seriously considering it at the moment, but we don't already have something that we can share with you, but we're seriously considering it.”

The session concludes with attendees asking to bring back the final slide containing the workshop QR code so they can clone the code repository and access the hands-on materials.

## Notable quotes > [17:14](https://www.youtube.com/watch?v=qJtcEDc_WJU&t=1034s) We have seen that the best model for multi-tenancy is not bring your own key because you lose observability because it runs on your end users' API key rather than yours. — Gabe Cemaj

## Mentioned Anthropic, Claude, Claude Managed Agents, Claude Code, Claude Cowork, Claude Sonnet, Claude Platform for AWS, Amazon Web Services (AWS), Amazon Bedrock, Gabe Cemaj, Priyanka Phatak, Google, Microsoft, NVIDIA, Notion, Atlassian Jira, GitHub, OpenTelemetry, Kubernetes, Model Context Protocol (MCP)

## Video description Agents on a schedule, fan-out across sessions, and a research preview that improves memory from past runs.

NEXT UP: AI ENGINEER CODE SUMMIT Join us in SF for the second annual AIE CODE Summit, Nov 10–12, our last flagship summit of 2026. Applications live now: https://aie.codes

Gabe Cemaj fans one request out into a session per company with a custom tool, sets up deployments that run an agent on a schedule, and demos Dreaming, a research preview that reviews 30 days of past sessions to improve a memory store. The Q&A covers observability, 10-hour sessions and compaction, workspaces for tenancy and access, skills vs multi-agent, how this relates to Claude Code, Claude Platform on AWS, scaling and on-prem.

This is part 3 of 4 of the Claude Managed Agents workshop from Anthropic.

In this video: • Multi-session fan-out with a custom tool • Deployments: agent plus schedule plus resources • Dreaming: improving memory from past sessions (research preview) • Workspaces as the tenancy and access boundary

SPEAKERS Priyanka Phatak, Member of Technical Staff, Anthropic (leads the Claude Managed Agents engineering team)

Gabe Cemaj, Member of Technical Staff, Anthropic GitHub: https://github.com/gcemaj

LINKS Claude Managed Agents docs: https://platform.claude.com/docs/en/managed-agents/overview Scaling Managed Agents: Decoupling the brain from the hands: https://www.anthropic.com/engineering/managed-agents

CHAPTERS 0:00 Multi-session orchestration demo 1:01 Deployments: scheduled sessions 2:54 Dreaming research preview 4:40 Q&A: telemetry and observability 5:59 Q&A: long-running agents and compaction 6:43 Q&A: orchestration topologies 7:46 Q&A: RBAC and workspaces 8:53 Q&A: deployments vs memory 9:38 Q&A: defining a harness, evals 11:17 Q&A: skills vs multi-agent 12:57 Q&A: dreaming and evals 15:07 Q&A: relation to Claude Code 17:14 Q&A: AWS, models, multi-tenancy 20:09 Q&A: scaling and rate limits 21:09 Q&A: shipping to customers at scale 23:13 Q&A: new model support 23:44 Q&A: Cowork vs managed agents 25:18 Q&A: on-prem for enterprises

Recorded at the AI Engineer World's Fair 2026 in San Francisco. Subscribe for more talks from the engineers building with AI.

AI Engineer: https://ai.engineer YouTube: https://www.youtube.com/@aiDotEngineer X: https://x.com/aiDotEngineer LinkedIn: https://www.linkedin.com/company/aidotengineer/

#Claude #AIAgents #AIEngineer

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

Reading summary

Anthropic's Claude Managed Agents (CMA) provides an API-first execution platform that runs autonomous, multi-session workflows while abstracting backend infrastructure and rigid orchestration constraints. Speaking at an AI Engineer event, Gabe Cemaj and Priyanka Phatak outline how the system pairs scheduled sessions and persistent memory with autonomous self-improvement features. Runtime Primitives and Orchestration Philosophy (0:01) Claude Managed Agents establishes the single execution session as its core primitive, handling context windows and tool-execution loops directly. In a live demonstration, Cemaj shows a top-level prompt triggering a custom tool (`dispatch_analysis`) that fans out tasks into parallel sessions for separate equity tickers, where sub-agents collaborate against predefined outcome targets. Anthropic automates context compaction on the backend, enabling continuous multi-hour sessions—including production runs lasting up to 10 hours—without developer maintenance. Deployments, Scheduled Runs, and Dreaming (1:06) To handle recurring operational routines, CMA uses deployments that combine an agent definition, cron-style schedules, seed messages, and external resources like GitHub repositories or persistent memory stores. Unlike hard-coded configurations, memory stores remain independent entities mounted to sessions across runs. Anthropic is also testing Dreaming, an asynchronous research preview where evaluator sub-agents inspect up to 30 days of execution transcripts. The process flags operational failures or skill gaps and modifies memory stores, with future plans to autonomously rewrite skills and system instructions. Evaluation Rubrics and Scaffolding Evolution (10:01) Cemaj and Phatak argue against rigid, visual graph builders or static routing rules, claiming that frontier models perform better when given broad delegation authority and fewer guardrails. While builders must still construct their own multi-agent topologies and run comprehensive evals across task suites, Cemaj observes that rigid scaffolding tends to dissolve as models become more capable. Phatak notes that CMA steers agent outcomes through explicit success rubrics and iteration caps, allowing automated verifier loops to prompt retries until criteria are satisfied. Enterprise Tenancy, Observability, and Cloud Scalability (4:40) CMA completely abstracts cluster orchestration, eliminating the need for developers to manage Kubernetes pods or Horizontal Pod Autoscaling. Observability is built-in with raw event-level timings accessible via REST and streaming APIs, allowing teams to route data to standard enterprise observability stacks without platform lock-in. For multi-tenant SaaS products, Cemaj explicitly warns against Bring-Your-Own-Key architectures because they break developer telemetry. Instead, the platform relies on Workspaces as administrative isolation boundaries while fine-grained Role-Based Access Control remains in development. While Claude Managed Agents already supports production enterprise workflows at companies like Notion and Atlassian, Anthropic limits the platform strictly to Claude models. Self-hosted VPC or on-premises deployments remain under active evaluation without a formal release timeline.

Source quotes

[17:14] Gabe Cemaj: We have seen that the best model for multi-tenancy is not bring your own key because you lose observability because it runs on your end users' API key rather than yours.

Original transcript

[0:01] [music] [0:12] Okay. So, yeah, let's let's see what [0:15] this looks like. Uh, analyze [0:18] uh Google and Microsoft. Um, so ideally [0:21] what would happen and I hope this works [0:23] live for y'all um is that uh this main [0:26] agent is going to um evaluate if it has [0:30] information and then it's going to give [0:32] us a custom tool where we're going to [0:34] then spin up individual sessions for [0:36] each of those financial artifacts. So [0:38] you'll see this dispatch analysis thing. [0:41] Um it's going to call it for two tickers [0:43] and then it's going to kick runs for [0:45] each of those. Um so this is how we can [0:47] orchestrate our multiseession. [0:50] um harness and each of those sessions [0:52] has multi- aent uh that are doing [0:54] collaborative work and each of those uh [0:56] also have outcome definition so that [0:58] there's self-supervision happening using [1:00] memory stores to learn from one another [1:03] um etc etc. Um so let's move on to the [1:06] finale which is um [1:09] what if you want to do recurring work? [1:11] What if you want to do uh you want to [1:13] have a list of companies you care about [1:14] and you want every day at 9:00 am or [1:17] first of the month to do the analysis [1:19] over all of these companies uh on a [1:22] schedule. So that's what deployments [1:23] are. Deployments is everything is API [1:25] based. So we you can obviously interact [1:27] with our platform via the console. Um [1:30] but their main way that we intend to you [1:32] for you to interact with it is via the [1:34] API and the SDK. So you can build uh [1:36] custom UIs and custom workflows. Um all [1:39] of these are just building blocks uh [1:41] that you can compose together to build [1:43] your application into something bigger. [1:45] Um so you can see here what cloud did is [1:48] it created a uh deployment um and that [1:52] is right here. A deployment is takes in [1:55] a agent definition. [1:58] Uh in this case it's this research uh [2:01] desk weekly memo using this specific [2:03] agent. um it takes in a schedule uh of [2:06] when it's going to run and it gives it [2:08] an initial set of messages that it's [2:09] going to run with. You can also pass in [2:12] uh resources like uh uh memory stores or [2:15] GitHub repos or files that it's going to [2:17] use on each of those. Uh and so what [2:20] this means is that every I think this is [2:23] first of the month at 1 p.m. or [2:24] something like that. It's going to run [2:27] um this uh specific session. I could run [2:30] one now. So I could trigger it via the [2:32] console. it's going to do that. Um, [2:36] but I could also build a UI for it and [2:38] that's what we've done here. Um, so I [2:40] can, you know, I have all the crowd. I [2:42] can list and and search uh for my [2:45] deployments and then I can also kick one [2:47] off um at any given point. And I don't [2:49] know why they're failing, but I'll ask [2:51] Cloud about it later. Um, and this has [2:54] come up a few times, which is what about [2:56] dreaming? What about self-improvement? [2:58] Um, so before I get to your questions, [3:00] which I'm sure there are many, uh, I'm [3:03] going to show you a preview that we've, [3:05] uh, have out for for dreaming. So what [3:07] dreaming is, it lets you select, um, so, [3:11] okay, before I show you a previous one, [3:13] it lets you select a memory store. In [3:15] this case, it we'll we'll use the memory [3:17] store that we've been using. You can [3:19] select a model. Um, you can give it [3:21] custom instructions if you want to, but [3:23] we'll use a default prompt. Um, and then [3:26] we're going to let it uh run uh the the [3:29] last 30 days of sessions through this [3:31] streaming analysis. So when I click [3:33] start streaming, what it's going to do [3:34] is it's gonna spin up a session using [3:37] manage agents actually um spin up many [3:40] sub agents to analyze the transcripts of [3:42] each of the other sessions that we told [3:44] it to evaluate at all of them which use [3:46] the memory store. Um and it's going to [3:48] analyze, hey, did the memory store [3:50] encode all the information that was [3:51] required? did a session uh run into any [3:54] issue that uh that caused problems? Can [3:57] we learn anything from it? Did this [3:58] happen multiple times? Can we update the [4:00] instructions in any way? You can see [4:02] here what it actually did is that it [4:04] found that the skill that we created [4:06] actually had a few gaps um on the way [4:09] that it was written and it updated the [4:11] memory store to tell it even though [4:13] there is this skill, you should extend [4:14] this knowledge with the fact that we've [4:16] learned from it. Uh and you can imagine [4:18] that we will continue to extend this to [4:20] not only improve memory stores but [4:22] improve skills directly uh agent [4:24] prompts, sub agent prompts, etc., etc. [4:28] Um that's that's it. That's the demo. I [4:31] sorry about the Wi-Fi. I hope you follow [4:33] uh later on when when you get home. Um [4:36] and let's uh keep going with some [4:37] questions. [4:38] >> Yeah, we can all take questions. [4:40] >> We have a question over here. [4:41] >> Yep. [4:42] >> Go ahead. [4:43] >> Uh thank you for the demo. Uh we didn't [4:45] see any uh telemetry uh instrumentation [4:48] in the agent. Is that a default native [4:50] feature? [4:51] >> What do you mean by telemetry? Because [4:52] you have the full observability of all [4:54] of the events uh that happened. Right? [4:56] If you go into the console, you can see [4:58] it live, but you can also obviously get [5:01] it from the API where this transcript [5:03] view is like a nice view, but if you go [5:04] to debug, it's every event that occurred [5:07] in that session. So you can see exactly, [5:09] for example, when did we start calling [5:11] the model? uh when did we finish calling [5:13] the model? So you can get latency [5:15] metrics in that. Is there something else [5:16] that you mean by telemetry? [5:18] >> Yeah. Uh the thing is that uh usually in [5:20] software development cycle you kind of [5:22] define what you want to observe. Uh how [5:24] did we kind of pick what did we want to [5:27] observe. [5:28] >> Uh right now you get all the events and [5:31] you just filter them on your end. If [5:33] there are things that you think are [5:34] missing, uh hit us up and we'll talk [5:36] about adding them. [5:37] >> Okay. And can I bring my own [5:39] observability stack in here? Uh you mean [5:42] like export to OTEL? [5:43] >> Yeah. [5:44] >> Uh you you could because it's an API you [5:47] could build that connector fairly [5:48] easily. Uh we just everybody has [5:51] different requirements and we don't want [5:52] to be opinionated but everything is just [5:55] API calls. [5:56] >> Mhm. Thank you. [5:58] >> We have a question. [5:58] >> Uh I I had a question. So how long can [6:01] these agents run? I I I know you [6:04] mentioned this dreaming thing but can [6:06] you run them indefinitely or do you see [6:08] that persistent store keep increasing in [6:10] size and at some point you need to [6:12] recompact it offline or something? [6:15] >> We we are running compaction for you so [6:17] that you can run these for days. We've [6:19] seen 10-hour sessions in production uh [6:22] from some of our users. [6:23] >> So you could run these agents like for a [6:26] year or indefinitely in theory. [6:27] >> Yeah. Are you talking about running the [6:29] agent for a year or you talking about [6:30] like one specific session that keeps [6:32] going for [6:33] >> No, basically the agent if I had to if I [6:36] had a task that I need to do every day, [6:37] can I just keep it running for 6 months? [6:39] Will it not blow its uh persistence? [6:42] >> That's right. [6:42] >> Yeah. [6:43] >> And is there any orchestration piece [6:46] like where I could have three agents, [6:48] agent A does something and delegates to [6:50] B and C. That's some capability that you [6:53] have or [6:54] >> for for now you would spin you would do [6:56] sub agents and you would tell claude [6:57] what you want. We find that uh there's a [7:01] desire as humans to constrain what [7:03] claude does and the way it does it. As [7:05] cloud gets smarter we have continuously [7:08] remove those guard rails and let claude [7:10] just let it cook uh let it do what it [7:12] thinks it's best. So uh right now you [7:14] think maybe three sub aents is the best [7:17] topology for it. But if we just let [7:19] Claude figure that out, it actually ends [7:21] up outperforming. [7:23] >> But any topological or like graph based [7:25] workflow thing in the UI here like where [7:28] I could have [7:30] >> Not yet. Not yet. Not yet. But but maybe [7:32] soon. [7:34] >> Uh [7:36] >> you can probably just like speak up. [7:38] Yeah. Sorry. Sorry. We'll come back to [7:40] you. [7:41] >> Sorry about that. [7:42] >> Hey over here on your right. [7:45] >> On my right. Okay. Yeah. So question. [7:47] Um, looks great. A lot of integration [7:50] points. What I'm curious about, uh, for, [7:52] you know, an organ, a a complex [7:54] organization that potentially manages [7:56] multiple agents, um, you know, I I I [8:00] think they want some sort of separation, [8:03] arbback, whatever else. Um, how is that [8:05] what is what is I guess the recommended [8:07] approach for uh, a complex organization [8:10] that has those different agents in here [8:13] to effectively manage? We we have [8:16] workspaces that's our primitive today [8:18] where you can put different customers in [8:21] different workspaces and then uh segment [8:24] them that way and give access to [8:25] specific users into those workspaces. Uh [8:29] but we know that there's still a gap in [8:31] what we offer and um that's that's [8:34] something [8:36] >> our back is on our road map. So we we do [8:38] want to provide more like granular [8:39] controls but right now workspace is like [8:41] a clean way of like separating your [8:43] agents where you have like a group of [8:45] people access to workspace A and they [8:46] can access all agents within that. You [8:48] can have workspace B with like different [8:50] set of users that can have different [8:51] levels of access. [8:54] >> So hi excellent presentation really [8:56] excited. Uh two questions. One is [8:58] deployment. My understanding was that a [9:00] deployment is like at a snapshot a [9:03] moment in time of all the agents. [9:06] >> No [9:07] >> deployment is essentially a way for you [9:09] to run sessions for a specific agent on [9:11] a schedule. So you can say like oh [9:13] research desk agent go research NVIDIA [9:16] once every quarter and it'll just create [9:18] a session every quarter to go research [9:21] and produce you that report. And then [9:22] memory which is a state is persisted [9:25] across all sessions. [9:27] >> That's right. [9:27] >> You attach your memory store to the [9:29] session. So you decide which which [9:31] session you want to attach which memory [9:33] store too. So the memory store is like a [9:35] independent entity that you just attach [9:37] whenever you need to [9:38] >> right and the final question is [9:41] harnesses right one what is harnesses [9:44] for you because everyone have their own [9:46] definition [9:47] >> and second is the confident right. So [9:49] when I change something here, how do I [9:52] know that it's not [9:54] >> it's working as expected? Right? My own [9:56] confident as a developer. [9:58] >> Um for you're right, everybody has a [10:01] different definition of a harness. Uh we [10:04] when we talk about a harness in CMA, we [10:07] mainly mean the tool loop execution. So [10:09] managing the context and managing the [10:11] session state and making sure that the [10:14] agent can do the work that it wants to [10:15] do. When most builders talk about [10:18] harnesses, they they really mean, you [10:20] know, they really mean um the ability to [10:22] coordinate multiple agents and sessions [10:25] together as a unit of work to achieve [10:27] some sort of bigger task in a topology [10:29] of sorts. Um we're giving you the [10:32] abstraction of a single session as a [10:34] unit of work for you to go out and build [10:36] your harness uh with it as the session [10:39] being one of the primitives. [10:41] >> Um [10:41] >> and then your second question about how [10:43] do how do I know how my agent is [10:44] performing? Our best recommendation [10:46] would be to run evals on your agent with [10:48] like different types of tasks that you [10:49] want the agent to perform and see how [10:52] the agent does on those tasks. Um [10:54] outcomes is a really good way where we [10:56] steer the agent for you to get you the [10:58] specific outcome where you can define an [11:00] exact rubric for like hey this is the [11:02] exact outcome I want and you can define [11:05] max iterations and the agent will keep [11:06] going into it until it gets you that [11:08] outcome. [11:10] >> Yeah, the the the verifier agent that [11:12] that Gabe talked about. [11:14] >> Hi So [11:16] >> after. [11:17] >> Cool. Hey, thanks for the demo. I [11:19] enjoyed it. Um my my question at the [11:22] core is a bit about how to choose [11:24] between skills and agents and I wanted [11:26] to ask how would you all say what's like [11:29] the fundamental difference? Is there an [11:31] advantage to the harnessing that [11:32] surrounds an agent that makes it produce [11:34] better results than a scale? Um, and one [11:37] of the reasons I'm asking is because I'm [11:39] afraid of always investing in new kind [11:42] of like I guess harnessing and tooling [11:44] around models and it's it can be kind of [11:47] tiring always trying to do a new thing. [11:49] Um, so yeah, I just want to hear what [11:50] you think is like is there a big [11:52] difference and is it going to change any [11:54] time? [11:54] >> I [11:56] yes, no. Um, the qu thick hardness, thin [12:00] harness, thick skills um is is a [12:03] question that's constantly evolving. I [12:05] think what we find is that as Claude [12:06] gets smarter, the boundaries and and and [12:10] help that we want to give Claude start [12:12] to melt away and disappear. And so what [12:15] you need today might not be what you [12:17] need tomorrow. The boring answer is just [12:19] run evals and and evaluate these things. [12:22] That sounds exhausting obviously like [12:24] yeah [12:24] >> every time a new model comes out I need [12:26] to evaluate all these things. Um what [12:28] what we find is skills is a good [12:30] abstraction today. uh it gives the model [12:32] enough [12:34] >> information to do what it needs to do. [12:35] But I presume that it will start to [12:37] shift and melt and become thinner and [12:39] thinner where the model will just be [12:41] able to do things on its own without any [12:43] special requests and instructions uh [12:46] down the line. So uh multi-agent seems [12:49] to be more useful uh in my opinion, but [12:52] your your mileage may vary on your task. [12:57] >> Hi. [12:57] >> Hey. Hi. So my question ties up to last [13:00] two questions and especially on top of [13:02] evals. [13:03] One thing I'm excited about is dreaming [13:05] but how will dreaming actually affect [13:08] the final outcome [13:09] >> something that's where eval comes into [13:11] the picture but you can have multiple [13:13] iterations of dreaming sel that can go [13:15] in different directions. So is there a [13:18] plan or do you already support some [13:20] automated kind of dreaming with run with [13:23] evals and see that hey how to different [13:25] direction go into which one should we [13:27] pick based upon what's going on. [13:30] >> Yeah. So so dreaming what it does is it [13:32] looks over you you can choose the [13:34] duration for which you want the agent to [13:36] dream over. So you can say I want to [13:38] dream over this agent session over the [13:40] last 30 days and then look at all the [13:43] transcripts and analyze what task you're [13:45] trying to achieve and then come up with [13:46] like a new memory store that's more [13:48] geared towards like what you were trying [13:49] to do and we typically will run evals on [13:53] our end to make sure that dreaming is [13:54] providing you with better outcomes and [13:56] we've seen customers were able to get be [13:59] get a significant improvement on their [14:01] evals by running Dreaming and then using [14:03] the new memory server but again [14:05] everything kind of ties back to eval. So [14:07] like that that's how you would know [14:08] whether something is performing [14:10] >> as you expect it. [14:20] >> Yeah, I think it'd be good to have your [14:21] own set of evals. Um [14:23] >> the other thing is dreaming is in [14:25] research preview. So these are early [14:27] early. It's like a big experimental [14:29] thing. We've seen uplift uh on it [14:31] generally. This is we we hear you right [14:34] like uh how do I gain the confidence [14:36] that this is [14:36] >> yeah it's like eval connected to [14:38] dreaming and then we can find out [14:40] multiple pathways that that has been [14:42] taken and decide oh this makes more [14:44] sense because even though nine sessions [14:47] may have been saying that hey this is [14:50] wrong [14:50] >> one says that hey this is good so if you [14:53] just rely on that session dreaming thing [14:55] I feel like we may not be grabbing all [14:57] insights without evalu [14:59] >> if I tell you just to trust me is that [15:00] no [laughter] [15:03] Thank you. [15:06] >> Yeah. [15:07] >> Hi. Uh thank you very much. Um this is [15:09] very impressive. Uh those of us who have [15:11] been working with cloud code for a year [15:13] or more um have been doing things that [15:16] are similar to this but this was nice to [15:18] see this in a really mature form. Um, [15:21] one question I have is how much of this [15:24] was just built on top of cloud code? [15:27] That is if somebody was, you know, [15:29] ambitious, could they could they build [15:31] something similar to this? And um, what [15:34] I wanted to ask you was uh, encourage [15:36] you to keep things open. uh some of us [15:39] are already harvesting what's in the [15:41] JSON session files uh and starting to [15:43] experiment with things like uh hepo and [15:46] that kind of thing for for managing the [15:49] um the memories and um and creating a [15:52] memory pool. So uh congratulations. [15:55] Thank you. Please keep it open and um [15:58] can we is there are you doing anything [16:01] here that's not just built on site on [16:03] top of cloud code? Thank you. [16:06] We we took the cloud code harness as an [16:07] inspiration. We found that it was very [16:10] well attuned for coding tasks. Um and [16:13] different it's different levels of [16:15] flexibility for other tasks. We're [16:17] building an API where we want you to [16:19] bring your context, your information, [16:21] your capabilities and build on top of it [16:23] where cloud code is trying to give you a [16:26] a product out of the box. So we have [16:28] slightly different uh you know value uh [16:32] props um and so it's not just clocked [16:35] out in a box uh though [16:38] you know ideally it performs as well if [16:42] not better and all sorts of tasks. Um so [16:45] not not exactly but it's definitely [16:46] inspired and motivated by by some of the [16:49] uplifts that we have seen from cloud [16:50] code [16:51] >> and and cloud code is a terminal tool [16:54] and we obviously want to be an API [16:57] product that and infrastructure uh that [17:00] is going to scale that's going to be [17:01] reliable. So there there there were like [17:03] challenges that I talked to you about um [17:05] in the beginning of the presentation [17:06] that we really worked in to make sure [17:08] we're providing a really solid um [17:10] product for you all to use. [17:14] Yeah. Um, so for a bedrock, is there a [17:18] console like clawed console like you [17:20] have here? That's quite straightforward [17:22] question, but yeah, I just want to [17:23] manage and see everything. [17:24] >> This is not available on bedrock, but it [17:26] is available via cloud platform for AWS. [17:29] So there is a AWS version of console [17:32] that you could go use this with. [17:36] >> Yep. [17:37] >> Yeah. Uh first uh uh is there any uh how [17:41] you say is there any restriction on the [17:43] model to be used like uh non-anthropic [17:45] models [17:47] >> uh [17:47] >> just like cloud code I can run on [17:49] nonanthropic models [17:51] >> for for now we we you [17:52] >> yeah it's cloud models only for now [17:54] >> okay so so the second question is what [17:57] about end user use uh do they have to [17:59] have a console accounts in order to use [18:01] it or just a free uh I can create a [18:04] customized UI for this and they can use [18:06] it [18:07] >> so cloud Cloud Console helps you with [18:08] creating your API key. [18:11] >> So that's how you get access to our [18:12] APIs. So you cloud you're not paying [18:14] separately for cloud console. It's free [18:16] to sign up. You create an API key and [18:18] then you're paying based on like token [18:20] usage. So for for for the case like uh [18:23] SAS like uh maybe we have multiple [18:26] tenants right. So in order to provide [18:28] this uh agent what kind of a uh how you [18:31] say model you have already uh depict on [18:35] so that we can follow for example what [18:37] kind of a each company are supposed [18:38] tenant are supposed to have a uh a [18:41] different space or or even there is a a [18:45] sub module for this uh each tenant. So [18:48] are are we going to how do we actually [18:50] going to organize that? In terms of this [18:52] >> we we we have seen that the best model [18:54] for multi-tenency is not bring your own [18:56] key because you lose observability [18:58] because it runs on your end users API [19:01] key rather than than yours. So we [19:03] encourage you to model things with [19:05] workspaces as a tenency primitive. Um [19:08] and we're improving that so that it's [19:10] easier and easier to build uh on top of [19:13] this for multi-tenant applications like [19:15] >> yeah so I think currently you could [19:17] either have put all your customers data [19:19] into like a single workspace and then [19:20] you maintain a mapping on your end on [19:23] like which agent maps to which of your [19:25] customers. Alternatively like Gabe said [19:27] you could create a workspace per [19:29] customer of yours but that can get more [19:31] complicated because then you have to [19:33] like recreate your agent. So, so is any [19:35] you see the examples that uh people did [19:38] the additional security layer or RBAC [19:41] layer over the this workspace because to [19:43] me it may be a little bit you know [19:45] >> yeah that that would probably be like a [19:47] good good way to do it right now because [19:50] we don't have any arvback [19:52] >> uh controls uh on our level other than [19:54] like workspace because everything within [19:56] your workspace is accessible to everyone [19:58] in the workspace but we are working on [20:00] making our back better and then making [20:02] the experience better if you're working [20:04] with cloud manage agents but building on [20:05] behalf of your customers and how do we [20:07] make that easy something [20:09] >> so so is there any way you can show how [20:11] to scale this uh if there's a multiple [20:14] uh how you say tenant working on that [20:16] >> yes [20:17] >> any scaling parameters like uh what is [20:19] the how you say the the minimal uh pod [20:22] or whatever these parameters that's was [20:25] yeah [20:26] >> uh I mean you're you're defining on a [20:28] you can create as many sessions as you [20:30] want yeah like there's no limitation I [20:32] mean we have some rate limits obviously [20:34] but um but there's no scaling parameter [20:37] for you to say now I need to run 10,000 [20:39] pods [20:40] >> so so currently no no such thing as like [20:42] uh like HPA in the Kubernetes like you [20:45] can do these kind of setting scaling uh [20:47] parameters right like timeout or [20:49] whatever [20:50] >> you you don't need that [20:51] >> you don't need to because we're managing [20:52] it all for you you're just making API [20:54] calls that's all [20:55] >> okay okay sure uh thanks for your uh [20:58] answer the last uh by the way I the [21:01] offering link does not work for me I'm [21:02] not sure if it's the only one. [21:05] >> Yeah. Thank you for the sharing. [21:06] >> Thank you. Thank you. [21:08] >> Yeah. Go ahead. [21:09] >> Hi. First, thank you very much. I've [21:12] been having a ball with everything that [21:13] you've been releasing and um I'm really [21:16] interested in how you're using UI. Um [21:19] you're spinning up a server, you're [21:20] distributing this, but how might we [21:22] deploy that either internally, but I'm [21:25] interested in to sort of a customer [21:28] base. If I want to make for example an [21:32] astrologer [21:33] >> um that person has to enter sensitive [21:36] data. So it's actually really nice for [21:37] me to be able to like have that in a [21:39] >> have a layer. Yeah. [21:40] >> So there are some procedural things you [21:42] get like a star chart example. I'm not [21:44] building this but it's a good example [21:47] like I can have a sub agent do an [21:49] interpretation that could last for like [21:52] 90 seconds. It could create some assets [21:54] etc. When the outcome is met it could [21:56] shut down. So this gives me a way to [21:58] actually just make a really clean [22:00] implementation where all I need is off [22:03] >> and then everything can spin up from [22:05] there. [22:05] >> Yeah, exactly. [22:06] >> So there are a couple of things like MCP [22:08] channels that kind of point to this with [22:10] like fake chat for example, a way for [22:13] you to kind of just use claude and have [22:16] a channel to communicate with it through [22:18] UI. But I'm seeing a lot where you're [22:21] just spinning up a server inside a [22:23] project that's easy to distribute [22:25] internally. But how can you deploy that [22:26] at scale? [22:28] >> Um I mean we've this is uh being [22:31] deployed today at scale in production. [22:33] For example, notion external agents are [22:35] built on top of this. So this is [22:37] something that exists today that you can [22:39] go and use and uh basically leverage [22:42] cloud managed agents through notion in [22:44] Atlassian for Jira integrations for [22:46] example. Uh there's definitely ways to [22:48] do it. I think if you have specific [22:50] questions we could talk uh [22:51] >> yeah we we can talk after this but [22:53] typically you would probably build your [22:55] product your UI that you're distributing [22:56] to your customers and then calling into [22:59] us for like your actual agent [23:01] >> the phrase [23:02] >> management everything is through the API [23:04] >> everything that's right [23:06] >> so you will manage all the API calls and [23:07] build your product and UI around that [23:10] yeah [23:12] >> hi [23:13] >> hi hi first thanks for a great workshop [23:15] and demo and uh my question is Not [23:18] really to like the agent itself. It's [23:20] just like I saw the Android just [23:23] released the sunet five. Yes. [23:24] >> So I just was wondering if any anything [23:28] you guys could share with us. Yeah. [23:31] >> It's a great model. [23:32] >> Yeah. [laughter] [23:34] >> Try it. [23:37] >> It is supported in cloud manage agents. [23:40] Go give it a try. [23:41] >> You can use it today and see. [23:43] >> Hey there. Um hi if we've got uh [23:45] business partners that are using like [23:47] cloud co-work today some of them more [23:49] techsavvy cloud code to build some like [23:51] spot solutions for specific business [23:52] cases. [23:53] >> What do you see as sort of the level of [23:55] sophistication up level to start using [23:58] man like managed agents instead because [24:00] this seems like more powerful [24:02] >> but the you know cloud platform could be [24:03] intimidating to folks that aren't [24:05] engineers let's say. Yeah, I think the [24:07] console quick start is probably like the [24:10] part of my demo where you're literally [24:11] just like telling Claude the agent that [24:13] you're trying to build should make that [24:15] pretty easy for even non-technical users [24:18] to come in and build their first agent. [24:20] But obviously this is an API product and [24:22] is naturally going to be a little bit [24:24] more intimidating. But if they're [24:25] comfortable with cloud code, we do have [24:27] a manage agent skill with cloud code [24:29] that basically just like in natural [24:31] language will walk you through building [24:33] your first agent. And that would [24:34] probably be my advice uh to try it out. [24:37] I think the biggest difference is [24:39] co-work building building personal [24:40] agent. With this one, you're trying to [24:41] build probably an agent that's like [24:43] available to like your team, your [24:45] internal organization, or you're [24:46] building a product that you're shipping [24:48] to your end customers. But if you're [24:49] building personal agents, co-work is [24:51] still a really great tool to continue [24:53] doing that. [24:54] >> Are there any skills to kind of like [24:55] take something that exists in co-work? [25:01] there's a skill to interact with our [25:03] API. So that cloud is probably good [25:06] enough. So if you say here's what I did [25:08] in co and here's the skill to call the [25:10] API make the translation I feel pretty [25:13] confident. Yeah five we'll we'll do it [25:15] for you. [25:17] >> Um my question is about enterprise. uh [25:20] there are c lot of enterprises who'd [25:22] like to run these things inhouse because [25:25] they have sensitive data sets that they [25:27] won't want going out also they may have [25:30] already set up their own secure proxies [25:32] to anthropics models um GIS and also the [25:35] other question was about scaling so [25:37] within the enterprise now you can [25:38] actually allocate compute to scale it [25:40] our own way right uh so an on-prem kind [25:43] of solution have you all thought about [25:46] it [25:47] >> uh definitely been a customer ask from a [25:49] bunch of for enterprise customers and [25:50] and we're seriously thinking considering [25:53] it at the moment, but we we don't [25:54] already have something that we can we [25:56] can share with you, but we're we're [25:58] we're seriously considering it. [26:01] >> Excuse me. Could you show the last slide [26:04] that show the QR code of the workshop? [26:08] >> Uh are you looking for the repo or the [26:10] credits? [26:11] >> The repo. Okay. Yeah.