Back to Skills

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases.

230,578stars35,187forksUpdated 7/17/2026

Security Assessment

Low Risk(80/100)

Detected risks:

Sensitive File Access([SKILL.md] .env)
Security Score80/100

About agentic-os

This skill teaches how to treat Claude Code as a persistent runtime or operating system rather than a one-off chat session. It solves the problem of context and automation that disappear when a session ends by codifying an architecture where a kernel config routes tasks to specialist agents, memory lives in files, and automation runs on a schedule. State is stored in a JSON and markdown filesystem rather than an external database, making the whole system inspectable and editable without debugging code.

The architecture has four layers, each a directory in the project root: the kernel (CLAUDE.md) which holds identity, routing rules, and an agent registry; agents/ containing specialist markdown prompts with scoped memory and tools; .claude/commands/ holding user-facing slash commands like /daily-sync, /outreach, and /research; scripts/ for daemon tasks; and data/ for append-only logs, project state, and decision records. The kernel acts as an orchestrator that parses request intent, matches keywords to the agent registry, loads the matching agent file, hands off execution, and synthesizes results. Slash commands are auto-discovered markdown files, and multi-agent tasks can run sequentially or in parallel via Claude Code's background task capability or shell scripts. Memory follows conventions like daily logs, ADR-format decisions, and an inbox for triage, plus an auto-reflection pattern that appends session retrospectives to create a feedback loop.

This skill is aimed at users building multi-agent workflows, a personal or agentic OS, or long-running projects where context must survive across sessions. A key stated design principle is that the kernel should be small and declarative, with routing logic in plain markdown tables rather than code. A notable limitation and requirement: scheduled automation should use external cron such as a macOS LaunchAgent, because Claude Code's built-in cron dies when the session ends.

FAQ

What are the four layers of an Agentic OS?

The kernel (CLAUDE.md) for identity and routing, agents/ for specialist agent definitions, .claude/commands/ for user-facing slash commands, scripts/ for daemon tasks, and data/ for file-based state. Each layer is a directory in the project root.

How does task routing work?

The kernel parses the user request for intent keywords, matches them to the trigger column of the Agent Registry, loads the corresponding agent file from agents/<name>.md, hands off execution with full context, and then synthesizes and presents the result.

Does this require a database?

No. Memory is file-based using JSON and markdown files in data/, with no vector DB, Redis, or PostgreSQL. Conventions include append-only daily logs, ADR-format decisions, and an inbox for triage.

How is scheduled automation handled?

Tasks run on a schedule using external cron, not Claude Code's built-in cron, which dies when the session ends. On macOS this can be done with a LaunchAgent plist.

How are slash commands added?

Place command files as markdown in .claude/commands/<command-name>.md. Claude Code auto-discovers them, and users invoke them with /<command-name>.

Install agentic-os

Download and extract the skill files to your .claude/skills/ directory.

Quick Setup:

  1. Copy the skill folder to .claude/skills/
  2. Claude will automatically detect and use the skill