Artibot

Cognitive orchestration OS for Claude Code with hierarchical memory, RLVR self-learning, MCP server, and multi-platform agent teams.

This repository ships two complementary plugins under one marketplace:

Plugin	Target	Version	Best for
`artibot`	Claude Code (developer CLI)	4.40.0	full Agent Teams orchestration, TDD, code review, security audits, RLVR learning, MCP server, Goal-driven autopilot, `/learning` diagnostics, `/save` + `/resume` single-shot handoff, `/go` → `/orchestrate` build-sequence hand-off, ambient conversation ledger (no-command capture), safety boost (machineId frontmatter, git-lock fail, 10m throttle)
`artibot-cowork`	Claude Cowork (knowledge workers)	3.1.0	marketing campaigns, long-form writing, AEO/GEO content, KR-market SEO, AI-slop detection, Claude Design, Routines, Ultraplan, Monitor

Both plugins share the same DEV protocol, Korean market expertise, data-sovereignty policy, and 6-stage content quality pipeline. They differ only in target environment and skill mix.

A cognitive orchestration plugin for Claude Code powered by dual-process routing, lifelong learning, and the native Agent Teams API. Artibot uses a System 1/2 cognitive architecture to classify every request, assembles specialized agent teams with P2P communication, and continuously learns from session outcomes to improve routing accuracy over time.

Overview

Most Claude Code plugins use simple sub-agent (Task()) delegation -- fire-and-forget with one-way result reporting. Artibot takes a fundamentally different approach by using Claude's native Agent Teams API as its core engine, enabling true team orchestration:

Capability	Sub-Agent (Task)	Agent Teams (Artibot)
Communication	Return result to parent only	P2P bidirectional messaging (SendMessage)
Task Management	Parent manages everything	Shared task list (TaskCreate/TaskList)
Self-Assignment	Not possible	Teammates self-claim from task list
Peer Communication	Not possible	Direct DM + broadcast
Plan Approval	Not possible	plan_approval_response
Lifecycle	One-shot	Create -> Work -> Shutdown -> Cleanup

Key Features

Cognitive Architecture -- Dual-process System 1/2 routing inspired by Kahneman's theory: fast intuitive responses for simple tasks, deep deliberative reasoning for complex ones
Lifelong Learning -- GRPO-based batch learning from session outcomes with automatic knowledge transfer between System 1 and System 2 caches
CTO-Led Orchestration -- orchestrator agent leads 28 specialist agents as a team coordinator (delegation mode: no direct coding)
Intelligent Delegation -- Auto-selects Sub-Agent (simple) vs Agent Team (complex) based on cognitive complexity scoring
5 Orchestration Patterns -- Leader, Council, Swarm, Pipeline, Watchdog
8 DAG Playbooks -- Feature, Bugfix, Refactor, Security + Marketing Campaign, Marketing Audit, Content Launch, Competitive Analysis (DAG-based with parallel node execution, topological sort, and cycle detection)
78 Slash Commands -- /sc smart router, /save, /resume, /daily, /team, /orchestrate, /spawn, /implement, /visual-check, /sc playbook, /learning, /ultrareview, /ultraplan, /audit-claude-md, /export, and more
28 Specialized Agents -- Architecture, security, frontend, backend, testing, DevOps, marketing, SEO, analytics, and more (fable 71%, opus 29%)
113 Domain Skills -- 11 persona skills, 8 core skills, 16 language skills, 8 utility skills, 35 marketing skills, visual-validation, daily, team, session-worklog, vibe-coding, repo-benchmarking, git-worktree, dynamic-context-injection, claude-md-auditor, skill-authoring (all enhanced with Anthropic best-practice descriptions, workflow checklists, HITL v2 conversational checkpoints, output templates, and freedom levels)
8 Auto-Activating Rules -- DEV protocol, quality gates, agent coordination, config safety, frontend/backend/test patterns, clean state enforcement
Guard Registry -- Centralized guard pipeline with registerGuard()/executeChain() API, 6 built-in guards extracted from hook scripts (75% code reduction)
Loop Detection -- Circular buffer-based agent loop detection with fingerprint matching, automatic warn/block on repeated tool calls
Clean State Enforcement -- TaskCompleted hook ensures lint+test verification at feature completion boundaries
57 Event Hook Registrations -- Cognitive routing, lifelong learning, session lifecycle, dangerous command blocking, auto-formatting, team tracking, loop detection, clean state checks, HTTP webhook notifications, git autopilot
Advisory File Locking -- Spin-lock based file locking for concurrent hook state access, fail-open pattern prevents workflow blocking
DEV Protocol -- Mandatory Decompose-Execute-Verify workflow with zero-skip policy for all code changes
Vibe Coding Support -- Natural language request handling with read-first, verify-after, evidence-based completion
Visual Validation Pipeline -- SSIM-based screenshot comparison, auto-fix suggestion, iterative correction loop via Playwright MCP
Conversation-to-Memory -- Auto-extracts rules and decisions from user messages (Korean/English), injects into skills dynamically
Project CLAUDE.md Seeding -- install.sh auto-generates project-level CLAUDE.md with Artibot methodology and DEV protocol
Runtime Middleware Pipeline -- 11-stage middleware engine (lifecycle, router, memory, skills, tasks, subagents, guardrail, summarization, token-usage, checkpoint, cache-roi) for runtime context injection
Output Design System -- 7 output styles with design tokens (tokens.md) and narrative template for consistent formatting
Forked Context Skills -- All 113 skills run in isolated forked context for clean execution without cross-contamination
HTTP Webhook Notifications -- Session events sent to Slack, Discord, or custom endpoints via configurable webhooks
Cross-Platform Compatible -- Works with Gemini CLI, OpenAI Codex, and Cursor via platform adapters
Zero Dependencies -- Pure Node.js built-in modules only (node:fs, node:path, node:os)

Get Started

Prerequisites

Agent Teams is auto-enabled by Artibot on first session start. No manual setup needed.

Installation

Recommended: native marketplace (no clone) — run inside any Claude Code session:

/plugin marketplace add Yoodaddy0311/artibot
/plugin install artibot@artibot

Claude Code fetches the plugin straight from GitHub into its plugin cache — no git clone, no shell script. Commands, agents, skills, and hooks load via ${CLAUDE_PLUGIN_ROOT}; updates come through /plugin marketplace update artibot. Native install namespaces every command under the artibot: prefix (call /artibot:save, /artibot:sc). Agent Teams auto-enables on first session start. To uninstall: /plugin uninstall artibot@artibot.

Native install does not deliver the 8 auto-activating rules (DEV Protocol, Quality Gates, agent-coordination, config-safety, clean-state, frontend/backend/test patterns). Claude Code's plugin schema has no rules field, so they load only when install.sh copies them to ~/.claude/rules/artibot/. If you want that automatic DEV-protocol / quality-gate enforcement, use the full install below. /theme and the themed statusline now auto-resolve both layouts (native install included); a native-only install may need /theme re-run after a major /plugin update. /update still assumes the flat layout and is being migrated. Commands, agents, skills, and hooks themselves work identically on both paths.

Full install: install.sh (flat commands, no prefix)

git clone https://github.com/Yoodaddy0311/artibot.git
cd artibot/plugins/artibot
bash install.sh          # macOS / Linux / Git Bash on Windows

This flat-copies agents and commands into ~/.claude/, so slash commands are called without a prefix (/save, /sc, /daily). It enables Agent Teams, wires the themed statusline, and seeds a conservative read-only permission allowlist (Read/Glob/Grep) into ~/.claude/settings.json, removing the repeated approval prompts new users hit on first run. To uninstall: bash install.sh uninstall.

Windows: run install.sh from Git Bash (Git for Windows), or use the native PowerShell installer: powershell -ExecutionPolicy Bypass -File install.ps1.

Command invocation differs by install method:

Install method	Command form	Example
Native marketplace (`/plugin install`)	namespaced `artibot:`	`/artibot:save`, `/artibot:sc`
`install.sh` / `install.ps1` (flat)	flat (no prefix)	`/save`, `/sc`, `/daily`

Requirements

Claude Code CLI
Node.js >= 18.0.0
Agent Teams (auto-enabled by Artibot, or manually set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1)

Cross-Platform Installation

Artibot works beyond Claude Code. Built-in adapters auto-convert agents, skills, and commands for each platform.

Replace <your-project> with the root directory path of the target project.

Platform	Compatibility	Agent Teams	Sub-Agent	Skills
Claude Code	10/10	✅	✅	✅
Gemini CLI	9/10	❌	✅	✅
Codex CLI	8/10	❌	✅	✅
Antigravity	8/10	❌	✅	✅
Cursor IDE	6/10	❌	⚠️	✅

Gemini CLI

git clone https://github.com/Yoodaddy0311/artibot.git
cd artibot
node --input-type=module -e "import { exportForGemini } from './plugins/artibot/lib/adapters/skill-export.js'; const r = await exportForGemini({ pluginRoot: './plugins/artibot' }); console.log(r.summary);"

OpenAI Codex CLI

git clone https://github.com/Yoodaddy0311/artibot.git
cd artibot
node --input-type=module -e "import { exportForCodex } from './plugins/artibot/lib/adapters/skill-export.js'; const r = await exportForCodex({ pluginRoot: './plugins/artibot' }); console.log(r.summary);"

Google Antigravity

git clone https://github.com/Yoodaddy0311/artibot.git
cd artibot
node --input-type=module -e "import { exportForGemini } from './plugins/artibot/lib/adapters/skill-export.js'; const r = await exportForGemini({ pluginRoot: './plugins/artibot' }); console.log(r.summary);"

Note: Agent Teams API is exclusive to Claude Code. Other platforms automatically fall back to Sub-Agent mode (one-way delegation). Learning, memory, and swarm intelligence work identically across all platforms.

For the full cross-platform guide including Cursor IDE and batch export, see plugins/artibot/README.md.

What can Artibot do?

`/implement` -- Feature Implementation Pipeline

Before (manual):

You: "implement user authentication"
Claude: writes code in one file, misses edge cases, no tests, no review
You: manually request tests, then review, then fix issues found in review
-> 4+ back-and-forth prompts, inconsistent coverage

After (with Artibot):

You: "implement user authentication"
Artibot: /implement triggers automatically
  -> planner agent: decomposes into 5 subtasks
  -> architect agent: designs auth flow + data model
  -> backend-developer + frontend-developer: implement in parallel (Agent Teams)
  -> tdd-guide agent: writes tests (80%+ coverage)
  -> code-reviewer agent: reviews with 4-severity classification
  -> result: complete feature with tests, reviewed, ready to merge
-> 1 prompt, full pipeline

`/team` -- Parallel Team Execution

Before (manual):

You: "refactor the payment module and update the API docs"
Claude: does refactoring first (10 min), then docs (5 min) = 15 min sequential
No cross-check between the two tasks

After (with Artibot):

You: "refactor the payment module and update the API docs"
Artibot: /team triggers automatically
  -> refactor-cleaner agent: refactoring (teammate A)
  -> doc-updater agent: documentation (teammate B)
  -> both run in parallel via Agent Teams API (P2P messaging)
  -> cross-check phase: each reviews the other's output
  -> result: 7 min total, cross-verified

`/export` -- Cross-Platform Export

Before (manual):

You want to use Artibot agents in Cursor IDE
-> manually rewrite each agent .md file to .mdc format
-> figure out Cursor Rules-for-AI conventions
-> repeat for 28 agents = hours of tedious work

After (with Artibot):

/export cursor
  -> auto-converts all 28 agents to .mdc format
  -> places them in .cursor/rules/ with correct frontmatter
  -> preserves agent expertise and tool permissions
  -> supports: cursor, codex, opencode, antigravity, all
-> 1 command, all platforms

Usage

Smart Routing

The /sc command analyzes natural language intent and routes to the optimal command:

/sc implement login feature
-> routes to /implement -> TeamCreate -> spawns planner + architect + developer + reviewer

/sc analyze security vulnerabilities in auth module
-> routes to /analyze --focus security -> delegates to security-reviewer sub-agent

/sc launch email marketing campaign for product launch
-> routes to /campaign -> TeamCreate -> spawns marketing-strategist + data-analyst + ad-specialist

Direct Commands

/implement user authentication API --type api --tdd
/code-review @src/auth/
/test --coverage
/git commit
/campaign product launch --channels email,social
/seo audit @website

Team Orchestration

For complex tasks, Artibot assembles a full Agent Team:

/orchestrate payment system --pattern feature

This triggers the full team lifecycle:

TeamCreate("payment-feature") -- create the team
Task(planner, team, "planner") + Task(architect, team, "architect") + ... -- spawn teammates
TaskCreate per phase (plan -> design -> implement -> review) -- populate task list
TaskUpdate -- set dependencies and assign teammates
SendMessage -- P2P coordination between teammates
shutdown_request -> TeamDelete -- graceful cleanup

Marketing Orchestration

/campaign product launch --channels email,social,ads

Uses the marketing-campaign playbook:

[Leader] marketing-strategist defines strategy
[Council] team plans channels and content
[Swarm] specialists create content in parallel
[Council] review and optimize
[Leader] launch coordination

Parallel Execution

/spawn full codebase security audit --mode parallel --agents 5

Spawns 5 teammates that self-claim tasks from the shared task list and report findings via SendMessage.

Architecture

+-------------------------------------------------+
|                  User Request                    |
+------------------+------------------------------+
                   |
                   v
+-------------------------------------------------+
|           /sc Router (Intent Analysis)           |
|       keyword 40% + context 40% + flags 20%      |
+------------------+------------------------------+
                   |
                   v
+-------------------------------------------------+
|       Delegation Mode (Complexity Scoring)        |
|    score < 0.4 -> Sub-Agent  |  >= 0.4 -> Team   |
+-------+---------------------------------+-------+
        |                                 |
        v                                 v
+---------------+         +-----------------------+
|   Sub-Agent   |         |   Agent Teams Engine   |
|   Task()      |         |                       |
|   one-way     |         |  TeamCreate           |
|               |         |    -> Task(spawn)     |
|               |         |    -> TaskCreate      |
|               |         |    -> SendMessage(P2P)|
|               |         |    -> TeamDelete      |
+---------------+         +-----------+-----------+
                                      |
                                      v
                          +-----------------------+
                          |  orchestrator (CTO)    |
                          |  Leader | Council |    |
                          |  Swarm | Pipeline |    |
                          |  Watchdog              |
                          +-----------+-----------+
                                      |
                                      v
                          +-----------------------+
                          |  28 Specialist Agents  |
                          |  TaskList -> self-claim|
                          |  SendMessage -> P2P    |
                          |  TaskUpdate -> report  |
                          +-----------------------+

Cognitive Architecture

Artibot uses a dual-process cognitive model inspired by Daniel Kahneman's System 1/System 2 theory to classify and route every user request:

User Request
      |
      v
+-------------+
|  Cognitive   |    Complexity Score = weighted sum of:
|   Router     |      steps (0.25) + domains (0.20)
| (hook-based) |      + uncertainty (0.20) + risk (0.20) + novelty (0.15)
+------+------+
       |
       +--- score < 0.4 ---> System 1 (Fast / Intuitive)
       |                       - Pattern-matched from cached experience
       |                       - Target latency: < 100ms
       |                       - Keyword-based heuristic scoring
       |
       +--- score >= 0.4 ---> System 2 (Deep / Deliberative)
       |                       - Multi-step structured reasoning
       |                       - Full context + dependency analysis
       |                       - Sandbox verification for high-risk ops
       |
       +--- confidence < 0.6 or latency exceeded ---> Escalation
                                System 1 -> System 2 automatic fallback

Escalation Rules

System 1 confidence drops below 0.6
Processing time exceeds 100ms
No matching pattern in System 1 cache
Security or production keywords detected
Request spans 3+ domains
Explicit --think, --think-hard, or --ultrathink flag

Integration with Delegation

The cognitive router feeds directly into the orchestration delegation mode:

Complexity Score	System	Delegation Mode
< 0.4	System 1	Sub-Agent (Task tool)
>= 0.4	System 2	Agent Team (Teams API)

Sub-Agent vs Agent Teams

Aspect	Sub-Agent	Agent Teams
Delegation	Task() single call	TeamCreate → Task(team_name)
UI Visibility	Hidden (background)	Teammates shown below prompt
Communication	One-way (result only)	P2P bidirectional (SendMessage)
Task Management	None	Shared task list (TaskCreate/Update/List)
Persistence	One-shot	Session-persistent
Speed	Fast (low overhead)	Slower (9+ API calls)
Token Cost	1x	~5x
Best For	Single file analysis, search	Complex features, multi-agent collaboration

Lifelong Learning

Artibot continuously improves its routing accuracy through a session-based learning pipeline:

Session Start                    Session Active                    Session End
     |                                |                                |
     v                                v                                v
Load thresholds              Record experiences              Batch learning (RLVR)
Load System 1 cache          (routing decisions +            Knowledge transfer
                              outcomes)                      Persist updated state

Note (2026-06 lean redesign): The GRPO policy optimizer was removed (no measurable improvement). Learning now uses verifiable-reward (RLVR) signals (test-pass / typecheck / no-revisit) to adjust routing thresholds and promote/demote patterns between System 1 and System 2 caches. No external reward model or RL policy optimizer is used.

Knowledge Transfer

Direction	Condition	Action
Promote (S2 -> S1)	3 consecutive System 2 successes	Cache pattern in System 1 for fast retrieval
Demote (S1 -> S2)	2 consecutive System 1 failures	Remove from System 1, flag for System 2 re-analysis

Learning Storage

~/.claude/artibot-learning/
  +-- experiences.jsonl      # Raw experience log (append-only)
  +-- system1-cache.json     # Promoted fast patterns
  +-- system2-cache.json     # Complex pattern registry
  +-- thresholds.json        # Adaptive threshold state
  +-- transfer-log.json      # Promotion/demotion history

Agent Teams API Tools

Tool	Purpose
`TeamCreate`	Create a named team with description
`Task(type, team_name, name)`	Spawn teammates into the team
`TaskCreate`	Add work items to shared task list
`TaskUpdate`	Set status, owner, dependencies (blockedBy/blocks)
`TaskList` / `TaskGet`	View and read tasks
`SendMessage`	DM, broadcast, shutdown request/response, plan approval
`TeamDelete`	Clean up team resources

Team Levels

Level	Mode	Agents	When
Solo	Sub-Agent	0	Single file edit, quick fix
Squad	Agent Team	2-4	Feature implementation, bugfix, refactoring
Platoon	Agent Team	5+	Large feature, architecture change, security audit, marketing campaign

Playbooks

8 DAG playbooks (4 dev + 4 marketing) with parallel node execution.

Feature:

TeamCreate -> [Leader] plan -> [Council] design -> [Swarm] implement -> [Council] review -> [Leader] merge -> TeamDelete

Bugfix:

TeamCreate -> [Leader] analyze -> [Pipeline] fix -> [Council] verify -> TeamDelete

Refactor:

TeamCreate -> [Council] assess -> [Pipeline] refactor -> [Swarm] test -> [Council] review -> TeamDelete

Security:

TeamCreate -> [Leader] scan -> [Council] assess -> [Pipeline] fix -> [Council] verify -> TeamDelete

Marketing Campaign:

TeamCreate -> [Leader] strategy -> [Council] plan -> [Swarm] create -> [Council] review -> [Leader] launch -> TeamDelete

Marketing Audit:

TeamCreate -> [Leader] scan -> [Council] assess -> [Pipeline] optimize -> [Council] verify -> TeamDelete

Content Launch:

TeamCreate -> [Leader] plan -> [Swarm] create -> [Council] review -> [Leader] publish -> TeamDelete

Competitive Analysis:

TeamCreate -> [Council] research -> [Swarm] analyze -> [Council] synthesize -> [Leader] report -> TeamDelete

Agents

28 specialized agents: 1 orchestrator (CTO) + 27 specialist teammates. Fable 71%, Opus 29% (security-reviewer stays opus via denylist).

Agent	Model	Role	Team API Tools
orchestrator	fable	CTO-level team leader. Coordination only (delegation mode).	TeamCreate, SendMessage, TaskCreate, TaskUpdate, TaskList, TaskGet, TeamDelete, Task()

The orchestrator never writes code directly. It assembles the team, distributes tasks, coordinates between teammates, and synthesizes results.

All teammates have their specialist tools + team collaboration tools (SendMessage, TaskList, TaskGet, TaskUpdate).

Design & Analysis:

Agent	Model	Specialty
architect	fable	System architecture, ADR, trade-off analysis
planner	fable	Implementation planning, risk assessment
llm-architect	fable	LLM architecture, prompt design, RAG

Quality & Security:

Agent	Model	Specialty
code-reviewer	fable	Code review (4 severity levels, 5 dimensions)
security-reviewer	opus	OWASP Top 10, threat modeling
tdd-guide	fable	TDD (RED->GREEN->REFACTOR), 80%+ coverage
e2e-runner	fable	Playwright E2E testing

Development:

Agent	Model	Specialty
frontend-developer	fable	UI/UX, WCAG accessibility, Core Web Vitals
backend-developer	fable	API, database, services
database-reviewer	fable	SQL optimization, schema design
typescript-pro	fable	Advanced types, strict mode
build-error-resolver	fable	Build error diagnosis and auto-fix

Utilities:

Agent	Model	Specialty
refactor-cleaner	fable	Dead code removal, refactoring
doc-updater	opus	Documentation sync, changelog
content-marketer	opus	Blog, SEO, social media
devops-engineer	fable	CI/CD, Docker, monitoring
mcp-developer	fable	MCP server development

Marketing:

Agent	Model	Specialty
marketing-strategist	fable	Campaign strategy, market positioning, brand architecture
data-analyst	opus	Marketing analytics, attribution modeling, KPI dashboards
presentation-designer	opus	Pitch decks, marketing collateral, visual storytelling
seo-specialist	opus	Technical SEO, keyword strategy, SERP optimization
cro-specialist	opus	Conversion optimization, A/B testing, funnel analysis
ad-specialist	opus	PPC campaigns, ad creative, ROAS optimization
repo-benchmarker	fable	Repository analysis, competitive benchmarking

Performance & Infrastructure:

Agent	Model	Specialty
performance-engineer	fable	Performance profiling, bottleneck analysis

Commands

70+ slash commands across development, marketing, and workflow automation. Key commands: /sc (smart router), /implement, /team, /code-review, /save//resume.

Command	Description
`/sc [request]`	Smart router entry point with auto-routing
`/build [target]`	Project builder with framework auto-detection
`/build-fix`	Build error auto-diagnosis and fix
`/implement [feature]`	Feature implementation pipeline
`/improve [target]`	Evidence-based code enhancement
`/design [domain]`	System design and architecture

Command	Description
`/analyze [target]`	Multi-dimensional code/system analysis
`/troubleshoot [symptoms]`	Root cause analysis
`/explain [topic]`	Educational explanations

Command	Description
`/code-review [target]`	Code review (CRITICAL/HIGH/MEDIUM/LOW)
`/test [type]`	Test runner with auto-detection
`/tdd [feature]`	TDD workflow (RED->GREEN->REFACTOR)
`/verify`	Validation pipeline (lint->type->test->build)
`/refactor-clean [target]`	Refactoring and dead code removal

Command	Description
`/orchestrate [workflow]`	Agent Teams multi-agent workflow
`/spawn [mode]`	Team spawn with parallel task execution
`/team [task]`	Parallel team orchestration with cross-check

Command	Description
`/plan [feature]`	Implementation planning
`/task [operation]`	Task management (CRUD)
`/git [operation]`	Git workflow automation
`/checkpoint`	State snapshot save/restore
`/daily`	Daily work recap and retrospective
`/save`	Session handoff save (context restore in next session)
`/resume`	Restore previous session handoff
`/visual-check [url]`	Visual validation with SSIM screenshot comparison
`/sc playbook list`	Browse and discover playbooks

Command	Description
`/document [target]`	Documentation generation
`/content [type]`	Content marketing and SEO
`/learn [pattern]`	Pattern extraction and memory storage

Command	Description
`/campaign [name]`	Marketing campaign orchestration and management
`/seo [target]`	SEO audit, keyword research, and optimization
`/social-media [platform]`	Social media content strategy and scheduling
`/email-marketing [campaign]`	Email campaign design and automation
`/competitive [target]`	Competitive analysis and market intelligence
`/ad-campaign [platform]`	Paid advertising campaign management
`/content-calendar [period]`	Editorial calendar planning and management
`/ab-test [target]`	A/B testing design and analysis
`/analytics [report]`	Marketing analytics and performance reporting
`/funnel [stage]`	Conversion funnel analysis and optimization

Command	Description
`/cleanup [target]`	Technical debt reduction
`/estimate [target]`	Evidence-based estimation
`/index [query]`	Command catalog search
`/load [path]`	Project context loading
`/doctor`	Automated health check
`/export [platform]`	Cross-platform agent/skill export

Skills

113 auto-activating domain skills organized in six categories.

orchestration, cognitive-routing, lifelong-learning, token-efficiency, principles, coding-standards, security-standards, testing-standards

architect, frontend, backend, security, analyzer, performance, qa, refactorer, devops, mentor, scribe

git-workflow, tdd-workflow, delegation, mcp-context7, mcp-playwright, mcp-coordination, continuous-learning, strategic-compact

TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, Swift, C++, C#, Ruby, PHP, Scala, Elixir, R, Flutter/Dart

marketing-strategy, campaign-planning, seo-strategy, technical-seo, content-seo, social-media, email-marketing, competitive-intelligence, advertising, ab-testing, brand-guidelines, copywriting, customer-journey, data-analysis, data-visualization, lead-management, marketing-analytics, presentation-design, report-generation, segmentation, cro-page, cro-funnel, cro-forms, and more

daily (work recap/retrospective), team (parallel orchestration), session-worklog (auto session tracking), vibe-coding (natural language coding protocol), repo-benchmarking (external repo analysis and comparison), git-worktree (worktree isolation), dynamic-context-injection (runtime context management)

Hooks

24 hook registrations across 15 event types.

Event	Script	Purpose
SessionStart	`session-start.js`	Environment detection, config loading
PreToolUse (Write)	`pre-write.js`	Block writes to sensitive files (.env, .pem)
PreToolUse (Bash)	`pre-bash.js`	Block dangerous commands (rm -rf, force push)
PreToolUse (Bash)	`bash-risk-guard.js`	Classify command risk (classifyRisk): block danger, warn caution, feed autopilot pause
PostToolUse (Edit)	`post-edit-format.js`	Auto-format suggestion for JS/TS
PostToolUse (Bash)	`post-bash.js`	Auto-detect PR URLs after git push
PreCompact	`pre-compact.js`	State snapshot before context compression
Stop	`check-console-log.js`	Detect leftover console.log statements
UserPromptSubmit	`user-prompt-handler.js`	Intent detection and agent suggestion
UserPromptSubmit	`cognitive-router.js`	System 1/2 cognitive routing classification
SubagentStart/Stop	`subagent-handler.js`	Teammate registration/deregistration tracking
TeammateIdle	`team-idle-handler.js`	Alert idle teammates about pending tasks
SessionEnd	`session-end.js`	Persist session state
SessionEnd	`nightly-learner.js`	Batch learning (GRPO) + knowledge transfer
SessionEnd	`http-notify.js`	HTTP webhook notifications (Slack/Discord/generic)

Auto-Update

Artibot checks for new versions on session start via GitHub Releases API (24h cached).

Session start:
  Artibot v1.8.0 initialized
  ✅ You are running the latest version

/update command (flat install; /artibot:update if installed via marketplace):

Flag	Behavior
`--check`	Check version only (default)
`--force`	Clear cache and force reinstall
`--dry-run`	Show plan without executing

MCP Integration

Artibot integrates with MCP servers for extended capabilities:

Context7 -- Library and framework documentation lookup

{
  "context7": {
    "command": "npx",
    "args": ["-y", "@upstash/context7-mcp@latest"]
  }
}

Playwright -- Cross-browser E2E testing, performance metrics, visual testing

{
  "playwright": {
    "command": "npx",
    "args": ["-y", "@executeautomation/playwright-mcp-server"]
  }
}

Cross-Platform Compatibility

Artibot includes platform adapters for use beyond Claude Code:

Platform	Adapter	Status
Claude Code	Native (no adapter needed)	Full support
Gemini CLI	`adapters/gemini-cli.js`	Agent mapping, command translation
OpenAI Codex	`adapters/openai-codex.js`	Tool mapping, prompt adaptation
Cursor	`adapters/cursor.js`	Extension integration, command bridging

Each adapter translates Artibot's Agent Teams API calls into the target platform's native orchestration primitives while preserving the CTO-led coordination pattern.

Plugin Structure

plugins/artibot/
+-- .claude-plugin/
|   +-- plugin.json              # Plugin manifest
+-- agents/                      # 28 agent definitions
|   +-- orchestrator.md          #   CTO / Team leader (Agent Teams API)
|   +-- [17 dev specialists].md  #   Development teammates
|   +-- [8 marketing agents].md  #   Marketing specialists
+-- commands/                    # 78 slash commands
|   +-- sc.md                    #   Smart router
|   +-- daily.md                 #   Daily work recap and retrospective
|   +-- team.md                  #   Parallel team orchestration
|   +-- orchestrate.md           #   Team orchestration (TeamCreate)
|   +-- spawn.md                 #   Team spawn (parallel execution)
|   +-- [25 dev commands].md
|   +-- [10 marketing commands].md
+-- skills/                      # 113 skill directories
|   +-- orchestration/           #   Delegation mode + team routing
|   +-- cognitive-routing/       #   System 1/2 dual-process routing
|   +-- lifelong-learning/       #   GRPO batch learning + knowledge transfer
|   +-- delegation/              #   Sub-Agent/Team strategies
|   +-- [23 dev skills]/
|   +-- [23 marketing skills]/
|   +-- [7 workflow skills]/
+-- rules/                       # 8 auto-activating rules
|   +-- dev-protocol.md          #   DEV (Decompose-Execute-Verify) protocol
|   +-- quality-gates.md         #   Quality enforcement gates
|   +-- agent-coordination.md    #   Agent collaboration patterns
|   +-- [4 domain rules].md
+-- hooks/
|   +-- hooks.json               # Hook event mappings
+-- scripts/
|   +-- hooks/                   # 59 hook scripts (ESM)
|   +-- ci/                      # 6 CI validation scripts
|   +-- evals/                   # Runtime eval suite
|   +-- utils/
+-- lib/
|   +-- core/                    # Core modules (platform, config, cache, playbook-parser, playbook-registry, guard-registry, event-bus, blocked-patterns)
|   +-- runtime/                 # Runtime pipeline (15 middleware modules; 11-stage default chain: lifecycle, router, memory, skills, tasks, subagents, guardrail, summarization, token-usage, checkpoint, cache-roi)
|   +-- visual/                  # Visual validation (SSIM differ, style-fixer, validator)
|   +-- intent/                  # Intent detection (language, trigger)
|   +-- context/                 # Context management (session)
|   +-- privacy/                 # PII protection (pii-detector, pii-scrubber, homoglyph, token-rotation, differential-privacy)
|   +-- learning/                # Lifelong learning (15 modules: memory, GRPO, pattern-analyzer, tool-history, rule-extractor, skill-injector, knowledge-demotion, etc.)
|   +-- adapters/                # Cross-platform adapters
+-- output-styles/               # 7 output styles (default, compressed, mentor, team-dashboard, tokens, narrative, statusline)
+-- templates/                   # 5 writing templates
+-- artibot.config.json          # Plugin config (Agent Teams settings)
+-- package.json                 # Node.js ESM runtime
+-- .mcp.json                    # MCP server configuration

Configuration

Key settings in artibot.config.json:

Setting	Description	Default
`version`	Plugin version	`1.14.1`
`cognitive.router.threshold`	System 1/2 boundary	`0.4`
`cognitive.router.adaptRate`	Per-feedback adjustment step	`0.05`
`cognitive.system1.maxLatency`	System 1 max response time (ms) (unused — engine removed)	`100`
`cognitive.system1.minConfidence`	System 1 minimum confidence (unused — engine removed)	`0.6`
`cognitive.system2.maxRetries`	System 2 max retry attempts (unused — engine removed)	`3`
`cognitive.system2.sandboxEnabled`	Enable sandbox for high-risk ops (unused — engine removed)	`true`
`learning.lifelong.batchSize`	Experiences per lifelong-learning batch	`50`
`learning.lifelong.grpoGroupSize`	Experiences per comparison group	`5`
`learning.knowledgeTransfer.promotionThreshold`	Consec

Artibot

README

Artibot

Overview

Key Features

Get Started

Prerequisites

Installation

Requirements

Cross-Platform Installation

Gemini CLI

OpenAI Codex CLI

Google Antigravity

What can Artibot do?

/implement -- Feature Implementation Pipeline

/team -- Parallel Team Execution

/export -- Cross-Platform Export

Usage

Smart Routing

Direct Commands

Team Orchestration

Marketing Orchestration

Parallel Execution

Architecture

Cognitive Architecture

Escalation Rules

Integration with Delegation

Sub-Agent vs Agent Teams

Lifelong Learning

Knowledge Transfer

Learning Storage

Agent Teams API Tools

Team Levels

Playbooks

Agents

Commands

Skills

Hooks

Auto-Update

MCP Integration

Cross-Platform Compatibility

Plugin Structure

Configuration

Comments (0)

`/implement` -- Feature Implementation Pipeline

`/team` -- Parallel Team Execution

`/export` -- Cross-Platform Export