AI Engineer World's Fair 2026

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

Loading slides…

Read the talk

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

A company-research demo connects session fan-out, scheduled work and memory improvement. The Q&A then tests the practical boundaries: evaluation, observability, tenancy, scaling and where the application developer still has work to do.

From a talk by Gabe Cemaj and Priyanka Phatak

At a glance

Ideas worth remembering

  • A custom tool can fan one request into multiple sessions, while each session contains its own multi-agent collaboration and outcome definitions.

  • A deployment schedules new sessions using an agent definition, initial messages and resources. Memory remains an independent store attached to selected sessions.

  • Dreaming reviews past session transcripts to improve memory. Its proposed lessons still need task-level evaluations, especially when past experiences disagree.

  • Workspace membership grants broad access within that workspace. Multi-tenant applications must account for the absence of granular platform RBAC in the version discussed.

  • Managed Agents handles session infrastructure behind API calls, subject to rate limits. Developers still build the customer product, and on-premises operation was only under consideration.

One research request becomes a session per company

“Analyze Google and Microsoft” is the opening request in this part of Anthropic’s Claude Managed Agents workshop, presented by Gabe Cemaj with Priyanka Phatak joining the Q&A. The intended execution begins with a main agent checking whether it has enough information. A custom batch-analysis tool then takes the two tickers and starts an individual research session for each company.

There are two levels of coordination here. The application’s custom tool distributes work across sessions; inside each session, multiple agents collaborate on that company’s research. Outcome definitions provide self-supervision, while memory stores carry knowledge the agents can learn from. A session is therefore a substantial unit of work, capable of containing its own collaboration, rather than simply one model response.

Where does the request split, and where does collaboration happen? The diagram separates the application’s session fan-out from the multi-agent work inside each branch. Google and Microsoft are sibling jobs; neither company’s analysis is described as waiting for the other.

Session fan-out contains another level of agent collaboration

Main agentReceives the Google-and-Microsoft request and checks whether it has the information needed.
Custom batch-analysis toolAccepts two tickers and starts a run for each.
Google research sessioncompany-sessions — Contains collaborating agents, outcome definitions and memory use.
Microsoft research sessioncompany-sessions — Contains collaborating agents, outcome definitions and memory use.
The custom tool starts separate company sessions. Each session contains collaborative multi-agent work and outcome definitions.
Read the diagram as text
  • Main agent. Receives the Google-and-Microsoft request and checks whether it has the information needed.
  • Custom batch-analysis tool. Accepts two tickers and starts a run for each.
  • Google research session. company-sessions — Contains collaborating agents, outcome definitions and memory use.
  • Microsoft research session. company-sessions — Contains collaborating agents, outcome definitions and memory use.
  • Main agent → Custom batch-analysis tool: Calls with two tickers.
  • Custom batch-analysis tool → Google research session: Starts a company run.
  • Custom batch-analysis tool → Microsoft research session: Starts a company run.
0:120:42

Deployments turn research into recurring work

The next requirement changes when work begins: keep a list of companies and research them every day at 9 AM, or on the first of each month. A deployment supplies that recurring trigger. Managed Agents exposes these building blocks through its API and SDK, allowing an application to provide its own interface and workflows instead of depending on the console.

What must a scheduled run know before it starts? The demonstrated deployment combines several inputs:

  • Agent definition: which agent should perform the work, illustrated by a research-desk memo agent.
  • Schedule: when to create the run.
  • Initial messages: the instructions the new session begins with.
  • Resources: memory stores, GitHub repositories or files that the session should use.

These inputs explain how recurring research can reuse the same agent and supporting material while starting a fresh piece of work at each scheduled time.

A deployment can also be triggered manually. The demo moves between the console and a custom interface that can list, search and launch deployments, showing that scheduling and an on-demand “run now” action can coexist. The attempted runs fail during the demonstration; Cemaj leaves their cause unresolved. The visible failure therefore limits what this live attempt establishes about successful execution, while the configuration and intended API behavior remain clear.

1:121:42

Dreaming looks across past sessions for missing knowledge

Dreaming, introduced as a research preview, moves from repeating work to learning from previous runs. Its inputs are a memory store, a selected model, optional custom instructions and a time window. The demo uses the default prompt and the last 30 days of sessions. Starting Dreaming creates a Managed Agents session that launches sub-agents to examine transcripts from the selected sessions that used that memory store.

The analysis asks whether memory contained the information each task needed, whether sessions encountered problems, whether those problems repeated and whether instructions should change. In the previous result shown during the demo, Dreaming found gaps in a skill’s written guidance and updated the memory store with supplementary knowledge. The correction went into memory: future work could retain the existing skill while also receiving lessons from its use. The recording does not specify the missing instructions themselves, so it supports this correction mechanism without establishing a particular domain fix.

Directly improving skills, agent prompts and sub-agent prompts is described as a possible extension. The demonstrated capability is narrower: review prior sessions and improve the knowledge available through a memory store. That distinction matters when deciding what an application must evaluate after Dreaming runs—memory can change even when the skill file stays the same.

2:423:12

Observability begins with session events

The first audience question asks where telemetry instrumentation lives. Managed Agents exposes session events in both the console and API. The transcript provides a readable account of the interaction; the debug view exposes individual events, including when a model call starts and finishes. Those timestamps let a developer inspect model-call latency rather than infer it from the final response.

Selecting what to observe remains application work. At this point in the product, developers receive the event stream and filter it themselves. For an existing observability stack, Cemaj suggests building a connector from the API, including for OpenTelemetry export. That answer describes an integration path, rather than a demonstrated built-in exporter: the platform supplies events, and the application decides how to select and forward them.

4:434:51

Long-running work and model-chosen delegation

Managed compaction supports sessions that continue beyond a short interaction. Cemaj reports production sessions lasting 10 hours and says the service handles compaction so agents can run for days. The audience then sharpens the question: does “running for six months” mean one continuous session, or an agent performing a task every day? The presenters affirm the recurring-task case. The concrete production observation is a 10-hour session; this exchange does not demonstrate a single session running indefinitely or explain persistent-storage growth limits.

For delegation—Agent A assigning work to B and C—the recommended approach is to describe the desired work to Claude and use sub-agents. Cemaj’s preference is to remove prescribed topology as models improve: “let it cook.” He reports better results from allowing Claude to choose how to organize work, but gives no task or measurement for that comparison here. A graphical workflow editor for specifying agent topology is explicitly unavailable at the time of the workshop.

5:586:15

Workspaces separate access; memory attaches to sessions

For organizations managing multiple agents, the available access primitive is the workspace. Different customers or groups can occupy different workspaces, with selected users admitted to each. Access within a workspace is broad: its members can access its agents. More granular role-based access control is on the roadmap, so a workspace should not be mistaken for per-agent permission controls.

The next question corrects a different mental model: a deployment is not presented as a point-in-time snapshot of all agents. It runs sessions for a specified agent on a schedule. The example is a research-desk agent producing an Nvidia report once each quarter; each quarter creates another session. Memory is an independent resource that the developer chooses to attach to a session. Reusing a memory store can carry knowledge across runs, but that sharing comes from the attachment decision rather than from every session automatically sharing one global state.

7:468:15

The managed harness runs the session; evals test the design

“Harness” carries two meanings in the discussion. Within Claude Managed Agents, it primarily means executing the tool loop, managing context and maintaining session state so the agent can work. Application builders often use the same word for coordinating multiple agents and sessions toward a larger task. Managed Agents supplies the session as a primitive from which that larger orchestration can be built—the opening company-research fan-out is one example.

Confidence after a change comes from evaluations on the kinds of tasks the agent is supposed to perform. Outcomes serves a related execution-time purpose: the developer defines the desired result through a rubric and sets a maximum number of iterations; the agent keeps working toward that result within the configured limit. The presenters connect this to the Verifier agent discussed earlier in the workshop. A rubric can steer an individual run, while a set of representative tasks tests how the overall agent behaves.

Choosing between skills and more elaborate agent machinery brings an uncomfortable cost into view: a new model may change which scaffolding helps. Cemaj calls skills a useful abstraction for supplying information today, while predicting that some instructions will become unnecessary as models improve. He considers multi-agent work promising, but makes that judgment task-dependent. The practical answer is to compare designs with evals—and he acknowledges that repeating those comparisons for new models sounds exhausting. There is no stable, universal rule offered here for how thick a harness should be.

9:5810:28

Repeated experience still needs an independent quality test

The audience returns to Dreaming with a harder question: if repeated analyses produce different memory updates, how should the system choose among them? Reviewing a month of transcripts can discover patterns, but a frequent pattern is not automatically the right lesson. The questioner makes that concern concrete: nine sessions might call something wrong while one identifies a useful exception. A memory update based only on the dominant experience could discard that insight.

The presenters describe using evaluations internally and report customers improving their eval results after Dreaming generates a better-suited memory store. They also recommend maintaining an application’s own evals. No benchmark, numerical gain or automated system for selecting among competing Dreaming branches is established in this exchange. Dreaming remains an early research preview: its transcript analysis proposes useful knowledge, while task-level evaluation is how developers gain confidence that the revised memory actually helps.

12:5713:09

An API product brings different integration and tenancy choices

Claude Code’s harness inspired Managed Agents, particularly its effectiveness on coding tasks. The intended product differs: Claude Code supplies a ready-to-use terminal tool, while Managed Agents lets developers bring context, information and capabilities into an API-based application. The engineering goal includes operating reliable infrastructure at scale. Inspiration from Claude Code does not establish that the service is simply the same tool hosted behind an endpoint.

Two integration constraints are stated for the workshop’s version of the service. Managed Agents is available through Claude Platform for AWS, rather than Bedrock, and it supports Claude models only. The console provides API-key creation; the answer describes usage-based token billing rather than a separate console charge, without presenting a complete pricing breakdown.

For a multi-tenant SaaS product, the presenters prefer workspaces over having every customer bring an API key. Their stated reason is observability: activity under an end user’s key is harder for the application operator to observe. Two workspace arrangements have different costs:

  • One shared workspace: keep customer data together and maintain an application-side mapping between customers and agents. The application must enforce the distinctions it needs within that shared workspace.
  • One workspace per customer: separate customers through the platform’s workspace primitive, at the cost of recreating agent definitions across workspaces.

This is an authorization decision as much as an organizational one. The presenters explicitly say that everything within a workspace is accessible to everyone in that workspace, and endorse adding an application security or RBAC layer where needed. More granular platform controls are planned; they are not part of the demonstrated tenancy mechanism.

15:0716:06

Scale sessions through the API, and build the customer experience around them

Scaling does not require choosing pod counts or configuring a Kubernetes Horizontal Pod Autoscaler. Developers create sessions through API calls, and Anthropic manages the underlying capacity. Rate limits still apply. The useful distinction is between requesting more units of agent work and provisioning the compute that runs them; the service takes responsibility for the latter, without promising unlimited request throughput.

A customer-facing example makes the remaining application work tangible. An audience member imagines an astrology service: a customer supplies sensitive information, a sub-agent interprets a star chart for roughly 90 seconds, creates assets and stops when the outcome is met. This is a proposed use case, not a demonstrated application or measured runtime. Its architectural question is how to turn a locally running interface into something customers can use.

The answer puts the product interface in the developer’s application and agent creation and management behind API calls to Managed Agents. Cemaj cites Notion external agents and Atlassian Jira integrations as production uses. Authentication, the customer interface and the application’s handling of sensitive inputs still need their own design; the exchange does not establish that a managed execution environment alone supplies customer-level data isolation. “Everything’s through the API” explains how the product connects to the service, rather than eliminating the product layer.

A brief model-release question receives a narrower answer: the newly discussed model is supported in Managed Agents and available to try. No additional mechanism or evaluation result accompanies that compatibility confirmation.

20:0920:16

From personal automation to shared agents—and the on-prem limit

When should someone move from Cowork or Claude Code to Managed Agents? The distinction offered is who will use the result. Cowork remains a suitable tool for personal agents. Managed Agents is aimed at agents shared with a team, used across an organization or embedded in a product shipped to customers. That transition introduces an API product and its integration work, even if the agent’s task began as a small personal automation.

The suggested entry points are the console quick start, where a user describes the agent to build, and a Managed Agents skill for Claude Code that guides setup in natural language. For an existing Cowork workflow, Cemaj suggests supplying both a description of that workflow and the API skill, then asking Claude to translate it. This is a proposed assisted migration approach; no automatic conversion is demonstrated in the recording.

The final substantive question exposes a deployment limit that managed scaling does not solve. Enterprises may need sensitive datasets to remain in-house, already route model traffic through secure proxies or want to allocate their own compute. The presenters say on-premises operation has been requested by several enterprise customers and is under serious consideration, but they have no offering to share. For those requirements, the workshop ends with an open product question rather than an available deployment path.

23:4423:53

Resources

Transcript download
Full transcript

Loading transcript…