AI Engineer World's Fair 2026
Scheduled Agents, Dreaming and Q&A: Claude Managed Agents (Part 3 of 4) — Anthropic
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
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
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.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Related talks
- Beating RL With Reflection: GEPA and Optimize Anything
Develops the evaluation question raised by Dreaming: how execution traces can guide text changes, and how retaining competing candidates can preserve useful alternatives.
Read the complete timestamped transcript
- 0:12
Okay, so yeah, let's, let's see what this looks like. Uh, analyze, uh, Google and Microsoft. Um, so ideally what would happen, and I hope this works live for y'all, um, is that, uh, this main agent is going to, um, evaluate if it has the information, and then it's gonna give us a custom tool where we're going to then spin up individual sessions for each of those financial artifacts. So you'll see this, this batch analysis thing. Um, it's gonna
- 0:42
call it for two tickers, and then it's gonna kick runs for each of those. Um, so this is how we can orchestrate our multi-session, um, harness. And each of those sessions has multi-agent, uh, that are doing collaborative work. And each of those, uh, also have outcome definitions so that there's self-supervision happening, using memory stores to learn from one another, um, et cetera, et cetera. Um, so let's move on to the finale, which is, um, what if you wanna do recurring work? What if you wanna do,
- 1:12
uh, you wanna have a list of companies you care about, and you want every day at nine AM or first of the month to do the analysis over all of these companies, uh, on a schedule? So that's what deployments are. Deployments is-- Everything is API-based, so we-- You can obviously interact with our platform via the console. Um, but the main way that we intend to you-- for you to interact with it is via the API and the SDK. So you can build, uh, custom UIs and custom workflows. Um, all of these are just building blocks, uh, that you can compose together
- 1:42
to build your application into something bigger. Um, so you can see here what Claude did, is it created a, uh, deployment, um, and that is right here. A deployment is-- takes in a agent definition. Uh, in this case, it's this, uh, research, uh, desk weekly memo using this specific agent. Um, it takes in a schedule, uh, of when it's gonna run, and it gives it an initial set of messages that it's gonna run with. You can also pass in, uh,
- 2:12
resources like, uh, uh, memory stores or GitHub repos or files that it's gonna use on each of those. Uh, and so what this means is that every, I think this is, uh, first of the month at one PM or something like that, it's gonna run, um, this, uh, specific session. I could run one now. So I could trigger it via the console. It's gonna do that. Um, but I could also build a UI for it, and that's what we've done here. Um, so I can... You know, I have all the CRUD. I
- 2:42
can list and, and search, uh, for my deployments, and then I can also kick one off, um, at any given point. And I don't know why they're failing, but I'll ask Claude about it later. Um, and it-- this has come up a few times, which is what about dreaming? What about self-improvement? Um, so before I get to your questions, which I'm sure there are many, uh, I'm gonna show you a preview that we've, uh, have out for, for dreaming. So what dreaming is, it lets you select, um... So, okay, before I show
- 3:12
you a previous one, it lets you select a memory store. In this case, it will, will use the memory store that we've been using. You can select a model. Um, you can give it custom instructions if you want to, but we'll use the default prompt. Um, and then we're gonna let it, uh, run, uh, the, the last thirty days of sessions through this dreaming analysis. So when I click Start Dreaming, what it's gonna do is it's gonna spin up a session using Managed Agents, actually. Um, spin up many sub-agents to analyze the
- 3:41
transcripts of each of the other sessions that we told it to evaluate at, all of them which use the memory store. Um, and it's gonna analyze, hey, did the memory store encode all the information that was required? Did a session, uh, run into any issue that, uh, that caused problems? Can we learn anything from it? Did this happen multiple times? Can we update the instructions in any way? And 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
- 4:11
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. Uh, and you can imagine that we will continue to extend this to not only improve memory stores, but improve skills directly, uh, agent prompts, sub-agent prompts, et cetera, et cetera. Um, that's, that's it. That's the demo. I-- Sorry about the Wi-Fi. I hope you follow, uh, later on when, when you get home. Um, and let's, uh, keep going with some questions. I'll-
- 4:38
Yeah, we, we can all take questions.
- 4:39
Yeah. Frank, come on up.
- 4:40
Uh, Dave, we have a question over here.
- 4:41
Yep. You can go ahead. You can go.
- 4:43
Uh, thank you for the demo. Uh, we didn't see any, uh, telemetry, uh, instrumentation in the agent. Is that a default native feature?
- 4:51
What, what do you mean by telemetry? Because you have the full observability of all of the events, uh, that happened, right? 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, so you can see exactly, for example, when did we start calling the model? Uh, when did we finish calling the model? So you can get latency metrics in that. Is there something else that you mean by telemetry?
- 5:18
Yeah. Uh, the thing is that, uh, usually in software development cycle, you kind of define what you want to observe. Uh, how did we kind of pick what did we want to observe?
- 5:28
Uh, right now you get all the events, and you just filter them on your end. If there are things that you think are missing, uh, hit us up, and we'll talk about adding them.
- 5:37
Okay. And can I bring my own observability stack in here? Um-
- 5:42
Uh, you mean like export to OTel?
- 5:43
Yeah.
- 5:44
Uh, you c-- you could-- Because it's an API, you could build that connector fairly easily. Uh, we just-- Everybody has different requirements, and we, we don't wanna be opinionated, but everything is just API calls.
- 5:56
Mm-hmm. Thank you.
- 5:58
We have a question.
- 5:58
Oh, I, I had a question. So how long can these agents run? I, I, I know you mentioned this dreaming thing, but h- can you run them indefinitely or do you see that persistent store keep increasing in size and at some point you need to re-compact it offline or something? That was-
- 6:15
We, we are running compaction for you-
- 6:17
Yeah
- 6:17
... so that you can run these for days. We've seen 10-hour sessions in production, uh, from some of our users.
- 6:23
So, so you could run these agents, like, for a year or indefinitely in theory?
- 6:27
Yeah, yeah. A- are you talking about running the agent for a year or are you talking about, like, one specific session that keeps going for a year?
- 6:33
No, basically the agent, if I had to-- If I had a task that I need to do every day, can I just keep it running for six months?
- 6:39
Yeah.
- 6:40
You could, yeah.
- 6:40
Will it, will it not blow its, uh, persistent store?
- 6:42
That's right.
- 6:42
Yeah.
- 6:43
A- and is there any orchestration piece, like, where I could have three agents, Agent A does something and delegates to B and C?
- 6:51
Uh-
- 6:52
That's some capability that you have or if you have something-
- 6:54
For, for now you would spend... you would do sub-agents and you would tell Claude what you want. We find that, uh, there's a desire as humans to constrain what Claude does and the way it does it. As Claude gets smarter, we have continuously removed those guardrails and let Claude-- just let it cook, uh, let it do what it thinks is best. So, uh, right now you think maybe three sub-agents is the best topology for it, but i- if we just let Claude figure that out, it actually ends up outperforming, uh-
- 7:22
But, but any topological or, like, graph-based workflow thing in the UI here, like, where I could have...
- 7:30
Not yet, not yet.
- 7:30
Not yet.
- 7:30
No, not yet.
- 7:31
Not yet, but, but maybe soon. Yeah. Uh, you, you can probably just, like-
- 7:37
Oh, yeah
- 7:38
... speak up.
- 7:38
So-
- 7:38
Yeah, yeah. Sor- sorry. We'll come back to you.
- 7:41
Sorry about that. Hey, uh, over here on d- on your right.
- 7:45
On my right.
- 7:45
On my right.
- 7:46
Yes.
- 7:46
Okay, yeah. Hi.
- 7:46
So question. Um, looks great. A lot of integration points. What I'm curious about, uh, for, you know, an organ- a complex organization that potentially manages multiple agents, um, you know, I, I, I think they want some sort of separation, RBAC, whatever else. Um, how is that-- What is, what is, I guess, the recommended approach for, uh, a complex organization that has those different agents, uh, in here to effectively manage?
- 8:15
We, we have workspaces. That's our primitive today, where you can put different customers in different workspaces and then, uh, segment them that way and give access to specific users into those workspaces. Uh, but we know that there's still a gap in what we offer and, um, that's, that's something, you know, on the roadmap as well.
- 8:36
Yeah. Uh, RBAC is on our roadmap, so we, we do wanna provide more, like, granular controls, where right now workspace is, like, a clean way of, like, separating your agents where you have, like, a group of people access a workspace A and they can access all agents within that. You can have workspace B with, like, a s- different set of users that can have different levels of access.
- 8:53
So hi.
- 8:54
Hi.
- 8:54
Excellent presentation.
- 8:56
Thank you.
- 8:56
Really excited. Uh, two questions. One is deployment. My understanding was that, uh, deployment is like at a snapshot, a moment in time of all the agents.
- 9:06
Mm-mm.
- 9:06
No?
- 9:07
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-
- 9:21
Okay
- 9:22
... that report.
- 9:22
And then memory, which is a state, is persisted across all sessions.
- 9:27
That's right.
- 9:27
You attach your memory store to the session, so you decide which, which session you wanna attach which memory store to. So the memory store is like a independent entity that you just attach whenever you need to.
- 9:38
Right. And the final question is harnesses.
- 9:42
Mm-hmm.
- 9:42
Right. One, what is harnesses for you? Because everyone have their own definition.
- 9:46
Yeah.
- 9:47
And second is the confident, right? So when I change something here, how do I know that it's not-
- 9:54
Mm. Like how you're-
- 9:54
... it's working as expected?
- 9:55
... confident.
- 9:55
Right, my own confident as the-
- 9:57
Yeah
- 9:57
... developer.
- 9:58
Um, for, uh, yeah, you're right. Everybody has a different definition of a harness. Uh, we-- When, when we talk about a harness in CMA, we mainly mean the tool loop execution, so managing the context and managing the session state and making sure that the agent can do the work that it wants to do. When most builders talk about harnesses, they, they really mean... Oh. They really mean, um, the ability to coordinate multiple agents and sessions together as a unit of work to achieve some sort of bigger
- 10:28
task in a topology of sorts. Um, we're giving you the abstraction of a single session as a unit of work for you to go out and build your harness, uh, with it as the session being one of the primitives. Um-
- 10:41
And then your second question about how do, how do I know how my agent is performing, uh, our best recommendation would be to run evals on your agent with, like, different types of tasks that you want the agent to perform and see how the agent does on those tasks. Um, 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, th- 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.
- 11:09
Verifier. That last-
- 11:10
Yeah, the, the, the Verifier agent that, that Gabe talked about.
- 11:14
Hi. So-
- 11:16
Hi.
- 11:16
Oh, sorry. After you.
- 11:17
Cool. Hey, thanks for the demo. I enjoyed it. Um, my, my question at the core is a bit about how to choose between skills and agents, and I wanted to ask: How would you all say what's, like, the fundamental difference? Is there an advantage to the harnessing that surrounds an agent that makes it produce better results than a skill? Um, and one of the reasons I'm asking is 'cause, uh, I'm afraid of always investing in new kinda, like, I guess harnessing and tooling around models, and it's, uh, it can be kinda tiring always
- 11:47
trying to do a new thing. Um, so yeah, I just wanted to hear what you think is, like, is there a big difference and is it gonna change any time?
- 11:54
I, I, yes, no. Um, the que- uh, uh, thick harness, thin harness, thick skills, um, is, is a question that's constantly evolving. I think what we find is that as Claude gets smarter, the- ... boundaries and, and, and the help that we wanna give Claude start to melt away and disappear. And so what you need today might not be what you need tomorrow. The boring answer is just run evals and, and, uh, evaluate these things.
- 12:22
Mm-hmm.
- 12:22
That sounds exhausting, obviously. Like-
- 12:24
Yeah
- 12:24
... every time a new model comes out, I need to evaluate all these things. Um, what, what we find is Skills is a good abstraction today. Uh, it gives the model enough-
- 12:33
Mm
- 12:33
... information to do what it needs to do, but I presume that it will start to shift and melt and become thinner and thinner, where the model will just be able to do things on its own without any special requests and instructions, uh, down the line. So, uh, m- multi-agent seems to be more useful-
- 12:50
Mm-hmm
- 12:50
... uh, in my opinion, but your, your mileage may vary on your task.
- 12:57
Hi.
- 12:57
Hey. Hi. So my question ties up to last two questions, and especially on top of evals. One thing I'm excited about is dreaming, but how will dreaming actually affect the final outcome?
- 13:09
Mm-hmm.
- 13:09
Something that's where evals come into the picture. But you can have multiple iterations of dreaming, so that one, that can go into different directions. So is there a plan or do you already support some automated kind of dreaming with run with evals and see that, hey, how did the dirf- different direction go into? Which one should we pick based-
- 13:28
Mm
- 13:28
... on what's going on?
- 13:30
Yeah. So it, so it... Dreaming, what it does is it looks... Oh, you, you can choose the duration for which you want the agent to dream over. So you can say, "I wanna dream over this agent session over the last thirty days," and then look at all the transcripts and analyze what task you're trying to achieve and then come up with, like, a new memory store that's more geared towards, like, what you were trying to do. And we typically will run evals on our end to make sure that dreaming is providing you with better outcomes, and we've seen customers are able to get back-- get a
- 14:00
significant improvement on their evals by running dreaming and then using the new memory store. But agai- again, everything kind of ties back into evals, so, like, that, that's how you would know whether something is performing-
- 14:10
Where, where-
- 14:10
... as you expect it.
- 14:20
Mm. Yeah, I think it'd be good to have your own set of evals, um.
- 14:23
The, the other thing is-
- 14:24
Yeah
- 14:24
... dreaming is in research preview.
- 14:26
Yeah.
- 14:26
So these are early, early.
- 14:28
Mm.
- 14:28
It's like a big experimental thing.
- 14:30
Mm-hmm.
- 14:30
We've seen uplift, uh, on it generally, but this is... We, we hear you, right? Like, uh, how do I gain the confidence that this is actually-
- 14:36
Yeah, it's like eval's connected to dreaming, and then we can find out multiple pathways that ta- that has been taken and de- decide, "Oh, this makes more sense," because even though n- nine sessions may have been s-saying that, "Hey, this is wrong"-
- 14:50
Mm
- 14:50
... one says that, "Hey, this is good." So if you just rely on that session dreaming thing, I feel like we may not be grabbing all the insights without evals.
- 14:58
The... If I tell you just to trust me, is that...
- 15:03
Thank you.
- 15:06
Yeah.
- 15:07
Hi. Uh, thank you very much. Um, this is very impressive. Uh, those of us who have been working with Claude Code for a year or more, um, have been doing things that are similar to this, but this is nice to see this in a really mature form. Um, I, one question I have is, how much of this was just built on top of Claude Code? That is, if somebody was, you know, ambitious, could they, could they build something similar to this? And, um, what I wanted to ask you was, uh, encourage you to keep
- 15:37
things open. Uh, some of us are already harvesting what's in the, uh, JSON session files, uh, and starting to experiment with things like, uh, Heparag and that kind of thing for, for managing the, um, the memories and, um, and creating a, a memory pool. So, uh, congratulations. Thank you. Please keep it open. And, um, can we... Is there... Are you doing anything here that's not just built on site on top of Claude Code? Thank you.
- 16:06
We, we took the Claude Code harness as an inspiration. We found that it was very well attuned for coding tasks, um, and different... it's different fle- levels of flexibility for other tasks. We're building an API where we want you to bring your context, your information, your capabilities, and build on top of it, where Claude Code is trying to give you a, a product out of the box. So we have slightly different, uh, you know, value, uh, props. Um, and so it's not just, uh, Claude Code in a
- 16:36
box. Uh, though, though, you know, i-ideally, it performs as well, if not better, in all sorts of tasks. Um, so not, not exactly, but it's definitely inspired and motivated by, by some of the uplifts that we have seen from Claude Code.
- 16:52
And, and Claude Code is a terminal tool, and we obviously wanna be an API product, uh, and, and infrastructure, uh, that is gonna scale, that's gonna be reliable. So there, there, there were, like, challenges that I talked to you about, um, in the beginning of the presentation that we really worked at im- to make sure we're providing a really solid, um, product for you all to use.
- 17:14
Yeah.
- 17:14
Um, so for AWS Bedrock, is there a console, like Claude console, like you have here? Uh, that's just quite straight great for question was, yeah, I just wanna manage and see everything.
- 17:24
This is not available on Bedrock, but it is available via Claude Platform for AWS.
- 17:29
Right.
- 17:29
So there is a AWS version of console that you could go use this with.
- 17:36
Yep.
- 17:37
Yeah. Uh, first, uh, uh, is, is there any, uh, how to say, is there any restriction on the model to be used, like, uh, non-anthropic models?
- 17:47
Uh-
- 17:47
Just like, uh, Claude Code, I can run on non-anthropic models.
- 17:50
For, for now we're, we... You can-
- 17:52
Yeah, it's, it's Claude models only for now.
- 17:54
Oh, okay.
- 17:55
Yeah.
- 17:55
So, so the second question is, what about end user use? Uh, do they have to have a console account in order to use it or just a free, uh, u... Well, I can create a customized UI for this, and they can use it.
- 18:07
So Cl-Claude Console helps you with creating your API key- So that's how you get access to our APIs. So you-- Claude-- You're not paying separately for Claude Console. It's free to sign up. You create an API key, and then you're paying based on, like, token usage.
- 18:20
So for, for, for the case like, uh, SaaS, like, uh, maybe we have multiple tenant, right?
- 18:26
Mm-hmm.
- 18:27
So in order to provide this, uh, agent-
- 18:30
Yeah
- 18:30
... what kind of, uh, uh, how you say, model you have already, uh, depict on so that we can follow? For example, what, what kind of, uh, each company are supposed-- tenant are supposed to have a, uh, a different space or, or even there is a, a sub module for this, uh, each tenant. So are, are we going-- how do we-- are we actually going to organize that in term of this?
- 18:52
We, we, we have seen that the best model for multi-tenancy is not bring your own key because you lose observability 'cause it runs on your end user's API key rather than, than yours. So we encourage you to model things with workspaces as a tenancy primitive. Um, and we're improving that so that it's easier and easier to build, uh, on top of this for multi-tenant applications like-
- 19:15
Yeah. So I, I think currently you could either have-- put all your customers' data into like a single workspace, and then you maintain a mapping on your end on, like, which agent maps to which of your customers. Alternatively, like Gabe said, you could create a workspace per customer of yours, but that can get more complicated 'cause then you have to, like, recreate your agent-
- 19:34
So, so is any-
- 19:35
... across various workspaces
- 19:35
... you see the examples that, uh, people did the additional security layer or RBAC layer over the-- this workspace because to me, uh, it may be a little bit, uh, you know-
- 19:45
Yeah. Uh, that, that would probably be, like, a good, good way to do it right now 'cause we don't have any RBAC-
- 19:52
Mm
- 19:52
... uh, controls, uh, on our level other than, like, workspace. So everything within your workspace is accessible to everyone in the workspace. But we are working on making RBAC better and then making the experience better if you're working with Claude Managed Agents, but building on behalf of your customers and how do we make that easy something, uh, top of mind.
- 20:09
So, so is there any way you can show how to scale this, uh, i-if there's a multiple, uh, how to say, tenants working on that?
- 20:16
Yes.
- 20:16
Is there any scaling parameters like, uh, what is the, how to say, the, the minimal, uh, pod or whatever, these parameters that was... Yeah.
- 20:26
Uh, I mean, you're, you're defining on a... You can create as many sessions as you want.
- 20:30
Yeah.
- 20:30
Like, there's no limitation. I mean, we have some rate limits obviously, but, um, but there's no scaling parameter for you to say, "Now I need to run-
- 20:39
Oh, yeah
- 20:39
... ten thousand pods here."
- 20:39
So, so currently no, no such thing as like, uh, like HPA in the Kubernetes, like you can do these kind of setting, scaling, uh, parameters, right?
- 20:48
Well, you-
- 20:48
Like amount or whatever.
- 20:50
You, you don't need the, the, the-
- 20:51
You don't need to-
- 20:51
You don't need that-
- 20:51
... 'cause we're managing it all for you. You're just making API calls. That's all.
- 20:55
Okay.
- 20:55
Yeah.
- 20:55
Okay.
- 20:56
Yeah.
- 20:56
Sure. Uh, thanks for your, uh, answer. The last, uh... By the way, I, uh, the offering link does not work for me. I'm not sure-
- 21:03
Oh, no
- 21:03
... if it's the only one. But 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 been having a ball with everything that you've been releasing. And, um, I'm really interested in how you're using UI. Um, you're spinning up a server, you're distributing this, but how might we deploy that either internally, but I'm interested into sort of a customer base. If I want to make, for example, an astrologer-
- 21:33
Mm
- 21:33
... um, that person has to enter sensitive data, so it's actually really nice for me to be able to, like, have that in a sandbox.
- 21:39
You should have a layer. Yeah.
- 21:40
So there are some procedural things. You get like a star chart example.
- 21:44
Mm.
- 21:44
I'm not building this, but it, it's a good example. Like, I can have a sub-agent do an interpretation that could last for like ninety seconds. It could create some assets, et cetera. When the outcome is met, it could shut down. So this gives me a way to actually just make a really clean implementation where all I need is auth.
- 22:03
Yeah.
- 22:03
And then everything can spin up from there.
- 22:05
Mm-hmm. Yeah, exactly.
- 22:06
So there are a couple of things like MCP channels that kind of point to this with like fakechat, for example, a way for you to kind of just use Claude and have a channel to communicate with it through UI. But I'm seeing a lot where you're just spinning up a server inside a project that's easy to distribute internally, but how can you deploy that at scale?
- 22:29
Um, I mean, we've-- this is, uh, being deployed today at scale in production. For example, Notion external agents are built on top of this. So this is something that exists today that you can go and use and, uh, basically leverage Claude Managed Agents through Notion and Atlassian for Jira integrations, for example. Uh, there, there's definitely ways to do it. I think if you have specific questions, we could talk, uh, after-
- 22:51
Yeah, we, we can talk after this. But typically-
- 22:53
Mm-hmm
- 22:53
... you would probably build your product, your UI that you're distributing to your customers, and then calling into us for like your actual agent-
- 23:01
The phrase everything-
- 23:02
... creation management
- 23:02
... yeah, everything is through the API.
- 23:04
Everything's through the API.
- 23:04
Yeah, exactly.
- 23:04
That's, that's right.
- 23:05
Yeah.
- 23:05
Thank you.
- 23:06
So you'll manage all the API calls and build your product and UI around that.
- 23:09
Thank you very much.
- 23:10
Yeah.
- 23:12
Hi.
- 23:13
Hi. Hi. First, thanks for a great workshop and demo. And, uh, my question is not really to like the agent itself. It's just like I saw the-- and sorry, just released the Sonnet five.
- 23:24
Yes.
- 23:24
So I just wa-- was wondering if any- anything you guys could share with us. Yeah.
- 23:31
It's a great model.
- 23:32
Yeah. Try it.
- 23:37
It is supported in Claude Managed Agents.
- 23:39
Yeah.
- 23:40
Go, go give it a try.
- 23:41
You can use it today and see.
- 23:42
Yeah.
- 23:43
Hey there. Um-
- 23:44
Hi
- 23:44
... if we've got, uh, business partners that are using like Claude Cowork today or some of them more tech-savvy Claude Code to build some like spot solutions for specific business cases-
- 23:53
Mm
- 23:53
... what do you see as sort of the level of sophistication up level to start using man-- like, uh, managed agents instead? 'Cause this seems like more powerful.
- 24:02
Yeah.
- 24:02
But the, you know, Claude platform could be intimidating to-
- 24:04
Right
- 24:04
... folks that aren't engineers, let's say.
- 24:07
Yeah. I think, I think the console quick start is probably like the part of my demo where you're literally just like Telling Claude the agent that you're trying to build should make that pretty easy for even non-technical users to come in and build their first agent. But obviously this is an API product and is naturally gonna be a little bit more intimidating. But they're, they're comfortable with Claude Code. We do have a managed agent skill with Claude Code that basically just like in natural language will walk you through building your first agent, and that would probably be my advice, uh, to
- 24:37
try it out. I think the biggest difference is Cowork, you're buil- building personal agent. 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. But if you're building personal agents, Cowork is still a really great tool to continue doing that.
- 24:54
Are there any skills to kind of like, take something that exists in Cowork and translate it into something that's in like a managed agent skill?
- 25:00
Mm.
- 25:00
I-- There's a skill to interact with our API so that Claude is probably good enough. So if you say, "Here's what I did in Cowork, and here's a skill to call the API," make the translation, I feel pretty confident-
- 25:14
Yeah
- 25:14
... on Five we'll, we'll do it for you.
- 25:17
Um, my question is about enterprise. Uh, there are cus- lot of enterprises who would like to run these things in-house because they have sensitive data sets-
- 25:26
Mm-hmm
- 25:26
... that they won't want going out.
- 25:28
Yeah.
- 25:28
Also, they may have already set up their own secure proxies to Anthropic's models. Um, do you guys... And also, the, the other question was about scaling. So within the enterprise now you can actually allocate compute to scale it our own way, right? Uh, so an on-prem kind of solution. Have you all thought about it?
- 25:46
Uh, definitely been a customer ask from a bunch of our enterprise customers and, and we're seriously thinking, considering it at the moment. But we, we don't already have something that we can, we can share with you. But we're, we're, we're seriously considering it.
- 26:01
Cool.
- 26:01
Yep.
- 26:01
Excuse me. Could you show the last slide that show the QR code of the workshop?
- 26:08
Oh, yeah. Yeah. Uh, are you looking for the repo or the credits?
- 26:11
Yeah.
- 26:11
The repo. Okay. Yeah.