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
| Source | Date | Audience | Tool stack | Distinctive framing |
|---|---|---|---|---|
| **[[hermes-agent/_index | Simon Scrapes — Connected Skills as Agentic OS]]** | 2026-03-15 (YouTube, 13:24) | Solopreneurs / agency operators | Vanilla Claude Code |
| **[[ai-marketing/lead-magnet-creation-claude-code-brandon-storey | Brandon Storey — Lead Magnet Creation course]]** | 2026-04-15 (YouTube, 1:55:54) | Freelance copywriters / coaches | Claude Code + ChatGPT + Beehiiv + Kajabi + Zapier + Vizard.ai + ManyChat |
| **[[claude-ai/nate-herk-claude-code-operating-systems-course | Nate Herk — AIS-OS masterclass]]** | 2026-05-01 (YouTube + public MIT repo) | SMB operators / AI consultants | Claude 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.
| Dimension | Simon Scrapes | Brandon Storey | Nate Herk |
|---|---|---|---|
| 1. Shared brand context as foundation | brand-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 + graphic | context/about-me.md, context/about-business.md, context/voice.md, references/ — populated by /onboard 7-question interview |
| 2. Self-improving skills via feedback | learnings.mmd — feedback bucketed by skill, folded into SKILL.md at end-of-day by the wrap-up skill | Iterate by talking back (“make it more centered”), 4-6 conversational turns to acceptable | The 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 primitive | A folder at .claude/skills/<name>/ with SKILL.md; categorized by tier | Each 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 direction | Foundation → Strategy → Execution → Ops tiers; lower tiers feed upper tiers | Six-phase pipeline (ideation → production → triple format → email → landing → distribution); each phase outputs the next phase’s inputs | Skill → routine pipeline; /level-up identifies the next skill worth building; ops tier wraps mature capabilities |
| 5. The system improves itself, not just outputs | Heartbeat 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
| Source | Stance |
|---|---|
| Simon Scrapes | Explicitly cites OpenClaw memory model as inspiration. Implements on vanilla Claude Code but the design is portable. |
| Brandon Storey | Single-runtime (Claude Code + auxiliary SaaS). No portability conversation. |
| Nate Herk | Tool-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
| Source | Stance |
|---|---|
| Simon Scrapes | Stay in Claude Code. Skills do everything. |
| Brandon Storey | Multi-tool by necessity (lead-magnet pipeline crosses Beehiiv / Kajabi / ManyChat / ChatGPT). Claude Code is the production surface, not the operations surface. |
| Nate Herk | Claude 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
| Source | Stance |
|---|---|
| Simon Scrapes | Heartbeat at session start, wrap-up at session end — explicit named layer of the architecture. |
| Brandon Storey | Not addressed. The pipeline is one-shot per lead-magnet. |
| Nate Herk | The 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
| Source | Stance |
|---|---|
| Simon Scrapes | ”Agentic OS” is the speaker’s branded version of the pattern; offers paid community access. No trademarks in the public material. |
| Brandon Storey | Six 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.mdpattern mirrors Simon’sbrand-context/+skills/+CLAUDE.md, Brandon’s brand-guidelines-on-disk + skill-driven production, and Nate’scontext/+references/+CLAUDE.md. - Karpathy’s index files (
_master-index.md,_index.md) play the same role as Nate’sCLAUDE.md“Where things live” section. - Karpathy’s append-only
log.mdmirrors Nate’sdecisions/log.md. - Karpathy’s
hot.mdsession-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 dimension | Existing WEO surface | Gap |
|---|---|---|
| Shared brand context | OmniPresence 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 feedback | OmniPresence script feedback loops; Clawdbot output review | Feedback isn’t folded back into the skill file; it lives in chat history |
| Skill as capability primitive | Limited use; most automation lives as Python or n8n flows | Skills-first refactor would unlock the rest of the pattern |
| Skill chaining | BAW pipeline (Blog-Agent-Worker) approximates this | Chain happens in code, not as composable skills |
| Self-maintenance | Hermes learning loop, Clawdbot weekly refresh | Not 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:
- Pick the shared-context folder. Create
brand-context/(or whatever name you prefer) at your project root. Addvoice.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. - 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>.mdfile. End of week, ask Claude Code to fold the learnings into theSKILL.md. You’ve just built Simon’s / Nate’s feedback loop. - 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.mdfirst, 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:
| Layer | Description |
|---|---|
| 1. System instructions | CLAUDE.md as “operating manual” — Cowork-only emphasis, since IDE-style and claude.md don’t apply |
| 2. Security | Sandbox VM + permissions — Cowork-native (sandbox is the runtime substrate) |
| 3. Program | Skills, 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. MCP | External-system access — required for Cowork because no native IDE/CLI access |
| 6. Scheduling | Smart schedules so the agent runs autonomously without manual kicks |
| 7. Mobile | Dispatch (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:
| Dimension | Jay (Cowork-native AIOS) |
|---|---|
| 1. Shared brand context as foundation | Pod-by-pod (acquisition/delivery/support/operations) audit feeds context layer; explicit knowledge-vs-state-vs-memory decomposition |
| 2. Self-improving skills via feedback | Implicit (continuous correction during build); not a named layer |
| 3. Skill as the capability primitive | Yes — .claude/skills/<name>/ skills are the program layer; explicitly recommends marketplace-vetted plugins for distribution |
| 4. Skill chaining / dependency direction | Pod-led (acquisition skills feed delivery skills feed operations skills); MCP-mediated where external systems are involved |
| 5. The system improves itself, not just outputs | Not 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.mdlean and routed. Cap the rootCLAUDE.mdat ~300 lines, give it an explicit routing table (“where things live”), and push detail into per-subfolderCLAUDE.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.
| Dimension | Jay, 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 feedback | Explicit: review feedback carries an “update this skill” instruction; /note backlog and /calibrate |
| 3. Skill as the capability primitive | Yes, sorted into database, artifact and self-triggered types |
| 4. Skill chaining / dependency direction | Routing files rather than chains: CLAUDE.md maps departments, department files route to skills and references |
| 5. The system improves itself, not just outputs | Yes. 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 routingCLAUDE.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 routedCLAUDE.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.
| Dimension | Ben AI, October 2026 |
|---|---|
| 1. Shared brand context as foundation | 5 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 feedback | Indirect: skills point at brain files, so one edit to a reference file updates every skill that uses it |
| 3. Skill as the capability primitive | Yes; skills live in the Claude account, reference files live in the brain |
| 4. Skill chaining / dependency direction | Routing, not chains: a root AGENTS.md routing table plus an index file per subfolder |
| 5. The system improves itself, not just outputs | Yes: 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.mdfor cross-provider use. Claude Code reads it only when noCLAUDE.mdexists (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 withvoice-buildermatching the shared-context pattern) or Corey Haines (Marketing Skills Bundle uses the sameproduct-marketing-contextfoundation 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.
Related
- Simon Scrapes’ Connected Skills as Agentic OS — the OpenClaw-lineage source
- Simon Scrapes’ second AIOS video — Nine-Component Agentic OS — Simon’s May 2026 follow-up filling several open questions flagged in this article (multi-client architecture via parent-folder
CLAUDE.mdinheritance; six-level memory taxonomy; predictable outputs; access-from-anywhere via VPS + Channels). The five-dimension comparison table above stays correct, but the “open question on multi-client” is now answered by Simon’s framework. - Brandon Storey’s Lead Magnet course — the multi-tool pipeline source
- Nate Herk’s AIS-OS masterclass — the most architectural-and-trademarked source, with the public MIT repo
- Jay’s ARMS Agentic OS (Robo Nuggets) — the October 2026 update’s source: apps, routines, memory and skills in three levels each
- Ben AI’s Second Brain Playbook — the June mistakes video’s creator; 18 lessons including team rollout
- Karpathy’s LLM-wiki pattern — the knowledge layer sibling pattern
- Google Open Knowledge Format (OKF) — Google’s open standardization of that knowledge layer (2026-06-12); the portable file-format substrate this pattern’s context layer could adopt
- Karpathy Pattern (topic) — community implementations of the wiki pattern
- Agent Skills Overview — Anthropic’s official skills doc that all three frameworks build on
- Skill Design Patterns — the five canonical patterns; the AIOS frameworks operate one tier above (system, not single skill)
- Corey Haines’ Marketing Skills Bundle —
product-marketing-contextfoundation pattern at the skill-bundle level - Charlie Hills’ social-media-skills —
voice-builderfoundation pattern at the skill-bundle level - Rick Mulready’s seven use cases — Operator-track companion (Cowork-only, doesn’t reach for the AIOS abstraction)
- oh-my-claudecode (OMC) — orchestration-first sibling third-party framework
- Superpowers — closed-methodology sibling third-party framework
- OpenClaw Use-Case Cookbook — the predecessor runtime Simon’s framework lifts memory patterns from
- 8 Figure Agency Hermes Playbook (Jordan Ross) — adjacent agency-operations field guide; same audience, different runtime (Hermes Agent)
- Gartner Strategic Impact of AI Agents — the industry-analyst frame; the AIOS pattern lives in Gartner’s Basic-Intermediate band on Decisioning + Knowledge dimensions
- WEO Intermediate Claude Course — natural slot for the convergent-pattern reference material
- Loop Engineering (Cobus Greyling) — the orchestration/automation layer of the AIOS: scheduled loops + state + maker/checker verification, as a cross-tool pattern catalog.