Cas

Claude Agent System Plugin

A Claude Code plugin that spawns parallel agent swarms to plan, implement, and review code — from multi-task batch sprints to single-task deep orchestration.

Skills

/zk - Intelligent Router BETA

AKA "Zero Knowledge" — for the people who don't want to use their brain. Just type /zk and let Claude figure out the rest.

Analyzes your request and auto-routes to the best execution mode — no manual skill selection needed. Uses a deterministic decision tree to pick between /siege, /legion, /hydra, /pcc-opus, and /pcc.

/zk build a complete todo app from scratch      # -> Legion (holistic project, iterative)
/zk add a button to the settings page           # -> PCC (simple, clear scope)
/zk refactor the payment processing system      # -> PCC-Opus (keyword + risk domain)
/zk fix auth; add dashboard; update API         # -> Hydra (3 independent tasks)

Best for:

• When you don't want to think about which skill to use
• Any implementation task — ZK picks the right mode for you

Escape hatch: You can always bypass ZK and invoke /legion, /pcc, /pcc-opus, or /hydra directly.

/siege - External Orchestrator with Worker-Judge Separation BETA

Spawns fresh claude -p sessions per iteration — workers can't refuse re-spawning. Independent two-skeptic adversarial verifiers evaluate work they didn't produce. Exit decisions are arithmetic, not judgment: COMPLETE = p1==100% AND tests_pass AND build_pass AND both_skeptics_agree AND iter>=3.

Requires Agent Teams: Run /setup-swarm to enable. Workers use Agent Teams internally for coordination.

Very High Token Usage Warning: Each iteration spawns 2-3 external Claude sessions, each with their own Agent Teams. Recommended only for MAX plan subscribers.

/siege build a production-ready e-commerce platform with auth, billing, and dashboard
/siege create an entire SaaS API from scratch --max-iterations 8
/siege implement the full platform end to end --checkpoint

Best for:

• Mission-critical, reliability-sensitive projects
• Large projects needing maximum rigor (XL scope, 10+ modules)
• When you need independent verification (worker-judge separation)
• Projects where premature exit is unacceptable

Features:

• Three-tier architecture — orchestrator (thin loop) + workers (fresh sessions) + verifiers (independent sessions)
• Two-skeptic adversarial debate — two independent verifiers must AGREE before exit
• 4-layer anti-premature-exit — objective gates + checkbox arithmetic + skeptic debate + hard rules
• Active mid-task coordination — mandatory interface contracts, broadcast-on-discovery, sync checkpoints
• Arithmetic-only exit decisions — no judgment, pure number comparison
• Mandatory hardening round — always runs, even on stall
• Post-loop simplification — module-grouped cleanup

/legion - Iterative Swarm Loop BETA

Submit a holistic project description. Legion deploys a full agent swarm each iteration — scouts, CTO analyst, wave-based implementers, verifiers — then checks if the project is complete. It keeps iterating autonomously until everything is built, the max iteration limit is hit, or progress stalls.

Requires Agent Teams: Run /setup-swarm to enable this automatically. ⚠️ Close all other Claude Code sessions first — editing settings.json while other sessions run can crash them.

Very High Token Usage Warning: Legion runs multiple iterations of agent swarms. Each iteration spawns 5-30 Opus agents. Recommended only for MAX plan subscribers.

/legion build a complete todo app with local storage from scratch
/legion create an e-commerce platform with auth, cart, and checkout --max-iterations 8
/legion implement the full API layer end to end --checkpoint

Best for:

• Building complete features or applications from scratch
• Projects that need multiple rounds of build-test-fix
• When you want autonomous completion without manual re-runs

Features:

• Autonomous iteration loop — keeps deploying swarms until the project is done
• Master task list — living checkbox document, updated each iteration by the CTO analyst
• Iteration scaling — iteration 1 is heavy (15-30 agents), iteration 2+ is light (5-12 agents)
• Circuit breaker — stops after 2 consecutive iterations with no progress
• Checkpoint mode (--checkpoint) — optional pause between iterations for user approval
• Configurable max iterations (--max-iterations N, default 5)
• Post-loop simplification — module-grouped code cleanup after project completion

/hydra - Multi-Task Parallel Swarm Coordinator

Submit N tasks at once. Hydra plans them together, detects cross-task file conflicts, then deploys implementation swarms in dependency-ordered waves — fully parallel where files don't overlap, sequentially ordered where they do. Agents within each wave collaborate in real-time via mailbox messaging, and global verification uses a two-skeptic adversarial debate.

Requires Agent Teams: Run /setup-swarm to enable this automatically. ⚠️ Close all other Claude Code sessions first — editing settings.json while other sessions run can crash them.

High Token Usage Warning: Hydra uses Anthropic's Agent Teams feature (currently in beta). It spawns multiple Opus-level agents in parallel swarms, which can result in very high token consumption. Recommended only for MAX plan subscribers.

/hydra add auth; build dashboard; fix payments
/hydra 1. refactor models 2. add API endpoints 3. update tests

Best for:

• Multiple independent tasks in the same project
• Batch implementation sprints
• When tasks might share files (Hydra detects and resolves conflicts)

Features:

• Agent Teams powered — uses TeamCreate, TaskCreate/TaskUpdate/TaskList, SendMessage for structured coordination
• Cross-task file conflict analysis — builds a DAG of file ownership at plan time
• Wave-based execution — parallel where safe, sequential where files overlap
• Inter-agent collaboration — mailbox messaging with pre-coding contract exchange, broadcast-on-discovery, and sync checkpoints
• Two-skeptic adversarial global verification — two independent skeptics must AGREE before global pass; disagreements escalate to user
• Mailbox persistence across waves — Wave 2+ agents can read Wave 1 interface decisions
• Collaboration health metrics — message counts, interface proposals, and zero-message warnings in final report
• Shared scout pool — Opus scouts explore for all N tasks simultaneously
• Per-task plans + coordination file — editable before implementation
• Module-grouped simplification — ensures cross-task code consistency
• Full lifecycle management — creates team, tracks tasks, shuts down teammates, cleans up

/pcc-opus - PCC Opus Edition

Uses Opus scouts AND Opus implementers for maximum quality.

/pcc-opus refactor the entire payment processing system

Best for:

• Critical production systems
• Complex architectural changes
• Unfamiliar codebases

/faster - Single-Turn Parallel Burst

Same all-Opus quality as /pcc-opus, but no plan file and no approval gate — runs end-to-end in a single conversation turn. For when you're already in flow and just want speed without ceremony.

/faster add a /healthz endpoint with a unit test
/faster wire up Stripe webhooks for the billing module
/faster add dark mode toggle to the settings page and persist it

Best for:

• Single tasks with 3–6 genuinely independent subtasks
• "Make this faster" moments where /pcc-opus's plan-file phase is overkill
• When you already know the task is parallelizable and don't want a confirmation gate

How it differs from siblings:

• vs /pcc-opus — same model (Opus everywhere), but skips the plan file and skips user confirmation. One turn instead of three.
• vs /hydra — one task, not N. If decomposition turns up >6 independent pieces, /faster escalates you to /hydra.
• vs /zk — /zk is a router; /faster is opt-in. Type /faster directly when you know what you want.

Guardrails (built into the skill):

• Phase 0 stop-test — if subtasks aren't genuinely independent, /faster redirects you to /pcc-opus rather than burn tokens parallelizing sequential work.
• Hard escalation at >6 subtasks — won't silently truncate; recommends /hydra instead.
• In-prompt file ownership — each subagent gets explicit "files you OWN" and "files you may READ but NOT modify" lists. No mailboxes, no .cas/plans/ files.

High Token Usage: spawns up to 6 Opus scouts + 6 Opus implementers per invocation. Cost-comparable to one /pcc-opus run, but faster wall-clock.

/pcc - Parallel Claude Coordinator

Uses Sonnet scouts for fast exploration and Opus agents for implementation.

/pcc implement user authentication with JWT tokens

Best for:

• Most development tasks
• Cost-conscious workflows
• When exploration speed matters

/review - Code Review Swarm

Deploys 7 parallel review agents to analyze code, then automatically fixes CRITICAL and MAJOR findings with your approval. Uses official Anthropic review plugin agents when available, with bundled fallback agents for standalone use.

/review                  # Review all uncommitted changes (default)
/review staged           # Review only staged changes
/review src/auth.ts      # Review specific file(s)
/review "auth module"    # Review files matching a description

Review agents deployed (all 7 run in parallel):

Agent	Focus
Bug & Logic Reviewer	Security vulnerabilities, crashes, logic errors, resource leaks
Code Reviewer	Code quality, readability, maintainability, best practices
Project Guidelines Reviewer	Style conventions, CLAUDE.md standards, best practices
Silent Failure Hunter	Swallowed exceptions, bad fallbacks, inadequate error handling
Comment Analyzer	Stale docs, misleading comments, missing documentation
Type Design Analyzer	Encapsulation, invariant expression, type safety
Test Coverage Analyzer	Test gaps, missing edge cases, test quality

Features:

• 7 review agents — bundled as .md files, with official Anthropic plugin fallback
• Health score (0-10) with severity-weighted formula
• Cross-agent correlation - related findings from different agents grouped together
• Deduplicated report - orchestrator merges overlapping findings
• Agent verdicts table - quick pass/fail per agent
• Opt-in fix phase - parallel fix agents resolve CRITICAL and MAJOR findings (you choose: fix critical+major, fix all, or report only)

/cccontrol - Lightning-Fast Native macOS App Control

Control any macOS application at lightning speed using Accessibility APIs instead of slow screenshot-based computer use. 10-60x faster than computer-use.

/cccontrol test my macOS app and click through all tabs
/cccontrol launch TextEdit and type a document
/cccontrol verify the settings menu works in my app
/cccontrol open the iOS Simulator and test the onboarding flow

Architecture:

• Accessibility-first: Reads the UI via AXUIElement tree (~100ms) instead of screenshots (~3-6s)
• Screenshots-last: Only captures images for visual evidence, not for understanding UI state
• Any app: Works with SwiftUI, AppKit, Electron, Qt, Java, iOS Simulator — anything with a window
• Bundled MCP: Includes its own cccontrol-bridge (Swift CLI) and Node.js MCP server — no extra installs

Requirements:

• macOS with Xcode Command Line Tools (xcode-select --install)
• Accessibility permission in System Settings > Privacy & Security > Accessibility

/systemcc - Auto-Routing Workflow Selector

The catch-all convenience command. Auto-analyzes task complexity, risk, and scope to select and execute the optimal workflow automatically.

/systemcc fix the login bug
/systemcc refactor the authentication system
/systemcc migrate all models to new ORM

Features:

• 3-dimensional task analysis (complexity, risk, scope)
• Two-phase decision engine with confidence scoring
• Lyra AI prompt optimization
• Build configuration auto-detection and enforcement
• Automatic workflow selection and execution
• Triple code review (Senior Engineer, Lead Engineer, Architect)

/setup-swarm - Agent Teams Setup

Enables the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS env var in your ~/.claude/settings.json. Required before using /hydra or /legion.

/setup-swarm

Best for:

• First-time setup before using swarm skills
• Enabling Agent Teams without manually editing JSON

⚠️ Close all other Claude Code sessions first — editing settings.json while other sessions are running can crash or corrupt those sessions.

/setup-hooks - Safety Hooks Installer

Installs PreToolUse hooks into your ~/.claude/settings.json that intercept risky actions and prompt you before proceeding. All hooks use "ask" mode — Claude pauses and asks for your approval instead of silently blocking.

/setup-hooks

Three hooks available:

Hook	What it catches
push-guard	Any git push or gh pr create — commits are allowed freely
dangerous-commands	rm -rf ~/, dd to disk, git reset --hard, curl | sh, fork bombs, etc.
protect-secrets	.env files, SSH keys, AWS creds, secret variables, exfiltration attempts

Best for:

• Preventing Claude from pushing code without your approval
• Catching destructive commands before they execute
• Protecting sensitive files from accidental exposure

Features:

• "Ask" mode — you see a yes/no prompt, not a hard block. Approve when you asked for the action, deny when Claude acts on its own.
• Selective install — choose which hooks you want during setup
• Non-destructive — merges into existing settings without overwriting
• Audit logging — all intercepted actions logged to ~/.claude/hooks-logs/

Based on: karanb192/claude-code-hooks, modified to use "ask" instead of "deny".

Installation

/plugin marketplace add Kasempiternal/Claude-Agent-System
/plugin install cas

Skill Comparison

Skill	Use Case	Agents	Modifies Code?
/zk	Auto-routes to best mode	Router only (delegates to siege/legion/hydra/pcc-opus/pcc)	Via delegated skill
/siege BETA	Max-rigor iterative completion	External claude -p workers + two-skeptic verifiers (Agent Teams inside)	Yes
/legion BETA	Iterative project completion	Opus scouts + CTO + wave-based Opus implementers, looped (Agent Teams)	Yes
/hydra	Multi-task parallel swarms with collaboration	Opus scouts + analyst teammates + wave-based Opus implementers + two-skeptic verifiers (Agent Teams)	Yes
/pcc-opus	Max quality orchestration	Opus scouts (2-6) + Opus implementers (2-6)	Yes
/faster	Single-turn parallel burst (no plan file, no approval gate)	Opus scouts (3-6) + Opus implementers (3-6)	Yes
/pcc	Parallel orchestration	Sonnet scouts (2-6) + Opus implementers (2-6)	Yes
/review	Code review & analysis + fix	7 review agents + 1-4 fix agents	Only if opted in
/systemcc	Any implementation task - auto-routes	Auto-selected	Yes
/setup-swarm	Enable Agent Teams for Hydra/Legion	None (installer)	No (modifies ~/.claude/settings.json)
/setup-hooks	Install safety hooks (push guard, dangerous commands, secrets)	None (installer)	No (modifies ~/.claude/settings.json)

How It Works

/zk Flow

1. Analyze - Walks a 5-step decision tree against the user's request
2. Route - First matching rule wins:
   • Step 0: Holistic project needing iterative completion?
     • XL scope / reliability-critical / mission-critical -> Siege
     • Standard scope -> Legion
   • Step 1: Multiple independent deliverables? -> Hydra
   • Step 2: Scale word + broad noun ("entire codebase")? -> Hydra
   • Step 3: High-stakes keyword + qualifying signal? -> PCC-Opus
   • Step 4: Everything else -> PCC (default)
3. Delegate - Invokes the selected skill with the original task unchanged

/siege Flow

1. Prerequisites - Verify Agent Teams enabled, locate templates, detect test/build commands
2. Parse + Confirm - Parse project description + flags (--max-iterations, --checkpoint), write config, user confirms
3. First Worker (FULL) - Spawn claude -p session with full exploration + Agent Teams (scouts, architect, wave-based impl with collaboration protocols)
4. Orchestrator Loop - For each iteration:
   • Spawn DELTA worker via claude -p (delta scouts, architect updates, targeted impl)
   • Orchestrator runs test/build as independent gate check
   • Spawn TWO-SKEPTIC verifier via claude -p (two skeptics debate independently)
   • Arithmetic decision: COMPLETE = p1==100% AND tests_pass AND build_pass AND both_skeptics_agree AND iter>=3
5. Hardening - Always runs: spawn hardening worker (scouts find issues, fix agents resolve)
6. Simplification - Always runs: module-grouped cleanup worker
7. Final Report - Per-iteration progress, skeptic debate highlights, hardening results

/legion Flow

1. Prerequisites Check - Reads ~/.claude/settings.json, verifies CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
2. Project Parse - Parses holistic project description, extracts --max-iterations and --checkpoint flags
3. Team Init - TeamCreate + TaskCreate for structural phases
4. Full Exploration - Opus scout teammates explore the entire project scope (once)
5. CTO Analysis - CTO analyst creates master task list, decomposes project into modules and waves
6. User Confirmation - You review the CTO's plan, then confirm
7. Iteration Loop - The core autonomous loop:
   • Iteration 1: full wave-based implementation (Hydra-scale)
   • Iteration 2+: delta scouts -> CTO updates task list -> targeted implementation
   • Each iteration: verify -> assess completion -> loop or exit
   • Exit: all P1 tasks done + tests pass, OR max iterations, OR stall detected
8. Simplification - Module-grouped cleanup (only if project completed)
9. Final Report & Cleanup - Iteration log, final task status, shutdown, TeamDelete

/hydra Flow

1. Prerequisites Check - Reads ~/.claude/settings.json, verifies CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
2. Task Parsing - Splits input into N discrete tasks
3. Team Init - TeamCreate + TaskCreate for all N tasks and phase-tracking tasks
4. Parallel Exploration - Shared pool of Opus scout teammates explores for all N tasks
5. Delegated Synthesis - analyst-synthesis teammate reads scout reports, writes N plans + coordination.md, resolves conflicts, sends compressed summary back to orchestrator
6. Clarification - Batched questions across all tasks (using analyst summary)
7. User Review - You review summary + plan files, then confirm
8. Wave Implementation - Per wave: analyst-wave-prep teammate prepares agent specs with mailbox paths; orchestrator creates inbox files and spawns impl agents with inline collaboration protocol. Agents exchange interface proposals before coding, broadcast discoveries, and read inboxes at sync checkpoints
9. Per-Wave Verification - Single verifier per wave; after ALL waves: two-skeptic adversarial global verification (two independent skeptics evaluate, write findings, debate disagreements, review collaboration health)
10. Simplification - Module-grouped cleanup across all task boundaries
11. Final Report & Cleanup - Per-task status, collaboration metrics (messages, proposals, broadcasts), two-skeptic verdict, shutdown teammates, TeamDelete

/pcc and /pcc-opus Flow

1. Task Understanding - Clarifies the task with you
2. Parallel Exploration - Spawns 2-6 scout agents (Sonnet or Opus)
3. Synthesis - Combines findings into unified understanding
4. Clarification - Asks questions if multiple approaches exist
5. Plan Creation - Creates editable .cas/plans/{task}.md
6. User Review - You edit and approve the plan
7. Parallel Implementation - Spawns 2-6 Opus agents
8. Verification - Tests and code review
9. Simplification - Parallel cleanup agents
10. Final Report - Summarizes everything

/review Flow

1. Scope Detection - Determines what to review (uncommitted changes, staged, files, or description)
2. Load Agents - Reads 7 agent definition files (official Anthropic plugin agents preferred, bundled fallbacks available)
3. Review Swarm - 7 specialized agents launch in parallel (same wall-clock time as 1)
4. Synthesis - Orchestrator deduplicates, cross-references, and scores findings
5. Report - Consolidated findings by severity (CRITICAL > MAJOR > MINOR) with health score
6. Fix Findings (opt-in) - Parallel fix agents resolve CRITICAL/MAJOR issues (grouped by file, exclusive ownership)

/systemcc Flow

1. Detection - Acknowledges command, shows Lyra AI optimization
2. Analysis - Two-phase decision engine scores complexity, risk, scope
3. Selection - Routes to optimal workflow with confidence scoring
4. Execution - Runs all phases automatically
5. Review - Triple code review (Senior Engineer, Lead Engineer, Architect)
6. Complete - Summary with session learnings

License

MIT e

MIT e

MIT