Lesson 6: Agent Plugins & Skills

Code for this lesson can be found here.

The Problem of the Growing System Prompt

So far we’ve been learning the building blocks for building agent harnesses in isolation with small focused examples. Now we’re going to start composing those primitives into something more realistic. We’re going to build out a customer service agent and use it as one of the examples over the next few videos.

One of the common issues with building larger agent systems, especially things like customer support agents, is that your system prompt basically never stops growing. Every time you add business rules, workflows, or instructions, the prompt just keeps getting bigger. Eventually, it becomes bloated, expensive, and harder for the model to reliably follow. On top of that, you’re often burning tokens on instructions that are completely irrelevant to the current conversation.

We’re going to look at a few different ways to address this problem over the next several videos, but we’re going to start with skills.

Understanding Skills and Progressive Disclosure

Skills let you create a sort of knowledge package that contains the instructions, best practices, examples, and specific guidance for any given task.

Using skills lets the agent dynamically load the relevant instructions for a task when it needs them, instead of putting everything in the system prompt or having to continually reprompt the agent with instructions in context. The important idea behind this is progressive disclosure. At startup, the agent only sees the skill names and descriptions. The full instructions stay out of the model’s context window until the agent chooses to activate a skill.

This is one form of context engineering: being deliberate about what enters the context window and when it gets there.

For our customer service agent, we’ll create separate skills for refund processing, for order tracking, and account troubleshooting. Inside of the skills directory, each skill has its own subfolder, and each one contains a markdown file for the instructions for that specific task. We’re not going to go over all of these now, but they are included in the repository if you’re interested in learning more about them.

Composing Primitives with Plugins

Now, skills in Strands are implemented using something called a plugin, and this is where the primitives you’ve learned so far really start to come together.

A plugin modifies or extends how an agent behaves. They can package together multiple primitives, like model system prompt messages, tools, hooks, and logic, into one reusable component to improve an agent’s behavior. Strands ships with several built-in plugins, and you can also build your own.

For this agent, we have a simple mocked backend with customer accounts and order history data. In a real system, this would be coming from a database or from an API, but dictionaries keep the example simple. Then we have several tools mocked up to do things like look up customer, get order history, and process refund. This simulates the kinds of operations a customer support agent might need to perform.

Then we have our system prompt, and then we use agent skills and point it at our skills directory. The plugin automatically discovers the available skills and registers them with the agent. Then we create the agent with the customer service tools, the skills plugin, and a system prompt telling the agent to activate skills whenever it needs workflow guidance.

Running the Customer Service Agent

Let’s run it. So now I’m going to say, “Help me return my order.” And our agent will think and return back to us. It’s asking for the customer ID, which, if I scroll up to the mocked data, I can see the two customer IDs that we have, so I’ll copy and paste that into our chat.

We can see it’s already calling the tools. It called lookup_customer, get_order_history, and then it called the skills tool, which was made available to the agent through the plugin. Then it says:

“Hi Morgan, I found your account. You have two orders. Which one would you like to return?” And I’ll just say, “wireless headphones,” hit enter, and this will then call the return once I confirm it.

There it is calling process_refund, and then I’ll type exit and the program stops.

The Power of Plugin Composability

Now the agent can dynamically load workflow guidance only when it actually needs it, instead of carrying every instruction all the time.

This lesson focused on the skills plugin, but plugins are a broader concept. You can build plugins for memory systems, orchestration, observability, runtime governance, context management, or custom workflows specific to your domain. But the point is the composability and how you can apply common behavior across agents in a coherent way.

In the next lesson, we’ll improve the reliability of the same customer service agent using another plugin-based pattern called steering, which lets us inject guidance and validation directly into the agent loop at runtime. I’ll see you there.

Learn more: Plugins · Skills