The argument in one line.
An agentic operating system is not software you build once — it is a maintenance contract, and the layer with the highest rot rate (Tools/MCPs) will break your system long before you think to look.
Read if. Skip if.
READ IF YOU ARE…
- You have started building with Claude Code or Codex and your setups keep drifting out of sync with how the models actually behave.
- You have a CLAUDE.md but it has grown into a wall of instructions with no clear ownership or update cadence.
- You are curious about multi-agent systems but keep hitting maintenance complexity that outweighs the productivity gain.
- You run a small business or solo practice and want AI handling repetitive domain tasks without rebuilding from scratch every quarter.
SKIP IF…
- You are a software engineer building production multi-agent pipelines at scale — this is a practitioner mental model, not a systems-design spec.
- You have never opened a terminal or edited a markdown file; the examples assume Claude Code familiarity.
The full version, fast.
Agentic operating systems have five layers — Identity, Rules & Hooks, Skills, Agents, and Tools/MCPs/CLIs — and each goes stale at a different speed. Identity survives months; MCPs can break in hours when an API changes. The presenter's core insight is the 'rot rate': every OS needs a rot.md file written at v0 that tells the system when to revisit each layer. Two worked examples — a mini CFO OS and a personal Health OS — show how the same five-layer model scales from solo health coaching to fractional CFO work.
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 →Where the time goes.
00:00 – 00:44
01 · The dashboard is worthless without the plumbing
Cold open reframes the common over-indexing on dashboards and mission control UIs — the real work is everything happening under the hood.
00:44 – 02:14
02 · The layered mental model
Introduces the Earth-layers analogy: inner core is stable identity, outer atmosphere is volatile data wiring. Sets up the five-layer tour.
02:14 – 02:51
03 · Five layers — quick tour
Identity, Rules & Hooks, Skills, Agents, Tools/MCPs/CLIs introduced in order from core to surface.
02:51 – 03:44
04 · The rot rate
Each layer has an expiration date. A perfect AIOS today can be fully obsolete in 90–180 days without active maintenance.
03:44 – 05:30
05 · Layer 1 — Identity
The soul file / CLAUDE.md as a pointer registry. High upfront cost, minimal ongoing changes. Months-level rot rate.
05:30 – 07:09
06 · Layer 2 — Rules & Hooks
Guardrails you discover by running the system, not by planning upfront. Rules are soft; hooks are deterministic. Graduates-at-three principle.
07:09 – 09:56
07 · Layer 3 — Skills
Process-oriented vs functional skills. Moderate rot rate. /goal + /schedule patterns for automated skill optimization.
09:56 – 12:11
08 · Layer 4 — Agents
Skills aggregate into roles; roles become agents. Bootstrapped-founder framing. Fastest rot rate due to model release cycles.
12:11 – 14:09
09 · Layer 5 — Tools, MCPs & CLIs
The live data layer. MCPs are fading; CLIs are rising. Highest churn — API changes, schema drift, vendor deprecations.
14:09 – 17:05
10 · Worked example — mini CFO OS
Numbered folder structure as training wheels: CLAUDE.md nucleus, always.md/never.md rules, monthly-close skill, client portfolio agent, QuickBooks/Fathom data layer.
17:05 – 18:55
11 · The rot file nobody creates
A rot.md file documents at v0 when each layer is expected to need review — write it while the reasoning is fresh.
18:55 – 20:03
12 · Two free scaffold prompts
Prompt A (guided OS build interview) and Prompt B (dynamic workflow scaffold) walk Claude Code through building a full AIOS blueprint.
20:03 – 22:10
13 · Personal example — Health OS
Built live in 15 days. Blood panels + DNA results as LLM-readable markdown. Supabase + WHOOP API for daily health data. Claude as personal trainer.
22:10 – 24:23
14 · Personal, business, or enterprise — same globe
The five-layer model scales to any context. Enterprise just renames the layers. Closing CTA.
Lines worth screenshotting.
- The dashboard is worthless without the plumbing — building the control panel first is the most common mistake in agentic OS design.
- Every layer of an agentic OS has a different rot rate: identity survives months, hooks need weekly attention, MCPs can break in hours.
- A rule earns automation as a hook only after it fires correctly three times — build the hook before you know you need it and you will over-engineer the wrong thing.
- People love building skills but hate maintaining them — the skill layer rots because smarter models need fewer tokens to do the same job.
- Having an army of agents is more of a maintenance nightmare than a blessing — push one agent as far as possible before creating a second role.
- Agent prompts rot the fastest of all layers because every model release can change behavior enough to invalidate existing instructions.
- MCPs are on their way out — CLIs have become the preferred data-layer wrapper because they fit better with how Claude Code and Codex actually work.
- A lean CLAUDE.md that points to other files beats a fat CLAUDE.md that tries to contain everything — pointer architecture keeps the context window clean.
- Write your rot.md right after v0, not months later when you have already forgotten why each choice was made.
- You can build 80 percent of a functional agentic OS in a single weekend — the remaining months are about refining the edge cases.
Your agentic OS rots if you ignore maintenance.
WHAT TO LEARN
Every layer of an AI operating system has an expiration date, and the one closest to live data expires fastest.
01The dashboard is worthless without the plumbing
- Building the dashboard or mission control UI before the underlying plumbing is in place is the most common mistake in agentic OS design.
02The layered mental model
- Mapping each OS layer to Earth's geology helps calibrate how often you should expect to revisit it — stable core, volatile atmosphere.
04The rot rate
- Every AIOS layer has an expiration date that is not driven by bad design but by model updates, API changes, and business evolution.
05Layer 1 — Identity
- Identity files are the most stable layer — write them carefully once, then update only when your role or domain fundamentally shifts.
06Layer 2 — Rules & Hooks
- Rules should emerge from actual failure modes, not upfront planning — run the system first, then add guardrails for the behaviors that surprised you.
- A hook is a deterministic trigger attached to a specific event; treat it differently from a soft rule and never write one before you have evidence you need it.
07Layer 3 — Skills
- Skills rot because better models need less instruction to reach the same output — a skill that needed 40 lines last quarter may need 10 today.
- Using /goal and /schedule to auto-optimize skills keeps them current without requiring manual review on every model release.
08Layer 4 — Agents
- Spinning up a second agent before the first one is fully loaded is the fastest path to an unmaintainable system; one well-loaded agent consistently beats three half-baked ones.
- Every model release is a potential breaking change for agent prompts — plan agent maintenance cadences around release cycles, not calendar dates.
09Layer 5 — Tools, MCPs & CLIs
- The Tools layer breaks most often and with least warning — build data connections to be swappable, and write architectural decision records that document why each tool was chosen.
11The rot file nobody creates
- Writing a rot.md file at v0 — documenting when each layer is expected to need review — is the single maintenance habit most builders skip and most regret skipping.
14Personal, business, or enterprise
- The same five-layer mental model applies at any scale, from a personal health coach to an enterprise CFO system; only the naming convention changes.
Terms worth knowing.
- Agentic OS (AIOS)
- A structured folder system of identity, rules, skills, agents, and data connections that gives a language model persistent context, behavioral guardrails, and callable capabilities — analogous to an operating system for an AI assistant.
- Soul file
- A markdown file (soul.md, agents.md, or CLAUDE.md) that defines the identity, personality, and working style of an agent — the most stable layer of an AIOS, changed rarely and with care.
- Rot rate
- The pace at which a given layer of an AIOS becomes obsolete or inaccurate due to model updates, API changes, or evolving business needs. Different layers rot at different speeds.
- Hook
- A deterministic, event-triggered rule in an AIOS — unlike soft behavioral guidelines, hooks fire automatically on a specific event such as a pre-commit check that strips PII before any GitHub push.
- Process-oriented skill
- A slash-command workflow that involves human-in-the-loop judgment and repeated execution with slight variation — distinct from a purely functional skill that wraps a fixed API call.
- Materialized agent
- A named, role-defined AI agent that is maintained over time with its own identity, skill set, and cadence for updates — as opposed to an ephemeral agent spun up ad hoc.
- Pointer architecture
- A design pattern where CLAUDE.md contains short references to other files rather than inline content, keeping the context window lean while still giving the model access to detailed rules and skills.
- Substrate wiki
- A second-brain knowledge file attached to an AIOS that the agent can tap into for domain reference material without bloating the core CLAUDE.md.
Things they pointed at.
06:44productClaude Code Living Course (weekly updates)
06:44toolClaudeClaw system (8 generations)
20:50toolAndrej Karpathy substrate.wiki
20:50toolWHOOP wearable API
20:50toolSupabase
12:30toolQuickBooks
07:40toolFathom / Fireflies (meeting transcripts)
02:31toolOpenClaw (agent framework)
02:31toolHermes (agent framework)
Lines you could clip.
00:14
“The dashboard is actually meaningless and worthless without all the plumbing that goes into the system itself.”
07:09
“People love building skills, but they hate maintaining them.”
10:30
“Having an army of agents is more of a maintenance nightmare than it is a blessing.”
13:57
“MCPs are on their way out.”
23:30
“You can do 80% in a weekend of this setup.”
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.
metaphoranalogy
00:00Building an agentic OS is probably one of the most over complicated concepts that I see in the AI space today. People have really over indexed on things like building the final dashboard that puts everything together or this fantasy of creating the final mission control where everything just works. But in reality, the dashboard is actually meaningless and worthless without .
00:22So everything happening underneath the hood is the entire game of building a proper I've taught this mental model so much to companies around the world that I found the simplest way to explain this concept in just a few layers. The same way that the earth has multiple layers in its crust, you have multiple layers in an AIOS system.
00:41And once you understand how these layers work and the nuances between them, you'll never get confused ever again. So if you're tired of watching videos that make it seem like this is rocket science, then this is for you. And this mental model will apply to you whether you're building something for your personal, your business, or both.
00:56Let's dive in. So to make this as clear as possible, we'll go through every single layer from the inside all the way out, and you'll see a lot of resemblances to the core of the earth all the way to the outer surface where the core is more stable and static, and the outside is more subject to things like weather, different patterns, forecast that can change the way that you do business.
01:17So the first layer is identity, and identity is really what's called the soul file in a lot of these agent frameworks like OpenClaw, Hermes, and any other agent like it. And then we have rules and hooks, and these are paradigms that span across Claude code, codex, and pretty much every single language model with a harness today.
01:35And the whole point of these is offering very strong suggestions to the AI as to what it should or shouldn't do in certain scenarios. And when it comes to hooks, these are things that are deterministic.
01:46Technically, the only deterministic parts of an AIOS system that can fire relative to specific events that happen. And then we have the skills layer where this is the one that most people fully understand. We have some form of process or workflow.
01:59And if you do the exact same workflow in similar ways over and over again, but it's still not fully deterministic, then it can deserve to be a slash command and a skill. And once you felt like you've mastered skills and you keep iterating on them to make them infinitely better, you might decide that it's time to employ some materialized or crystallized agents where you have a designated set of roles and responsibilities for tasks that have evolved beyond things like skills.
02:25And last but not least, we go to the tools, MCPs, and CLIs where now you have a system, might have primed your context, you have your identity of what the system is for.
02:35Is it for bookkeeping? Is it for your law practice? Is it for your personal taxes?
02:40It could be anything you want. Myself, I now have 20 different command centers, each of which is meant to have this domain subject matter expertise that is composed of these five different layers.
02:51Now there's one element to all of these that I've yet to mention, which is what I call the rot rate. And the rot rate is really the pace at which that specific piece of context has an expiration date because you could build the absolute perfect AIOS for whatever domain today.
03:07But in one month, ninety days, a hundred and eighty days, let alone a year, it might be fully obsolete. So you have to have systems in place to both detect and remedy any of these issues. So to give a visual layer to this problem, imagine that we played out your AIOS over the course of a year.
03:24You'll notice that things like maybe the way you use your tools, MCPs, CLIs, the agents instructions, the skills they use, and even your identity will need to be updated over time because they will become deprecated, obsolete, out of date, and that will poison the context window of whatever language model you choose.
03:43So based on this, let's take a fine tooth comb through every layer and I'll also provide you some examples of operating systems that I've built as well. When it comes to the sole, this could be a physical sole file for your agent of choice or it could be an agents dot m d file or a cloud m d file if using Cloud Code. Now again, the identity or the sole layer is meant to be one of the most static layers where you don't update it as often, and it's meant to have an upfront cost that's a bit higher than the other layers.
04:09But with that upfront cost, you only have to do slight modifications over time. Now this could be composed of a physical file called soul dot m d for your agents like Hermes, OpenClaw, etcetera, or it could be something like an agent's m d file or a clot m d file if you're using something like Cloud Code.
04:26And in all of them, a lot of these files will be composed of very similar characteristics. Number one, the identity, the personality, the way of working, the way of simplifying or overcomplicating an entire session with you, the user.
04:40So if you're talking about very complicated legal concepts and you always want your agent to break it down in a very easy to understand way, you might have this as a one liner.
04:50Explain everything at seventh grade reading levels for the very complex concepts that will ask you about. And the way that I use this layer is this becomes my inventory and pointer layer. And when I say pointer, means that I will use my CloudMD file to point at all of the relevant rules, the relevant skills, and I just basically have a very short sentence.
05:10Maybe a series of twenty, thirty sentences saying, when we're doing x y z, refer to these documents.
05:17Because I'm loading a very lean and mean ClotMD into every single one of my sessions, I can guarantee that all the core references it needs to be powerful and effective irrespective of whatever model I choose.
05:29It could even be an open source model. It will know exactly where to refer to. When it comes to rules and hooks, this is not only one of the simplest layers but it's also the one that you rarely will start with because you might not know the exact behaviors from the language model that you need to contain or create roadmaps around or SOPs until you run into issues.
05:48Let me give you an example. Let's say you were building yourself a business coach where it was trained on a compendium of files of all the relevant influencers, information that you find helpful to help you take your business to the next level.
06:01It's only when you start interacting with said coach and it's giving you extremely generic advice or advice that's not localized to where your business lies is when you realize, ah, we should have a rule that says, only give me feedback in this way or about said topic or at this level of granularity. And you know what? Anytime I wanna push my changes to something like GitHub, I wanna make sure that there's never any form of personal identifiable information.
06:27So then this is when you start employing a hook which is deterministic. It's attached and it's tethered to a specific event which in this case would be pushing and using the tool of GitHub. And by the way, if you're enjoying the content and you find it clear and tactical, this is only a glimpse of everything that I offer exclusively in my early AI adopters community.
06:46We have something called the Claude code living course that I update every single week with a brand new module that you'll never see on YouTube. Just for this topic on AIOS engineering, I have close to a one hour master class that goes infinitely deeper on all the nuances in building these kinds of systems.
07:00So if you want access to resources like that on top of things like our Claude Claw system that has gone through eight different generations of updates and our new enterprise OS system, then check out the first thing down below, and I'll see you inside. Alright. Back to video.
07:13When it comes to something like skills, people love building them, but they hate maintaining them. So the core rules of thumb here is to imagine a skill as a specific workflow that you've done maybe five, ten, 15 times in ever so slightly similar ways, but typically they have some form of human in the loop element where you wanna be involved as a part of the process.
07:33So these are what I call process oriented skills, which are different from other skills. Let's say creating a skill to connect to your fathom or your fireflies to pull the latest transcript from all your meetings.
07:44That would be more of a functional skill, something that connects to an existing API and there's not a lot of nuance in what it has to do. This layer has a moderate rot rate where you'll be updating or you should be updating a skill almost weekly even if you've had it for months. Up until now, I have skills that I still change ever so slightly every single day, especially as I start pushing them and employing them on edge cases irrespective of whatever it is I'm working on.
08:09And one of the many reasons why this will rot over time is as we get smarter models, sometimes some models will need way less instruction to get the exact same outcome with way less tokens. And at the same time, let's say you start pivoting to open source models and having a hybrid model where you use an orchestrator that's closed source, let's say Opus, Fable, if it ever comes back out again or something else.
08:31And then you have executor agents that are all using open source models like GLM, DeepSeq, etcetera.
08:38At that point, you might still need a lot of instruction for those models to follow and execute said skills. You might eventually have different versions of the same skill that might work with different versions of language models. One expert tip is if you want to continually improve your skills in a very efficient way, you could run something like slash goal and with that goal, basically tell it I want to optimize it based on the latest and greatest best practices.
09:02So if you were to hop into a terminal real quick, it would look something like this where you'd say slash goal, I want you to optimize x skill in y way according to the best practices as of today.
09:18And then if you're using Claude code, then I'd like to do this thing like cc as if you're cc ing someone on email, and then I will tag the Claude code guide agent. Because what will happen is it will use and fetch all the relevant documents to make sure that your skill is as optimized as it possibly can be. And if you wanna take it to the next level and you wanna make sure this happens without you even at the computer, you could do a slash schedule where every single week you have a process that ever so slightly prunes and optimizes every single skill that you have and you can give it a rubric of criteria to decide what is worth updating versus what is worth maintaining.
09:53And naturally, you wanna keep some logs to track all these changes over time just in case it makes a change on your behalf that doesn't make it fire as well as it used to. Now the same way that a skill is adjacent to a verb, an agent is adjacent to a role. So once your skills seem to now create this aggregate overall person equivalent of a role, it makes sense to hire quote unquote an agent.
10:17And the way you do it, if you wanna create materialized agents that are really detailed and things that you maintain over time, you wanna decide as if you're a bootstrapped startup founder with no venture capital cash to throw at you, what is the best absolute first hire that you can have, and how far can you push this first hire agent before it makes sense to add another role?
10:37A lot of people get excited by the concept and the whimsy of having an army of agents, but they don't realize that having an army of agents is more of a maintenance nightmare than it is a blessing. So let's say you create an agent that is tax oriented and you call it tax optimizer, and its specific role is a senior tax strategist.
10:55So you basically have it scan all your transactions in the business, maybe it liaises and double checks what region you're operating in, and where can you actually save on tax and write things off legally in a way that you can lower your cost basis. Within this agent, now that you have your infrastructure that you've built of skills, you tell it, I want you to do all of these roles and responsibilities.
11:15And when it comes to bookkeeping and checking my tax structure, I want you to employ and use these skills in said way. Just in this example, hopefully, you can see that this is very additive.
11:26If you had built agents without the skill infrastructure or the identity infrastructure and everything around it, these become a lot more frail and brittle. One last thing on this layer is that it rots at one of the fastest rates compared to the others. And the main reason is as we have brand new model releases, with each model we get ever so slightly or sometimes vastly different behavior.
11:48When you have different behavior that culminates in different ways that you have to prompt it to get to the same outcome or better. Meaning that the prompt that you write today will become obsolete or dated as soon as a new version of the model you're using comes out. And if you work with things like codex and Claude code interchangeably like I do, you'll have to create a set of instructions that are as nuanced and neutral kind of Switzerland between both models behaviors as much as possible to make sure that it can fire the same way on both models.
12:18The last layer is the tools, API, MCP, and CLI layer. And I know there's a lot of acronyms there, but all of them point to the same thing, which is that this is the data layer.
12:28This is where you enrich your process with live access to information, which could be accessed to databases where you're pulling in information, where you're writing and reading, let's say a CRM, a HubSpot, a QuickBooks.
12:40If we take that prior example, you would need something like a QuickBooks to go and pull all of your invoices, your accounting information, maybe somehow marry that with conversations that you've had with clients on something like Fathom or Fireflies to pull in the fact you have to write a proposal, they have to document that proposal, and this becomes a system that needs logic and identity, a set of skills, maybe some agents, and finally that final layer that brings everything together and writes it to your CRM of choice.
13:07And one of the reasons why I tag this as potentially, not necessarily, having one of the highest rot rates is as these APIs change, as they become deprecated, you're gonna have to quickly pivot your entire system to adapt to the best way to pull that data, in what way it's being pulled because sometimes the data structure that we pull that information changes ever so slightly.
13:29Maybe the provider is providing some way to have more efficient gains in latency, in fluency, etcetera. So you'll always have to look out for what's happening with this layer.
13:39The prime example of this is that a few years ago, MCPs were the darling of AI. They were everything people could talk about. If you didn't have an MCP, you were not relevant to the conversation.
13:49Now it appears that MCPs are on their way out. Some providers don't show their API and only show their MCP layer for whatever reason, but for the most part, command line interfaces have become one of the more popular tools just because they're a wrapper around the API, but they're a very command line interface friendly wrapper given that codex and Claude code really deliver in that domain.
14:10So to make this tactical instead of just theoretical, let's look at two tangible examples. So let's say we have a myOS system, and the whole point of myOS system is a pseudo mini CFO for my business.
14:23Just for all intents and purposes, you could just to give yourself the training wheel structure, number and name each folder by that layer in your AIOS layers.
14:33Realistically, these rules and hooks should and will live in something like dot claud where it hosts your hooks, your workflows, and everything else. But if it helps you initially simplify the mental model, you can put these in separate folders, and then once you've materialized and finalized them, then you can graduate them to end up in the core dot cloud folder where you know you have an inventory of all these assets.
14:56Now naturally, have a lot of assets here. So let's put some color as to what's happening underneath the hood. If we flip over, you'll see that our general structure is composed of the folders that you saw before and we have a substrate dot wiki file.
15:10This is meant to build on top of the work of Andre Karpathy that basically built a second brain library that you can tap into, and I have a prompts folder. Now this folder is specific for you to give you two options on ways to interview yourself to build a similar structure and approach to building each one of these layers.
15:27The CloudMD is the nucleus of the entire system, and it contains thing like the role and responsibility, which is the solo fractional CFO, the point of view, which is to focus on things like cash flow, profit and loss, the fact that it should never blend or compare any two clients in the client folders, and it points to different playbook files, additional files of context that I don't want to bloat my context window and my CloudMD with.
15:53Then we have the rules and hoax layer where we have the always dot markdown file that contains nine rules on how to handle things like our finances and a never dot m d. Again, I'm simplifying the naming just to understand.
16:05Eight things to avoid and never do. Again, never blending clients and never outsourcing certain numbers that haven't been fully validated. And examples of hooks you could have are basically double checking that before you send off any work to a client that you're double checking that the data is coming from that exact client name in the database and that there's no confusion.
16:24And maybe some level of PII guard to making sure that there are no names, emails, etcetera, in whatever is leaving either your email, your GitHub repo, etcetera. And when it comes to skills, you'll have ones like monthly close, which will go through all the clients that you service as a fractional CFO and close on their income statements, cash flow statements, everything for the month, and draft them a report.
16:46And then you have the singular agent which is called client portfolio dot markdown file, which is an overall strategist, and then you start drafting what the next agent could be. But you also outline criteria as to when it makes sense to hire said agent depending on circumstance.
17:02And on top of that, one file that people never create that I recommend you actually think about is creating a raw file. And if I open this up in Sublime Text here, you'll see how it's composed.
17:13It basically structures and tells Claude code, and you can store this as a pointer in your CloudMD, at which rate you expect each layer to rot.
17:23And it's a lot easier to do this right after you've built the 80% or you've built v zero versus a couple months down the line where you've kind of been comfortable, maybe not as proactive with building this to be as maintainable as possible.
17:36Now one thing I didn't touch on in this video is that these layers will rot at different rates for different businesses in different industries. So you will have to be the judge of how often this thing called identity needs to change, how often your connection to some system or service will have to be updated or looked at.
17:55Now like I said, I have another set of files in here in this prompts folder that I'm gonna make available to you in the second link down below on top of a few other goodies to get you started on this journey or to help you improve what you already have. We have prompt a, the more simple one, and prompt b, which is more akin to helping you with workflows.
18:12So if we open prompt a, naturally, I'm not going to read this whole thing. AI helped me generate it based on a lot of the lessons that I've been teaching and the lessons that I've learned personally. So, basically, if you just zoom in a bit more, it says you are an agentic OS architect.
18:27I want to set up a simple personal agentic operating system inside Cloud Code or the language model you're using in this folder, and I want you to walk me through it start to finish. Read all of these instructions. So it will break down all of the layers that I've mentioned to you here over here, and then it'll explain exactly how they interlink.
18:45If you wanna include a wiki, an Obsidian second brain, you could tap into that as well, and it will go through all the steps. So it'll ask you, what is the file path we're gonna be building this operating system in? Then interview me.
18:57Go through and ask me, what is my role? Who do I serve? What is my point of view?
19:01And it should be as relevant as possible to your specific business. And it will offer you in step two, two paths, two different ways that you could build your operating system, and it will create a blueprint file, an operating system blueprint file.
19:14And just to give you a little preview of that, if we zoom in and we take this to the side here, it will basically break down and say revisit my changes at this date because maybe it's interlinked with a raw dot net m d file.
19:27And then as you scroll down, it will walk through and break down exactly every single layer, what should be in there. And then once you give this to Claude code in a brand new session, it should be able to use it as a blueprint and fully create a draft of your entire system end to end.
19:42Now will it build it perfectly and blow your mind the first time it attempts this? Absolutely not. But the whole point of these systems is that they are infinite games.
19:51They are things that you keep iterating on over and over again. So , the moment you build an operating system, you're on the hook to maintain it and make sure it's always up to date. So that was a business example.
20:03Let me drive the point home by showing you a personal example. This is my health operating system, and this is something that I built in public in front of my community for fifteen days. And the goal was to build my own what I call a Claude Claude agent.
20:16Basically, think of Hermes but better and uses your Claude subscription, and I make it tailored to be my health coach. So it's aware of all of my DNA structure.
20:25It's aware of all of my blood panels. It's aware of my tendencies, my issues in the past, everything that it needs to help me focus on an ideal diet, an ideal exercise regimen, etcetera.
20:35And you'll notice here that we don't have numbered and named folders like we did with the demo example because as soon as you get the handle of it, you now have the training wheels off and you can start building operating systems with the general structure in mind. So here, we have the extracted data from our raw documents.
20:52So these raw documents are my PDFs of all of my blood panels, all of my DNA analysis results, etcetera. And then we have the extraction piece that basically takes these PDFs and converts them into easy to read for an LLM markdown files. And then we have the data layer, which is the super base that maintains every single thing that I eat now, my synced WHOOP data via API every single morning.
21:15Anything you can imagine is stored in that super base to help reinforce and inject in memory so I can have back and forth with a pseudo personal trainer. And the result is a system where I can take pictures of food that I eat. I can voice note exercises that I've done.
21:29I can take a video of what I'm attempting to eat or do or in the shopping aisle, and it will give me fully tailored advice to everything related to me, my last seven days of performance, sleep. If we pop into our little dashboard here, on top of the operating system, I have my goals in terms of weight, sleep, structure, protein to sodium to carbohydrates.
21:52You can make these operating systems very potent with only a few folders. The only thing you need to make these increasingly more sophisticated is the mental model of understanding what are we solving for, what is the subject matter expertise that we need to make this agent which is pulling from average training data specialized in one specific domain.
22:11And one last thing to note is whether we're talking about personal or even enterprise, this globe looks very similar. It might not be called identity, but it would be called data landscape.
22:21It won't be called necessarily rules and hooks, but it could be tool access in general, especially if there's some IT red tape in the mix. Then you have agentic systems in general versus just a markdown file. Then you have specific client software and overall operational systems.
22:36So this paradigm of the different layers and crusts of an operating system can apply to different domains, either personal, small business, or enterprise. So, hopefully, that breakdown with the visual aid, with the examples show you that this is not very complicated. It's not rocket science.
22:52It's actually more of an art with the guardrails of science, which is understanding what is it that you need, how do you create that type of asset, how do you make sure you optimize that type of asset, but there's no one specific blueprint that applies to every single operating system like a lot of other creators or advertising.
23:09In a way, my operating system for health or finance or tax will be different from yours because the way we do things and the way we structure our businesses and the systems they talk to and the way we want them to deliver assets will be special snowflake assets. So if this walkthrough helped break down some limiting beliefs that you can do it, I can tell you that you can do 80% in a weekend of this setup.
23:32And then you'll spend the next weeks to maybe a couple months perfecting the system to a point where it is additive enough that it actually helps move the needle and delivers tangible outcomes. And like I said, I'm gonna make available to you a care package of a couple prompts to get you on the journey or to optimize your existing one along with some other goodies in the second link for free down below.
23:50And if you found this helpful and you wanna nerd out and go down the rabbit hole, I have almost a one hour addition to this YouTube video on top of some specific skills, my Claude Claw system that you can clone yourself and build through something like Telegram or Slack or Discord on top of everything else we offer in the community.
24:07So if you wanna check that out and you're really serious about harnessing and honing your operating system, check the first link down below, and maybe I'll see you inside. And for the rest of you, if you found this clear and helpful, I'd super appreciate a like on the video, a comment if you so choose, and I'll see you in the next one.
The Hook
The bait, then the rug-pull.
Everyone is obsessed with the dashboard. The mission control. The final interface where everything just works. The presenter opens by calling that fantasy worthless — and means it. Without the plumbing underneath, the most beautiful control panel is just a pretty screen pointing at nothing.
Named ideas worth stealing.
02:14model
The Five Layers of an Agentic OS
- Identity (soul file)
- Rules & Hooks (guardrails)
- Skills (process verbs)
- Agents (roles with judgment)
- Tools / MCPs / CLIs (data wiring)
Maps agentic OS architecture to Earth's geological layers — stable core to volatile atmosphere — each with a distinct rot rate and maintenance cadence.
Steal forAny agentic project kickoff doc or AI team onboarding guide
02:51model
The Rot Rate Model
- Identity: months
- Rules & Hooks: weeks
- Skills: days-weeks
- Agents: days
- Tools/MCPs: hours
A maintenance schedule framework — assign each layer a rot rate at v0 so the system self-reports when it needs review.
Steal forAI system documentation, rot.md template, team maintenance calendars
10:10concept
Bootstrapped Founder Agent Hiring
Before spinning up a second agent, ask how far you can push the first one. Treat agent proliferation like headcount — expensive to maintain.
Steal forAny multi-agent design decision
05:56concept
Graduates at Three
A behavioral rule earns elevation to a deterministic hook only after it fires correctly three times. Prevents over-engineering guardrails before you understand the pattern.
Steal forRules/hooks layer design, AIOS build playbooks
05:10concept
Pointer Architecture (lean CLAUDE.md)
Keep CLAUDE.md short (20–30 sentences) and use it to point to external rule files, skill docs, and context rather than inlining everything. Keeps context window lean across all model sessions.
Steal forAny CLAUDE.md design, agent system prompt architecture
How they asked for the click.
VERBAL ASK
06:44product
“Check out the first thing down below and I will see you inside.”
Mid-video CTA at 6:44 for the paid community, then a softer close CTA. Mid-video placement during Rules & Hooks feels slightly early — the demo content that follows is more compelling than what preceded the ask.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
