Video summary

The Agentic OS Setup That Will 10x Claude Code

Main summary

Key takeaways

Technology

Technological focus: “Agentic OS” value is in the fundamentals (not the UI)

The video argues that “agentic OS” (AIOS) systems—whether web-app, Obsidian-based, or terminal-based—provide real leverage mostly from what’s under the hood:

  • Loop engineering (closed improvement cycles)
  • Skill architecture (turning repeated tasks into reusable capabilities)
  • State & memory management (a “second brain” backed by structured knowledge)
  • Bundling these into a coherent, personalized product

Core idea: UI visuals alone are “smoke and mirrors” unless the underlying architecture supports consistent, improving execution.

Four-level AIOS framework (what to build, in what order)

Level 1: Skill architecture + loop engineering (the “backbone”)

This level includes four subphases:

  1. Workflow audit (identify tasks you repeatedly do and outputs you need)
  2. Skill creation (encode tasks into specific, consistent skill outputs)
  3. Automation (convert skills into scheduled/routine actions)
  4. Loop engineering (add self-improvement on top of automated workflows)

Workflow audit methods (3 approaches)

  • Manual: create skills directly from your own existing Claude Code workflows.
  • Mine past sessions: ask Claude Code to review the last 3/5/10/20 sessions, extract repeated tasks, and propose a skill list/output spec.
  • Interview approach: have Claude Code interview you via “stream of consciousness,” detect blind spots, and turn your described routine into candidate skills.

Automation example idea

  • Convert a skill into a scheduled routine (e.g., “run this skill on a schedule”), often via Cloud Desktop “routines.”

Key claim

  • Levels 1 & 2 contain ~90% of the value.
  • UI visuals alone won’t deliver leverage without the underlying skill + loop architecture.

Level 2: Memory + state management (“second brain”)

Main message: the AIOS needs a map to your knowledge and a way to log what happened in past runs so loops can improve.

Obsidian-centered setup (database-agnostic)

  • Choose a folder as the Obsidian vault (a file structure that stores your data).
  • Connect by opening Claude/Claude Code from within that vault folder.

Important requirement: clear vault hierarchy

  • The vault must have a clear hierarchy / filing cabinet logic.
  • If it’s a single huge folder with unstructured sprawl, Claude Code will be slower and more expensive (more tokens).

“Map” concept via knowledge-graph-like navigation

Inspired by a “Carpathy Obsidian RAG” pattern:

  • raw (unstructured data)
  • wiki (structured summaries/articles)
  • outputs (deliverables like slide decks)

Core mechanism:

  • Use index.md files at each directory level.
  • Each index.md explains what’s inside that folder and where to route queries.

Also recommends creating a claw.md document describing vault conventions and navigation patterns.

Connection to loop engineering

  • Outputs/state from runs should be stored/logged in the same coherent place so later runs can reference past results for self-improvement.

Level 3: Visual interface wrapper + customization

Level 3 adds a “custom visual wrap” around Levels 1–2:

  • Either web-app based or Obsidian command center based
  • Main feature: turning skills/automations into custom metrics + one-click actions

Example UI behavior

  • Left side: personalized metrics (e.g., content/community/schedules)
  • Right side: buttons for skills/automations (e.g., “Inbox brief”)

Example interface execution

  • Clicking a button triggers a headless Claude Code run that performs a workflow (e.g., triaging threads, drafting a write-up)
  • Then surfaces results (possibly in Obsidian)

Voice model mention

  • Demonstrates voice interaction where the voice model can be local (on the user’s machine), described as not going to an external provider.

Level 4: Distribution (share the AIOS with team/clients)

Level 4 is about making the system easy for others to use:

  • Turn capabilities into buttons/voice commands so non-technical users don’t need to learn terminal workflows.
  • Web distribution is easier:
    • Publish on GitHub
    • Distribute a repo/zip
    • Help teammates get it running quickly
  • Obsidian distribution is more hands-on:
    • Requires installation/setup as an Obsidian plugin or similar approach

Core product goal

  • “Raise the floor” for an organization and lower the barrier for people who are scared of terminal/desktop tooling.

Under-the-hood mechanism referenced for UI buttons (key technical detail)

When a UI button runs a skill:

  • It calls a headless version of Cloud/Claude Code execution (terminal runs invisibly)
  • Uses a command referred to as claude-p
  • Mentions a recent “drama”/policy concern:
    • using claude-p might draw from a $200 API credit instead of subscription
    • it’s been walked back (claim: for now it pulls from the max plan)

Main speakers / sources

  • Speaker: the video narrator (referenced throughout as “I” and promoting “my Claude Code master class”; also mentions “Chase AI Plus”).
  • External source referenced: Carpathy (cited via a highly viewed tweet about an Obsidian RAG-style vault structure).

Original video