Communitygithub.com

agentic-os

Construisez des systèmes d'exploitation multi-agents persistants sur Claude Code. Couvre l'architecture du noyau, les agents spécialisés, les commandes slash, la mémoire basée sur fichiers, l'automatisation planifiée et la gestion d'état sans base de données externe. À utiliser lors de la construction d'un système multi-agent persistant sur Claude Code avec sa propre mémoire, ses commandes et sa planification.

Qu'est-ce que agentic-os ?

Le skill **agentic-os** transforme Claude Code en un système d'exploitation persistant et multi-agents, plutôt qu'une simple session de chat. Il fournit une architecture complète, structurée en couches, comprenant un noyau (`CLAUDE.md`) pour l'acheminement des tâches, des agents spécialisés dans `agents/`, des commandes slash dans `.claude/commands/`, des scripts d'automatisation dans `scripts/`, et une couche de données persistante basée sur des fichiers JSON/Markdown dans `data/`. Cette approche permet de construire des flux de travail complexes et réutilisables qui survivent aux redémarrages de session, sans dépendre de bases de données externes. Le skill est particulièrement utile pour les développeurs et les utilisateurs avancés de Claude Code qui souhaitent créer des systèmes d'agents personnalisés, des routines automatisées (comme des synchronisations quotidiennes) et une mémoire à long terme pour des projets de longue durée. Il s'appuie sur les mécanismes natifs de Claude Code (commandes slash, fichiers de configuration) et peut être étendu avec des planificateurs externes (cron, launchd, systemd) pour une automatisation fiable.

Compatible avec✓Claude Code✓Codex CLI~Cursor✓Antigravity
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/agentic-os

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Agentic OS

Traitez Claude Code comme un système d'exploitation / runtime persistant plutôt qu'une session de chat. Ce skill codifie l'architecture utilisée par les configurations agentic de production : un noyau qui achemine les tâches vers des agents spécialisés, une mémoire persistante basée sur des fichiers, une automatisation planifiée et une couche de données JSON/markdown.

Quand l'activer

  • Construire un workflow multi-agent dans Claude Code
  • Mettre en place une automatisation persistante de Claude Code qui survit aux redémarrages de session
  • Créer un "système d'exploitation personnel" ou "OS agentic" pour des tâches récurrentes
  • L'utilisateur dit "agentic OS", "personal OS", "multi-agent", "agent coordinator", "persistent agent"
  • Structurer des projets de longue durée où le contexte doit survivre entre les sessions

Architecture générale

L'Agentic OS a quatre couches. Chaque couche est un répertoire dans la racine de votre projet.

project-root/
├── CLAUDE.md          # Noyau : identité, règles d'acheminement, registre des agents
├── agents/            # Définitions des agents spécialisés (prompts markdown)
├── .claude/commands/  # Commandes slash : CLI utilisateur
├── scripts/           # Scripts daemon : tâches planifiées ou pilotées par événements
└── data/              # État : système de fichiers JSON/markdown, pas de base de données externe

Responsabilités des couches

CoucheObjectifPersistance
Noyau (CLAUDE.md)Identité, acheminement, politiques de modèle, registre des agentsSuivi Git
Agents (agents/)Identités spécialisées avec outils et mémoire dédiésSuivi Git
Commandes (.claude/commands/)Commandes slash utilisateur (/daily-sync, /outreach)Suivi Git
Scripts (scripts/)Daemons Python/JS déclenchés par cron ou webhooksSuivi Git
État (data/)Journaux append-only, état du projet, décisionsIgnoré ou suivi Git

Le Noyau

CLAUDE.md est le noyau. Il agit comme le COO / orchestrateur. Claude le lit au démarrage de la session et l'utilise pour acheminer le travail.

Structure du noyau

# CLAUDE.md - Noyau Agentic OS

## Identité
Vous êtes le COO de [nom-du-projet]. Vous acheminez les tâches vers des agents spécialisés.
Vous n'écrivez jamais de code directement. Vous déléguez au bon agent et synthétisez les résultats.

## Registre des agents

| Agent | Rôle | Déclencheur |
|---|---|---|
| @dev | Code, architecture, débogage | L'utilisateur dit "construis", "corrige", "refactore" |
| @writer | Documentation, contenu, e-mails | L'utilisateur dit "écris", "brouillon", "blog" |
| @researcher | Recherche, analyse, vérification des faits | L'utilisateur dit "recherche", "analyse", "compare" |
| @ops | DevOps, déploiement, infrastructure | L'utilisateur dit "déploie", "CI", "serveur" |

## Règles d'acheminement
1. Analysez la demande de l'utilisateur pour les mots-clés d'intention
2. Faites correspondre à la colonne Déclencheur du Registre des agents
3. Chargez le fichier agent correspondant depuis `agents/<nom>.md`
4. Passez l'exécution avec le contexte complet
5. Synthétisez et présentez le résultat à l'utilisateur

## Politiques de modèle
- Modèle par défaut : utilisez le dépôt ou la configuration par défaut.
- Tâches @dev : préférez un modèle à raisonnement supérieur pour les architectures complexes.
- Tâches @researcher : utilisez le modèle configuré pour la recherche et les outils de recherche approuvés.
- Plafond de coût : prévenez avant de dépasser le seuil de dépenses configuré du projet.

Principe clé

Le noyau doit être petit et déclaratif. La logique d'acheminement réside dans des tableaux markdown simples, pas dans du code. Cela rend le système inspectable et modifiable sans débogage.

Agents spécialisés

Chaque agent est un fichier markdown autonome dans agents/. Claude charge le fichier d'agent pertinent lors de l'acheminement d'une tâche.

Format de définition d'agent

# @dev - Ingénieur logiciel

## Identité
Vous êtes un ingénieur logiciel senior. Vous écrivez du code propre, testé et de qualité production.
Vous préférez les solutions simples. Vous posez des questions de clarification lorsque les exigences sont ambiguës.

## Périmètre de mémoire
- Lisez `data/projects/<projet-actuel>.md` pour le contexte
- Lisez `data/decisions/` pour les décisions architecturales
- Ajoutez les journaux d'exécution à `data/logs/<date>[email protected]`

## Accès aux outils
- Accès complet au système de fichiers dans la racine du projet
- Opérations Git (status, diff, commit, branch)
- Accès au lanceur de tests
- Serveurs MCP configurés dans `.claude/mcp.json`

## Contraintes
- Écrivez toujours des tests pour les nouvelles fonctionnalités
- Ne commitez jamais directement sur `main` ; utilisez des branches de fonctionnalité
- Préférez modifier les fichiers existants plutôt que d'en créer de nouveaux
- Gardez les fonctions sous 50 lignes si possible

Modèle de collaboration multi-agent

Lorsqu'une tâche implique plusieurs agents, le noyau les exécute séquentiellement ou en parallèle :

Utilisateur : "Construis une page d'accueil et écris le billet de blog de lancement"

Acheminement par le noyau :
1. @dev - "Construis une page d'accueil avec [exigences]"
2. @writer - "Écris un billet de blog de lancement pour [produit] en utilisant le texte de la page d'accueil"
3. Le noyau synthétise les deux sorties en une réponse unifiée

Pour une exécution parallèle, utilisez la capacité de tâche en arrière-plan de Claude Code ou des scripts shell qui invoquent Claude Code avec des contextes d'agent spécifiques.

Commandes et workflows quotidiens

Les commandes slash sont des fichiers markdown dans .claude/commands/. Elles définissent des workflows réutilisables.

Structure de commande

# /daily-sync

Exécutez le briefing du matin :

1. Lisez `data/logs/last-sync.md` pour le contexte
2. Vérifiez l'état du projet : `git status`, PR en attente, santé CI
3. Consultez `data/inbox/` pour les nouvelles tâches ou décisions nécessaires
4. Générez un résumé des blocages, priorités et prochaines actions
5. Ajoutez le briefing à `data/logs/daily/<date>.md`

Ensemble de commandes standard

CommandeObjectif
/daily-syncBriefing matinal : statut, blocages, priorités
/outreachExécuter le workflow de prospection (e-mail, LinkedIn, etc.)
/research <sujet>Recherche approfondie avec suivi des citations
/apply-jobsAdapter le CV + lettre de motivation pour un poste cible
/analyticsExtraire des métriques de Stripe, GitHub ou de sources personnalisées
/interview-prepGénérer des flashcards ou des questions d'entretien simulées
/decision <sujet>Enregistrer une décision avec les avantages/inconvénients et la voie choisie

Activation des commandes

Placez les fichiers de commande dans .claude/commands/<nom-commande>.md. Claude Code les découvre automatiquement. Les utilisateurs les invoquent avec /<nom-commande>.

Mémoire persistante

La mémoire est basée sur des fichiers. Pas de base vectorielle, pas de Redis, pas de PostgreSQL. Les fichiers JSON et markdown dans data/ sont la base de données.

Structure des répertoires de mémoire

data/
├── daily-logs/         # Journaux d'activité quotidiens (append-only)
├── projects/           # Fichiers de contexte par projet
├── decisions/          # Décisions architecturales et métier (format ADR)
├── inbox/              # Nouvelles tâches ou idées en attente de tri
├── contacts/           # Personnes, entreprises, notes relationnelles
└── templates/          # Prompts et formats réutilisables

Format du journal quotidien

# 2026-04-22 - Journal quotidien

## Sessions
- 09:00 - Session 1 : Refactorisation du module d'authentification (@dev)
- 11:30 - Session 2 : Rédaction de la mise à jour pour les investisseurs (@writer)

## Décisions
- Passage de JWT aux cookies de session (voir `data/decisions/2026-04-22-auth.md`)

## Blocages
- En attente de la clé API du fournisseur (suivi le 2026-04-24)

## Prochaines actions
- [ ] Fusionner la PR de refactorisation de l'authentification
- [ ] Envoyer la mise à jour pour les investisseurs pour révision

Modèle d'auto-réflexion

À la fin de chaque session, le noyau ajoute une réflexion :

## Réflexion - Session 3
- Ce qui a fonctionné : L'exécution parallèle des agents a fait gagner 20 minutes
- Ce qui n'a pas fonctionné : @researcher est tombé sur une source payante, besoin d'un meilleur classement des sources
- Ce qu'il faut changer : Ajouter un champ `source-tier` aux notes de recherche (crédibilité A/B/C)

Cela crée une boucle de rétroaction qui améliore le système au fil du temps sans modification de code.

Automatisation planifiée

Les tâches Agentic OS s'exécutent selon un planning en utilisant un cron externe, et non le cron intégré de Claude Code (qui se termine lorsque la session se termine).

macOS : LaunchAgent

<!-- ~/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

# ~/.config/systemd/user/agentic-daily-sync.service
[Unit]
Description=Synchronisation quotidienne Agentic OS

[Service]
Type=oneshot
ExecStart=/usr/local/bin/claude --cwd /path/to/project --command /daily-sync
# ~/.config/systemd/user/agentic-daily-sync.timer
[Unit]
Description=Exécuter la synchronisation quotidienne chaque matin

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

[Install]
WantedBy=timers.target

Multi-plateforme : pm2

# 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
  }]
};

Couche de données

La couche de données est votre système de fichiers. Utilisez JSON pour les données structurées et markdown pour le contenu narratif.

JSON pour l'état structuré

// 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 pour le contenu narratif

Utilisez markdown pour tout ce qu'un humain lit : décisions, journaux, notes de recherche, fiches contacts.

Évolution du schéma

Ne renommez jamais les champs existants. Ajoutez de nouveaux champs et marquez les anciens comme dépréciés :

{
  "name": "Website v2",
  "status": "in-progress",
  "milestone": "beta-launch",
  "_deprecated_priority": "high",
  "priority_v2": { "level": "high", "rationale": "Bloque la démo pour les investisseurs" }
}

Cela permet de conserver la lisibilité des données historiques sans scripts de migration.

Anti-patrons

Agent unique monolithique

# MAUVAIS - Un seul agent fait tout
Vous êtes un développeur full-stack, rédacteur, chercheur et ingénieur DevOps.

Divisez en agents spécialisés. Le noyau gère l'acheminement.

Sessions sans état

# MAUVAIS - Aucune mémoire entre les sessions
Commencer à zéro à chaque ouverture de Claude Code.

Lisez toujours data/ au démarrage de la session et écrivez à la fin de la session.

Informations d'identification codées en dur

# MAUVAIS - Clés API dans les fichiers agents ou CLAUDE.md
Votre clé API OpenAI est sk-xxxxxxxx

Utilisez des variables d'environnement ou un fichier .env chargé par les scripts. Les agents référencent process.env.API_KEY.

Base de données externe pour un état simple

# MAUVAIS - PostgreSQL pour l'OS agentic d'un seul utilisateur

Utilisez des fichiers JSON/markdown jusqu'à ce que vous ayez plusieurs utilisateurs simultanés ou des gigas de données.

Acheminement sur-ingénierie

# MAUVAIS - Logique d'acheminement dans le code au lieu de tableaux markdown
if (intent.includes('deploy')) { agent = opsAgent; }

Gardez l'acheminement déclaratif dans les tableaux markdown de CLAUDE.md. C'est inspectable, modifiable et débogable.

Bonnes pratiques

  • CLAUDE.md fait moins de 200 lignes et tient dans la fenêtre de contexte
  • Chaque fichier agent fait moins de 100 lignes et se concentre sur un seul domaine
  • data/ est dans .gitignore pour les journaux sensibles, suivi Git pour les décisions et specs
  • Les commandes utilisent des noms impératifs : /daily-sync, pas /run-daily-sync
  • Les journaux sont en append-only ; ne modifiez jamais les journaux quotidiens passés
  • Chaque agent a une section Périmètre de mémoire définissant les fichiers qu'il lit
  • Les réflexions sont écrites à la fin de chaque session
  • Les tâches planifiées utilisent un cron externe (LaunchAgent, systemd, pm2), pas le cron de session de Claude Code
  • Suivi des coûts : enregistrez les dépenses d'API par session dans data/logs/<date>-costs.json
  • Un projet = un Agentic OS. Ne partagez pas un seul CLAUDE.md entre des projets non liés.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

agent-self-evaluation

Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.

Skills associés