Build a Research Agent with Claude Managed Agents (Part 2 of 4) — Anthropic

Thank you for the presentation. Out of curiosity for the design of the session, in, um, first iteration and second iteration, what has changed?

Good question. Gabe, do you wanna take that question on what changed within, uh, the storage of the session between the first and the second iteration?

Um, sure. The, the, the main thing that changed was that we wanted to abstract away as many things and compa-compartmentalize them into different components, um, to make it so that we could extend the storage mechanisms for future events that we wanted to store, uh, without tying them, you know, so tightly coupled to the mechanics of the session work. Um, so we basically applied the same principle of building and virtualizing interfaces all the way down, uh, not only across service boundaries,

but also at the event layer.

All right, thank you. Um, so it sounds like maybe everyone might not be able to follow along, but hopefully, um, we can find a way to share out these slides, and you can try it out at home. Or if you have your phone, maybe you can try to pair it with your hotspot and see if you can follow along. Um, all right, so let, let's try this one more time. We're gonna say, "Build me an agent that tells me jokes every time, given a topic." And then you just

hit Enter.

And you can see Claude is coming up with a system prompt. It came up with a name, a description, chose a model. You can, like, go change this model if you want to, and then, um, gave the agent access to the agent tool set. And then you'll hit, uh, Create Agent. That should basically call the V1 agent's endpoint to create the agent. Okay, that, that got created. Next, we're gonna configure the environment, uh, which is the template for the sandbox.

Uh, we're just gonna create a new one.

And then we'll just give it unrestricted access for this one, but you can... Obviously, when you're bui-building a production agent, you, you wanna tighten the access, control which domains it can, uh, reach out to, or specific MCP servers. So we'll do unrestricted.

Almost like after-

And then here you can see, you can, like, choose packages you wanna install, um, et cetera. And then next, we'll just go and start the session.

All right, now we're gonna go test run our session. Uh, write, "Tell me jokes about cats."

And you'll see the model started thinking,

and it came up with a cat joke. But yeah, that, that was like a-- That, that's how easy it is for you to go build your agent. Now this, uh, agent is up and running in the cloud. All you have to do is start a session with the agent, send events, get back events. Everything else is managed by us. So we're managing all the infrastructure, the hosting, the harness, the sandbox management, the scaling, the storage of your event log, um, and then you can focus on building your product around this. Um, thank you.

I'll now hand it over to Gabe to do the more hands-on bit of the workshop, and hopefully, hopefully we have better wa-luck with wi-Wi-Fi. Thank you.

Can you hear me? Great. I see there's a bunch of people that are kind of squished in the back. There's room here and here, if you wanna come in, uh, so we can fit everybody in. Um, before we start, here's a repo that we're gonna be using. Um, so if you wanna take a picture of the QR code, Git clone that repo, um, CD into the research desk, uh, directory, and then run, uh, NPM install or bun i. Um, I'll let you do that,

and then I'll walk you through, through what we're gonna be building today, uh, together. Um, I still see some phones out. I know you're-- there's Wi-Fi issues. Hopefully you can, you can get, uh, you can get to the repo. Um, okay. Oh, oh, I see you. Okay.

Cool.

All right. So what are we, what are we gonna be building today? We're-- I'm gonna show you how you can use, uh, Claude managed agents to build a variety of different applications. We're gonna start with, uh, building a custom chat-like interface, so that you can talk to an agent. We can say, "Hello." Um, then we're gonna augment that agent into a multi-agent, uh, ecosystem, so that it can delegate tasks, uh, to sub-agents. We're gonna give it skills, uh, specifically a skill to be able to call, um, the SEC website and get

SEC filings for individual tickers, uh, and analyze specific forms. Um, then we're gonna be able to use the, these new enhanced agents to run more asynchronous, um, agentic tasks that can take a long time to run. Um, and then we're gonna bring it all together by enabling the sort of map reduce interface, where we can talk to an agent, and that agent can then delegate to many agents, uh, and do sort of like a map reduce thing, um, showing you how you can build a

custom harness on top of CMA to orchestrate, you know, your own work with custom tools, uh, and manage multi-session, um, kind of interactions. Uh, and then we'll finish up by... I'll show you, uh, our deployments API that allows you to set up recurring work on a schedule, so that you can run, uh, sessions, uh, on a, on a given cadence to run kind of longer term analysis that keeps updating itself. Sound good?

Quiet. Okay, great. Um, all right, so let's switch over to, um, a coding interface. I'm gonna be using, uh, Claude Code for this. You're free to use whatever coding agent you prefer. Uh, I don't think anybody's writing code by hand, so I'm not going to do that either. Um, there is a skill that we've loaded up in your repository that's gonna walk you through the workshop step by step. Um, so if you wanna rerun the workshop after I'm done, uh, later on when you have better Wi-Fi and

better internet access, uh, you're able to do so, um, at home. Um, so the first thing you wanna wanna do is, I assume you've checked out the repository, you've CD'd into the research desk repo, you've run Bun I. We're gonna spin up our, uh, server with, uh, Bun run dev. I'm gonna make this bigger. I'm assuming nobody can see. Okay, is that better? Yeah.

And then if you have questions while Gabe, Gabe is presenting, feel free to raise your hand and I can run to you with the mic.

We, we have helpers, so if you run into issues, raise your hand. People will come, um, help you, help you out. Um, cool. So if you've gone this far, you'll bas- basically be able to load this website. Uh, and the first thing you're gonna wanna do is go to the setup page. Um, everybody with me so far? Yep. Yeah? Okay. Um, now we're gonna... Yeah. Um, okay, once, uh, once, uh, the... he takes a

picture, we're, we're gonna start up, uh, our workshop skill. So in Claude Code, you can type in, uh, workshop start, uh, and it's gonna start running through the workshop for you. We're gonna do it in six acts. Uh, I apologize, there's no intermission in between. Um, I hope that's okay with y'all. Um, but we're gonna go through it. Uh, Claude will... Oh, uh, sure. We're gonna go into auto mode. Um, Claude, Claude is gonna keep track of each of the acts so

that, uh, you can continue on. You can keep typing workshop next so that it, you know, is gonna keep, uh, progressing through the, through the thing. Uh, I'm gonna ask Claude to do it for me, but handhold m- ha- handhold me and teach me what it's doing. Um, and so the first thing, it's gonna basically make sure that our prerequisites are set. Um, it's gonna copy the .env.example file into a .env.local. Um... Oh, no, stop. We're not there yet.

Okay. It's a little eager. Okay. It's gonna copy th- that file. That file, um, has a few values for you to fill in. You're gonna wanna paste in your API key. Um, you're gonna wanna paste in... The SEC wants to know who you are when you're calling their API, so you're gonna have to put in your name and email. Um, this is just so that they know who's calling them. Um, and then that's basically it. Once, um, once you've done all that, um, it's going to... Well, we're gonna move on to the n- to the next thing. So

everybody with me so far? You've put in your API key into your .env.local. You've put in your EDGAR identifier. Show of hands.

Give me a quick show of hands or how, how many of you are able to follow along who might have Wi-Fi or other ways.

Okay. Okay. We got one, one person at least, so

One.

MVP. Pardon?

The repo. Uh, oh, oh, for the repo. This one? That's the one,

yeah.

Uh, Rohan, you wanna hand them the mic?

Credentials.

Yeah. Thank you.

Yeah, the slide with the credential. That's it. The setup one.

This one.

Thank you.

Oh, okay. Sure.

And then, and then given, given people don't have Wi-Fi, ple- please, like, stop us and ask questions so we can at least make this more interactive and help you understand concepts so that you can build with your own time after the workshop.

Okay. Um, I'm... Yeah. I have a-

Is this in the GitHub or where do we have- Yeah. This is the app spinning up, uh, when you clone and CD into research desk and run Bun run dev. This is the website you will, you will get.

Uh, can I ask a question?

Yeah. I don't see you, but

Oh, here. Uh, I'm wondering, like, you know, so when you say Claude handle and manage the agents, where is this running? Is this running on AWS-

Yeah, that's a good question

... after all?

Um, so we, we, we're gonna run it in our own infrastructure. Um, today we, we have, like, a 1P offering, uh, that we run on, but we also have Claude Platform on AWS if you wanna run on AWS using your AWS credits. What we also offer, and maybe we can talk about this after this demo, is self-hosted sandboxes. So if you wanna bring your own sandbox through, uh, c- different providers like Vercel or Modal or Daytona or a bunch of others, you can do that. Uh, even, you know,

through Google Cloud and, and AWS, if you wanna run your sandbox in that, uh, environment, you can. Um, okay. I'm gonna continue with the demo. Um, the, the first thing you want-- The next thing you wanna do is create, push this button, which is gonna create, um, your agent. So it's gonna create two things for us. Um, an environment, which Priyanka talked about, is a template of what the sandbox is gonna look like. Um, for this demo, we're gonna give it access to a few websites that it can reach out to, mainly the

SEC. We're gonna add, uh, some Python packages so that it can reach out to, to, uh, the SEC with, you know, some predefined, uh, Python packages. Um, it's also gonna create, uh, an agent. So it's gonna create this very basic agent. Right now it has no tools. Um, it has, uh, just a prompt. Uh, well, it has the basic tools, but there's no skills, there's no sub-agent coordination, nothing like that. Um, I'm gonna tell Claude to Um,

continue and implement the interface with which we can talk to this agent in our application. Uh, like Priyanka mentioned, the main, uh, way you communicate with a session is through an event stream. So you listen onto that stream for all the events that the agent is pushing back down to you, and you can use that as, uh, an endpoint to push events back up. So really, everything that happens in the communication for these more chat-like applications happens on that stream. So we can see here what Claude is doing is it's,

uh, implementing the section so that when I press enter in my chat box, it's gonna send the user.message event with the content that I'm sending to that session. And then it's gonna route the SSE stream back onto my browser from my back end. So it's gonna listen onto, um, the events that are coming in the s-stream connection to our API and then restream them directly back onto the front end so that I can render them in a nice way. Um, and once Claude has done that, we

should be able to go to this desk tab and just say hi to our agent. Um, and if everything worked...

Hopefully. Great. Um, so we can see here now we're, we're talking to our agent. If you wanted to build a chat-like application, this is where you would stop, um, which is great, but we wanna do more. The whole point of Claude Managed Agents is that you can do long-running asynchronous tasks, um, not just for minutes, but hours, days, weeks, and even months. Um, so let's see what we, we have to do next, right? The next thing that we're gonna wanna do is, um... Oh, Claude is very

eager today. Um, okay. The next thing is we, we wanna augment our agent, right? We wanna give our agent the skills so it can call the SEC. We wanna use multi-agent coordination so that, um, our session can delegate work to subagents that are more specialized and capable of doing some tasks. Um, and we wanna basically move up the ladder of intelligence. Um, so let's do that, um, by saying, uh, workshop next. Um, now what Claude is gonna do

is it's gonna implement the provisioning scheme to upgrade our agent so that it uses, uh, more subagents or any subagents. Um, is we're gonna give it a skill, a skill that lets it, uh, um, talk to the SEC. We've described how to use the Python package. We've described that it has to use the EDGAR identity to call. Um, we've, we've described all of that. And we're gonna give it a custom tool, uh, for later in the workshop. Um, that custom tool is

what we're gonna be able to use to tell our head of research agent to spin off multiple sessions that we will coordinate, uh, for a, a sort of custom harness. So this is what Claude is doing here. Um, it's updating its progress, creating this custom tool called dispatch analysis. We're gonna come back to this in a second. Um, we give it a schema. Um, it's going to update the, the description of the main agent so that it creates a new version of that agent. Uh, this new version will have,

um... Oh, pager duty. Um, uh, this new version will have, uh, a few different subagents, uh, that it can delegate work to, as well as a reference to itself. So if the main agent ever wants to spin off a copy of itself with its same prompt, it can do that. Um, this is important because, uh, sometimes you don't necessarily know what sort of tasks your session's gonna wanna do, but you have a general, uh, idea that you wanna have subagents that, you know, spin up and

do work. Uh, so you can define a self-reference to y-you know, yourself, that Claude can then spin up a subagent for. Um, important-- This question has come up in the past. It doesn't copy the transcript of that session into the subagent. It just copies over the tool description and the schemas, uh, and the prompt, uh, into, into that subagent. Um, cool. So now, if we go into here, we should see that there's a new agent.

Oh, I think I need to provision them. So there should be a button in our setup, uh, that says staff to desk. When I do that, it's actually gonna run... Oh. Uh, uh, okay. I ran this before. Let me delete the skill so that I can recreate it for you. Um, I was trying to do the magic, uh, cook show thing, but that's fine. Um, okay, so we'll delete the skill. We'll ask Claude to reprovision it. Um, it's gonna create all those resources, and then we'll

be able to see here all the subagents, the skill that we created, um, a memory store. So for these sessions, we, we, we also support, um, long-running memory store that can be shared across sessions. Uh, and we're gonna use that so that different sessions can learn about different financial instruments, and they can share that knowledge, uh, with each other. And at the end of this workshop, I'll show you how you can use that memory, long-running memory to keep improving your agents long term over many, many, uh, sessions, days, months, years.

Um, cool. So we should see here that the agent now, right here, um, has the skill that we described. It has subagents, uh, with their own prompts and tools and permissions. Uh, it has a prompt, and it has a model. Um, and I think we're, we're ready to use this new dedicated subagent to do our first asynchronous long-running task. So let's, uh, tell Claude

to move on to the next thing. The next thing that we wanna do is, um, we wanna tell Claude, not in a chat-like application, but a more asynchronous thing, "Hey, research this financial instrument and give me a report in a format that I define and I care about." And we're gonna use something called Outcomes. Outcomes is how we've created self-supervision. So in an Outcome, you tell Claude, "This is your task. This is your rubric to evaluate your task." It's gonna go off and do that work, and then when it thinks it's

completed, it's gonna ask a sub-agent to look at the rubric and the work that it-- Claude did, uh, and evaluate did it do it correctly and did it do it to completion. Uh, if it does, then great, and if it doesn't, it will try again. Um, so here what Claude is implementing for us is basically this user-defined outcome event so that anytime we start a session in our UI that I'll show you for a specific ticker, it's gonna send this user-defined outcome with a specific rubric,

uh, max iterations, um, and a description of the task at hand. And so, then Claude will go run that task for us. Um, and so what does that look like in the UI? If you look to this scorecard, um, I can tell Claude, "Hey, I, I wanna analyze NVIDIA." Oh. Please.

Okay, great. So it's gonna kick off a session to do the analysis on NVIDIA. Um, this is gonna take a while. I'm gonna do the cook show thing and show you a previous session, um, of what, of what happened. Uh, it's gonna take about ten-ish minutes. Um, but here's something I ran yesterday. Uh, the first thing we're telling Claude is, "Here is an outcome. I want you to analyze NVIDIA's most recent, uh, SC-- you know, quarterly filings. Um, you're gonna use EDGAR identities. This is where your EDGAR identities are. Um,

you have memory, so check if you've already done analysis previously and make sure that you use that instead of refiling and researching things that you already know. Um, I want you to find the most, uh, recent form that, that I care about and run any analysis over that. Um, and then I want two deliverables. I want you to write a note in, in my memory, um, for that specific company, and I want you to write a scorecard in a well-defined, structured output, and I want you to save that in

a specific file location." Um, so then Claude went off to work, started calling tools. It didn't find any notes in its memory store. Um, it, uh, looked in a few different places, and then it decided, "Okay, I know what to do. I'm gonna leverage my sub-agents to do the bulk of this work. Um, I'm gonna spin up a financial, um, expert analysis agent, uh, or extractor, and then a risk evaluator analysis." And you can see all of that

in the, uh, console here for full observability. Each of these lines here represents a thread, and a thread represents the work done by a sub-agent. And so each of the sub-agents went off to work, and then when they were done, they let the main agent know, "Hey, this is what you asked of me." Uh, and then the main agent woke up, uh, got that information from the sub-agents, and then, uh, filed everything it needed to do and created the deliverable. It created the JSON file that, you know, we specified, uh, and it made sure to update

the memory. And then the self-supervision started. So it kicked off a sub-agent to verify that the outcome that we define is being met. Um, it looked at the rubric, it analyzed all the work that was done, uh, in the session, and analyzed the artifacts that it created. Uh, and it, uh, decided in the end that this was satisfied. That the s-- you know, scorecard was delivered, uh, that the numbers are well-defined, uh, that the memory update, you know, was correct, um, and everything looked good.

Um, I don't-- I think this is still running, but once that completes, uh, you would see a table here of each of those tickers, um, because we can extract the report, the scorecard from the session and download it. You put it in a database. For this demo, we put it locally, um, but I think you get the idea. Um, okay, this is great, but what if you wanna do a hundred or, or ten tickers at a time? Wouldn't it be great if I could chat with an agent to build a custom harness that could then delegate

work, uh, for each of the tickers into a different session, and then when it's all done, aggregate the results and give me, uh, a bunch of scores? Um, so that's, that's what we're gonna do next. Um, we're gonna leverage that tool, the custom tool that we created to build our custom orchestration harness in our server, um, where when we talk to our main agent, at some point, that main agent is gonna decide, "Hey, I wanna spin up, uh, ten different sessions to do work." Um, we'll get that-- Oh, I

skipped a step. Sorry. Um, for-- We're, we're gonna update the skill, uh, first. Um, so I, I want to show you that these skills are, are live artifacts that you can update. Um, so you can improve the skill. Uh, in this case, uh, we're adding the ability to look at a new form. Uh, and then when you do so, any new sessions that, uh, reference that skill will get that new information. Um, so this is something that you can continuously update. You can look at previous sessions to see how they performed. We're

gonna see that, uh, at the end of this, uh, demo that, that happens with, with something we call dreaming. Um, but yeah, this, this is what is happening. Um, okay, I'm, I'm gonna move on to the orchestration bit. Um, so now that, yeah, that-- basically that skill is published. Um, I think if I go here, we should see-

Any, any questions so far? Um, I know this is a lot to take in. Uh, Travis, there's a question over here. Yeah.

Um, and I, I know someone came up to me asking about, like, how long it takes to get the credits. It should be only five minutes. Um, I know the form says one to two days, but you should see it within five minutes.

Um, I was curious about the, the data access, uh, from the SEC that the, the research agent is grabbing. Does that require some sort of credentials, and are you gonna walk through the part of how the-- how that credential injection or, or brokering works?

Yeah. So for, for the SEC, it just requires your email and your name. Um, for this demo, we just inject that in the prompt. But in a real production application, we would use something called vaults. Uh, the way vaults work is you define a secret, uh, that you wanna u-- inject in an environment variable. And instead of putting the real secret in, what we put is a, is a placeholder. Uh, and then when Claude is doing work and it wants to use that environment variable, um, it just injects the placeholder value. We at egress

swap it out for the real value only on the host domains that you specified are allowed for that secret. So if you say, uh, "My super secret env var can only be used for the SEC," and then Claude tries to use it for anthropic.com, we wouldn't inject, we wouldn't do the swap. But when it tries to call the sec.com, it would do the swap for that.

And Vault is essentially like an API where you can use it on console, where you just go create a Vault, give it a name, you'll get an ID, and then you essentially include that ID in your session as a way for us to authenticate with your MCPs, your CLI. You... For example, you could do like a Google Workspace CLI that you install on your, um, sandbox, and then you can give us like your API key as your environment credential, and again, we'll, we'll kind of follow the same method that, uh-

Well-

... Gabe talked about. So that, that allows us to essentially have that credential.

Well, Vaults also work with OAuth credentials for MCPs.

Yeah.

And they also work-

Gabe, I don't know if you wanna just show it on, on console, like, uh, the, uh, quickly, like the Wal- Vault creation.

Yeah. Um-

As well

... so you can, you can create a Vault here, and then in a Vault you would bundle credentials. Um, so you can have MCP auth. Um, maybe you do Notion. You know, we have a few predefined things for OAuth things. Um, so whenever you reference a session, you inject that Vault ID and it will bundle all the credentials into your session, and whenever it tries to use any of the domains that you specify in your credentials, it will swap for the real, um, credential instead of the placeholder.

Thank you.

Yeah.

Um, quick question. What part of the capabilities in the Claude Agents SDK and what's about it?

Can you... What, what do you, what do you mean?

You, you have the Agent SDK, right? Uh, presumably this is built on top of the Agent SDK. I want to know what part of the capabilities are in the Agent SDK layer, and what's outside of it.

So the, the Agent SDK is packaged for, uh, like m- more, more... It's like a headless Claude code version. So it's actually, we've built a generic version of that. We've tak- taken a lot of inspiration about the benefits and lessons from the Agent SDK, but we've rebuilt, uh, the harness to be a more generic, not just coding specific thing. Um-

So it's sort of a fork?

Uh, yeah.

Yeah. It, it's basically like its own harness. Agent SDK is basically like a Claude code in the form of a binary that you can take and run wherever you want. This is a fully hosted solution running in our cloud, and we have our own harness that's heavily inspired by Claude Code's harness, and we frequently stay, stay in touch for like any enhancements across the board. Uh, I, I saw another hand in the, in the back, uh, over there.

We, we have a question here. Yeah.

A couple more.

Thank you. Uh, I guess the question as you're orchestrating between multiple agents, um, is there some guardrails that those agents would not go into loops and like consume a lot of tokens, um, as they're generating or working together?

Um, some of that we leave up to you to orchestrate and figure out. I mean, we're... If you're building these sort of custom harnesses, there's nothing stopping you from using, uh, like other providers if you wanted to do a sort of multi- uh, multi-provider system. Um, we are exploring the idea of what it means to do like budget, tighter budget controls, so that you can say, "Use no more than this amount of money per session. Use no more than, uh, this amount of tokens per session." Um, but that's not something we offer today.

Um, yeah, go ahead.

Couple more hands.

Question. Uh, earlier you were showing us in console kinda a transcript of the manager and then the sub-agents, and you could kinda go through and see what they were doing. If you were to come across maybe, uh, a mistake or like it was going down the wrong path or you wanted to change history, I mean, obviously that's-

Yeah

... what's happened, is there some way to correct it or to kinda go back to that point in time and kinda start over, try it with some additional guidance? Is there any- anything like that in here?

You can steer it. So I could, I could, uh, I think here if I say, uh, send event, I could send a new user, uh, .message_event and steer the agent. Uh, it'll queue it up. It's, you know, you can send the 10 messages at a time and it's fine. We don't currently have a way for like rewind and roll forward, um, but that's definitely something that, uh, if, if people are interested, we, we would look into.

Yeah. S- session forking is essentially what you're asking for.

Yeah. Yes, yes.

We've, we've had a couple, a, a few customers who have asked around that. It's, it's, it's on our roadmap, so hopefully we'll have it at some point.

Thank you.

Uh, yeah, I see a couple hands here. If you wanna hand... Yeah. Thank you, Rohan.

Oh. S- so-

Where are you? Okay. Okay. Okay. Yeah, go ahead.

Assuming all of this is running in the cloud-

Yeah

... like, like, you know, um, you gu- you guys have any roadmap to get collective knowledge across these agents? Like, like say in this one particular application you have 10 users-

Would, would you mind speaking up? It's a little hard to hear.

Oh. So, so if you... Assuming all of this is running in the cloud-

Mm-hmm

... and this application is being distributed across tens and hundreds of users, and all of them are using it for the purposes of like, you know, doing this financial research, do you have... I, I know you guys have session logs. Is there a collective-

Yeah

... memory that you guys are looking into or even have a roadmap of?

We have it today. We actually used it in this demo. So we use the m- a memory store, um, that allows you to share knowledge across sessions. Uh, and you can see here that what's happening is, um, the agents are each populating individual information about what they've done so far. Um, and then I'll show you at the end how you can consolidate that knowledge over time using dreaming so that you can continuously improve the memory stores as different agents run into different edge cases and collectively learn from each other.

S- s- just to follow up on this, so you're storing this in Anthropic's infrastructure.

That's right.

Let's say if you wanna- delineate that and, and have things running in AWS Bedrock, and I have my own, like, uh, data on our clusters or something for sandboxing. Then you mentioned about self-hosting. How much of a lock-in is this piece versus, like, how flexible is it?

So all of this is API-based, so you, you can extract the memories and put them in different systems if you want to. We don't currently support out of the box other memory providers in the session, but you would just build an MCP or a custom tool to do so. It's the way I would imagine doing it.

A- and also to add to your initial question about, like, having user level org level memory, we do allow for attaching multiple memory stores. So you can imagine having a user level memory store and then having some sort of org-wide memory store, and then you bring both to each session, so you can start collecting user level, uh, as well as org level memories. And then, like Gabe said, n- none of this is locked in. You can, like, take your data and go anywhere else if you wanted to. Ev- everything is an API call.

Yeah.

Um, I had a quick question. As you walked through the agent workflow, I noticed that the, a grader is at the main agent level, right? Like, so how do you grade these sub-agentic tasks that are happening, and then how do you manage memory across those as well?

That's a good question. So, uh, there's two dimensions to this. Sub-agents, in the way that we've built them, are meant to, uh, augment your context and leverage the capabilities of your mo- of your session by collaborating between them. Uh, the outcome definition happens at, like, an overall arching, uh, session level. So you define the outcome, and you say, "This is what I want you to accomplish." The main agent then use it, you know, use the sub-agents to accomplish that work. It collaborates between them, and it eventually

says, uh, "I'm done." Um, there is no currently support for, like, a sub-outcome definition.

Quick follow-up. Like, so as you have this dreaming feature, right? Like, so how do you learn? Like, if the sub-agents have some sort of, you know, uh, you know, off-course sort of actions, then how do you sort of learn from that?

Yeah. Uh, today the dreaming's constrained to, uh, memory stores. So I'll, I'll show you that, uh, uh, in, in a second. But basically the way dreaming works is it will analyze the transcripts and the memories created across multiple sessions, uh, so that it can update its memory so that future agents know what to pull. Um, but you can imagine that we can continue to expand that for skills and for prompts and for agent definitions so that you can... You have this continuous learning, uh, functionality. But right now we just have it for,

for memory stores.

I see a hand here, and then I'll, I'll, I'll go back to-

Hi. Hello.

Yeah.

Here.

Where, where is here?

Here.

Oh, hi.

Thank you. Uh, if you have your, let's say, company data in either, I don't know, traditional store or RAG or whatever, and you want to expose it to these type of agents through a custom CLI or MCP, what would be the safe path to put it in your environment?

Yeah, that's a great question. There's two, two ways to do this. If you are using-- If you can access that, uh, via CLI with an API or via, uh, an MCP, uh, you would just create an MCP, give it, uh, give it the authentication vault, uh, and it would just be able to call your MCP directly. If you don't wanna expose your MCP to the internet, we have a feature called MCP Tunnels, which lets you, uh, create a tunnel from your, um, network into ours so that you don't

expose it to the internet, and we would do it that way. If, if that's, uh, too big a barrier to climb, we do support self-hosted sandboxes so that you can bring your own sandbox, which has-- which is peered with your network and has access to your applications and services, and the agent would just call the sandbox that you manage and host, um, and be, uh, be able to access your, your resources that way.

Yeah.

Um, I had a question on dependencies for the environments. So I saw something you could load in dependencies. Um, is that at runtime or right before, um, it's created?

It- it's at creation time, uh, and then we'll cache it and reuse, uh, that environment across, like, re- reinstantiations of the sandbox.

So can you specify, like, internal dependencies, or do you have to pick NPM package?

Right, right now, uh, they are all-- they all have to be accessible via NPM, Cargo, uh, PIP, whatever. But you can upload files, uh, directly into, um, the session if... or GitHub repos if you wanna install them that way.

Okay. And one more thing, uh, deployments. I see a tab for that.

Yeah, yeah. I, I'm gonna get to it. I'm gonna-

We're gonna get to that

... I'm gonna continue to the-- with the demo, and then we'll, we'll do more questions in a second.