A production-grade skill and agent system for AI coding assistants. It ships skills (domain knowledge), commands (reusable workflows), agents (specialized personas), and safety hooks — configured to auto-activate based on what you're working on.

Works with Claude Code, Cursor, Windsurf, Gemini Code Assist, and any AI coding agent that reads markdown context files.

You: "write a blog post about AI agents"
  → Agentic Creator OS detects: creation + blog
  → Auto-loads: content-strategy skill
  → Routes to: /article-creator workflow
  → Result: Guided article with SEO, images, social distribution

The Agentic Creator OS is structured in four layers, each auto-activating based on context:

git clone https://github.com/frankxai/agentic-creator-os.git
cd agentic-creator-os
./install.sh

# Open any project with Claude Code
claude
/acos

git clone https://github.com/frankxai/agentic-creator-os.git
cd agentic-creator-os
./install.sh --platform=cursor    # or --platform=windsurf

This generates a .cursorrules or .windsurfrules file with all skills embedded.

git clone https://github.com/frankxai/agentic-creator-os.git
cd agentic-creator-os
./install.sh --platform=gemini

This generates a GEMINI.md context file for Gemini to read on session start.

git clone https://github.com/frankxai/agentic-creator-os.git
cd agentic-creator-os
./install.sh --platform=generic

Generates a CONTEXT.md file. Point your agent at it as a system prompt or project instructions file.

See QUICKSTART.md for detailed setup per platform

The Agentic Creator OS is built around six foundational concepts. Understanding these unlocks the full system.

Skills are markdown files containing deep domain expertise. They activate automatically when the Agentic Creator OS detects relevant context in your work.

You start writing a blog post
  → skill-rules.json matches: "blog" + "write"
  → Auto-loads: content-strategy + seo-content-writer + schema-markup
  → Your AI agent now has SEO expertise, content structure, and metadata knowledge

Commands are multi-step workflows triggered by a single slash command. Each command orchestrates skills, agents, and tools in sequence.

Each agent has distinct expertise, voice, and tool access. The Agentic Creator OS routes to the best agent based on task type.

The /acos command analyzes your request and routes to the optimal subsystem:

/acos "create an infographic about machine learning"
  ├── Intent detected: visual + educational
  ├── Agent selected: Visual Creator
  ├── Skills loaded: infogenius, design-excellence
  ├── Command chain: /research → /infogenius
  └── Output: 4K infographic with research-grounded content

Five systems that run automatically to keep the Agentic Creator OS reliable:

The Agentic Creator OS tracks tool sequences and outcomes across sessions, then injects successful patterns as context for similar future tasks. No external API — pure local intelligence.

v10 introduces 5 safety-first autonomous systems that make your AI coding agent smarter over time:

The agent remembers what worked. Past successful tool sequences are injected as context for similar new tasks.

Per-profile scoping — a content writer can't modify your build config, a music producer can't run shell commands. 6 profiles with tool and directory restrictions.

Tracks failures per file. After 3 failures: warn. After 5: restrict. After 8: block. Prevents the agent from brute-forcing broken approaches.

Before changing its own config, ACOS snapshots the current state and measures intelligence score. If the score drops more than 5 points after a change: auto-revert.

Append-only JSONL logging of every tool use, IAM decision, gate verdict, and config change. The ground truth for what happened in a session.

                        /acos (Smart Router)
                            |
              +-------------+-------------+
              |             |             |
         Commands (35+)  Skills (75+)  Agents (38)
              |             |             |
              +------+------+------+------+
                     |             |
              +------+------+  +--+--+
              |             |  |     |
          Hooks (v10)   Workflows  MCP Servers
              |
    +---------+---------+---------+
    |         |         |         |
 Circuit   Audit    Self-Mod   Agent
 Breaker   Trail    Gate       IAM

Commands are Claude Code slash commands. On other platforms, describe the task and ACOS skills guide the agent to the same workflows.

Skills are domain knowledge modules that activate automatically based on what you're doing. No manual invocation needed.

How Auto-Activation Works:

skill-rules.json → 22 pattern rules
  "tests" + "component" → loads test-driven-development + react-patterns
  "blog" + "write"      → loads content-strategy + seo-content-writer
  "deploy" + "vercel"   → loads vercel-deployment + nextjs-best-practices

Everything starts with /acos. It parses intent and routes to the best subsystem:

/acos "write a blog post about AI agents"
  → Detects: creation + blog
  → Routes to: /article-creator
  → Auto-loads: content-strategy skill
  → Result: Guided article creation workflow

For multi-domain requests, it chains commands:

/acos "Create a blog post about AI music with images and social posts"
  → /research "AI music production"
  → /article-creator (with research context)
  → /infogenius (hero image)
  → /generate-social (distribution)

The Agentic Creator OS learns from every session through a four-stage cycle:

Session Start → Create trajectory record
Session Active → Track operations and outcomes
Session End → Extract patterns → Store learnings
Future Sessions → Apply accumulated intelligence

The install script detects your platform and configures accordingly:

./install.sh                      # Auto-detect platforms
./install.sh --platform=claude    # Claude Code only
./install.sh --platform=cursor    # Cursor only
./install.sh --platform=windsurf  # Windsurf only
./install.sh --platform=gemini    # Gemini Code Assist only
./install.sh --platform=generic   # Any agent (CONTEXT.md)
./install.sh --platform=all       # All detected platforms

Claude Code gets the full feature set including slash commands, lifecycle hooks, and auto-activation rules. Other platforms get skills and agent definitions embedded in their context files.

agentic-creator-os/
├── .claude/
│   ├── commands/           # 35+ slash commands
│   ├── skills/             # 75+ auto-activating skills
│   ├── agents/             # 38 specialized agents
│   ├── hooks/              # v10 safety hooks
│   │   ├── circuit-breaker.sh
│   │   ├── audit-trail.sh
│   │   ├── self-modify-gate.sh
│   │   └── quality-gate.sh
│   ├── agent-iam.json      # Role-based access control
│   ├── skill-rules.json    # 22 auto-activation rules
│   └── hooks.json          # Hook lifecycle config
│
├── adapters/               # Platform adapters
│   ├── cursor/             # .cursorrules generator
│   ├── windsurf/           # .windsurfrules generator
│   ├── gemini/             # GEMINI.md generator
│   └── generic/            # CONTEXT.md generator
│
├── departments/            # Agent team definitions
│   ├── content/
│   ├── design/
│   ├── dev/
│   ├── marketing/
│   └── business/
│
├── mcp-servers/            # MCP integrations (optional)
├── templates/              # Reusable templates
├── workflows/              # Workflow definitions
├── docs/infographics/      # Visual documentation
├── install.sh              # Multi-platform installer
├── CLAUDE.md               # Claude Code context
└── package.json            # v10.1.0

ACOS is the Claude Code implementation of the Starlight Intelligence System — a universal, platform-agnostic framework for multi-agent orchestration.

Starlight Intelligence System (Framework)
├── 5-layer cognitive architecture
├── 7 council agents with emergent leadership
├── 6 orchestration patterns
└── Platform adapters
     └── ACOS (Claude Code + Multi-Platform)
         ├── 35+ commands routed through /acos
         ├── 38 agents aligned to Starlight council
         ├── 75+ auto-activating skills
         ├── v10 safety systems (IAM, circuit breaker, audit)
         └── Self-learning via trajectory patterns

1. Configuration over Code — Markdown + JSON + AI's native abilities. Zero install friction.
2. Commands over Prompts — Reusable workflows beat one-off prompts. Build once, use forever.
3. Agents over Chat — Specialized expertise beats general conversation.
4. Files over Memory — Persistent artifacts beat ephemeral threads. Everything is git-trackable.
5. Progressive Disclosure — Load only what you need. ~100 tokens metadata before 5K skill definition.
6. Open and Forkable — MIT licensed. Every component replaceable.

Extend ACOS with installable domain plugins from agentic-creator-skills:

# Install plugins (Claude Code)
claude plugin marketplace add frankxai/agentic-creator-skills
claude plugin install core content-engine design-excellence

ACOS = the operating system. Plugins = the app store. Install only what you need.

ACOS builds on work from the open-source community:

Built on: Claude Code by Anthropic, Model Context Protocol

• agentic-creator-skills — Plugin marketplace (8 domain plugins)
• Starlight Intelligence System — The universal framework powering ACOS
• Arcanea — AI-native creative platform built with ACOS

MIT — Use it, fork it, build your own OS with it.