Skip to main content
Agent skill

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. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

Get started

Get the complete skill folder, including its scripts and reference files.

·

When to use this skill

Use Agentic Os when an AI agent needs a reusable SKILL.md workflow for this job: 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. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

When not to use it

Skip Agentic Os when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/agentic-os
# Save SKILL.md to ~/.claude/skills/agentic-os/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/agentic-os/SKILL.md. For a shared project, commit the folder at .claude/skills/agentic-os/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Agentic Os skill for this task: Use Agentic Os when this documented workflow matches the task. Confirm any required inputs or files before making changes.

What supports this recommendation?

76/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
85/100
Practical detail
76/100
Source evidence
63/100
Source signals
70/100
Model compatibility evidence
  • claudeinferred

    The skill text mentions Claude or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • chatgptinferred

    The skill text mentions ChatGPT or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# 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-project>.md` for context - Read `data/decisions/` for architectural decisions - Append execution logs to `data/logs/<date>[email protected]`

## Tool Access - Full filesystem access within project root - Git operations (status, diff, commit, branch) - Test runner access - MCP servers as configured in `.claude/mcp.json`

## Constraints - Always write tests for new features - Never commit directly to `main`; use feature branches - Prefer editing existing files over creating new ones - Keep functions under 50 lines when possible ```

### Multi-Agent Collaboration Pattern

When a task spans multiple agents, the kernel runs them sequentially or in parallel:

``` User: "Build a landing page and write the launch blog post"

Kernel routing: 1. @dev - "Build a landing page with [requirements]" 2. @writer - "Write a launch blog post for [product] using the landing page copy" 3. Kernel synthesizes both outputs into a unified response ```

For parallel execution, use Claude Code's background task capability or shell scripts that invoke Claude Code with specific agent contexts.

## Commands and Daily Workflows

Slash commands are markdown files in `.claude/commands/`. They define reusable workflows.

### Command Structure

```markdown # /daily-sync

Run the morning briefing:

1. Read `data/logs/last-sync.md` for context 2. Check project status: `git status`, pending PRs, CI health 3. Review `data/inbox/` for new tasks or decisions needed 4. Generate a summary of blockers, priorities, and next actions 5. Append the briefing to `data/logs/daily/<date>.md` ```

### Standard Command Set

| Command | Purpose | |---|---| | `/daily-sync` | Morning briefing: status, blockers, priorities | | `/outreach` | Run outreach workflow (email, LinkedIn, etc.) | | `/research <topic>` | Deep research with citation tracking | | `/apply-jobs` | Tailor resume + cover letter for a target role | | `/analytics` | Pull metrics from Stripe, GitHub, or custom sources | | `/interview-prep` | Generate flashcards or mock interview questions | | `/decision <topic>` | Log a decision with pros/cons and chosen path |

### Activating Commands

Place command files in `.claude/commands/<command-name>.md`. Claude Code auto-discovers them. Users invoke them with `/<command-name>`.

## Persistent Memory

Memory is file-based. No vector DB, no Redis, no PostgreSQL. JSON and markdown files in `data/` are the database.

### Memory Directory Structure

``` data/ ├── daily-logs/ # Append-only daily activity logs ├── projects/ # Per-project context files ├── decisions/ # Architectural and business decisions (ADR format) ├── inbox/ # New tasks or ideas awaiting triage ├── contacts/ # People, companies, relationship notes └── templates/ # Reusable prompts and formats ```

### Daily Log Format

```markdown # 2026-04-22 - Daily Log

## Sessions - 09:00 - Session 1: Refactored auth module (@dev) - 11:30 - Session 2: Drafted investor update (@writer)

## Decisions - Switched from JWT to session cookies (see `data/decisions/2026-04-22-auth.md`)

## Blockers - Waiting on API key from vendor (follow up 2026-04-24)

## Next Actions - [ ] Merge auth refactor PR - [ ] Send investor update for review ```

### Auto-Reflection Pattern

At the end of each session, the kernel appends a reflection:

```markdown ## Reflection - Session 3 - What worked: Parallel agent execution saved 20 minutes - What didn't: @researcher hit a paywalled source, need better source ranking - What to change: Add `source-tier` field to research notes (A/B/C credibility) ```

This creates a feedback loop that improves the system over time without code changes.

## Scheduled Automation

Agentic OS tasks run on a schedule using external cron, not Claude Code's built-in cron (which dies when the session ends).

### macOS: LaunchAgent

```xml <!-- ~/Library/LaunchAgents/com.agentic.daily-sync.plist --> <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" ...> <plist version="1.0"> <dict> <key>Label</key> <string>com.agentic.daily-sync</string> <key>ProgramArguments</key> <array> <string>/claude</string> <string>--cwd</string> <string>/path/to/project</string> <string>--command</string> <string>/daily-sync</string> </array> <key>StartCalendarInterval</key> <dict> <key>Hour</key> <integer>8</integer> <key>Minute</key> <integer>0</integer> </dict> <key>StandardOutPath</key> <string>/tmp/agentic-daily-sync.log</string> </dict> </plist> ```

### Linux: systemd Timer

```ini # ~/.config/systemd/user/agentic-daily-sync.service [Unit] Description=Agentic OS Daily Sync

[Service] Type=oneshot ExecStart=/usr/local/bin/claude --cwd /path/to/project --command /daily-sync ```

```ini # ~/.config/systemd/user/agentic-daily-sync.timer [Unit] Description=Run daily sync every morning

[Timer] OnCalendar=*-*-* 8:00:00 Persistent=true

[Install] WantedBy=timers.target ```

### Cross-Platform: pm2

```bash # ecosystem.config.js module.exports = { apps: [{ name: 'agentic-daily-sync', script: 'claude', args: '--cwd /path/to/project --command /daily-sync', cron_restart: '0 8 * * *', autorestart: false }] }; ```

## Data Layer

The data layer is your filesystem. Use JSON for structured data and markdown for narrative content.

### JSON for Structured State

```json // data/projects/website-v2.json { "name": "Website v2", "status": "in-progress", "milestone": "beta-launch", "agents_involved": ["@dev", "@writer"], "files": { "spec": "docs/website-v2-spec.md", "design": "designs/website-v2.fig" }, "metrics": { "commits": 47, "last_session": "2026-04-22T11:30:00Z" } } ```

### Markdown for Narrative

Use markdown for anything a human reads: decisions, logs, research notes, contact records.

### Schema Evolution

Never rename existing fields. Add new fields and mark old ones deprecated:

```json { "name": "Website v2", "status": "in-progress", "milestone": "beta-launch", "_deprecated_priority": "high", "priority_v2": { "level": "high", "rationale": "Blocks investor demo" } } ```

This keeps historical data readable without migration scripts.

## Anti-Patterns

### Monolithic Single Agent

```markdown # BAD - One agent does everything You are a full-stack developer, writer, researcher, and DevOps engineer. ```

Split into specialist agents. The kernel handles routing.

### Stateless Sessions

```markdown # BAD - No memory between sessions Starting fresh every time Claude Code opens. ```

Always read `data/` at session start and write back at session end.

### Hardcoded Credentials

```markdown # BAD - API keys in agent files or CLAUDE.md Your OpenAI API key is sk-xxxxxxxx ```

Use environment variables or a `.env` file loaded by scripts. Agents reference `process.env.API_KEY`.

### External Database for Simple State

```markdown # BAD - PostgreSQL for a solo user's agentic OS ```

Use JSON/markdown files until you have multiple concurrent users or GBs of data.

### Over-Engineered Routing

```markdown # BAD - Routing logic in code instead of markdown tables if (intent.includes('deploy')) { agent = opsAgent; } ```

Keep routing declarative in `CLAUDE.md` markdown tables. It is inspectable, editable, and debuggable.

## Best Practices

- [ ] `CLAUDE.md` is under 200 lines and fits in context window - [ ] Each agent file is under 100 lines and focused on one domain - [ ] `data/` is git-ignored for sensitive logs, git-tracked for decisions and specs - [ ] Commands use imperative names: `/daily-sync`, not `/run-daily-sync` - [ ] Logs are append-only; never edit past daily logs - [ ] Every agent has a `Memory Scope` section defining what files it reads - [ ] Reflections are written at the end of every session - [ ] Scheduled tasks use external cron (LaunchAgent, systemd, pm2), not Claude Code's session cron - [ ] Cost tracking: log API spend per session in `data/logs/<date>-costs.json` - [ ] One project = one Agentic OS. Do not share a single `CLAUDE.md` across unrelated projects.

Intended uses

  • Use Agentic Os when this documented workflow matches the task.

Implementation notes

  • [ ] CLAUDE.md is under 200 lines and fits in context window
  • [ ] Each agent file is under 100 lines and focused on one domain
  • [ ] data/ is git-ignored for sensitive logs, git-tracked for decisions and specs
  • [ ] Commands use imperative names: /daily-sync, not /run-daily-sync
  • [ ] Logs are append-only; never edit past daily logs
  • [ ] Every agent has a Memory Scope section defining what files it reads
  • [ ] Reflections are written at the end of every session
  • [ ] Scheduled tasks use external cron (LaunchAgent, systemd, pm2), not Claude Code's session cron
  • [ ] Cost tracking: log API spend per session in data/logs/<date>-costs.json
  • [ ] One project = one Agentic OS. Do not share a single CLAUDE.md across unrelated projects.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.