Transcription
So, some people use tools like Claw Code and it looks a little bit like this. It's forgetting context. You've got generic outputs and you're wasting time, quite frankly.
Whilst other people use the exact same tools and it feels a little more like this. They're shipping faster. They're getting better results and are actually saving time. So, the funny thing is they're both using the same tools, the same models underneath, but have completely different outcomes. And it's not because they're better at prompting. It's because one group built something underneath the tool and the other group didn't. And that is an agentic operating system. So it's a system that tells the AI who you are, what you've done, what matters to you, how you work, and how to execute on complex briefs. And with the right system in place, you too can get these consistent high-quality outputs 90% of the time that you use it. So in this video, I'm going to break down exactly how to build your own Agentic OS step by step. So whatever AI tool you're using right now, it will actually work the way you expect it to.
So let's get into the goal of the system. So we effectively want to build with the Agentic OS something that overcomes the limitations of LLM out of the box. So we want it to know who you are and how you work and that extends all the way to actually your business, your clients, what projects you're working on and we want that to be understood and injected at the right time in granular detail. We want it to be able to remember exactly what we worked on last week, last month, recall those decisions, recall the sessions, and actually inject that context without us having to reprompt it. We want to overcome the limitations that our LLMs are generalists and make them specialists in our processes. Make those processes repeatable with consistent high-quality outputs. And of course, the dream is to go away from the laptop and have these operate as multi-step workflows that execute autonomously without your supervision on a schedule.
We want to be able to plan for different types of projects. So, if we're building out a complex SAS, we want to make sure that the planning is in granular detail to match that project. Many of you will be working across multiple clients, multiple businesses, multiple projects. So, we want to ensure the architecture maintains that clean separation between clients. One of the most painful things I've seen is outputs being put everywhere in different file structures, etc. So, we're going to show you how to put those in predictable places and of course access it from anywhere. So, you don't need to be sat at your laptop to actually run these systems. You've got the power of the system, but the ability to actually access it from anywhere in the world.
So each one of these is actually a limitation of the LLMs and the tools we're using out of the box and each one is a section inside this video. So tick all of these nine off and you've got an agentic operating system that's going to produce you high-quality outputs on a consistent basis. So we'll walk you through one at a time and as we go we'll build up a full architecture diagram. So by the end of the video you've got a complete picture that you can take away and you'll know exactly where to start when building out your own AgentOS.
And the simplest way to think about all of this is that an Agentic OS is just clever context management. So it's all about folders, files, and a structure that tells your AI tool exactly what it needs to know, exactly when it needs to know it. And by the way, none of this is code. If you can organize a Notion workspace, then you can actually build out this for yourself, too.
So out of the box, your AI tool is going to start every session from zero. and you're going to re-explain your role, your communication style, and all of those non-negotiables. So, we need to build a system that effectively tells the AI who you are, who it is, and how you work. And that extends then to knowing your business context, your clients, and your projects. And if AI is missing this foundational layer, then you're going to keep getting generic outputs every single time.
So, the fix is what I call static context. So static context about you as the user and static context about your business. So let's start with you because every agentic tool reads an identity file first and it just goes by a different name depending on the tool that you're actually using. So in Claw Code you might be familiar with Claude.md, in CodeX and some others it's agents.md. In OpenCLAW it's going to be the soul.md file, but it's the same idea. It's just held with different names. And you can think of this as just something that's injected into the system prompt at the start of every session so that the AI tool responds in a way that is relevant to you and or your context.
Now, here's the trap that most people fall into when they're creating these. They're going to start building these from scratch. But actually, I wouldn't do that at all. I'd highly recommend actually just letting AI interview you. So, you can open any of your tools, ideally one that has some past conversations with you because it will have some memory already of the things you've spoken to it about. And you can leverage the in-built "ask user questions" feature to get it to actually interview you. So say something like, "I'm building my identity file. Ask me 15 questions about how I work, what I want, what I don't want, how I want you to respond." And once you answer those questions, you'll effectively be able to put that into your user.md or your personality.md file. Now, it doesn't matter the naming of user.md, personality.md, but the way we've distinguished these is user is all about you. The personality is all about the agent that's going to respond to you. And then in your Claude.md file, if you're working in Claw Code, you'd reference these files to get that to inject the context at the right time.
So that covers you. But the other part of static context, and the reason we call it static is it's not going to change very often, is your brand context. So this is things like how your business speaks in the marketing messaging they produce, who is your ideal customer profile, how are you positioned in the market, etc., etc. Now this won't necessarily be injected at the start of the conversation inside the Claude, but there are certain things when you converse with the LLM and certain skills which we'll come to later that will be able to reference them for your context and this alone will 3x your output quality. If you're producing any sort of knowledge work, having inbuilt context, shared brand context is going to 3x to 10x your output quality, I guarantee it.
Now if you're looking for an off-the-shelf system, a good Agentic OS will not just ask you to actually write your identity file from scratch, not ask you to input your brand voice. It's actually going to run interviews on your behalf. So when you do install it, it will run you through a process of actually gathering examples of your brand voice or getting you to answer questions so they can actually spin out those documents in as short a time as possible and get to a 70% version within 10 minutes or so.
So the way we've tackled these two things in our own Agent OS: Firstly, we have a context folder which you can consider the agent and user context. We have the user.md and we've also emulated the OpenCLAW method of having a soul.md file which is effectively the personality of the agent responding to us. And all of these are generated on first install of the system. Then separately, we've got a shared brand context folder with all of our business assets like our brand links, our links to our school. It scrapes those automatically, our positioning and most importantly our voice profile, which is a comprehensive log of examples of how we speak in all of our messaging that's injected into certain skills at the right time. And the reason it's important to be shared is you update it in one place and all the skills then pull from that shared context folder.
So that's all static context. Let's talk about your ongoing projects and your dynamic context which you need to maintain with a memory system. So this is all about recalling session data, recalling your decisions you made a couple of months ago. All the learnings then feeding in to self-improve the Agentic OS. And you know, this is the stuff that happened yesterday, last week, three sessions ago, whatever. And there's a ton of options in the memory space. But what I will say is the out-of-the-box memory is pretty poor. So the more context and knowledge you push into a conversation window, the worse the recall will become. And that is effectively called context rot. So, if you're trying to run a business on this system, it's literally impossible because your AI is forgetting what it learned about the project progress in the previous week and you might as well just start the project from scratch. So, it's so critical to have a memory system and there's a ton of frameworks out there.
So, let me distill it for you. And I made a full video recently breaking down memory systems. I tried a ton of them and I researched a whole lot to break down these memory systems into just six levels. So, this is all the way from your native files like your Claude.md or your agents.md and the inbuilt functionality there all the way up to cross-tool shared memory. So if you're working across different devices, different LLMs, shared memory across those. But here's the quick 101 on that and where most people will land for this. So level one is your Claude.md or the equivalent. So these are, as we've discussed, static rules that never change and that's totally built-in, but that still relies on Claude actually reading and understanding those instructions. So level two is a step higher and it's a session start hook. So all this does is forces your project context to load every single time. So a hook deterministically says push this data into the conversation window. Whether it likes it or not, it's going in. Whereas a Claude.md file might tell it to read another file for context, but Claude doesn't actually have to listen. A session start hook forces that action to take place. So if you want your business context or your brand voice to go into that conversation every single time, you can force it in with a session start hook.
Now level three is what most businesses probably need on top of that, which is a framework that's separate that is all about semantic search. So searching by meaning and you've got tools like Mem.search or ClaudeMem that effectively help you recall information at the right time that help you search over notes that are stored from your structured markdown conversations. So think of it like you ask a question and the system is going to look for the most relevant memory pieces and pull that out into the context. So level three there is the 80/20. So you can combine levels one, two, and three. And that's going to be sufficient for most people. Levels four, five, and six are the optional bolt-ons for specific use cases. So level four is like word-for-word verbatim recall. And you can use something like Mem.palace for this. And you probably add this if you're doing client work where exact phrasing matters. So then we have like a step up from there. We have levels five and six, knowledge bases and cross-tool memory. So, this is only worth it if you've got a specific reason to do that. And you can always check out that separate video if you want to check out more about those memory systems. But the important part here is you don't have to pick one and stick with it. You can actually layer multiple of these concepts together with one file structure. And that's exactly what we're doing inside our AgentOS. So, we've got level two with the hook injection of the right context at the right time with level three with the semantic search bolted on so that we improve the recall across multiple projects. And that semantic search is alone one of the reasons that everybody loves a framework like OpenCLAW because its ability to actually remember what you've spoken about in previous conversations kind of just blows your mind.
So then with memory sorted and once you've picked a framework, your system is actually going to start remembering what matters across sessions and massively improve what you get out of the box. Okay. So that is all the input layers covered: your identity, your business context, your memory. Now, let's talk about getting high quality from doing the work itself. And as a quick aside, if everything I've shown you so far sounds like a lot to set up, the identity files, the brand context, structured folders, the interview process, the memory layer, we've already done it. So, if you just want to grab it out of the box, one-line install, 10 minutes to get all this context set up, then make sure to check out the Agentic Academy linked in the description below. And if you'd rather keep building it yourself, then no stress. Just keep watching and we're going to walk you through every single piece left.
Now, how do we achieve repeatable processes with consistent outputs when AI models are designed out of the box to be jack of all trades, not specialists? We actually have to teach it how to do those specialist processes through our skills. So, the methodology, same as everywhere else in this video, is build a scrappy MVP version of a skill, use it for a week, try and actually get good outputs with that process, notice what's broken, fix it all up. Don't try and make a perfect skill on day one. But you can leverage things like Anthropic's Skill Creator skill to get a head start and build it in the right way. And the most important thing for your agentic operating system is keeping your skills short and modular. So they're designed to use something called progressive disclosure. So they always load the name and the description and that tells Claude if they need to be used. Then the full skill.mmd file gets loaded in next. So we want to keep this under 200 lines as we know for a fact that Claude can reliably recall this amount of information. Then in each instruction set, we actually separate out additional context like examples of best practice and Claude then can choose whether it loads and unloads that context and it can do that exactly when it needs it in that step only, i.e., not bloating our context window.
Skills should also always reference your business context. So when your copywriting skill runs, it's not guessing your brand voice. It has access to that shared brand context that we brought up earlier. So when the research skill runs, it knows your custom segments because it's going to pull exactly from your positioning or your ICP. So when you're actually building these out for yourself, you just need to make sure you're always building them to reference your brand context. And you probably adapt Anthropic's Skill Creator skill to actually tell Claude how to build it so that it always references brand context when relevant from your shared folder. So what we're doing is building skills that are designed for the way in which your folder architecture works. And you get some bonus points if you've built in a rule inside your skill, which is effectively self-learning. So every time a skill is used, it's going to ask you for feedback, you're going to give it feedback, and then every time it runs again, it's going to read the feedback first before it runs. And you can do that through something like a learnings.mmd file or in the skill directly with a step in the skill to say "read the feedback before you take any action."
Skills are going to give us specialist knowledge to do certain things like copywriting, video creation, repurposing our content. Anything that you have a process for should be turned into a modular skill that can be used across multiple processes. So think of a skill as one step, something that can be reused and something that can be chained together to make multiple repeatable processes. So you might have a skill for example that just transcribes videos. So you give it a URL and it transcribes videos. That is a process in of itself. But that transcription skill can actually be used in multiple processes, right? It can be used in short-form video creation. It can be used to actually generate newsletters or blog articles. So what we've done then when we've built this skill is made it completely modular so that other domains and skill systems can actually pull from that, which is when we start chaining them together, which is the next step.
And this is something I rarely see people cover and I rarely see in other Agentic OS. I want you to start thinking about your skills not as single isolated skills, but as part of a full pipeline or process. So you don't build a copywriting skill to use it in isolation. That's not going to save you much time. You're still going to manually then need to schedule your content, find out about the topics. What you're actually going to do is chain multiple of these skills together in a chain, as it sounds. Something that we call skill systems. So you might actually have a scheduled task and you can do this through the Claude desktop app. And that scheduled task is going to conduct your topic research. From that topic research, another skill is going to actually write a script, maybe for a short-form video, maybe for a long-form video. And then that is actually going to then either create the video or do something in the next step. We might have a separate scheduled task, a separate skill system that is all about repurposing the content. So it understands that a video has been posted. It then uses the transcription skill. It's then going to go and actually repurpose the content. We might have a human-in-the-loop step where we review, approve and make changes and then from that it goes and posts the content. So actually, I want you to start thinking about skills as these modular components that you piece together on a schedule so that you don't have to be there when these skills run. And that's really how you get your time back, right? You're using this as an autonomous skill loop. So skill A is going to complete. We might have that human-in-the-loop step. Skill B is going to continue to iterate until it's complete. and each one passes to the next with one skill orchestrator actually kind of a meta skill chaining all of these together to finally achieve an output. Like for example, inside our community, we've been voting on what skill systems to build out next, which are chains of multiple isolated individual skills together. So like social media content generation, social carousels, ad generation and monitoring, SEO, blog content generation or GA4 page optimization. So, it's something we're really focused on for our own Agentic OS, something that you should be heavily focused on if you're looking to actually get back your time to. And they don't need to be completely autonomous. They can have multiple human-in-the-loop steps as well.
Now, single tasks and chained workflows are kind of one thing, but you need to make sure when you're doing day-to-day work that you have different levels of planning that match the project spec. What I mean by that is when we're actually working across tasks, right? We can be doing a small simple task in our day-to-day and that we might just use the in-built Shift+Tab twice planning mode inside Claude to generate a small plan for us. Or we might have a more complex plan, or even something highly complicated where we're building out a full SAS application, for example. And for those, I just highly recommend finding and solidifying three or four levels of planning so that you can actually leverage those frameworks out of the box. Now, level one is kind of inbuilt planning and only goes so far. You can absolutely build a complex SAS using the in-built planning mode with Claw Code, but I guarantee as you get a few hours into the project, it will start forgetting your original requirements, even if you documented those in certain files. So what we do is we pick two other levels of planning. Plenty of frameworks out there. Just Google "planning frameworks Claw Code". But the ones I'd recommend are something that generates a planned project like a PRD for half a day to multi-day, scopes out your project, puts them in specific files, and we can go through and actually tick boxes against those files. It's just breaking down your tasks into more granular detail. And then I'd highly recommend using the "Get Done" or GSD framework, which is a lightweight metaprompting, context engineering, whatever you want to call it, framework for breaking down complex tasks into phases. And this is just a simple way to plan out and inject context at the right time. So it's designed to solve the context rot that we talked about and quite literally has three things going on. So you start a new project, it's going to plan each phase, it's going to execute each phase, and then it's going to go through and help you verify each phase. So what you're doing is just walking through a complex plan broken down into much smaller plans, milestones, tasks, etc., with a roadmap so you can actually inject the context at the right time. That is literally all it is doing. But I just highly recommend that if you're going to build out an operating system, you want some level of planning determination dependent on the question you're asking or the task you're completing.
So the reason I know that this is a really critical feature for an operating system is that we've had so many people actually ask us when we were building out our own Agentic OS to add the functionality and architecture to handle this. So, I know it's a problem for many of you because it's all good and well thinking about the structure when you have one set of contacts, but what happens when you have five different layers with five different client contacts that you need to manage and inject into the right conversation at the right time? So the way we've effectively set this up is to have a multi-client architecture that at the root folder level handles a lot of shared skills, shared scripts, shared methodology, but we can still retain the business context that we mentioned earlier, this brand context at a client level. So for client A, B, and C. So the easiest way is just to show you exactly what we've done. So we've used the inbuilt context inheritance from parent folders inside Claw Code. So we have one master Claude.md and that is the parent folder that passes down a lot of the methodology that's consistent across multiple clients. And then inside the root folder, we have individual client folders. Inside those client folders, we have client one, client two, etc. Wherever we want specific client instructions, we've actually duplicated that Claude.md at the top and just added specific instructions which either conflict or override the Claude.md from the parent methodology. Then at each client level, we have its own client brand context. So the same concept that we talked about before, but just at a client level. We have individual brand context at that level. We also have the agent context at that level too. So the memory that we talked about and the learnings are all on a per-client basis. And because the skills need to work from the .claude/skills Claude/skills folder, whenever we're working in that client folder, by just `cd`-ing into that client folder, we need to make sure that we have access to those skills or make sure they're globally installed on our computer. So, we choose to keep them at the root level and actually have a working copy synced from the root that you can customize at the client level. This means we have a bunch of information in the shared layer and separately we have stuff at the client level so that we can deliberately work inside that client on their projects only. And that just represents itself as a client folder in the agent's root directory. So all of this inheritance of context means you can actually run as many clients as you want without inheriting the context from it all, but still sharing the important stuff like the skill methodologies which make it a specialist.
Now, two really quick but important ones to finish. Number eight, outputs in one predictable place, came from a personal limitation that I observed when I was getting so frustrated with producing a ton of outputs inside Claw Code. So when you start working with Claw Code or any of these apps, you'll realize that they store outputs wherever they want, effectively. There's no constraints on purpose around where outputs are stored and whether they're even put into files. So you get a lot of outputs in the terminal window. You get outputs saved in files, subfiles, wherever, but there's no specific file structure deemed necessary. So it seems really simple, but there's no out-of-the-box way to solve this. So we've just created a simple folder structure per project, per skill, so that when we run a specific skill, let's say the Excalidraw diagram skill, we can jump into the output folder, which is the AgentOS video, this video, and we can see directly the image that we're looking at inside of Excalidraw. So it's a projects folder, which is all the outputs inside that. We have it listed by skill, which are categorized by type, hence marketing is like marketing content repurposing. And then when it's not done by skill, when it's done by a skill system or collection of skills together, then we're actually creating more complex briefs. So we store all of our plans inside the briefs and then any outputs from those briefs are stored inside that relevant folder. For example, landing page copy is stored alongside the plan there. We can open that up and see directly that file. So it's just a simple way to frame putting all the context of that specific client in a project folder so that you can see it all in one place. Very simple, but very effective because it works with the client's methodology. Each client has their own projects folder, i.e., we're storing it with that client.
And the last important thing is that you want to access it from anywhere. So you effectively want the system to come with you. So the fix for accessing it from anywhere is kind of two parts. First is get the system off your laptop. And secondly, it's giving yourself a way to message it. So part one is actually running the system on a server and not on your laptop. So you can use something like a VPS or literally use Claw Cloud to host it anywhere and access these jobs from afar. So you don't need to keep running your machine continuously 24/7 to get these scheduled tasks done. And I'll admit at this point, we don't actually do this just yet with our own Agent OS. We just run it off our laptops. And the second part is actually just an access layer. So, do you need to open up the terminal to actually message and talk to the folders inside the AgentOS? And the easiest way to fix this one to get access on Telegram or Discord is to use Anthropic's built-in channels feature, which allows you to effectively talk from your phone via Telegram to the instance which has access to all of your files in the background. And this isn't just Claw Code. CodeX is heading the same way. OpenCLAW has it natively. Hermes has it natively. So in practice, you can actually just message it from anywhere and it still has access to all of the underlying file structure and therefore context that you've built in the background.
So that is the nine pieces that make up an agentic operating system. And you can just think about it as a structure that you're building to manage context under the hood for different use cases. And this architecture is completely portable. The tools are going to keep changing, but the underlying structure and the foundations that you built here today are going to stay true until the tools get better and they're able to do these things out of the box. We'll still need to continue to build our own Claude operating system or an Agentic operating system. So, you can either roll up your sleeves and build this yourself using everything we've walked through today and you will learn a ton as you build that out. Or if you want to skip the build, you can actually purchase one off-the-shelf, head to a community like our Agentic Academy or any of the other Agentic OSs out there, whichever one feels like the right path for you and spin it up in a much quicker way and then iterate from there.
So, in the next video, I'm going to dig deeper into these multi-step workflows on a schedule and talk about exactly why they're so powerful in improving your output quality. Thanks for watching. And subscribe if you haven't already.