This NEW Jev + Claude OS Just Changed Every AI Workflow

High-level concept

The video presents an “Agentic OS / Claude OS / Jev + Claude OS” workflow concept: a three-tier AI operating system that replaces terminal-centric interaction with a customizable interface + structured memory + a skills/automation layer tailored to the user’s real daily workflows.

What “Agentic OS” is (and what it’s not)

• It’s not mainly about fancy UI elements.
• The goal is to build a personal AI system that:
  • routes requests to different AI models (including Jev) based on task type,
  • integrates tools (browser/web app, Obsidian, and optionally terminals),
  • produces results that are fed back into the system.

Three-layer system architecture

1) Visual layer (UI / dashboard)

• Runs as a web app inside the browser.
• Can also be ported to an Obsidian plugin to get the UI benefits while keeping Obsidian desktop functionality.
• Features:
  • Connects to calendar and organizes “skills/automations.”
  • Offers tabs for deeper areas like audience research and “AI in general.”
  • Example “research tab” pulls from sources such as GitHub trends, YouTube, Hacker News (subtitles suggest these).
  • 100% customizable for personal, team, or client needs.
• Can launch skills that may open a terminal (via Claude Code / Codex).

2) Memory/storage layer (Obsidian “second brain,” but not as RAG)

• Uses Obsidian as a storage/memory layer, emphasized as practical structure, not “magical” knowledge graphs.
• Key claim: it’s not a RAG system; instead it uses a file/folder structure so the AI can locate information quickly and accurately even with thousands of files.
• Uses Karpathy-inspired Obsidian RAG-style organization (specific folder structure is highlighted in the tutorial section below).

3) Skills architecture (the core)

• The “foundation” layer: convert recurring user tasks into skills (and optionally automation).
• Skills produce outputs/results (reports, metrics, etc.) that the OS can track.
• The system translates “daily/weekly work” into a structured set of:
  • skills → outcomes → logged reports/metrics → dashboard

How the system works end-to-end (example-driven)

The speaker demonstrates how different requests trigger different execution paths:

• Simple command: “Open the morning briefing”

  • Routed as a fast request where Jev classifies the task.
  • Skips “AI generation” for speed (claimed hundreds of milliseconds).

• News question: “What was the biggest news in the world of AI today?”

  • Routed to smaller/cheaper models (e.g., Haiku or Luna, depending on configuration).
  • Jev classification decides the right model tier.

• Complex task requiring tooling + explanation: generating an explainer/report

  • Triggers launching a terminal / interaction with Claude Code or Codex.

Voice system (local-first)

The video includes a “completely local voice system”:

• Audio is transcribed locally using Whisper (“ears” of the model).
• Voice playback is done with a local/open-source voice model (subtitles mention Kokoro).
• The transcribed text is sent to Jev for classification/routing.

Model routing with Jev (what it’s used for)

• Jev is framed as not an LLM chat replacement, but as a classifier/router that returns:
  • probabilities over predefined categories/options.
• The OS uses Jev to choose among three request tiers:

Tier 1 (ultra-fast, extremely simple)

• Direct commands like opening the briefing or Obsidian actions.
• Claimed speed: ~hundreds of milliseconds.
• “Artificial intelligence isn’t introduced” for these requests (per the speaker).

Tier 2 (simple questions)

• Runs small/cheap/fast models (Haiku or Luna suggested).
• Example: “biggest news in AI today.”

Tier 3 (complex work)

• Opens Claude Code / Codex in a terminal.
• Performs heavier tasks like generating explainer reports and tool-assisted outputs.

Why Jev matters

• Claimed to be ~200x faster and cheaper than using larger LLMs for classification-style routing tasks.
• Example (customer service):
  • Instead of generating a billing/tech response sentence, Jev returns something like: “92% chance billing.” (probabilistic routing)

Tutorial / “how to build it” elements (actionable guidance)

Building the Skills layer (top practical takeaway)

The speaker suggests creating a skills base is “ahead of 99% of people” and provides a two-step method:

1) Ask Claude/Codex to review your past logs - Claude Code and Codex keep a written conversation history (~30+ days). - Prompt idea: “Based on everything I’ve done in the last 30 days, what skills can we build?”

2) Talk non-stop for 10–20 minutes - Describe what you do daily/weekly (stream-of-consciousness is acceptable). - Then prompt: “Based on everything I told you, how can we create skills or automate things?”

After skills are identified, automation decisions are made by asking Claude/X again. Automation can be:

• manual/scheduled (within Claude Code/Codex tools),
• or triggered automatically by events (like machine state).

Obsidian repository folder structure (Karpathy-inspired)

The storage structure is given as an example (not mandatory, but recommended):

• A top-level repository folder
• Subfolders:
  • raw (store downloaded/ingested data)
  • wiki (organize raw into wiki-style articles)
  • outputs (derived artifacts like slides/presentations)

Example flow described:

• Research about “AI agents” → goes into raw
• Organize “AI agents” → goes into wiki
• Generate a PowerPoint/slides → goes into outputs

Rationale:

• AI can find information via a clear map rather than scanning millions of disorganized files.
• Humans can navigate too.
• Obsidian helps navigation; the power depends on how you structure files.

Also recommended:

• For any storage folder, instruct the system on how to add new files/content so the structure stays balanced.

Visual layer for teams/clients (packaging & distribution)

The video discusses why dashboards matter beyond individual use:

• Terminal-based tools are harder to share.
• A dashboard can be customized for each team/client.
• Buttons in the dashboard call a headless version of the Claude Code/Codex agent to run skills in the background.
• Enables non-technical users to use 90–95% of the functionality without knowing terminal workflows.
• The speaker claims this approach can be packaged and even sold.

Sponsor / product mention

• Mentions “Chase AI Plus”, which:
  • offers the speaker’s exact Claude OS configuration,
  • includes access to a Claude Code and Codex masterclass,
  • is presented as updated weekly and oriented to real use cases.

Main speakers / sources

• Main speaker: The YouTube creator presenting “Claude OS / Agentic OS” (name not stated in subtitles).
• Referenced sources/people/tools:
  • Jev (classification/routing model)
  • Claude Code / Codex (tooling/workflow platforms)
  • Obsidian (storage/memory layer)
  • Karpathy (inspiration for folder organization)
  • Whisper (local speech-to-text)
  • Kokoro (local/open-source voice model)
  • Anthropic models (implied via “Haiku/Luna” variants in routing examples)