Agentic Os
Structure Claude Code as a persistent multi-agent OS with kernel routing, slash commands, and file-based state instead of one-off chat sessions.
Overview
Agentic OS is an agent skill most often used in Build (also Operate, Ship) that codifies a four-layer Claude Code architecture—kernel, specialists, commands, scripts, and file-based data—for persistent multi-agent automa
Install
npx skills add https://github.com/affaan-m/everything-claude-code --skill agentic-osWhat is this skill?
- Four-layer architecture: kernel CLAUDE.md, agents/, .claude/commands/, scripts/, and data/ with no external database
- Kernel config registers specialists and routing rules for task delegation inside Claude Code
- Slash commands as user-facing CLI over the same agent registry
- Daemon scripts in scripts/ for scheduled or event-driven work that survives session restarts
- JSON/markdown data layer for persistent memory across long-running projects
- Four architecture layers: kernel, agents, commands/scripts, and data
Adoption & trust: 1.2k installs on skills.sh; 210k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You want Claude Code to coordinate specialists and keep state across sessions, but ad-hoc chats lose context and have no stable routing or automation surface.
Who is it for?
Solo builders shipping long-lived Claude Code projects who need a coordinator, slash-command UX, and durable file memory in one repo.
Skip if: One-shot prompts, single-agent chats with no recurring automation, or teams that require a hosted orchestrator and external DB instead of git-tracked files.
When should I use this skill?
Building multi-agent Claude Code workflows, persistent automation, personal/agentic OS requests, or projects where context must survive session restarts.
What do I get? / Deliverables
You get a documented project skeleton—CLAUDE.md kernel, agent prompts, slash commands, scripts, and data files—so tasks route to specialists and automation survives restarts without standing up a database.
- CLAUDE.md kernel with agent registry
- Specialist markdown agents under agents/
- Slash commands and optional scripts/ with data/ state files
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build because the skill defines project layout (CLAUDE.md kernel, agents/, commands, scripts/) as the product you implement. agent-tooling matches specialist agents, coordinator routing, and Claude-native automation primitives rather than app business logic.
Where it fits
Lay out agents/ and CLAUDE.md routing before wiring your first specialist prompts.
Add scripts/ daemons and data/ JSON state so nightly jobs run without reopening chat history.
Freeze kernel rules and command catalog so collaborators invoke the same OS after deploy.
Reuse slash commands as repeatable content or support workflows driven by the same agent registry.
How it compares
Architecture-and-workflow skill for Claude Code layout, not an MCP server catalog entry or a generic brainstorming ritual.
Common Questions / FAQ
Who is agentic-os for?
Indie developers and small teams who run Claude Code as their primary agent environment and want kernel routing, specialist agents, and persistent file state in the project root.
When should I use agentic-os?
During Build when you stand up multi-agent workflows and slash commands; during Operate when you add scheduled scripts and JSON/markdown state; and during Ship when you harden long-running project structure before release.
Is agentic-os safe to install?
Review the Security Audits panel on this Prism page and inspect scripts/, commands, and daemon code before granting shell or network access in your environment.
SKILL.md
READMESKILL.md - Agentic Os
# Agentic OS Treat Claude Code as a persistent runtime / operating system rather than a chat session. This skill codifies the architecture used by production agentic setups: a kernel config that routes tasks to specialist agents, persistent file-based memory, scheduled automation, and a JSON/markdown data layer. ## When to Activate - Building a multi-agent workflow inside Claude Code - Setting up persistent Claude Code automation that survives session restarts - Creating a "personal OS" or "agentic OS" for recurring tasks - User says "agentic OS", "personal OS", "multi-agent", "agent coordinator", "persistent agent" - Structuring long-running projects where context must survive across sessions ## Architecture Overview The Agentic OS has four layers. Each layer is a directory in your project root. ``` project-root/ ├── CLAUDE.md # Kernel: identity, routing rules, agent registry ├── agents/ # Specialist agent definitions (markdown prompts) ├── .claude/commands/ # Slash commands: user-facing CLI ├── scripts/ # Daemon scripts: scheduled or event-driven tasks └── data/ # State: JSON/markdown filesystem, no external DB ``` ### Layer Responsibilities | Layer | Purpose | Persistence | |---|---|---| | Kernel (`CLAUDE.md`) | Identity, routing, model policies, agent registry | Git-tracked | | Agents (`agents/`) | Specialist identities with scoped tools and memory | Git-tracked | | Commands (`.claude/commands/`) | User-facing slash commands (`/daily-sync`, `/outreach`) | Git-tracked | | Scripts (`scripts/`) | Python/JS daemons triggered by cron or webhooks | Git-tracked | | State (`data/`) | Append-only logs, project state, decision records | Git-ignored or tracked | ## The Kernel `CLAUDE.md` is the kernel. It acts as the COO / orchestrator. Claude reads it at session start and uses it to route work. ### Kernel Structure ```markdown # CLAUDE.md - Agentic OS Kernel ## Identity You are the COO of [project-name]. You route tasks to specialist agents. You never write code directly. You delegate to the right agent and synthesize results. ## Agent Registry | Agent | Role | Trigger | |---|---|---| | @dev | Code, architecture, debugging | User says "build", "fix", "refactor" | | @writer | Documentation, content, emails | User says "write", "draft", "blog" | | @researcher | Research, analysis, fact-checking | User says "research", "analyze", "compare" | | @ops | DevOps, deployment, infrastructure | User says "deploy", "CI", "server" | ## Routing Rules 1. Parse the user request for intent keywords 2. Match to the Agent Registry trigger column 3. Load the corresponding agent file from `agents/<name>.md` 4. Hand off execution with full context 5. Synthesize and present the result back to the user ## Model Policies - Default model: use the repository or harness default. - @dev tasks: prefer a higher-reasoning model for complex architecture. - @researcher tasks: use the configured research-capable model and approved search tools. - Cost ceiling: warn before exceeding the project's configured spend threshold. ``` ### Key Principle The kernel should be **small and declarative**. Routing logic lives in plain markdown tables, not code. This makes the system inspectable and editable without debugging. ## Specialist Agents Each agent is a standalone markdown file in `agents/`. Claude loads the relevant agent file when routing a task. ### Agent Definition Format ```markdown # @dev - Software Engineer ## Identity You are a senior software engineer. You write clean, tested, production-grade code. You prefer simple solutions. You ask clarifying questions when requirements are ambiguous. ## Memory Scope - Read `data/projects/<current