Big Idea

The argument in one line.

Splitting Claude Code into named sub-agents each with its own prompt, model, and permission level converts a single overloaded session into a delegating team that gets smarter with every use.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You already use Claude Code daily but channel everything through one long conversation with no specialization.
You run or are building an AI automation agency and need repeatable, consistently-formatted client deliverables.
You want your Claude setup to carry preferences and project context forward across sessions without re-briefing from scratch.
You are comfortable editing markdown files and working in a terminal.

SKIP IF…

You have never opened Claude Code — this assumes a working installation and basic CLI comfort.
You want a no-code AI workflow; every technique here requires writing and editing markdown files directly.

TL;DR

The full version, fast.

One-conversation Claude Code is like running a one-person business forever: it can do anything but specializes in nothing and forgets everything between sessions. Sub-agents solve this by letting you write a markdown file that defines a named role, a model, and a permission level, then reference it by name in conversation. The key mechanic: Claude reads the description field to decide which agent to invoke, not the agent name itself. Adding a memory: project flag creates a persistent feedback log in the agent-memory folder so preferences carry forward automatically. The instructor demonstrates the full loop — create, trigger, read memory, improve — using a live email-writer agent, then closes with a three-tier permission model and a CTA for five pre-built business agent prompts.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:35

01 · Introduction

Pattern-interrupt hook promising a team-of-agents alternative to the default single-conversation. Lists three deliverables: definition, build steps, five business agents at the end.

00:35 – 01:35

02 · What Are Sub-Agents?

Diagram: YOU to CLAUDE (main brain) to Researcher / Writer / Tester. Boss-employee delegation analogy introduced.

01:35 – 03:13

03 · Create Sub-Agents via Terminal

/agents CLI wizard walkthrough; auto-generate from description prompt; model, color, memory scope selection; saved to .claude/agents/.

03:13 – 04:05

04 · Model Selection and Cost Control

Three-tier chart: Haiku (fast/cheap, lookups), Sonnet (balanced, daily tasks), Opus (complex reasoning). Decision rule stated in one sentence.

04:05 – 04:58

05 · Analyzing the Structure of a Sub-Agent

Annotated diagram of the .md file fields: name, description (most important), tools, model, instructions.

04:58 – 06:29

06 · Manual Configuration: Building from Scratch

Creates .claude/agents/email-writer.md by hand; file tree walkthrough showing agents/, agent-memory/, outputs/ folders.

06:29 – 09:08

07 · Breaking Down the Agent Prompting Framework

Each field dissected: description = routing signal, tools = permissions, model = brain choice, instructions = employee handbook.

09:08 – 10:39

08 · Testing the Email Writer Agent in Real-Time

Live demo: prompt fires agent; email output written to outputs/; shows Claude selecting agent from description automatically.

10:39 – 13:51

09 · 3 Ways to Trigger Sub-Agents

Natural language, @mention (guaranteed trigger), session-wide flag in terminal. Recommendation: start with natural language, graduate to @mention.

13:51 – 15:43

10 · Tool Restrictions and Safety Settings

Read-only (look, no touch), Balanced (read/edit/run, no delete), Full Access (empty tools: field). Intern-access analogy.

15:43 – 18:25

11 · Persistent Memory and Feedback Loops

memory: project flag creates agent-memory folder with memory.md index and feedback files. Live demo: tone preference persists across new session. Self-improving agent concept.

18:25 – 18:45

12 · 5 Sub-Agent Use Cases

CTA: free School community doc with five pre-built agent prompts across sales, marketing, operations, and finance.

Atomic Insights

Lines worth screenshotting.

The description: field, not the agent name, is what Claude reads to decide which sub-agent to invoke; write it as a precise when-to-use-me statement.
Sub-agents start from scratch each session by default; a single memory: project flag creates a persistent log that carries preferences forward automatically.
Use Haiku for file lookups and quick reads, Sonnet for writing and code review, and Opus only when a task requires hard debugging or full-stack architecture reasoning.
Read-only permission (read, grep, glob) is the safest default for research agents; balanced adds edit and bash but explicitly blocks file deletion.
The @mention trigger guarantees the correct agent fires — natural language routing degrades when you have multiple agents with similar descriptions.
An empty tools: field means full access including delete; only specify tools: when you want to restrict what an agent can do.
Each sub-agent is just a markdown prompt; the same mental model that applies to skills applies here — the file IS the agent.
Agent memory files accumulate feedback entries over time, creating a self-improving loop that sharpens tone and style without user re-explanation.
Organizing agent outputs into an outputs/ folder outside .claude/ keeps the workspace clean when agents generate many files across sessions.
Auto-generating via /agents in the terminal is faster for prototyping; writing the markdown by hand is better for version control and long-term maintenance.

Takeaway

The description field routes every agent — get that right first.

WHAT TO LEARN

A sub-agent is just a markdown file, but the one line that matters most is description: — it is the routing signal Claude reads to decide which specialist to invoke, not the agent name.

02What Are Sub-Agents?

The boss-employee analogy is the mental model: you give the manager (Claude) a task, the manager delegates to the right specialist, the specialist returns a clear summary.

03Create Sub-Agents via Terminal

The /agents CLI wizard handles model, permission, and memory scope selection in one flow — useful for prototyping before writing the markdown by hand.

04Model Selection and Cost Control

Use Haiku for file lookups and simple reads, Sonnet for writing and code review, and Opus only when a task requires hard debugging or multi-step architecture reasoning.

06Manual Configuration: Building from Scratch

Writing the markdown manually gives you version control and long-term maintainability; auto-generation is faster for prototyping.

07Breaking Down the Agent Prompting Framework

Write description: as a precise when-to-use-me statement — Claude routes on it to select the right agent, not on the file name or folder location.
The instructions field is the employee handbook: state the personality, the step-by-step procedure, and any hard constraints like word count or tone rules.

093 Ways to Trigger Sub-Agents

The @mention trigger guarantees the correct agent fires when you have multiple agents with similar descriptions — natural language routing works fine with one or two agents but degrades with a larger roster.

10Tool Restrictions and Safety Settings

Read-only permission (tools: read, grep, glob) is the safest default for research agents; balanced adds edit and bash but explicitly blocks file deletion.
An empty tools: field grants full access including delete — always specify tools: explicitly when you want to restrict what an agent can do.

11Persistent Memory and Feedback Loops

Sub-agents start from scratch each session by default; adding memory: project creates a persistent feedback log that carries preferences forward automatically.
Organizing agent outputs into an outputs/ folder outside .claude/ keeps the workspace clean as agents accumulate files across sessions.

Glossary

Terms worth knowing.

Sub-agent: A markdown file in .claude/agents/ that gives Claude a named role, a model selection, a permission level, and a set of instructions; Claude invokes it based on the description field matching the user's request.
description: field: The routing signal inside a sub-agent's markdown file; Claude reads it to determine whether this agent is the right fit for a given request, making it the most important field to write carefully.
tools: field: The permission declaration inside a sub-agent file; listing specific tools restricts what the agent can do, while leaving it empty grants full access to all tools including delete.
memory: project: A one-line flag in an agent's markdown that tells Claude to persist learned preferences and feedback to an agent-memory folder, enabling the agent to improve across sessions without re-briefing.
Balanced agent: A permission tier that allows read, search, edit, and run-commands but explicitly blocks file deletion — the recommended default for agents that need to build but should not be able to break things.
agent-memory folder: A .claude/agent-memory/ directory created when the memory: project flag is active; it stores memory.md (an index) and task-specific preference files for reuse across sessions.

Resources

Things they pointed at.

18:26productFree School community sub-agent prompts doc

18:37product1:1 AI Agency coaching 90 days ↗

18:48linkClaude Code Skills companion video

Quotables

Lines you could clip.

00:41

“That's like running a one-person business forever.”

Crystallizes the core pain in six words — no setup needed→ TikTok hook↗ Tweet quote

06:02

“The description is the most important part because you tell Claude when to use this agent.”

Counter-intuitive mechanic most users miss — standalone insight→ IG reel cold open↗ Tweet quote

07:43

“Use Haiku for simple tasks, Sonnet for most work, and Opus only when you need the big brain.”

Portable decision rule in one sentence — zero context needed→ newsletter pull-quote↗ Tweet quote

17:17

“Self-improving sub-agents.”

Punchy three-word label for a real mechanism→ TikTok hook↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

analogy

00:00What if instead of asking Cloud Code to do everything in one conversation, you had a team of agents that writes your client emails, one that researches your content, one that preps you for every Zoom call, all running in the background while you're focusing on something else? And what if the team gets smarter every single time that you use it?

00:14Your clients, your preferences, your projects, so you don't have to repeat things twice. Well, that's exactly what sub agents in ClawCode allow you to do, which is why in this video, I'm gonna break down exactly what sub agents are and why they're important. I'm gonna show you how you can build a team of sub agents step by step.

00:28And if you stick around until the end, I'll even give you five sub agents that I use every single day for my business. With that being said, let's dive in. K.

00:35So think of ClawCode as the business owner. Right now, what's happening is that you're asking ClawCode to do everything research, write, test, organize, right?

00:43And that's like running a one person business forever and so you can think of sub agents like hiring different employees. Each one has their own brain, each one has their own job description, their own tools and each one reports back to the main boss which is Claude in this case. Right?

00:56And so what happens here is that you tell Claude a task, you give it a task of what it has to do and then Claude delegates which means that it gives the work to the right employee, to the right agent in this case, And the employee works in their own space and then hands back a clear summary to the actual agent, which then gives it back to you.

01:14So you can think of this as a research assistant, a copywriter, and a QA employee. And so these are three different employees which are able for us to split up the tasks across different people so that each one is specialized in their own thing. And they all report back to the main agent here.

01:27So now that you know exactly what it is, how do you actually create sub agents? So there's the first way, which is using ClawCode, and the second way which is doing it manually, and we're gonna look at both ways. Okay.

01:36So here I am on Cloud Code. I made a new folder called sub agents, and for us to be able to create the sub agent, I can type slash agents.

01:45Okay? Now if you're on this view right here, you will then see a symbol which is this one right here. This symbolizes that to run this exact command to mix up agents, you have to run it through your terminal.

01:56And to run it through your terminal, got it here, you can go up terminal, You can press new terminal, and then you will be able to see the terminal here. And I can press Claude to initiate Claude to actually make Claude work, and then I'll have this screen right here. Let me actually go maxed out, and then I have this page right here.

02:12So now we're gonna be working with this page specifically to make the actual sub agent. Okay? Now that we're here, we can press slash agents even though the spelling's wrong.

02:20We can press enter. And now it's telling us, hey, agents. Do you wanna create a new agent?

02:25I can press enter again, which means yes. It's asking me the location. So project or personal, I can do project.

02:31That's fine. So now it's asking me how I want to create the agent. In this case, I'm gonna do generate it with Claude, and now I have to explain what it is that I want.

02:38For the sake of just showing you how it actually creates the agent, I wanna keep it very simple. I want a sub agent that can review or that can take an idea of a of a YouTube video, and then it can spin up 10 different YouTube ideas, give me the 10 ideas plus hooks that I can use for that specific video.

02:54Now I'm using just a very simple content creation kind of use case, but at the end of the video, I'll also show you three different use cases where you can actually apply this inside a real business. Right? Now that we have this here, I can press enter and now it's gonna generate the agent from description.

03:07And we should be able to see the files and the folder being created here, which is basically how it stores the actual agent itself. Okay. So now it's asking me to select the tools and I think of this as like the level of accessibility that you give to the agent itself.

03:19Like, for example, do you want to give it access to all the tools? Read only, uh, edit tools, execution tools, other tools. I'm gonna press continue because I can give pretty much access to everything.

03:29It's gonna ask me to choose the model that we're gonna use to be able to run the sub agent, and I'll walk you through, like, the model and which one should you choose in the first place. I'm gonna go for Sonnet because it says balanced performance best for most agents. Let's go.

03:41And then it's asking me for a color, so let's make this nice and pink. Then it's asking me where do I want to configure agent memory. Uh, keep it very, very simple.

03:49Use product scope because then it's gonna add it to your actual project. And then now you can see that it made a folder called doc log, and then I can press s to save. If I go here, I can see that it now made the agent memory, which doesn't really have much in it, and then it made the agent itself.

04:05So the agent itself, just so you know, each sub agent, all it is is a prompt. Right? The same way that you know skills, sub agents are just prompts as well.

04:13And the prompts is a list of instructions of what the agent should actually do. Okay.

04:17So now that we've made a sub agent step by step, let's go through the structure of the actual sub agent. K. I'm gonna press x here.

04:22I'm gonna expand this. And here you can see you have the name, description, model, color, memory, and then we have a whole description of the actual sub agent and what it needs to do. At this point, you have it ready, go to your chat window and then you can press file, you can press save or you can press command s and it's saved to your computer as well.

04:39And so what happens is that you'll start to have more and more agents which is more and more prompts. Right? And so you can run agents simultaneously if you want.

04:47Alright. So now you know how to make it automatically using Cloud. But just like everything, if you don't really understand the fundamentals of how it all works, then if you're stuck on something or if Claude doesn't do the right job, you won't know because you don't know what good looks like.

04:58So for us to create the sub agents, we first have to create a folder called the dot Claude folder. Now in case you haven't watched the skills video, check it out here, but I use that exact folder itself to store skills as well. And so you have agents, you have skills, you have agent memory, you have commands, you have all these things in the same exact folder.

05:15And then we have to make a folder called agents, make a folder called agent memory, which is the memory of the actual agent, and then we have the actual markdown file, which is dot m d because it's the way that it's written like this with hashtags, with asterisks, uh, to organize the text, which is the instructions of the actual agent.

05:32So I deleted the previous sub agent that we had. First things first to make our own sub agent is make a folder called the dot Claude folder. And inside this folder, we can make another folder called agent slash memory.

05:44Boom. And then inside the dot Claude folder as well, we can put the agents. And so this looks like the exact something that we had before.

05:51And then inside the agent here, we can then press new file and call this name of the actual agent. So let's say we're doing email writer dot m d.

06:01K? And then you have the actual mark on file where you'll be actually writing these instructions. Now the instructions for a sub agent prompt are divided into different parts.

06:12We have the name. We have the description. We have the tools, the model, and then we have the actual instructions here.

06:16First things first, we have the name, which is email writer in this case. It's what you call this agent. It's how you will be able to refer to it later.

06:23K. So remember the name. Then we have the description.

06:25So in this case, write professional client emails based on the context you give it. You tell Cloud when to use this agent. Cloud reads this to decide if it's the right fit, and the description is the most important part because you tell Claude when to use this agent.

06:37So when you tell her, hey. I wanna do x y z, Claude will read this exact description to decide if this is the right agent for your request. Then we have tools.

06:45In this case, we just wrote read or write. The tools are the permissions. Right?

06:48So what this agent is allowed to do? Well, it's like onboarding someone into your own project management system but not giving them access to everything. Then we have the model, which is in this case Sonnet, which is the brain that we're gonna use.

06:58So which clock of brain do you wanna use for this exact use case? Now bear in mind that we have three different models. We have HEICO, which is fast and cheap.

07:05We have Sonnet, which is why it's at balance recommended. Most agents use this. And then we have Opus, which is the most powerful.

07:11Bear in mind that the most powerful they are, the more costly they are. Paycode is very, very fast, but it's only used for things like reading files, searching code, or quick lookups. So looking for different things that don't necessarily require a lot of brain power.

07:23Then we have Sonnet, is typically good for most things. It's medium cost, so it's cost effective, hence why it's we say balanced, but it's good for writing code, code reviews, and most of the daily tasks that you do out there, like writing emails or making content. And then we have Opus, which is the most powerful.

07:37You're rarely gonna use this, but you would use this if you're doing very hard debugging, if you're making some sort of full stack application and you need a agent that can go there and debug, meaning fix the code that you're writing, or if it needs really, really complex reasoning for it. Right?

07:50So, basically, the overall summary here is use Heiku for simple tasks, Sonnet for most work, and Opus only when you need the big brain. And once we're done with the model, then we have the instructions. So this is the rules and personality and guidelines of the actual subagent.

08:03So for example, we have, uh, you are a professional email writer for an AI automation agency. When asked to write an email, you ask who it's for and the goal. You write a clear professional email, and you keep it under 150 words.

08:14Match the tone to the situation. Always end with a call to action. So this right here is the personality and step by step instructions.

08:20Think of this as an employee handbook. You tell it exactly how to do its job. Right?

08:24So these are the instructions that you give. And so that right there is the structure of the dot m d file, which is the file where we're gonna give everything that we need to the sub agent, to Claude in this case, to know that, hey, this is the sub agent that we want to run. I'm just gonna paste the example that I already showed you.

08:39We have the name, description, tools, model, and then we have the instructions here as well. So So now we can press command s to save it. We can go to Claude, and I can paste this one for here, which is write a follow-up email to my client, John, about the chatbot project.

08:51Now what it should do is it should look at the email writer MD, which is this right here. It will read through the instructions. It will look at what it has to do.

08:59In this case, the first thing it should ask me is ask who the email is for and what the goal is. In this case, we're already told it who it's for, not entirely because it doesn't have the email. So it should ask us the email itself.

09:09As you can see, it just made the email called email John follow-up dot MD where we have the to John. And by the way, we could actually make it so that it can send the emails for us. But in this case, I just wanted to to write the email.

09:20We have the subject line checking in chatbot project and next steps. Hey, John. Hope you're doing well.

09:24I wanted to touch base on the chatbot project and to see how things are progressing on your end. Made solid progress so far, and I wanna make sure that we keep the momentum going. If there's any questions, blockers, or feedback you've been sitting on, now is a great time to surface them.

09:34I love to align on the next steps and make sure we're on track with the timeline. Would you be available for a quick call this week or early next week? Happy to work around your schedule.

09:41Just let me know what works best for you. Looking forward to hearing from you. Best, Michele.

09:44Yeah. Very, very good email. And so as you can see, we just gave it a simple prompt to write a follow-up email to my client, John, about the chatbot project.

09:51Then it knew that it had to use the agent email writer dot m d to fulfill the actual task. Now in the grand scheme of things, you will have the output. So some of them are outputs.

09:58Right? Which is this right here, which is the output of the task that we gave it. But sometimes it can get very, very messy.

10:03So what we usually do is we make a folder, which is not in the Doc Cloud folder called outputs, and then we store this right here.

10:12Move. So that all the outputs go under outputs folder. It's all to keep things very, very structured.

10:17With that said, you got to see how I built it plus how I ran it step by step. Now in terms of triggering, which is, like, how do you start the agent itself? You saw me talking to the clogged agent and not really referencing the name of the actual agent itself, but that doesn't work too well when it comes to you having skills that are very, similar.

10:32And so the main ways that we actually run the actual agent is three different ways. We have the natural language, which is similar to what I just did, but in this case, we ask it to use the code reviewer to check my changes. Use the name of the actual agent to do x y z to run the task.

10:47So Cloud figures out which agent to use and then it runs the task. The second and the most common one is mentioning. So you're gonna use at, the name of the actual sub agent, to tell it to initiate x y z or to do whatever it has to do.

10:59Right? Create the task. Now this is guaranteed to trigger because you're referencing that specific agent only.

11:04Right? And then finally, we have session wide, which is use one agent for everything. So use Claude dash slash agent code reviewer.

11:11So my advice is to start with the first one, natural language because that is the easiest to start with and then move on to the second one mentioning. Right? The only reason for that is because most times you guys are not gonna have 35 different sub agents that you have to match.

11:24Right? And so you wanna keep it as simple as possible. So right here, to reference a sub agent, you can just say, can you make an email using the email writer agent to Jessica telling her we have dinner tomorrow?

11:34And then you put the actual name. Right? You can also not put the stash itself.

11:37It's just something that I like to do to keep it more precise. And in this right here, we'll know that it needs to use the agent itself. It's gonna look through the agents here.

11:46Of course, there's only one. Right? And it drafted the email itself.

11:48The second way, like I mentioned, is you go to tag and you can see the different options. And you would use the email writer dot m d. And then you can say, can you make an email for James and Jack telling them thank you for the business meeting that we had before and tell them that the next steps is to have an onboarding call tomorrow 5PM EST to go through the next steps.

12:07And so because I was very specific and turned this off so, you know, that you're not reading it and not cheating, but we were exactly referencing the agent that we wanna use. And so there's no way that it will fail in using the agent because we give it the exact instructions to use that agent. And as you can see, it made the email itself, James and Jack, saying great meeting onboarding call tomorrow five EST, and then it made the whole thing.

12:26Right? Obviously, you could change this by putting your name. I didn't really give it the main folder, is a claud dot m d folder just because, uh, I didn't wanna spend too much time on that, but you can give it more information as well.

12:36Now in case that you are using the terminal to run claud, can simply go to slash agents again, and then you'll be able to see the email writer agent, which is this one right here. And you can simply press enter again. You can view, edit, delete agent.

12:47You can back agent, and you can do all sorts of things here. And, again, you can simply just give it natural language or you can press at email writer agent, and you can tell it whatever you want.

12:56Make an email to James tomorrow, and you can run this. And it pretty much does the exact same thing. I just wanna show both things because I know some people get when I say some people, I mean, me at the start.

13:04I got a bit confused when it came to using the terminal versus using the normal Claude chat and how those actually work. Work. So as you can see now, one thing we didn't have before, I told Claude that if I don't tell her who specifically I have to send the email to and what the goal of the email is, then it should ask me.

13:18And so here it's saying, who is James, and then what's the purpose of the email? James is a client, and the purpose of the email is follow-up after a meeting. Whisper flow has changed my life, guys.

13:25Should definitely try it out. As you can see, we have the full email, James subject, and the body itself. Now one more thing that I spoke about before is restrictions and safety.

13:32Because the thing about sub agents is, like, they get really, really powerful because you can control what they can and cannot do. The same way that you wouldn't give an intern access to the whole company database, here's the exact same thing. And so we have the read only agent, we have the balance agent, and we have the full access agent.

13:47Now when you said read only, it can look at your files, it can search through the code, it can explore kinda what you have, but it cannot edit or write. Right? It can look but can't touch.

13:55It's perfect for research that you have to do without it actually doing something on your documents or changing anything in your computer. Then we have the balance agent. It can read search.

14:03It can also edit and run commands, but it cannot delete files. Right? It can build things, but can't break things.

14:09It can only add, but it can remove, which is great because a lot of times when you have an agent that's out of hand that's going everywhere, it can delete things that later on you can't get back. Right? And so you wanna keep it normal and clear.

14:19And then we have the full access agent. It can read, edit, write. So full power only uses when you really trust the task you're doing.

14:25Typically, it's for tasks that are easy, that don't require a lot of brainpower, that are very, very structured. You have a step by step. It's done this way, and it can be done pretty fast.

14:33So here you decide what each agent can do. The less access the safer it is, the more access, the more powerful, but the riskier it is for you as the person who's actually talking to the agents. And the way that you would change the actual permission is if I go here to the MD, you would have tools.

14:46Right? The tools is the permission. So you can literally think of this as if the word's permissions, but we use tools.

14:52Right? Now if you only want this to read, you can copy this.

14:56Read grep and glob. That's it. Now if you want a balanced, which is the most common, then you want this here.

15:02Read, edit, bash, grep, and glob. It's also gonna give you suggestions, but I'm gonna keep it normal for now. And then if you want the full access, you don't have to specify tools.

15:11It inherits everything. So if this is empty, then it will use any tool that it has access to. It's only if you specify the level of permission that you want the sub agent to have that it actually uses it per se.

15:21Now when it comes to sub agents, there's one issue which is the issue of memory. Because every single time that you have a new session with ClawCode, so a new conversation, these sub agents start from scratch, which means that they don't have a previous memory of the conversation that you had before.

15:34Now as you can see here, we have a folder called agent memory and this is where this comes into play because now we're able to actually have the sub agent remember the previous conversations, and we don't have to re explain things again. So all we have to do is go to the actual agent itself, the prompt, and then we can simply right below model and above this, we wanted to include.

15:52But all you have to do here is put memory colon project. Okay? And you press save.

15:56So let me show you how it actually works here. So if I go to a new tab, of course, again, save the project so it's here. So I can go to a new session and I can say email writer dot m d.

16:06That's fine. I can paste this right here which says make an email for John saying that we have dinner tonight or tomorrow night at 5PM and make it really, really, really, really, really happy with an exclamation mark. Also, the tone to the memory.

16:20I can press go. And so now what it does is gonna launch the email, right, to actually make the email that we asked it. But it's also gonna save the tone preference in parallel.

16:27So at the same time, write the email and save the tone into the memory itself. So you can see now it's starting to work with memory.m It's gonna save the tone preference to the memory itself, which is this folder right here.

16:35I can press accept. That's fine. Accept again.

16:38As you can see here, it made the email dinner email dot m d with all the exclamation marks. It's on a voice. And then we have the agent memory.

16:45The agent memory has two different things. Has feedback tone matching dot m d, and it has memory dot m d, which is the main one. So feedback tone matching means this is the, uh, explanation of the actual tone of the email that we need to use so that we don't have to re explain to it again to use exclamation mark, to use x y and z.

17:01This list of tone for emails is gonna be used again and again when we're making new emails. Right? And then we have memory dot m d, which has a memory index, which means that every single time that we give feedback to the actual agent itself, it's gonna store the feedback here.

17:14And so we'll have more and more feedback so that it remembers the previous things and it gets better over time. Self improving sub agents.

17:20And now that we have the memory and the prompt itself, I can go here and I can say I can reference, uh, the email writer dot m d. Is it this? Yep.

17:28And I can say, can you send an email to Jack saying that we have football tomorrow at 5PM? Bring the boys over as well so all of them can have a good time and, uh, yeah, make it exciting. So as you can see now, as it's running, it's gonna read the memory dot m d file, and it's gonna do that every single time because it's with this specific agent itself.

17:46The more memories you have, so the more self improving the system will become over time. Right? And the more effective and the accurate the results are when it comes to doing the exact task.

17:53It's also looking in the feedback tone matching dot m d and then we have the actual email itself with exclamation mark here, here, here, kinda looking at the matching here as well. So that right there is a full guide of sub agents using ClockCode. Now I'm gonna leave a resource in a second link down below in my free school community, which is a document that goes over the top five different sub agents and the prompts itself that you can download in your own ClockCode, which are across sales, marketing, operations, and finance for businesses.

18:20All you have to do is just download the prompt and you can put it in your own ClawCode project. And if you wanna work with me one to one to be able to start and scale your own AI agency in ninety days, check out the first thing down below. It goes through a full video.

18:31If it sounds like a good fit, then feel free to apply. And if you want to dive deeper into ClawCode, check out this video on the screen where I go through everything that you have to know about ClawCode skills in 2026. With that being said, I really hope you found value from this video, and I'll see you in the next one.

The Hook

The bait, then the rug-pull.

Most Claude Code users treat the tool like a one-person business — ask it everything, get everything back, forget everything next session. This tutorial reframes the tool as a team: a main Claude instance that delegates to named specialists, each holding its own job description, its own model budget, and its own memory of what you told it last time.

Frameworks

Named ideas worth stealing.

00:41model

Boss-Employee Delegation Model

Claude Code acts as the business owner/manager; each sub-agent is a specialized employee with its own job description, tools, and reporting structure. You give the manager a task; the manager delegates to the right employee; the employee hands back a clear summary.

Steal forExplaining AI agent architecture to non-technical clients or in pitches for automation agency services

07:40list

Three-Tier Model Selection

Haiku — fast and cheap, reading files, searching code, quick lookups
Sonnet — balanced, daily tasks, writing, code review, emails
Opus — most powerful, hard debugging, full-stack architecture, complex reasoning

Decision rule for which Claude model to assign to each sub-agent based on task complexity and cost tolerance.

Steal forAny multi-agent system where you want to control API costs by routing simple tasks to cheaper models

13:51list

Three-Tier Permission System

Read-Only: read, grep, glob — can look, cannot touch
Balanced: read, edit, bash, grep, glob — can build, cannot delete
Full Access: empty tools: field — inherits everything including delete

Controls what each agent is allowed to do; less access equals safer, more access equals more powerful but riskier.

Steal forAny workflow where you want guardrails on automated agents without fully disabling them

15:43model

Self-Improving Memory Loop

Adding memory: project to an agent file creates a persistent agent-memory folder. Each session appends learned preferences to memory.md. Future sessions load this file automatically, improving output quality without user re-briefing.

Steal forAny repeatable client-facing task where consistency and personalization compound over time

CTA Breakdown

How they asked for the click.

VERBAL ASK

18:25product

“I'll leave a resource in the second link down below in my free School community — a document that goes over the top five different sub agents and the prompts itself that you can download in your own Claude Code.”

Double CTA: free resource (low friction) followed by 1:1 agency coaching offer (high ticket). Internal cross-link to skills video keeps viewers in the funnel.

MENTIONED ON CAMERA

18:37product1:1 AI Agency coaching 90 days ↗

FROM THE DESCRIPTION

AFFILIATECommission earned if you click.

OTHER LINKSAlso linked in the description.