O2 Review Loop
openobserve/openobserve
Splits a change into planner, coder and independent reviewer roles: you confirm a spec, a subagent implements it, and a separate reviewer checks each round's local WIP commit.
Build persistent multi-agent operating systems on Claude Code.
$ npx skills add affaan-m/ECC --skill agentic-os -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install affaan-m/ECC agentic-os --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/agentic-os .claude/skills/agentic-os && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "agentic-os" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/agentic-os into .claude/skills/agentic-os/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "agentic-os", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/affaan-m/ECC/tree/main/skills/agentic-osType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add affaan-m/ECC --skill agentic-os -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install affaan-m/ECC agentic-os --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/agentic-os .agents/skills/agentic-os && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "agentic-os" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/agentic-os into .agents/skills/agentic-os/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "agentic-os", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add affaan-m/ECC --skill agentic-os -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install affaan-m/ECC agentic-os --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/agentic-os .cursor/skills/agentic-os && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "agentic-os" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/agentic-os into .cursor/skills/agentic-os/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "agentic-os", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/affaan-m/ECC.git --path skills/agentic-os--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add affaan-m/ECC --skill agentic-os -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install affaan-m/ECC agentic-os --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/agentic-os .gemini/skills/agentic-os && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "agentic-os" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/agentic-os into .gemini/skills/agentic-os/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "agentic-os", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install affaan-m/ECC agentic-osInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add affaan-m/ECC --skill agentic-os -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/agentic-os .github/skills/agentic-os && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "agentic-os" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/agentic-os into .github/skills/agentic-os/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "agentic-os", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add affaan-m/ECC --skill agentic-os -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install affaan-m/ECC agentic-os --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/affaan-m/ECC.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/agentic-os .opencode/skills/agentic-os && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "agentic-os" agent skill from https://github.com/affaan-m/ECC/tree/main/skills/agentic-os into .opencode/skills/agentic-os/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "agentic-os", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
agentic-osBuild persistent multi-agent operating systems on Claude Code.
Agentic Os is an agent skill from affaan-m/ECC. 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.
Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Agent Workflows, covering Hooks and plugins, Multi-agent orchestration and State management. It works with Git. The repository describes itself as: The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond. The licence is MIT.
Read from SKILL.md and the folder at commit 4eb71d9. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown, ini, json, xml and bash).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names these keys or tokens, usually read from environment variables:
API_KEYFrom names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Agentic Os loads about 3.1k tokens when it runs. Until then it costs about 85 tokens; SKILL.md has 697 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check noted patterns worth knowing about, such as sudo or a known installer.
Use environment variables or a `.env` file loaded by scripts. Agents reference `process.env.API_KEY`.Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from affaan-m/ECC at commit 4eb71d9, republished under its MIT licence (© affaan-m). 697 words, ~3,071 tokens.
.claude/skills/agentic-os/SKILL.md (or your agent's skills folder).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.
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 | 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 |
CLAUDE.md is the kernel. It acts as the COO / orchestrator. Claude reads it at session start and uses it to route work.
# 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.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.
Each agent is a standalone markdown file in agents/. Claude loads the relevant agent file when routing a task.
# @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>-@dev.md`
## 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 possibleWhen 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 responseFor parallel execution, use Claude Code's background task capability or shell scripts that invoke Claude Code with specific agent contexts.
Slash commands are markdown files in .claude/commands/. They define reusable workflows.
# /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`| 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 |
Place command files in .claude/commands/<command-name>.md. Claude Code auto-discovers them. Users invoke them with /<command-name>.
Memory is file-based. No vector DB, no Redis, no PostgreSQL. JSON and markdown files in data/ are the database.
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# 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 reviewAt the end of each session, the kernel appends a reflection:
## 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.
Agentic OS tasks run on a schedule using external cron, not Claude Code's built-in cron (which dies when the session ends).
<!-- ~/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># ~/.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# ~/.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# 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
}]
};The data layer is your filesystem. Use JSON for structured data and markdown for narrative content.
// 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"
}
}Use markdown for anything a human reads: decisions, logs, research notes, contact records.
Never rename existing fields. Add new fields and mark old ones deprecated:
{
"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.
# BAD - One agent does everything
You are a full-stack developer, writer, researcher, and DevOps engineer.Split into specialist agents. The kernel handles routing.
# BAD - No memory between sessions
Starting fresh every time Claude Code opens.Always read data/ at session start and write back at session end.
# BAD - API keys in agent files or CLAUDE.md
Your OpenAI API key is sk-xxxxxxxxUse environment variables or a .env file loaded by scripts. Agents reference process.env.API_KEY.
# BAD - PostgreSQL for a solo user's agentic OSUse JSON/markdown files until you have multiple concurrent users or GBs of data.
# 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.
CLAUDE.md is under 200 lines and fits in context windowdata/ is git-ignored for sensitive logs, git-tracked for decisions and specs/daily-sync, not /run-daily-syncMemory Scope section defining what files it readsdata/logs/<date>-costs.jsonCLAUDE.md across unrelated projects.© affaan-m, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in skills/agentic-os of affaan-m/ECC.
Open the folder on GitHubat commit 4eb71d9
We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in affaan-m/ECC, which our catalogue first saw on October 7, 2026.
Agentic Os next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Agentic Os this skillaffaan-m/ECC | 276k | 1 repos | ~3.1k | Automated safety check: Notes | MIT | |
| O2 Review Loopopenobserve/openobserve | 22k | — | ~3.7k | Automated safety check: Pass | AGPL-3.0 | |
| ClawTeam Multi-Agent Swarmwin4r/ClawTeam-OpenClaw | 1.5k | 1 repos | ~2.9k | Automated safety check: Pass | MIT | |
| Harness Evolution Feedback Looprevfactory/harness | 9.1k | — | ~855 | Automated safety check: Pass | Apache-2.0 | |
| Compound Engineering SetupEveryInc/compound-engineering-plugin | 25k | — | ~2k | Automated safety check: Pass | MIT | |
| Readyprekuter/dryforge | 413 | 1 repos | ~6.8k | Automated safety check: Pass | Apache-2.0 |
openobserve/openobserve
Splits a change into planner, coder and independent reviewer roles: you confirm a spec, a subagent implements it, and a separate reviewer checks each round's local WIP commit.
win4r/ClawTeam-OpenClaw
Launches a swarm of specialist Hermes agents in git-worktree-isolated tmux windows with a kanban board and file-based inboxes, using built-in templates like hedge-fund and code-review.
revfactory/harness
Collects feedback on how an agent harness performed, generalizes it, and updates the harness agents, skills and orchestrator along with a change-history table.
EveryInc/compound-engineering-plugin
Checks Compound Engineering plugin health and repo-local config, or scaffolds a Compound Pack when you ask for one by id.
prekuter/dryforge
Understand what you mean before anything is built. An agent skill from prekuter/dryforge.
meshery/meshery-operator
This skill should be used when creating a Claude Code slash command.
affaan-m/ECC
Audits your installed Claude skills and commands for quality, with a quick mode for recently changed skills and a full mode that evaluates all of them through subagents.
affaan-m/ECC
Ingests, indexes, searches, edits and monitors video, audio and live streams through the VideoDB Python SDK, returning stream links, clips and timestamps.
affaan-m/ECC
Route broad documentation-governance requests to existing ECC skills and run an opt-in, read-only audit of mapped documentation roles, links, ADR indexes, and evidence references.
affaan-m/ECC
Scans installed skills for principles that recur across them and proposes rule-file changes: append, revise, add a section, create a file or leave as covered.
affaan-m/ECC
Builds DRAFT counterparty agreements from one markdown template and a small JSON spec per party, with clauses picked by the party's role.
affaan-m/ECC
Measures whether agents actually follow a skill, rule or agent definition by generating scenarios at three strictness levels and scoring tool-call traces.
Works with
Categories
Build persistent multi-agent operating systems on Claude Code. Agentic Os is an agent skill from affaan-m/ECC. Build persistent multi-agent operating systems on Claude Code.
Agentic Os fits situations like: building a persistent multi-agent system on Claude Code with its own memory; tasks that involve Hooks and plugins; tasks that involve Multi-agent orchestration.
Run `npx skills add affaan-m/ECC --skill agentic-os -a claude-code`. Or copy the skill folder (skills/agentic-os in affaan-m/ECC) into .claude/skills/agentic-os in your project. Claude Code loads it when a task matches its description.
Run `npx skills add affaan-m/ECC --skill agentic-os -a codex`. Or copy the skill folder (skills/agentic-os in affaan-m/ECC) into .agents/skills/agentic-os in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add affaan-m/ECC --skill agentic-os -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/agentic-os, .gemini/skills/agentic-os, .github/skills/agentic-os and .opencode/skills/agentic-os in your project.
Going by SKILL.md and its folder, Agentic Os needs credentials named API_KEY. Our summary lists: A credential in API_KEY.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.
Agentic Os is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Agentic Os: O2 Review Loop (openobserve/openobserve, 22k stars), ClawTeam Multi-Agent Swarm (win4r/ClawTeam-OpenClaw, 1.5k stars), Harness Evolution Feedback Loop (revfactory/harness, 9.1k stars) and Compound Engineering Setup (EveryInc/compound-engineering-plugin, 25k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
affaan-m (a GitHub user) maintains it in affaan-m/ECC, which has 276,111 GitHub stars. The repository holds 683 skills in this directory. The repository was last updated on October 10, 2026.
Source: affaan-m/ECC on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.