AI Engineer World's Fair 2026

Claude Managed Agents Q&A: Evals, CI/CD and Multi-Tenancy (Part 4 of 4) — Anthropic

Read the talk

Claude Managed Agents Q&A: Evals, CI/CD and Multi-Tenancy (Part 4 of 4)

Priyanka Phatak and Gabe Cemaj explain how to version agent definitions, choose workspace boundaries, evaluate real behavior and keep a coordinator responsive while custom tools wait.

From a talk by Priyanka Phatak and Gabe Cemaj

At a glance

Ideas worth remembering

  • Keep one agent definition in YAML and synchronize deployed copies through CI/CD, including copies in separate customer workspaces.

  • Meaningful eval data matters more than a perfect score on an ill-defined task; historical sessions provide a practical starting dataset.

  • Use individual workspaces for the customer data segregation discussed here. Session metadata records customer identity without providing that separation.

  • For responsive conversation during custom tool waits, put the tool on a subagent and keep the main coordinator available for messages.

Check agent definitions into the codebase

An agent configuration needs a release path just as application code does. In the closing Q&A of Anthropic’s Claude Managed Agents workshop, Priyanka Phatak and Gabe Cemaj begin with a practical answer: keep long-term resource definitions in YAML in the codebase, then use CI/CD to apply changes through the ant CLI.

The CLI wraps API calls and accepts YAML, enabling what the answer calls “Terraform-like” operations. A checked-in definition becomes the input to an automated update whenever the resource changes. Anthropic uses this approach internally for long-term resources too. The comparison establishes a configuration-as-code workflow; it does not establish Terraform’s full planning, state or rollback semantics.

0:210:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:13 · section reference included

A custom tool wait changes which messages are accepted

The next question tests the promise that users can message an agent while it works. Two execution states behave differently:

  • Other work in progress: incoming messages can queue while the model continues working.
  • Waiting for a custom tool result: execution pauses, and the expected next input is that tool’s result. Sending an ordinary message at this point returns HTTP 400.

The stated reason is ordering: an outstanding custom tool call must receive its result before other calls proceed. This matters for human-in-the-loop tools, where the wait may be long enough for another user message to arrive. The Q&A returns to that architectural problem at the end rather than changing the API behavior.

A brief repository question follows. The other workshop materials came from Code with Claude, with corresponding conference recordings available on YouTube. Those recordings provide context for the neighboring repositories; this workshop serves as the overview for Managed Agents.

1:091:15
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:09 · section reference included

An eval harness must change as models change

New model capabilities can make old harness assumptions unnecessary. Anthropic evaluates early model releases against internal datasets so it can revise prompts, remove obsolete scaffolding and add what the new model needs. The scope includes general agent tasks, beyond coding.

Cloud execution makes large batches practical: the answer gives the example of spinning up 10,000 sessions in parallel, then evaluating their results. Parallelism supplies attempts to compare; interpreting those attempts is what determines whether a prompt or harness assumption should survive.

For builders, the recommendation starts with data quality. Claude Code can help construct an eval, but an ill-defined task can produce a perfect score with little connection to useful performance. Anthropic encountered initial evaluations that reached 100% and still left the essential question unanswered: what did that score mean?

Historical sessions offer a concrete starting dataset. Review the results those sessions produced, assign scores and use them to assess model behavior. This grounds evaluation in work the application actually encounters, while leaving the builder responsible for defining a meaningful problem and quality standard. The answer offers that method rather than an out-of-the-box evaluation solution.

2:472:55
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:47 · section reference included

Workspace membership determines resource sharing

The sharing question comes from a team already building shared skills and connectors in Claude Desktop. For Managed Agents, the resources under discussion—agents, memory stores and MCP channels—belong to a workspace. API keys within that workspace can access its resources, and teammates with access can modify what others build.

The organization’s platform administrator creates workspaces and decides who can enter each one. The practical design rule is to group people who should share access to the same resources. Workspace design therefore follows access requirements, rather than simply copying the organization chart.

Partial sharing exposes a limitation. The platform does not provide the fine-grained controls requested in the example: share a memory store with one group while sharing an MCP channel with another. A builder can implement selective access in the application integration for end users, but that application behavior is distinct from the workspace-level access available to platform users and keys.

4:444:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:44 · section reference included

More generated code creates a review bottleneck

Once agents generate code quickly, reviewing and merging it becomes the bottleneck. A pull-request integration can launch one or more Managed Agents sessions, with subagents inspecting changes and finding bugs. Anthropic reports that internal review agents reduce time spent per PR and help reduce bugs, but keeping up with the expanding volume of generated changes remains an open problem.

Review comments alone cannot establish that an application works. The audience proposes a review-and-revision loop followed by a deployable environment for testing. Another option is to run the application inside the sandbox and have Claude validate its own changes as a QA agent.

At the time of the recording, the sandbox lacked tunneling for a person to open the running UI directly. The suggested alternative is for Claude to interact with the application through a browser and validate it, potentially returning a video. That gives the builder a way to inspect behavior through an agent’s run, with a different review experience from opening the application themselves.

6:296:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:29 · section reference included

Reuse the definition while separating customer workspaces

An enterprise question first clears up a deployment distinction: on-premises operation was unsupported; serving multiple enterprise customers was possible. For a company supporting 100 customers, the available modeling choices include customer-specific agents, workspaces or organizations, with the integration maintaining the customer-to-agent mapping.

The follow-up makes the tension concrete: two customers need the same agent behavior, and the builder wants to define it once. There are two different ways to reuse that work:

  • Copy a shared definition into separate workspaces. Keep the system prompt, model name and tools in a single YAML definition, then synchronize copies through CI. Updating the source definition can update every customer’s copy.
  • Share an agent within one workspace. Maintain a customer-to-session mapping, using session metadata such as a customer ID to identify whose session it is. Separate agent copies are also possible within that workspace.

The deciding requirement is data segregation. Although the initial answer broadly associates customer-specific agents with segregated data, the follow-up explicitly directs builders to individual workspaces when segregation is required. Resources are allocated per workspace. A customer ID in session metadata identifies ownership; it does not supply the workspace separation recommended here.

When the audience clarifies that customers have a legal requirement to keep their data separate, the recommendation settles on one workspace per customer. The earlier CI/CD mechanism resolves the apparent conflict: one maintained agent definition can produce multiple deployed copies, so shared behavior does not require a shared customer workspace.

8:508:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:49 · section reference included

Use another sandbox provider for GPUs or more memory

Custom compute requirements belong to the execution environment. The provided sandboxes had a uniform resource configuration at the time of the workshop. An agent needing a GPU or a different memory allocation would use a self-hosted sandbox instead; Modal is the concrete GPU example.

The described integration connects Modal instances so the agent loop runs there instead of in the provided sandbox. Environment specifications and third-party integration cookbooks are available in the documentation, with Modal, E2B and Daytona named as examples. This moves the compute choice to the sandbox provider rather than exposing a larger preset in the managed sandbox.

12:1412:29
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:10 · section reference included

Map chat threads to sessions and make posting explicit

A multiplayer chat agent can map each conversation thread to a Managed Agents session. When someone posts, the integration injects a user.message and identifies the sender—for example, Gabe or Priyanka. Several people can then address the same agent while it retains the context of their shared thread.

Incoming messages and outgoing posts need different treatment. Give the agent a Slack posting tool so it explicitly chooses when to publish. Automatically mirroring every agent response into the channel would remove that decision and turn internal responses into public conversation by default.

Memory can be shared across sessions to carry learning between conversations. For channel-scoped behavior, the suggested design uses one agent per Slack channel, with separate memory and access limited to that channel’s messages. Thread-to-session mapping organizes conversations; channel-level agent and memory choices determine what context they share.

13:2213:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:22 · section reference included

Define completion separately from progress reporting

For tasks lasting more than six hours, the recommended mechanism is the outcome system demonstrated earlier in the workshop. Define an exit criterion and a rubric, and Claude continues iterating toward it—“mercilessly,” as the answer puts it. The presenters say no special module is needed merely to keep a session running beyond six hours; this is a description of supported operation, rather than a measured completion guarantee for a particular task.

Knowing whether the task is finished differs from knowing what it is doing now. The session event stream, available through an events API under the session, provides the observation path. A custom status-update tool can also let Claude send a human-readable update when it judges that it has made progress. That suggestion supplies agent-chosen progress reports, without specifying a fixed reporting schedule.

15:0615:29
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:34 · section reference included

Move the custom tool wait off the coordinator

The final question returns to the HTTP 400 problem: how can a conversational agent remain available while a human-in-the-loop tool waits? The proposed coordinator pattern puts custom tools on a subagent. The main agent remains free to receive messages while the subagent handles the blocking work.

In the concrete example, Agent A is the coordinator and can talk to Agents B and C. Agent B’s definition contains the custom tool. When B emits a tool-use request, the integration supplies its result through the main thread; the platform uses IDs to route it to the right subagent. B has a technically separate thread within the overall session, so the application does not have to treat it as an unrelated top-level conversation.

Which path stays available when the custom tool waits? The diagram separates delegation from tool-result delivery. The wait belongs to B’s work, while A remains the conversational entry point. This preserves the tool’s ordered request-and-result interaction while moving it away from the agent responsible for receiving new messages.

The final demonstration points to a gap where the main thread is idle while subagents continue working; they could also be waiting for tool results. That distinction matters: an idle coordinator does not mean the whole session is idle. The coordinator pattern keeps the agent “chatty” by separating availability for conversation from the state of delegated work.

A conversational coordinator with a waiting tool subagent

Application integrationSends user messages and supplies custom tool results through the main thread.
Agent A: coordinatorsession — Remains available for messages while delegated work proceeds.
Agent B: custom toolssession — Defines the custom tool; can wait for its result on a separate subagent thread.
Agent Csession — Another subagent the coordinator can address; no custom tool role is specified.
Delegation and tool-result routing share the main entry point, while the custom tool belongs to Agent B.
Read the diagram as text
  • Application integration. Sends user messages and supplies custom tool results through the main thread.
  • Agent A: coordinator. session — Remains available for messages while delegated work proceeds.
  • Agent B: custom tools. session — Defines the custom tool; can wait for its result on a separate subagent thread.
  • Agent C. session — Another subagent the coordinator can address; no custom tool role is specified.
  • Application integration → Agent A: coordinator: User messages.
  • Agent A: coordinator → Agent B: custom tools: Delegate custom tool work.
  • Agent A: coordinator → Agent C: Can communicate.
  • Agent B: custom tools → Application integration: Emit custom tool use through session.
  • Application integration → Agent B: custom tools: Tool result via main thread, routed by IDs.
16:3316:54
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:30 · section reference included

Resources

Read the complete timestamped transcript
  1. 0:13

    All right. We have a question here.

  2. 0:21

    Hey. Uh, how do you CI/CD the agent configs? Um...

  3. 0:27

    Ah, that's a great question. Uh, so we have something called ant CLI, which is a CLI that basically wraps our API to make calls, um, and allows you to do sort of Terraform-like things where you pass in YAML. So you can put your, uh, long-term, uh, resources in YAML in your code base, and then build, um, CI/CD to basically update the ant CLI- with ant CLI using the, those YAMLs, uh, every time you make a change to your, to your resource.

  4. 0:57

    Does that make sense?

  5. 0:58

    Got it. Uh, so I assume you guys use the same internally too?

  6. 1:02

    Yeah. That's how... If, if we need to build durable long-term resources, we just, we can check them in.

  7. 1:07

    All right. Thanks.

  8. 1:08

    Thanks.

  9. 1:09

    Um, so I think you mentioned you can send messages whenever you want.

  10. 1:14

    Mm-hmm.

  11. 1:15

    Um, can you still send messages if the model's waiting for a, a custom tool result?

  12. 1:19

    Uh, not when it's waiting for a custom tool result. We basically pause execution, uh, at that time. Um, but if the model is doing other work, uh, then we do allow you to queue up messages. Um, but when it's doing a custom tool result, we're expecting you to send that, um, so because of ordering purposes, we, we block the calls.

  13. 1:38

    Got it. But what happens if you do send the message?

  14. 1:40

    You'll get a 400.

  15. 1:41

    Okay. That makes sense.

  16. 1:43

    Uh, there was an ask to see the QR code slide one more time.

  17. 1:47

    The, uh-

  18. 1:48

    The, uh, the credits one? Yeah.

  19. 1:55

    Any, any other questions? If you're, if you're shy, we-

  20. 1:57

    Yeah

  21. 1:58

    ... we're also hanging out here

  22. 1:58

    Yeah. We'll hang out after for any, any questions you don't feel.

  23. 2:01

    Yeah.

  24. 2:02

    Awesome.

  25. 2:07

    Yeah. I'm looking through the repo. There's a lot of interesting workshop talks. Is there anything that's missing from that, like slides that would help us go through other-

  26. 2:16

    Yeah, yeah

  27. 2:16

    ... sessions, like, that you can post, or is it pretty much self-explanatory through the, the README files? You just like have, you know... 'Cause you had like a skill.workshop, which-

  28. 2:25

    Yeah, yeah. Uh, the other workshops came from our, uh, Code with Claude conference, um, most of which you can find online, uh, for the version we did in London about a month ago. So you can definitely-

  29. 2:34

    Yeah. All, all, all those talks are on YouTube if you're interested in the other repos that are in there, but this one should give you like a pretty good overview and it's pretty similar to what we've done at other conferences.

  30. 2:46

    Yeah.

  31. 2:47

    Yeah. So just going back to evals, can you talk a little bit about, you know, how you guys are maintaining quality, best practices around the, the eval harness?

  32. 2:55

    Uh, yeah. We run a lot of evals, especially as new models come up, as new capabilities come up. We have access to the models before you all do, obviously. Um, so one of the things that we as a managed offering wanna make sure we do is that we, uh, update our assumptions about the harness as early as possible so that we can remove things that are no longer needed. Uh, and we do all of that in the eval base. So we have internal tooling that basically looks like different datasets that we can then run our different sessions.

  33. 3:25

    It's... Because it's all in the cloud, it's easy to say like, "Spin up 10,000 sessions to do this, uh, all in parallel." Um, and then we evaluate those results and tune prompts and tune assumptions, remove things, add things, uh, to make sure that for every model release, we're doing the best we can. Uh, and we're evaluating all sorts of things for generic purposes, not just coding.

  34. 3:48

    So, so how does that extend into the agents that we would build? Is there a recommended path for, um, for evals, or is it kinda just bring your own solution?

  35. 3:56

    Uh, I think the, the best advice we can give you is get high quality data uh, to evaluate over. I think Cl- Claude, Claude Code is pretty good at building an eval for you, but garbage in, garbage out. We've seen that some of our initial ideas for how to evaluate things were sort of ill-defined, and you get 100%, but what does that mean in performance? So iterating on your data and making sure that you're setting up the problem correctly. Um, I know it's like not a out of the box solution, but it... generally

  36. 4:26

    the advice that we've seen works.

  37. 4:27

    And you can probably look at like your historical sessions and like what results you got and then sort of try to score it and see how the model's doing. Um, that would be a good way of like building your dataset, looking at your historical sessions. Um-

  38. 4:42

    I had a question o- oh, over here.

  39. 4:44

    Hey, thanks for sharing. Uh, I have a question about how to share those agent and all the resources across all the o- the entire organization. The reason I'm asking is because we use Claude Desktop quite a lot. We're building shared skills. We're building shared connectors.

  40. 4:58

    Mm.

  41. 4:58

    But for the, uh, everything you shared today, for example, agent, memory store, or MCP channel, can we actually share them or can we partially share them across the organization to different departments? So what is boundary? What is the privilege about those resources? Are those resources bounded to my account or how can I control this? So what's the, what's the way to do that?

  42. 5:21

    They're bound to your workspace.

  43. 5:22

    Oh.

  44. 5:22

    So any API key within your workspace can have access to the resources that-

  45. 5:27

    So can my, can my teammates add it or modify what I'm building, or it's-

  46. 5:33

    Yes

  47. 5:33

    ... completely controlled, right?

  48. 5:34

    So I, I think your, um, Claude platform admin... So you'll have an org for your organization.

  49. 5:40

    Yeah.

  50. 5:41

    And then your admin will be the one setting up the workspaces and deciding who gets access to which workspace.

  51. 5:47

    Yeah.

  52. 5:47

    So I think you would basically design your workspaces depending on your access control.

  53. 5:51

    Correct.

  54. 5:51

    You'd probably wanna do like- W- whatever group of people you want access to resources X, put them in one workspace

  55. 5:58

    So you can share whatever you want, even partially of the... You know, if you're the agent that can do something, but I only want to share part of that. For example, I share the memory to someone, I share the MCP channel to the others. Is that possible? Or I need to share the entire tech stack of what I'm building?

  56. 6:12

    We don't have fine-grain controls of like-

  57. 6:14

    Yeah

  58. 6:14

    ... this is shared, this is not. But you as a, a, as a builder and integration would be able to control that, uh, pretty granularly so that your end users can have access to-

  59. 6:23

    Yeah

  60. 6:23

    ... partial sharing.

  61. 6:25

    Right. Cool. Sweet. Thanks very much.

  62. 6:27

    Thank you.

  63. 6:28

    Yep.

  64. 6:29

    Yeah. So basically, we can generate a lot of code with a lot of agents, and then we're getting to the bottleneck of, uh, reviewing that code, making sure you can actually merge it. Um, how do you guys think about that in terms of are you deploying? Like, I see you deploy every 30 days, which, uh, might be a different definition of deployment, but is it deploying something you can actually test to make sure it works well? Or how are you reviewing, uh, this many lines of code from all the agents?

  65. 6:58

    So the, the original workshop that we wanted to do was actually answering that question, how do you, how do you build agents to review code? Um, what we found is you can build an integration with CMA, so that on PR it kicks off one, two, three, many sessions with many sub-agents to evaluate what has changed and find bugs. Internally, we, we have, uh, these sorts of agents do a lot of the uplift for us, and we've seen that that enables us to, uh, reduce the amount of

  66. 7:27

    time we need to spend on-

  67. 7:29

    Mm-hmm

  68. 7:29

    ... a per PR basis and reduce the number of bugs and keep the quality, uh, high. Um, but this is partially an open question of now we've removed the boundary of, uh, typing and exploded the number of PRs we can make per day, hour, second. Um, how do we keep up? And we're still exploring that, but-

  69. 7:49

    Yeah

  70. 7:49

    ... CMA is part of the answer, I think.

  71. 7:52

    Yeah. And you can iterate in a loop, you know, to like review, add comments, review until it's done, but then at some point you still need to run the thing to make sure it works well locally. So I think that's where the deployments can come in, where you can, um, you know, auto deploy something that you can test with a custom deploy agent, like you said. Um, it just depends, like if you have different environments for each branch, but...

  72. 8:15

    You, you can run your application in the sandbox as well and have Claude self-validate the changes that it made-

  73. 8:22

    Mm-hmm

  74. 8:22

    ... um, and make sure that like it acts as a QA agent as well.

  75. 8:28

    Are these like long-running sessions that you can go in and actually play around on the UI?

  76. 8:33

    We don't have, uh, uh, kind of tunneling today, but-

  77. 8:36

    So you would have Claude go in there, play around-

  78. 8:39

    Yeah

  79. 8:39

    ... with the browser.

  80. 8:40

    That's right.

  81. 8:40

    And then-- And validate. Yeah. And then maybe even give you back a video maybe.

  82. 8:44

    Yep, exactly.

  83. 8:45

    Cool. Thanks.

  84. 8:48

    Any other-

  85. 8:49

    Hello.

  86. 8:50

    Hi.

  87. 8:50

    Uh, for an enterprise company, if at all we want to maintain true tenant isolation that we want to support.

  88. 8:57

    Mm-hmm.

  89. 8:58

    I heard that you are not supporting yet the enterprise, uh, company, uh, use cases probably.

  90. 9:03

    We're not supporting on-prem.

  91. 9:05

    On-prem?

  92. 9:05

    Yeah. But-

  93. 9:06

    But what if I want to have, uh, let's say I have hundred customers that we support as an-

  94. 9:11

    Mm-hmm

  95. 9:11

    ... enterprise company.

  96. 9:12

    Yeah.

  97. 9:12

    Can I have separate, uh, Claude managed agent instances-

  98. 9:16

    Yeah.

  99. 9:16

    Yeah

  100. 9:16

    ... per, uh, company of ours-

  101. 9:19

    You could, yeah

  102. 9:19

    ... that we want to support?

  103. 9:20

    Yeah.

  104. 9:20

    Is that a viable option that you support? Is it only one instance that we get, or can we get one instance per company that we support as an enterprise?

  105. 9:28

    It, it's however you choose to define it. You can define an agent per customer, and then that way the data will be segregated. You can use a workspace per customer if you want, like true isolation. You could do an org per customer. Uh, so it depends on how you want to set up, uh, your agents. And you would probably want to maintain that mapping of like which customer maps to which agent.

  106. 9:51

    Okay.

  107. 9:52

    Yeah.

  108. 9:52

    Thank you.

  109. 9:54

    I th-

  110. 9:54

    Yeah

  111. 9:54

    ... I think I have a follow-up question. So, uh, just given the, uh, scenario that, uh, uh, we have two customers and we want to build, uh, the agent once, but the agent going to be shared by the two customers.

  112. 10:08

    Mm-hmm.

  113. 10:08

    Uh, how to achieve that?

  114. 10:11

    There, there, there's many ways to do it. You could do it through automation. So you could have your agent definition live in YAML in your code, and then build tooling to update it to both of your workspaces and basically synchronize them. Or you can model everything in a single organization and then do the, the modeling that way. Um-

  115. 10:28

    So you, you, you could create like a single agent across all your customers, and then you manage the mapping of like which customer is using which session.

  116. 10:36

    Which session. Yeah.

  117. 10:37

    Yeah. Then in, uh, in which workspace I ca- I create this agent?

  118. 10:42

    Yeah, if, if you do it per workspace, then you need-- We give you tooling to synchronize-

  119. 10:47

    Yeah

  120. 10:47

    ... a single definition in your code to multiple places, so that whenever you update it in your code through CI, you can update all of the definitions at once.

  121. 10:56

    So you can either make a copy of your agent, which is essentially a template of system prompt, model name, tools, and you can like make a copy across every workspace. Let's say you go down like the one workspace per customer. Or you can just put all your customers in a single workspace, and then you maintain the mapping of which... E- either you do, again, have like copies of your agent or you use a single agent and then have the mapping of like which session maps to which customer. We have like a metadata field on the session where you can put in like, let's say,

  122. 11:26

    customer ID, so you know which session w- mapped to which customer.

  123. 11:31

    Okay. That, you know, like putting all the customer data in one workspace, how do we, uh, satisfy the data segre- segregation, uh-

  124. 11:41

    Yeah

  125. 11:41

    ... requirement, you know?

  126. 11:42

    Yeah. If you, if you care about data segregation, then you need to put them in individual workspaces.

  127. 11:46

    Yeah.

  128. 11:46

    And the resources are allocated per workspace. But there's basically tooling to enable-

  129. 11:51

    Mm-hmm

  130. 11:51

    ... you to do, uh, each of, each of those things.

  131. 11:54

    And when you say data segregation, like, is, is that like a legal requirement or is that something just you want to maintain?

  132. 11:59

    Yes. Something legal, like customer doesn't want to share data-

  133. 12:03

    Got it

  134. 12:03

    ... with other customers, you know. They want to dedicate.

  135. 12:06

    Yeah. You would do it per workspace.

  136. 12:08

    Okay. Okay. Thank you.

  137. 12:10

    I saw a question here. You're gonna have to speak up or...

  138. 12:14

    Um, is there a way to modify the compute environment? Meaning, um, in some cases, I may need to have higher memory for my agent to do the work, or I need a GPU for my agent-

  139. 12:29

    Mm-hmm

  140. 12:29

    ... to actually do the work. Is it supported in this or...?

  141. 12:33

    To, to the-- today, if you wanna do custom resource allocations for your sandbox, you would use self-hosted sandboxes. You would use something like Modal that has GPU offerings.

  142. 12:42

    Yeah.

  143. 12:43

    And we have cookbooks and kind of first party integrations so that you can hook up your Modal instances to run your agent loop, uh, inside of Modal instead of our provided sandboxes, which today are all the same. Uh, so if you care about different scale, you would use a different provider for that.

  144. 13:01

    And do you have, like, a list of, uh, specifications-

  145. 13:05

    Yeah

  146. 13:05

    ... of what the environment these agents have access to?

  147. 13:07

    Yeah. You, you can find that in our docs, and you can find cookbooks to integrate with third-party providers as well in our docs.

  148. 13:13

    Yeah, we have a bunch of cookbooks on, like, how to work with Modal or E2B or Daytona, wh- whatever provider that you wanna use for sandboxes.

  149. 13:20

    Thank you.

  150. 13:21

    Yeah.

  151. 13:21

    Yeah.

  152. 13:22

    Hi.

  153. 13:22

    Hi. Thanks again. So out of curiosity, how to build a sim- similar version of CloudTag using CMA in a different chat channel, especially for the multiplayer mode?

  154. 13:35

    Yeah. Uh, this definitely is something you could do-

  155. 13:38

    Yeah

  156. 13:38

    ... uh, today, where you would on a per thread level map it to a session, and then any time a user messages that session, you inject that as a user.message, letting the agent know, "Hey, this is coming from Gabe," or, "This is coming from Priyanka." And so everybody can message, uh, that agent independently. You can have it share memory across sessions so that it learns, uh, from each other.

  157. 14:03

    Mm-hmm.

  158. 14:03

    You can give it tools to reply back, uh, using, like, the Slack post tool or something like that, so that the agent can decide when it wants to post. You don't necessarily wanna just mirror whatever the agent is responding. You want it to be explicit. Uh, but you could definitely model this, uh, using CMA and...

  159. 14:21

    And if you want it to be like CloudTag, you'd probably do, like, one agent per Slack channel, and then every agent has its separate memory and only has access to messages within that Slack channel.

  160. 14:34

    Yes.

  161. 14:34

    Hey. Thank you for the presentation. Very useful. Quick question. In terms of, um, looping and doing long runs, um, in this cloud console, how do you see that? Um, is this something you have, like, some specific module that I, I'm not finding, or, um, are you, you planning to develop that, um, more in the future? Um, thank you.

  162. 15:00

    D- do you mean how do we provide the observability for really long sessions or?

  163. 15:06

    No, no, no. Um, so more focused on, um, using this platform to build those, uh, long-running agents, like hours and hours, like plus six hours, for example. Um, is this something that is already embedded in what you have built in the agents, or I'm c- more curious to know i- if you are developing something specifically for that, or how you see that trend.

  164. 15:29

    The, the outcome system that I demoed is the best way to do really long sessions because you define an exit criteria, and Claude will just keep going until it meets that criteria, and it could be a really long task like, you know, rebuild blank. Uh, and it will just mercilessly iterate until it matches the, the rubric.

  165. 15:51

    There, there, there's nothing special you would need to do to get the session running longer than-

  166. 15:56

    Gotcha

  167. 15:56

    ... six hours. It should, it should just keep, keep going.

  168. 16:00

    One quick follow-up. So if I run, uh, the agent for hours and hours-

  169. 16:04

    Mm-hmm

  170. 16:04

    ... and I want to understand, like, checkpoints, status, the best way to do that would be through the session tab?

  171. 16:10

    Uh, yeah.

  172. 16:11

    It would be the session event stream. Yeah.

  173. 16:12

    Okay.

  174. 16:12

    There's a events API on-- under the session.

  175. 16:15

    Okay.

  176. 16:15

    You could have a custom tool called, like, update status for human-

  177. 16:19

    Mm-hmm

  178. 16:20

    ... or something like that, and Claude would on intervals, whenever it feels like it's made progress, call that tool and give you a status update.

  179. 16:28

    Thank you. Thank you very much.

  180. 16:30

    All right. Any other final questions?

  181. 16:33

    Yeah.

  182. 16:33

    Yes.

  183. 16:33

    Um, following up on that previous question about using this for CloudTag or just similar functionality, I've been, uh, analyzing a whole bunch of, uh, agent frameworks. So if you get a message while the, um, agent is waiting for a custom tool result, for example, human in the loop, um, you said it would four hundred.

  184. 16:53

    Mm.

  185. 16:54

    Do you have, uh, any suggestions on how you would deal with that?

  186. 16:58

    Um...

  187. 16:59

    Can you do custom tools on a sub-agent? I forget.

  188. 17:03

    You, you could do custom tools-

  189. 17:04

    Yeah

  190. 17:04

    ... on a sub-agent.

  191. 17:04

    'Cause then-- 'cause you could basically have, like, a sub-agent that's handling your custom tool, and then that way your main kinda coordinator agent's always free for receiving messages.

  192. 17:13

    In the API, can you directly return a custom tool result for the sub-agent's tool?

  193. 17:20

    Mm.

  194. 17:20

    Well, the sub-agent would emit-

  195. 17:21

    Yeah

  196. 17:21

    ... the custom tool use, and then you would po-populate it back to that-

  197. 17:25

    So essentially you-

  198. 17:25

    You know, with-

  199. 17:25

    ... you define, like, your main coordinator agent, and then you can say-

  200. 17:29

    Uh-huh

  201. 17:29

    ... Agent A can talk to Agent B and C, and then Agent B is the one, let's say, processing your custom tools, and your Agent B definition is where you'll define your custom tool.

  202. 17:38

    Right.

  203. 17:38

    And then that's the session thread that you would listen to to get the custom-

  204. 17:42

    Is that a different session thread or the same session?

  205. 17:44

    No, it's, it's part of, like, the same core session thread.

  206. 17:46

    It's, it's a different thread technically, but you only interact with the main thread, and we-

  207. 17:51

    Yeah

  208. 17:51

    ... correctly delegate it 'cause we know where-

  209. 17:52

    Yeah

  210. 17:52

    ... it needs to go based on IDs. Um-

  211. 17:55

    Okay

  212. 17:55

    ... but you-

  213. 17:55

    And then the main agent will pass it-

  214. 17:57

    Will pass it along

  215. 17:57

    ... onto-

  216. 17:57

    Exactly

  217. 17:58

    ... the sub-agent.

  218. 18:00

    Yeah.

  219. 18:00

    So the session is still idle even though the other agent-

  220. 18:03

    If, if, if a sub-agent is doing work, it's not idle. It's, it's-

  221. 18:06

    Uh-huh

  222. 18:06

    ... still running.

  223. 18:06

    But, like, if the main coordinator agent is idle, the sub-agents could still be waiting-

  224. 18:11

    It's still doing work.

  225. 18:11

    It's still doing work.

  226. 18:12

    Yeah. You, you can see that here.

  227. 18:13

    Okay.

  228. 18:13

    Yeah.

  229. 18:13

    That's really impressive.

  230. 18:14

    This, uh, gap here, the main session is, is idle.

  231. 18:18

    Oh.

  232. 18:18

    The main, the main thread is idle while the sub-agents were doing work.

  233. 18:21

    And they could be waiting for tool results.

  234. 18:22

    Exactly.

  235. 18:22

    Yeah, yeah. So if you're trying to do something where you want, like, the main agent to be always chatty, then I think the coordinator pattern works pretty well for that.

  236. 18:30

    That's awesome.

  237. 18:31

    Yeah.

  238. 18:31

    I think we're, we're at time, but we'll, we'll be-

  239. 18:33

    Yeah. We're-

  240. 18:33

    ... just outside if you wanna come talk to us. Uh, thank you for having us.

  241. 18:38

    All right. Tha- thank you so much.