Managed Deep Agents - Skills

0:00 In this video, we're going to cover how to add skills to your managed deep agents. Skills are basically contexts and scripts that your agent can run and read dynamically as it's running. So, instructions, and if you haven't seen the instruction video, go watch that, but instructions are always added into the agent context. So, anything in instructions the agent will always see. That's great for influencing how it acts, but sometimes there's a ton of context that you don't want the agent to always have, but you want it to be able to read it or even run some scripts or run code as it needs to. And that's what skills are.

0:34 They're loaded through what is called progressive disclosure. So, not all of the information is given to the agent ahead of time, only the basic information about what that skill is, and then the agent can choose to read more about that skill and use that skill further if it wants to. So, skills themselves, they live in the skills folder right here, and they're nothing more than a folder with a particular structure. So, each skill under skills will have a folder, and let's say that's research, and then there has to be this one core skill.md file.

1:09 This is This is a file with a particular structure. In particular, it's going to have two fields that are required, and this is going to be in the front matter of this markdown file. It's going to have a name, and this is the name of the skill, and then it's going to have a description, and this is the description of skill. And this is what is shown to the LLM. So, only the information here is shown automatically to the LLM. All of the other information here, this is loaded only when the LLM chooses to read it or chooses to load it. And so, that's what progressive disclosure means.

1:41 So, let's add an example to our agent. Let's go here. Let's add a new directory. Let's call this skills. Let's add a new directory under this. Let's call it QA. And then let's add our skill.md file. So, in here, let's add some front matter. So, we'll use three dashes, and then we'll call it name, and we'll call it question asking. And then let's give it a description.

2:12 And let's say, "Use this skill to ask follow-up questions when the user's initial question is vague." And then let's add some details. When the user's initial question is vague, ask a series of follow-up questions to get more info. Ask one at a time.

2:43 Always don't ask more than three total. Don't be too annoying. Great. So, this is a skill that we'll give to this agent so that it can run this question asking skill when it needs more information. So, let's try out the agent with this skill. So, if we go here, let's run MDA dev and spin up our agent so that we can interact with it.

3:25 And so, now let's ask it a purposely vague question so we can see how it handles it. What's in the newest version? We can see that it's running. We can see that it's reading a file, and then it asks a follow-up question. So, let's see what file it read. So, it read this skills file. So, it read skills qa skill.md. And remember, that's the exact file path that lives here. Awesome. That makes sense so far.

3:57 We can see that the result it gets back, this is the content of the file itself. So, it's just reading the file. There's nothing special about it. It's just reading the skill file, but this tells the agent how to behave. And so, how does it know how to do this? And what exactly is happening in even more detail under the hood? Let's click over here. Let's look at our trace. Let's open this up in a new tab, and then we can see what's going on. So, there's one model call, and then this read file tool, and then another model call. And so, let's look at the first model call.

4:26 And so, we can see that in here it has this context about skills. So, if we don't add skills, it won't actually have this in the system prompt because it doesn't know it. But now, it does have it in the system prompt. And so, what is it telling it? It's telling it has access to the skills library. It's telling it where it lives, and then it has this thing here, available skills. Question asking. This is the name of the skill. This is exactly what went there. And then description, that ends up being put right here. So, this is how the agent knows what these skills are and when to use them. It it gets from the description of the skill itself. And then it has more kind of like context on how to use skills, how to read the file, when to use them, executing skill scripts. So, we'll get to that in a little bit, and that's basically it.

5:10 So, this is how the agent can know how to use skills. It reads it basically treats it as as a file overall. Let's give it another skill that actually has a script to run. So, let's go here. Let's add another directory. Let's call this simple script. Let's add another skill. So, even though we want to add script, we still need to always have the skill.md file. Let's add front matter. Let's do name simple script.

5:43 Description contains a simple script. Script is in hello.py. Let's now add this Python file, hello. py. let's have it do something really simple like print hello world. Let's save that. Let's now go back here. And we notice that it remounts this thing, so we'll cover the internals of MDA Dev in the server it runs later on, but it basically remounts changes live.

6:19 And so let's go back here. Let's go to our agent. Let's go to chat. Let's open up a new thread. Let's say run simple script. We can see it reads a few files. And so if we take a look at what exactly is going on, we can see that it first reads this file. It reads the simple script tool. It then goes into LS, so it lists all files in this directory, and it sees skills.md and hello.py. It reads files, so it reads this hello.py file. It executes it, so it calls this command, and it actually runs Python to run this.

6:59 And then it it it gets hello world back as a result, and then the AI says that it ran the simple script successfully, and it gets this result back. So this is how skills can contain things beyond just markdown files. They can contain scripts that you can run and do things with. The last part of skills that I want to cover is Context Hub. So when you run MDA deploy, it will push these skills up to Context Hub. So previously, the only thing in Context Hub was our instructions.md.

7:26 So let's cancel this, and let's run MDA deploy and start pushing it up. When this deploy succeeds, we can see or even before it succeeds, we can see that it synced these things into Context Hub. So let's go here, and we now have these skills and so it actually pushed up these skills including the script here and they're now present in context hub and we can see the content here. If we wanted to modify it here, we totally could. So, we could say "Hello world foo." and save that and then if we go and use this in in the deployed version, it will now print out this. If I use the local version, notice that doesn't change and so this is the difference between context hub and the local thing. For more information, this is the exact same behavior that happens for instructions and so if you haven't seen our instructions video on what context hub is and how to use it, you should check it out there.

8:20 But this is a really convenient way to manage and change and update skills without actually having to redeploy the code. You can do that all through the UI.