Jonathon's AI Wiki

Nine-Component Agentic OS (Simon Scrapes — Creating Your Own Agentic OS Is Easy)

18 min read

Source: raw/Creating_Your_Own_Agentic_OS_is_Easy_Insanely_Powerful.md Creator: Simon Scrapes (YouTube) URL: https://youtu.be/w0S-khYCaB4 Published: 2026-05-02 Duration: 24:34 Platform: YouTube

Simon Scrapes’ second and more architecturally complete walkthrough of what he calls the Agentic Operating System. Where his earlier 13-minute Connected Skills as Agentic OS focused on the OpenClaw-style memory model ported to Claude Code, this 24-minute video enumerates nine concrete limitations of stock LLM tools and a nine-component fix — a full architecture diagram for an agency-scale AIOS. The framing thesis: “An Agentic OS is just clever context management. None of it is code. If you can organize a Notion workspace, you can build this.” The video doubles as a sales funnel for the speaker’s “Agentic Academy” community, which ships a prebuilt one-line-install version, but the framework itself is reproducible without buying anything.

Key Takeaways

  • Same tools, opposite outcomes — the differentiator isn’t prompting skill, it’s whether the operator built a context-management layer underneath the tool. That layer is the Agentic OS.
  • The nine components map one-to-one to nine limitations of stock LLM tools out of the box: cold-start identity, missing brand voice, session amnesia, generalist skills, isolated tasks, one-size planning, single-client mess, output sprawl, and laptop-tethered execution.
  • Static context splits cleanly into agent + user identity (user.md, personality.md / soul.md) and shared business context (a brand-context/ folder with voice, ICP, positioning, samples, assets). Letting AI interview you to bootstrap these files is the recommended fast path — 70% complete in ~10 minutes — versus writing them from scratch.
  • The identity file goes by different names per tool: CLAUDE.md in Claude Code, AGENTS.md in Codex, soul.md in OpenClaw — same pattern, different name.
  • Memory is best understood as six levels: (1) CLAUDE.md static rules, (2) SessionStart hooks that force-inject context, (3) semantic search frameworks like mem-search or claude-mem, (4) verbatim recall (e.g. Mem Palace ^[ambiguous]) for client work where exact phrasing matters, (5) knowledge bases, (6) cross-tool shared memory across devices/LLMs. Levels 1+2+3 are the 80/20 — combine them and you have what most operators need.
  • Skills should be short and modular — Simon’s stated rule of thumb is “under 200 lines for SKILL.md so Claude can reliably recall it,” using progressive disclosure to load deeper context only when the skill actually executes. Adapt Anthropic’s skill-creator skill so it always references your shared brand context. Build a self-learning loop: skill writes feedback to learnings.md; future runs read learnings before executing.
  • The leverage step most AIOS tutorials skip: chain skills into skill systems. A copywriting skill in isolation saves little time; chained on a schedule with topic research → script → produce → repurpose → human-in-the-loop → publish, with one orchestrator meta-skill linking them, is where time-back actually compounds.
  • Match planning depth to project depth. Use three planning levels: (1) Claude Code’s built-in plan mode (Shift+Tab twice) for small tasks, (2) PRD-style scope-to-files for half-day-to-multi-day projects, (3) the GSD (Get Shit Done) framework for complex multi-phase work — break into phases, plan each phase, execute, verify, inject context fresh per phase to defeat context rot.
  • Multi-client architecture uses Claude Code’s parent-folder context inheritance: one master CLAUDE.md at the agent root holds shared methodology; each client folder gets its own CLAUDE.md (overrides parent), its own brand-context/, its own context/ (memory + learnings). Skills live at the agent root and are referenced from any client folder via the synced .claude/skills/ directory.
  • Predictable outputs — every project + every skill writes into a deterministic projects/<client>/<skill-or-brief>/ folder. Briefs (plans) sit alongside their outputs (e.g. landing-page copy stored next to the plan that produced it). Solves Claude Code’s default behavior of strewing outputs across the terminal and ad-hoc subfolders.
  • Access from anywhere is two parts: get the system off your laptop (run on a VPS or cloud host) and give yourself a chat surface (Anthropic’s built-in Channels feature → Telegram/Discord; native equivalents exist in OpenClaw, Hermes, and Codex). Same underlying file structure; phone-as-remote-control.
  • The architecture is portable — tools change, but the underlying folder/file/context structure stays true until tools absorb these patterns natively. This is the same convergent-evidence finding documented in the 2026 Claude Code AIOS Pattern connection article.

How This Differs From Simon’s First AIOS Video

The earlier Connected Skills as Agentic OS (13:24, March 2026) was a single-operator argument: skills + shared context + heartbeat + wrap-up + learnings-folded-back-into-SKILL.md. Audience: solopreneurs.

This new video keeps that core but layers four agency-scale components on top:

New layerWhat it addsWhy it matters
Multi-level memory taxonomyThe six-level recall model and the 80/20 recommendationOperators can pick a memory stack instead of guessing — and combine layers without choosing one
Skill systems (chains)Multi-skill pipelines on a schedule, orchestrator meta-skillThe previous video named skill chaining; this one makes it the load-bearing time-back mechanism
Three-tier planningBuilt-in plan mode → PRD → GSD frameworkLets the system handle small tasks AND multi-day SaaS builds without context rot
Multi-client architectureParent-CLAUDE inheritance + per-client overrides + shared skillsThe thing that breaks when a solo framework meets agency reality
Predictable outputsprojects/<client>/<skill-or-brief>/ deterministic layoutSolves the “where did Claude put that file?” failure that compounds at agency scale
Access from anywhereVPS hosting + Channels surfaceDecouples the OS from the laptop

The first video was how a self-improving skill system works. This one is how to run that system across multiple clients without it collapsing.

The Nine Components in Detail

1. Static context — agent and user identity

A context/ folder with two files:

  • user.md — who you are: role, communication style, non-negotiables, what you want / don’t want from the AI
  • soul.md (or personality.md) — who the agent is: voice, behavior priorities, how it should respond

Bootstrap by letting the AI interview you. Open any tool that already has past conversation memory of you, prompt: “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.” Answer them; the assistant emits a near-complete file.

The identity file goes by different names per runtime:

  • Claude Code → CLAUDE.md
  • Codex → AGENTS.md
  • OpenClaw → soul.md

Same pattern, different filename. Whatever your tool uses, it loads the file at session start.

2. Static context — shared brand context

A brand-context/ folder, separate from agent context, holding:

  • Brand voice (samples + voice-profile derivation)
  • ICP (ideal customer profile)
  • Positioning and market angle
  • Brand assets (links, scraped from your school/site, logos, references)

The reason it’s shared is that you update it in one place and every skill pulls from that one source of truth. Simon’s claim: this alone “3x to 10x your output quality” on any knowledge work. A good off-the-shelf AIOS will run interview skills to populate this folder rather than asking the operator to write it from scratch.

3. Memory system — the six levels

Out-of-the-box memory is poor — push more context into the window and recall degrades (context rot). For business use, you need a deliberate memory stack:

LevelMechanismExample
1Static rules in CLAUDE.mdCoding conventions, tone rules — relies on Claude actually reading them
2SessionStart hooksDeterministic context injection at session start — forces files in regardless of Claude’s choice
3Semantic-search memory frameworkmem-search, claude-mem — search by meaning across structured markdown notes
4Verbatim recallMem Palace ^[ambiguous] — word-for-word quotes for client work where exact phrasing matters
5Knowledge basesTopic-specific structured stores
6Cross-tool shared memoryMemory that survives across devices and LLM vendors

The 80/20 is levels 1 + 2 + 3 combined. Layer them with one file structure — that’s exactly what the speaker’s stack does (level 2 hook injection + level 3 semantic search). Levels 4–6 are optional bolt-ons. Semantic search alone is “one of the reasons everybody loves a framework like OpenClaw” because cross-conversation recall feels like magic.

For a deeper dive into memory frameworks, the speaker references his own separate memory-systems video.

4. Skills — turning generalists into specialists

LLMs are jack-of-all-trades. Skills make them specialists at your processes.

Construction methodology:

  • Build a scrappy MVP of a skill, use it for a week, iterate based on what breaks. Don’t try for perfect on day one.
  • Use Anthropic’s skill-creator skill as a starting point — adapt it so every skill it generates references your shared brand context.
  • Keep SKILL.md under ~200 lines (Simon’s stated reliability threshold); use progressive disclosure — name + description load first, full SKILL.md next, deeper context (best-practice examples, sub-instructions) loaded on demand only when actually used.
  • Every skill that produces brand-touching work must reference brand-context/ — copywriting reads voice.md, research reads icp.md, etc.
  • Self-learning loop: every run of the skill ends with a feedback step. Feedback writes to learnings.md (or a per-skill equivalent). Next run reads learnings before executing. The skill gets smarter without manual SKILL.md edits.

Skills are one step — modular components that can be reused across multiple processes. A transcription skill is a single skill, but it feeds short-form video creation, newsletter generation, blog repurposing — same skill, multiple chains.

5. Skill systems — chains on a schedule

This is the layer Simon argues most AIOS tutorials skip and where time-back actually compounds.

A skill system is a chain of multiple modular skills, often executed on a schedule (Claude Desktop scheduled tasks; or [[claude-ai/scheduled-tasks|/loop + CronCreate in Claude Code]]; or Routines for cloud-hosted runs):

[scheduled task] → topic research skill → script writing skill →
  production skill → publish → [scheduled task triggered] →
  transcription skill → repurposing skill → human-in-the-loop review →
  content publishing

One orchestrator (a meta-skill) chains the steps. Human-in-the-loop checkpoints can sit anywhere in the chain. The community Simon references votes on which chains to build next: social-media content generation, social carousels, ad-generation-and-monitoring, SEO blog content / GEO ^[inferred — auto-captioned as “GAO”; in context of “blog content” generation, almost certainly Generative Engine Optimization (GEO)] page optimization.

The mental shift: skills aren’t standalone helpers, they’re parts of a pipeline. You stop being there when the pipeline runs.

6. Planning at multiple levels

Match planning depth to task depth. Three levels:

LevelTriggerMechanism
1Small day-to-day taskClaude Code’s built-in plan mode — Shift+Tab twice
2Half-day to multi-day projectPRD-style file scope — break into specific files with checkboxes; tick off as you go
3Complex multi-day SaaS / multi-phase buildGSD (Get Shit Done) framework — phases, plan each phase, execute each phase, verify each phase. Designed to defeat context rot by injecting fresh context per phase rather than carrying everything across the whole project

Without this, complex builds drift — even with files documenting requirements, Claude forgets original constraints a few hours in. Three levels means you don’t pay GSD overhead on small tasks but do pay it on the multi-day work where it earns back.

The GSD framework is described as “lightweight metaprompting / context engineering” — Simon doesn’t claim authorship; “plenty of frameworks out there, just Google planning frameworks for Claude Code.”

7. Multi-client architecture — the agency layer

Where most single-operator AIOS designs collapse: when you’re running 5 clients with 5 different brand contexts that all need to be injected into the right conversation at the right time.

Simon’s solution uses Claude Code’s parent-folder context inheritance:

agent-root/
├── CLAUDE.md                  ← master methodology, inherited by all clients
├── .claude/skills/            ← skills shared across clients (synced/duplicated to each client)
├── brand-context/             ← (only if you have agency-level context; usually not)
├── client-a/
│   ├── CLAUDE.md              ← duplicates parent + overrides for client A
│   ├── brand-context/         ← client A's voice, ICP, positioning, samples
│   ├── context/               ← client A's memory, learnings, agent context
│   └── projects/              ← all of client A's deliverables
├── client-b/
│   └── (same structure)
└── client-c/
    └── (same structure)

Working in client A means cd client-a/ — Claude Code reads parent CLAUDE.md first, then the client-level CLAUDE.md overrides. Brand context, memory, and learnings are per-client; methodology and skills are shared. Skills live at the root and are either globally installed or kept in a working .claude/skills/ copy synced from root that you can customize per client.

Net effect: scale to as many clients as you want without context cross-contamination, but skill methodology updates flow once to the root and propagate.

8. Predictable output structure

A personal-frustration component. Out of the box, Claude Code drops outputs wherever — the terminal window, ad-hoc files, deep nested subfolders. There’s no convention, and at agency scale that becomes “where did the landing-page copy go?”

The fix is a deterministic layout per client:

client-a/
└── projects/
    ├── <skill-name>/             ← e.g. "marketing", "video-repurposing"
    │   └── <output-files>        ← outputs grouped by which skill produced them
    └── <brief-name>/             ← e.g. "agentos-launch-page"
        ├── plan.md               ← the brief / plan
        ├── landing-page-copy.md  ← outputs co-located with their plan
        ├── hero-image.excalidraw.png
        └── ...

Skills write to projects/<skill>/, briefs (multi-skill chains with their own scope) write to projects/<brief-name>/ with the plan and outputs co-located. Trivial in concept, deeply useful at agency scale.

9. Access from anywhere

Two parts:

Part 1 — get the system off your laptop. Run on a VPS, Claude Cloud ^[inferred — auto-captions say “claw cloud,” context implies a cloud host like Cloudflare or Anthropic-adjacent hosting], or any cloud server so scheduled tasks run 24/7 without your machine staying awake. Simon notes that as of recording his own AIOS still runs locally — this is a stated future state.

Part 2 — give yourself a chat surface. Anthropic’s built-in Channels feature forwards Telegram or Discord messages into a running session. The same pattern is native in OpenClaw, Hermes, and is heading the same way in Codex. Phone messages reach the underlying file structure and all the context you’ve built.

End state: the OS comes with you. You don’t need to be at the laptop to use the system you spent the work building.

The Underlying Argument

Repeated several times in the video: an Agentic OS is just clever context management. No code. The hardest part is structure, not engineering. If you can organize a Notion workspace, you can build this.

The portability claim follows from the architecture: tools change but the structure doesn’t. Today it’s Claude Code + Codex + OpenClaw + Hermes. In 18 months it might be different runtimes — the folder layout, the context separation, the skill modularity, the planning tiers, the multi-client inheritance, the channels access pattern all transfer with minimal rework.

This is the same convergent-evidence finding documented in the 2026 Claude Code AIOS Pattern connection article — three independent practitioners (Simon, Brandon Storey, Nate Herk) arrived at functionally equivalent architectures for different audiences. This new video adds the architectural dimensions (multi-level memory, multi-client inheritance, predictable outputs, anywhere-access) that the prior synthesis flagged as open questions.

Implementation

Tool/Service: Vanilla Claude Code as the primary surface. Speaker’s “Agentic Academy” community sells a prebuilt one-line-install version of the same framework.

Setup (DIY, no purchase required):

  1. Create three top-level folders: context/ (agent + user identity), brand-context/ (shared business context), skills/ (modular processes).
  2. Run an interview to populate context/user.md and context/soul.md. Run separate interviews for brand-context/voice.md, brand-context/icp.md, brand-context/positioning.md.
  3. Pick a memory stack — at minimum, level 1 (CLAUDE.md rules) + level 2 ([[claude-ai/hooks|SessionStart hook]] forcing context-load) + level 3 (mem-search or claude-mem for semantic recall).
  4. Build skills under .claude/skills/. Adapt Anthropic’s skill-creator so every skill it scaffolds reads brand-context/. Keep SKILL.md under ~200 lines. Add a learnings-loop step.
  5. Chain skills into pipelines via [[claude-ai/scheduled-tasks|/loop + CronCreate]] or Claude Desktop scheduled tasks. Add human-in-the-loop checkpoints where editorial review matters.
  6. Add planning frameworks for medium and large work: PRD-as-files for half-day projects, GSD-style phased planning for multi-day builds.
  7. For agency setups, restructure into parent + client subfolders. Move shared methodology to parent CLAUDE.md. Per-client overrides go in client-level CLAUDE.md. Skills stay shared.
  8. Standardize output paths under <client>/projects/<skill-or-brief>/.
  9. (Optional, future state) move the system to a VPS / Claude Cloud and wire up Channels for Telegram/Discord access.

Cost: $0 for the DIY approach. The “Agentic Academy” community is paid (price not stated in video; promoted via the description).

Integration notes:

  • The video repeatedly notes the pattern is runtime-portable — the same architecture holds for Codex (AGENTS.md), Hermes (soul.md + native channels), OpenClaw (soul.md + cookbook), and Antigravity. Pick whichever runtime fits your stack; the file structure ports.
  • Apply the plugin vetting framework before purchasing any community AIOS bundle, including this one. The framework itself is reproducible from the video.
  • Auto-caption mishearings worth knowing if you re-search the transcript: “claw code” = Claude Code, “Aentic” / “Aentos” / “Aenttico OS” = Agentic / AgentOS / Agentic OS, “claud.md” = CLAUDE.md, “agents.m MD” = AGENTS.md, “skill.mmd” = SKILL.md, “do.claude/skills” = .claude/skills/, “GAO” = GEO ^[inferred], “me palace” = Mem Palace ^[ambiguous], “anti-gravity” = Antigravity, “Carpathy” would be Karpathy (not present in this transcript but a recurring auto-caption error in adjacent material).

Try It

Three concrete moves to begin applying the framework this week, ordered by leverage:

  1. Bootstrap the two static-context folders. Create context/user.md and context/soul.md for your agent identity, plus brand-context/voice.md, brand-context/icp.md, brand-context/positioning.md. Use the AI-interview shortcut: “Ask me 15 questions about how I work, what I want, and what I don’t want.” Answer; commit. ~15 minutes for a 70%-complete first pass.
  2. Add level-2 memory. Wire a [[claude-ai/hooks|SessionStart hook]] that injects context/ and brand-context/ into every session. This is the level-2 piece of the memory stack — deterministic, doesn’t rely on Claude choosing to read the files. Add level-3 semantic search later (mem-search or claude-mem).
  3. Pick one skill and chain it. Take a skill you already use weekly. Add a feedback step at the end that writes to learnings/<skill-name>.md. Add a second skill downstream of it (research feeds writing, writing feeds repurposing — pick what fits). Schedule the chain via [[claude-ai/scheduled-tasks|/loop or CronCreate]]. This is the minimum viable skill system; everything else compounds from here.

If you operate at agency scale (3+ clients), step 4 is to restructure into parent + per-client folders before the cross-contamination becomes painful. If you want to skip the build, the speaker’s community is the off-the-shelf option — apply the vetting framework first.

Open Questions

  • The speaker promises a follow-up video specifically on multi-step workflows on a schedule and “exactly why they’re so powerful in improving output quality.” That video is the natural deeper dive on component 5 (skill systems) and should be ingested separately when published.
  • Mem Palace identification is ambiguous — auto-captions render the level-4 verbatim-recall tool as “me palace.” Could be Mem (the popular memory app), Memory Palace as a generic technique, or a specific tool branded “MemPalace.” Worth verifying with a screen capture or the speaker’s previous memory-systems video before recommending it.
  • The GSD framework is described abstractly (phases, plan/execute/verify, context injection per phase) but not attributed to a specific source or repo. Is there a canonical GSD-for-Claude-Code framework, or is this a generic template anyone implements? The video says “plenty of frameworks out there, just Google planning frameworks for Claude Code” — implying the latter.
  • The multi-client architecture relies on Claude Code’s parent-folder context inheritance behavior. This works because CLAUDE.md files are read up the directory tree from cwd. Open question: does Codex’s AGENTS.md resolution follow the same rule, or does the multi-client pattern need to be re-engineered for non-Claude-Code runtimes that the speaker claims this is portable to?
  • The video mentions a “context matrix” updated by skills/MCP installs (carried over from his first video) but again doesn’t show its format. Same open question still applies.
  • “Claude Cloud” hosting is mentioned (“you can use something like a VPS or literally use Claude Cloud to host it anywhere”) but not specified. Auto-caption rendering suggests this might be a generic reference to cloud hosting rather than a named Anthropic product. Resolution needs a frame from the video or the speaker’s documentation.

Graph View

Backlinks