Source: wiki synthesis: Simon Scrapes’ Connected Skills as Agentic OS, Brandon Storey’s Lead Magnet Creation course, Nate Herk’s AIS-OS masterclass, Karpathy’s LLM-wiki pattern, Agent Skills Overview, Skill Design Patterns + (May 2026 update) raw/Run_Your_ENTIRE_Business_on_Claude_Cowork_Agentic_OS.md — Jay (Robo Nuggets) Cowork-native AIOS framework + (June 2026 update) raw/6_Things_People_Get_Wrong_Setting_up_An_AI_OS_+_Fixes.md — a sixth practitioner video framing the pattern from the failure side + (October 2026 update) raw/The_NEW_Agentic_OS_standard_for_Claude_5_Models_is_here_Full_Breakdown.md and raw/A_NEW_Agentic_OS_Standard_for_Claude_5.5_is_here_Claude_Mods_Jev_5.5_Models.md — Jay (Robo Nuggets) ARMS framework, August and October versions + (October 2026 update, 2026-10-28) raw/I_ve_Set_Up_500+_AI_Second_Brains._Here_s_The_Only_18_Things_You_Need_to_Know.md — Ben AI’s 18-lesson second-brain list, which also identifies the June video’s creator

Three independent practitioners shipped Claude Code “AI operating system” frameworks within a six-week window in spring 2026. They wrote for different audiences (solopreneurs, freelance copywriters, SMB operators). They wired up different tool stacks (vanilla Claude Code; Claude Code + ChatGPT + Beehiiv + Kajabi + ManyChat; Claude Code + Google Workspace CLI). They came from different places — one from agentic-systems content, one from copywriting coaching, one from running a 350,000-member AI automation community. None of them appear to have coordinated. Yet on the architectural questions that matter, they converged on the same answers. This article documents the convergence as evidence-of-correctness for what’s becoming the canonical 2026 Claude Code AIOS pattern, and flags the dimensions where they diverge as open design questions.

The three sources

SourceDateAudienceTool stackDistinctive framing
**[[hermes-agent/_indexSimon Scrapes — Connected Skills as Agentic OS]]**2026-03-15 (YouTube, 13:24)Solopreneurs / agency operatorsVanilla Claude Code
**[[ai-marketing/lead-magnet-creation-claude-code-brandon-storeyBrandon Storey — Lead Magnet Creation course]]**2026-04-15 (YouTube, 1:55:54)Freelance copywriters / coachesClaude Code + ChatGPT + Beehiiv + Kajabi + Zapier + Vizard.ai + ManyChat
**[[claude-ai/nate-herk-claude-code-operating-systems-courseNate Herk — AIS-OS masterclass]]**2026-05-01 (YouTube + public MIT repo)SMB operators / AI consultantsClaude Code + GWS CLI

The Five Convergent Design Dimensions

Each row below represents an independent design choice. Each cell is the practitioner’s specific implementation. Convergence on the principle, not the syntax.

DimensionSimon ScrapesBrandon StoreyNate Herk
1. Shared brand context as foundationbrand-context/voice.md, icp.md, positioning.md, samples/, assets.md — bootstrapped via 3 foundation interview skills”Brand guidelines on disk” — Claude Code locates by name and uses for every PDF + graphiccontext/about-me.md, context/about-business.md, context/voice.md, references/ — populated by /onboard 7-question interview
2. Self-improving skills via feedbacklearnings.mmd — feedback bucketed by skill, folded into SKILL.md at end-of-day by the wrap-up skillIterate by talking back (“make it more centered”), 4-6 conversational turns to acceptableThe 10-30 run feedback cycle — watch the skill work, note friction, tell Claude what to fix; “by run 30 the skill is sharp”
3. Skill as the capability primitiveA folder at .claude/skills/<name>/ with SKILL.md; categorized by tierEach pipeline phase wraps a Claude Code skill (downloaded design skill is the named example)Repo ships .claude/skills/<name>/SKILL.md; explicitly: “skills are ideation prompts and thinking tools, not heavy automations”
4. Skill chaining / dependency directionFoundation → Strategy → Execution → Ops tiers; lower tiers feed upper tiersSix-phase pipeline (ideation → production → triple format → email → landing → distribution); each phase outputs the next phase’s inputsSkill → routine pipeline; /level-up identifies the next skill worth building; ops tier wraps mature capabilities
5. The system improves itself, not just outputsHeartbeat at session start scans skills/ and reconciles against CLAUDE.md; wrap-up commits learnings(Implicit — by-talking-back is the only feedback channel)CLAUDE.md edited 2× per day; /audit Four-Cs scoring runs weekly; /level-up identifies the next leverage; the skill-builder skill builds skills

Three of three converge on dimensions 1, 2, 3, and 4. Dimension 5 (system self-improvement) is shared by Simon and Nate but not Brandon — Brandon’s framework is single-pipeline-deep, not platform-wide.

This is the central finding. Three teachers, three audiences, three tool stacks, all deciding independently that the answer is shared brand context + skill primitives + iterative skill improvement + tier-based chaining. When the same answer surfaces from independent paths, the answer is probably correct.

Where They Diverge (the design questions still open)

The convergent pattern is robust on the four-or-five named dimensions above. The divergences are the open design questions for anyone building on the pattern in mid-2026:

A. Runtime portability

SourceStance
Simon ScrapesExplicitly cites OpenClaw memory model as inspiration. Implements on vanilla Claude Code but the design is portable.
Brandon StoreySingle-runtime (Claude Code + auxiliary SaaS). No portability conversation.
Nate HerkTool-agnostic by stated design. Tested portability to Codex (~2 minutes); names Antigravity, [[hermes-agent/_index

Open question: Is portability earned at design time (writing skills as plain markdown that any harness can read) or at migration time (rewriting on the new harness)? Nate claims design-time; Simon’s port from OpenClaw memory model is migration-time evidence. No clean test yet.

B. Multi-tool vs Claude-Code-centric

SourceStance
Simon ScrapesStay in Claude Code. Skills do everything.
Brandon StoreyMulti-tool by necessity (lead-magnet pipeline crosses Beehiiv / Kajabi / ManyChat / ChatGPT). Claude Code is the production surface, not the operations surface.
Nate HerkClaude Code is the primary surface. GWS CLI is the one named exception — and it’s still a CLI Claude Code calls. Cowork Live Artifacts for lightweight dashboards only.

Open question: Where’s the right boundary between the AIOS surface (Claude Code) and the systems-of-record (CRM, email, calendar, content tools)? Brandon is the most honest about this — the AIOS doesn’t replace the SaaS stack, it orchestrates across it.

C. Self-maintenance as a first-class layer

SourceStance
Simon ScrapesHeartbeat at session start, wrap-up at session end — explicit named layer of the architecture.
Brandon StoreyNot addressed. The pipeline is one-shot per lead-magnet.
Nate HerkThe Four Cs put Cadence as a peer of Capabilities; /audit and /level-up are recurring system-improvement skills.

Open question: Is self-maintenance worth the engineering tax for a single-operator AIOS, or only when the AIOS scales to a team? Simon and Nate built it in early; Brandon never reached for it. The sample size is small and the workload mix differs.

D. Trademark / IP posture

SourceStance
Simon Scrapes”Agentic OS” is the speaker’s branded version of the pattern; offers paid community access. No trademarks in the public material.
Brandon StoreySix Figure Copy Academy is paid; the lead-magnet course itself is the funnel-top free artifact. No trademarks on the framework.
Nate Herk”The Three Ms of AI™” and “The Four Cs of an AIOS™” both ™ © 2026 Nate Herk. Repo is MIT, but the framework names are protected. “Use freely; don’t repackage as your own.”

Open question: Is the trademark strategy load-bearing for adoption (a clear, unique name spreads better than a generic pattern) or load-shedding (it adds friction for community contribution)? Three weeks of evidence is too short to say.

What This Means for the Karpathy LLM Wiki Pattern

Karpathy’s LLM-wiki pattern — the architecture this wiki implements — is itself convergent with the three practitioners’ frameworks at the implementation level:

  • Karpathy’s raw/ + wiki/ + CLAUDE.md pattern mirrors Simon’s brand-context/ + skills/ + CLAUDE.md, Brandon’s brand-guidelines-on-disk + skill-driven production, and Nate’s context/ + references/ + CLAUDE.md.
  • Karpathy’s index files (_master-index.md, _index.md) play the same role as Nate’s CLAUDE.md “Where things live” section.
  • Karpathy’s append-only log.md mirrors Nate’s decisions/log.md.
  • Karpathy’s hot.md session-continuity cache is exactly what Nate’s AIS-OS course cites as the cross-vault-query token-saver: “When you need information about me or my business that you don’t already have, go there. Read the hot cache first, then the index, then the relevant subindex, then search.”

Nate explicitly endorses the Karpathy pattern as a bonus section in his course — the pattern this vault has been quietly running for 8 months turns out to be the natural state of mature Claude Code knowledge management. The convergence isn’t just at the AIOS-architecture layer; it extends down to the file-and-folder layer.

This validates the bet that this Karpathy LLM Wiki is making — and suggests the natural next step is to operationalize Nate’s cross-vault-query pattern: point a project’s CLAUDE.md at this wiki/ directory, watch token usage drop, watch context-quality climb.

What This Means for WEO Marketly

The convergent pattern maps cleanly onto WEO surfaces:

Convergent dimensionExisting WEO surfaceGap
Shared brand contextOmniPresence voice profiles; client brand-context files (per-account)No single shared brand-context/ per client across surfaces; each project rebuilds it
Self-improving skills via feedbackOmniPresence script feedback loops; Clawdbot output reviewFeedback isn’t folded back into the skill file; it lives in chat history
Skill as capability primitiveLimited use; most automation lives as Python or n8n flowsSkills-first refactor would unlock the rest of the pattern
Skill chainingBAW pipeline (Blog-Agent-Worker) approximates thisChain happens in code, not as composable skills
Self-maintenanceHermes learning loop, Clawdbot weekly refreshNot a Claude-Code-native pattern yet

Concrete next step for the WEO AI Council: pilot the AIS-OS-style three-skill kit (/onboard, /audit, /level-up) against one WEO surface — most likely OmniPresence, since brand-context per dental client is already structured. If the pattern produces measurable gains (deltas Nate’s success indicators flag — team reaches AIOS instead of you; context-switching drops; knowledge leaves your head), generalize across BAW / Clawdbot / GHL.

Try It (for any operator on this wiki)

Three concrete moves anyone can make this week to apply the convergent pattern, ordered by leverage:

  1. Pick the shared-context folder. Create brand-context/ (or whatever name you prefer) at your project root. Add voice.md, icp.md, positioning.md — each one paragraph if that’s all you have. Have one existing skill open them at the top of its instructions. This is the foundation; everything else compounds on it.
  2. Make one skill self-improving. Pick a skill you run weekly. Next time you correct its output, don’t fix it in chat — append the correction to a learnings/<skill-name>.md file. End of week, ask Claude Code to fold the learnings into the SKILL.md. You’ve just built Simon’s / Nate’s feedback loop.
  3. Test the cross-vault-query pattern with this wiki. In any Claude Code project’s CLAUDE.md, add: “There’s a knowledge base at ~/Auto1111/Claude/karpathy/karpathy-obsidian-vault-main-2/wiki/. When you need information about WEO, Claude Code, marketing, AI, etc., that you don’t already have, go there. Read _master-index.md first, then the relevant topic _index.md, then the specific article. Don’t read the wiki unless you actually need it.” Compare token usage before/after. (This is Nate’s documented pattern; the vault is structured to support it.)

The convergent answer doesn’t require buying anything. The framework lives in plain markdown.

Update — May 2026: a fourth convergent voice (Cowork-native)

The “fourth convergent voice” question raised below has its first answer: Jay (Robo Nuggets) shipped Run Your ENTIRE Business on Claude Cowork — Agentic OS (YouTube, May 6 2026, source raw/Run_Your_ENTIRE_Business_on_Claude_Cowork_Agentic_OS.md). Jay’s framework converges on the same five dimensions but layers on a Cowork-specific seven-layer architecture:

LayerDescription
1. System instructionsCLAUDE.md as “operating manual” — Cowork-only emphasis, since IDE-style and claude.md don’t apply
2. SecuritySandbox VM + permissions — Cowork-native (sandbox is the runtime substrate)
3. ProgramSkills, sub-agents, plugins (with explicit warning: vet plugins outside Anthropic’s marketplace)
4. Context (most important)Knowledge + state + memory — explicitly differentiated. Knowledge = “what the system needs from you” (markdown files). State = “what is happening during runtime” (databases). Memory = “long-term learning” (RAG, etc., though Jay reports rarely needing it)
5. MCPExternal-system access — required for Cowork because no native IDE/CLI access
6. SchedulingSmart schedules so the agent runs autonomously without manual kicks
7. MobileDispatch (Cowork-native) for daily-brief-style mobile reach. Telegram integration TBD

Audit-by-pod approach. Jay’s /onboard-style intake breaks the business into acquisition / delivery / support / operations — a four-pod audit that produces the brand-context layer pod-by-pod. This is operationally very similar to Brandon Storey’s six-phase pipeline mapping (ideation → production → triple format → email → landing → distribution) but framed for SMB business operations rather than copywriter pipelines.

Adds to the convergent table:

DimensionJay (Cowork-native AIOS)
1. Shared brand context as foundationPod-by-pod (acquisition/delivery/support/operations) audit feeds context layer; explicit knowledge-vs-state-vs-memory decomposition
2. Self-improving skills via feedbackImplicit (continuous correction during build); not a named layer
3. Skill as the capability primitiveYes — .claude/skills/<name>/ skills are the program layer; explicitly recommends marketplace-vetted plugins for distribution
4. Skill chaining / dependency directionPod-led (acquisition skills feed delivery skills feed operations skills); MCP-mediated where external systems are involved
5. The system improves itself, not just outputsNot strongly addressed in the build phase covered

Five voices, four-of-five convergence on dimensions 1-4. Dimension 5 still splits Simon + Nate from Brandon + Jay. The Cowork-vs-Claude-Code-vs-Hermes runtime question is now a richer matrix:

  • Claude Code: Simon, Nate, Brandon (production)
  • Cowork: Jay (Cowork-native)
  • Cross-runtime: Nate (designed for portability), Brandon (multi-tool by necessity)

Implication for the open question on multi-tool vs Claude-Code-centric. Jay is the first convergent voice to position Cowork as the AIOS surface itself (not a Claude Code companion). The seven-layer model treats Cowork as the OS and the SaaS stack as MCP-reachable peripherals. This sharpens Brandon’s “AIOS doesn’t replace the SaaS stack, it orchestrates across it” thesis — the surface where orchestration happens is now a deliberate choice (Claude Code vs Cowork vs Hermes), not a default.

Update — June 2026: common setup mistakes (and fixes)

A sixth practitioner video — 6 Things People Get Wrong Setting Up an AI OS (+ Fixes) (raw/6_Things_People_Get_Wrong_Setting_up_An_AI_OS_+_Fixes.md; creator identified 2026-10-28 as Ben AI, YouTube lObeYn06BHI, uploaded 2026-06-12 — the same creator as Ben’s Five-Skill AIOS Setup; framed from “hundreds of support-call transcripts”) — approaches the pattern from the failure side. Its concrete prescriptions sharpen the convergent dimensions above rather than adding new ones:

  • Lead with an “80/20” shared-context set, not a document dump. Five-to-six small files do most of the work because they get pulled into nearly every task: me.md, business.md, icp.md, strategy.md, brand.md (+team.md). Effort spent here beats bulk-loading raw source docs — dimension 1 (shared brand context) with a specific file manifest.
  • Pick a fixed folder structure and keep it stable. A consistent six-folder layout — context/, daily/, intelligence/, projects/, resources/ (+team/) — matters more than the exact folders chosen, because stable paths make routing rules reliable. Consistency is the point, not the taxonomy.
  • Keep CLAUDE.md lean and routed. Cap the root CLAUDE.md at ~300 lines, give it an explicit routing table (“where things live”), and push detail into per-subfolder CLAUDE.md / index files — the same “hot cache → index → subindex” retrieval discipline Nate’s AIS-OS uses, stated here as an anti-bloat rule.
  • Feed real-time context via scheduled tasks. Use Claude Desktop scheduled tasks (daily/hourly) to pull meeting transcripts, email, Slack, and community activity into the vault automatically, so the context layer stays current without manual updates — dimension 5 (self-maintenance) made concrete.
  • Good context beats a bigger model. The load-bearing claim: an older model with good context outperforms the newest model without it, and since context windows won’t grow dramatically near-term, the leverage is in building the context layer now rather than waiting for the next model.

These are failure-mode-framed restatements of the convergent dimensions — which is itself further convergence evidence: the mistakes people make are precisely not doing the four-to-five things the practitioners independently converged on.

Update — October 2026: Jay’s ARMS framework closes dimension 5

Jay (Robo Nuggets) replaced his May Cowork seven-layer model with a four-layer Claude Code framework, ARMS (Apps, Routines, Memory, Skills), first in August 2026 (Claude 5 models, raw/The_NEW_Agentic_OS_standard_for_Claude_5_Models_is_here_Full_Breakdown.md) and rewritten in October (5.5 models, Jev and Claude Mods, raw/A_NEW_Agentic_OS_Standard_for_Claude_5.5_is_here_Claude_Mods_Jev_5.5_Models.md). Full breakdown: ARMS Agentic OS.

DimensionJay, October 2026 (ARMS)
1. Shared brand context as foundation”Database skills” hold tone of voice and visual references; an HTML brand book behind a design-system skill makes every artifact on-brand
2. Self-improving skills via feedbackExplicit: review feedback carries an “update this skill” instruction; /note backlog and /calibrate
3. Skill as the capability primitiveYes, sorted into database, artifact and self-triggered types
4. Skill chaining / dependency directionRouting files rather than chains: CLAUDE.md maps departments, department files route to skills and references
5. The system improves itself, not just outputsYes. A weekly routine mines sessions for repeated manual work and proposes routines, skill fixes and memory fixes

What changes in this article’s findings:

  • Dimension 5 is no longer split by runtime. In May, Jay was on the Brandon side (self-improvement not addressed). His October framework makes it a named level in three of four layers, so the split is now Simon, Nate and Jay against Brandon.
  • Jay moved from Cowork-as-the-OS to Claude Code plus a local dashboard. The May “Cowork as the AIOS surface” point above is now historical for him; with chat and Cowork merged in September 2026 (see Claude Cowork), the distinction he was drawing has also changed.
  • Two new design questions the earlier sources did not raise: token cost as a first-class OS concern (per-skill and per-routine token dashboards, model routing through Jev, prompt-cache management), and moving recurring work out of chat into small Claude-built apps and mods.
  • The plain-text routing consensus holds at scale. Jay reports about 420,000 files with MEMORY.md + a routing CLAUDE.md + department router files and no embeddings, the same “hot cache, index, subindex” discipline as Nate’s AIS-OS and the June failure-mode video’s lean routed CLAUDE.md.

Update — October 2026: Ben AI’s 18 lessons answer the team-scale question

Ben AI, the creator of the June mistakes video, published an 18-lesson list on 2026-10-28 drawn from what he says are 500+ second-brain setups. Full breakdown: Ben AI’s Second Brain Playbook.

DimensionBen AI, October 2026
1. Shared brand context as foundation5 to 10 core files (me, business, ICP, strategy, brand, team) give “80% of the value”; built from a dictated brain dump
2. Self-improving skills via feedbackIndirect: skills point at brain files, so one edit to a reference file updates every skill that uses it
3. Skill as the capability primitiveYes; skills live in the Claude account, reference files live in the brain
4. Skill chaining / dependency directionRouting, not chains: a root AGENTS.md routing table plus an index file per subfolder
5. The system improves itself, not just outputsYes: a daily operator task writes new insights and prunes stale files; a weekly optimizer rewrites routing and index files and merges duplicates

What changes in this article’s findings:

  • The root-file cap converges on 200 lines. Ben’s June figure was ~300 lines (recorded in the June update above); in October he says under 200, attributing it to Anthropic, which matches Anthropic’s steering post.
  • The root file is being renamed AGENTS.md for cross-provider use. Claude Code reads it only when no CLAUDE.md exists (v2.1.277+, see AGENTS.md), which Ben states correctly.
  • The team-scale open question below now has a practitioner answer. Ben’s rules: one shared brain rather than one per team, rollout in stages (yourself for a couple of weeks, then one person, one department, the company), one named owner who runs the weekly cleanup and approves structure changes, per-folder and per-file permissions, and a “business first” rule in the root file so each person’s agent checks requests against company strategy instead of agreeing with the user. His tooling is his own open-source app, Baalda (hosting options).
  • Dashboards are becoming a recurring element. Ben (daily, per-department and per-person dashboards) and Jay (a local dashboard with skill buttons) both treat a human-facing interface on the context layer as part of the OS. Nate’s course covers artifact dashboards too, but he says he uses on-demand reports more than dashboards. ^[inferred] See Agentic OS Command Center.

Open Questions

  • Is there a fourth convergent voice on the way? The pattern feels incomplete with three sources. First answer: Jay (Robo Nuggets) — May 6 2026, Cowork-native AIOS framework, superseded by his ARMS framework (August and October 2026, see the October update above). Worth watching for Charlie Hills (already a cited skill-builder with voice-builder matching the shared-context pattern) or Corey Haines (Marketing Skills Bundle uses the same product-marketing-context foundation pattern) to publish a system-level framework. Both are halfway there at the skill-bundle level.
  • What’s the right name for the convergent pattern? Simon calls it “Agentic OS.” Brandon doesn’t name his framework. Nate trademarks “Four Cs of an AIOS™.” This article calls it “the 2026 Claude Code AIOS pattern” — generic, descriptive, free. If a single name catches on in the community, it’ll likely be Nate’s “AIOS” given the trademarked attention.
  • Is the convergence evidence of design correctness or evidence of shared influences? All three creators publish on YouTube; the AI/automation YouTube ecosystem is small. They could be downstream of the same blog post or Twitter thread. Worth watching for the original source — if there is one.
  • Does the pattern hold at team scale? (2026-10-28: Ben AI gives the first multi-user rollout rules; see the October Ben AI update above. Still no measured outcome.) All three frameworks are single-operator. The “team reaches the AIOS instead of you” success indicator implies multi-user, but none of the sources show a multi-user implementation. WEO is a natural test bed for whether the pattern survives multi-operator usage.
  • Where does the Karpathy LLM-wiki pattern sit relative to the AIOS pattern? This article treats them as compatible — Karpathy’s pattern is the knowledge layer; the AIOS pattern is the skill+context+cadence layer. But there might be a deeper integration (skills that read from the wiki, wiki articles that index skill outputs) worth designing. Open R&D.