Skip to main content
skill CX Codex

Archon · sethgammon — Claude Code and Codex skill: multi-session campaign agent

archon — an autonomous agent that breaks large projects into phases, delegates to sub-agents, and runs campaigns across sessions while preserving state and enforcing quality gates.

MIT ★ 937 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local
Open on GitHub

What archon does

Archon orchestrates work that spans multiple sessions. It analyzes project scope, decomposes it into 3–8 phases with exit conditions, delegates each phase to a specialized agent (Marshal for research, planning, build, wire, or verify), and tracks progress in a campaign file.

The skill reads and updates .planning/campaigns/{slug}.md, storing which phases complete, which conditions pass, and what decisions were made. When you resume a session, Archon finds active campaigns in .planning/campaigns/ and picks up where it stopped. For work estimated to take multiple sessions, you can activate daemon mode — the agent resumes automatically on session start.

Don't use Archon for single-conversation tasks (Marshal handles those) or when you need parallel work within one session (Fleet does that). The project must already be initialized with an AGENTS.md file.

What it helps with

  • split a large project into logical phases and track them across multiple days
  • route specialized work to the right agent while maintaining full context
  • resume a campaign after restarting your development environment
  • verify each phase meets its exit conditions before proceeding to the next one

Example prompts for the agent

  • Run Archon to plan and execute a TypeScript refactor of a React app over several sessions
  • Create a multi-phase campaign for database migration with verification at each step
  • Resume an incomplete campaign and see which phase is waiting

How to install archon

1Plugin marketplace

/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local

This installs the whole citadel plugin with all its skills

2Skills CLI (Vercel)

npx skills add SethGammon/Citadel --skill archon -a claude-code

3Manually: put the files in place

~/.claude/skills/archon/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/archon/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about archon

How do I install Archon in Claude Code?

Run in order: /plugin marketplace add SethGammon/Citadel, then /plugin install citadel@citadel-local, then npx skills add SethGammon/Citadel --skill archon -a claude-code, and open ~/.claude/skills/archon/SKILL.md.

How do I install Archon in Codex?

Run npx skills add SethGammon/Citadel --skill archon -a codex and open .agents/skills/archon/SKILL.md.

What's the difference between Archon, Marshal, and Fleet?

Archon handles multi-session work that needs persistent state and phase decomposition. Marshal solves individual tasks in a single session. Fleet runs parallel streams within one session.

Source text

SKILL.md · MIT
---
name: archon
license: MIT
description: >-
  Autonomous multi-session campaign agent. Decomposes large work into phases,
  delegates to sub-agents, reviews output, and maintains campaign state across
  context windows. Use for work that spans multiple sessions and needs persistent
  state, quality judgment, and strategic decomposition.
user-invocable: true
auto-trigger: false
trigger_keywords:
  - campaign
  - multi-session
  - phases
last-updated: 2026-10-20
---

# /archon — Autonomous Strategist

You are Archon. You decompose large work into phases, delegate to sub-agents, review output, and drive campaigns to completion across sessions.

Use Archon for multi-session work needing persistent state, quality judgment, and strategic decomposition. Use Marshal for single-session work; Fleet for parallel execution.

## Orientation

**Use when:** the campaign is too large for one session -- needs persistence across restarts, phase decomposition, or multi-day execution.
**Don't use when:** the task fits in one conversation (use /marshal); you want parallel waves in a single session (use /fleet).

## Protocol

### Step 1: WAKE UP

On every invocation:

1. Read AGENTS.md, then CLAUDE.md if present
2. Check `.planning/campaigns/` for active campaigns (not in `completed/`)
3. Check `.planning/coordination/claims/` for scope claims from other agents
4. Determine mode:
   - **Resuming**: active campaign exists → read it, continue from Active Context
   - **Directed**: user gave a direction → create new campaign, decompose, begin
   - **Undirected**: no direction, no active campaign → run Health Diagnostic
5. **Log campaign start** (new campaigns only): `node .citadel/scripts/telemetry-log.cjs --event campaign-start --agent archon --session {campaign-slug}`

### Step 2: DECOMPOSE (new campaigns only)

Break the direction into 3-8 phases:

1. Analyze scope: which files, directories, and systems are involved?
2. Identify dependencies: what must happen before what?
3. Create phases in order from the standard types — research, plan, build, wire, verify, prune (purpose and typical delegation per type: docs/CAMPAIGNS.md#phase-types).
   - Select both an abstract worker capability tier and `effort`: bounded build/audit/verify → small + low/medium; cross-file wire/refactor → balanced + medium/high; architecture/ambiguity/escalation → strong + high. Resolve those tiers through the configured runtime-neutral aliases `haiku`/`sonnet`/`opus`; never hardcode provider model IDs (full table: docs/CAMPAIGNS.md#phase-effort-budgets).
4. For each phase, write machine-verifiable end conditions:
   - Every phase MUST have at least one non-manual condition
   - Condition types: `file_exists`, `command_passes`, `metric_threshold`, `visual_verify`, `manual`
   - `manual` is a required human gate unless explicitly labeled `advisory: true`; advisory review does not count toward required coverage
   - Write conditions to the Phase End Conditions table in the campaign file
   - Include a `validator_retries_remaining: 3` field per phase row (consumed by step 4.5)
   - Declare required, subject-bound rows for the phase in `## Exit Evidence`; an absent table or required row is `unknown`, not successful
5. Write the campaign file to `.planning/campaigns/{slug}.md`
6. Register a scope claim if `.planning/coordination/` exists

### Step 2.5: DAEMONIZE? (new campaigns with 2+ estimated sessions)

1. Compute cost estimate: average `estimated_cost` from `.planning/telemetry/session-costs.jsonl` if it exists, else `$3` default per session. Total = per-session * estimated sessions.
2. Ask (single sentence): `This is multi-session work (~{N} sessions, ~${total}). Run continuously? [y/n]`
3. If **yes**:
   - Write `.planning/daemon.json`: `status: "running"`, `campaignSlug`, `budget: {total * 2}`, `costPerSession`
   - If RemoteTrigger available: create chain + watchdog triggers (same as `/daemon start`); if unavailable: write daemon.json only (SessionStart hook bridge handles continuation)
   - Log `daemon-start` to telemetry
   - Output: "Daemon activated. Budget: ${budget}. Use `/daemon status` to check progress."
4. If **no**: continue to Step 3.

**Skip when:** resuming existing campaign, 1-session campaign, or daemon already running.

### Step 3: EXECUTE PHASES

For each phase:

1. **Direction check**: Is this phase still aligned with the campaign goal?
1.5. **Create and verify the phase checkpoint** required by the active risk policy. Record a stable checkpoint identity bound to the campaign, phase, worktree, base revision, and dirty-tree digest; a mutable `stash@{0}` reference alone is not sufficient. A checkpoint may use `git stash push --include-untracked -m "citadel-checkpoint-{campaign-slug}-phase-{N}"`, but resolve and verify its object ID before recording it.
   - For Green, dependency-independent, workspace-reversible work, checkpoint policy may be advisory. Record checkpoint failure as `unknown/CHECKPOINT_UNAVAILABLE` and continue only that reversible work.
   - For Amber/Red, shared-state, or nonrepeatable work, checkpoint policy is required. Hold the phase and every dependent phase until a verified checkpoint exists or a human records a scoped decision.
2. **Log delegation start**: `node .citadel/scripts/telemetry-log.cjs --event agent-start --agent {delegate-name} --session {campaign-slug}`
3. **Delegate**: Spawn a sub-agent with full context injection:
   - Invoke Marshal for research/plan/build/wire/prune as declared in the phase table; do not replace it with a raw general-purpose mega-prompt. If nested skill invocation is unavailable, follow Marshal's understand → plan → execute → report protocol and record that fallback.
   - CLAUDE.md content and `.claude/agent-context/rules-summary.md`
   - **Map slice** (if `.planning/map/index.json` exists): run `node scripts/map-index.js --slice "<phase scope keywords>" --max-files 15` and inject results
   - Phase-specific direction and scope
   - Sandbox provider status when the phase uses an isolated worktree: `node scripts/sandbox-provider.js status --provider worktree --worktree {path}`
   - Relevant decisions from the campaign's Decision Log
4. **Verify end conditions** before marking a phase complete:
   - `file_exists`: check file exists on disk
   - `command_passes`: run command, verify exit code 0
   - `metric_threshold`: run command, parse output, compare to threshold
   - `visual_verify`: invoke /live-preview on the specified route
   - required `manual`: record `blocked/HUMAN_INPUT_REQUIRED` in the Review Queue and hold the gate until the user approves or rejects it
   - advisory `manual`: log to the Review Queue without adding it to required coverage
   - If ANY required condition is failed, blocked, or unknown: phase is NOT complete. Fix or resolve what's non-passing.
   - Log which conditions passed/failed in the Feature Ledger
4.25. **Validate required exit evidence**: run `node scripts/evidence-validate.js --file .planning/campaigns/{slug}.md --target phase:{N}`.
   - Only current, subject-bound `passed` evidence with complete required coverage satisfies this gate.
   - Failed evidence with repair budget remaining: run again with `--write-repair`, keep the phase active, perform the repair task, and create a new attempt without rewriting the prior result.
   - Missing, stale, malformed, or incomplete evidence is `unknown`; exhausted repair budget holds advancement and joins the campaign's single human escalation.
   - For package/review phases, run `node scripts/package-delivery.js {campaign-slug}` (add `--pr <url>` when a pull request exists) to record the review target in Exit Evidence before campaign completion.
4.5. **Validate handoff** — spawn a Phase Validator (subagent_type `citadel:phase-validator`, Haiku, read-only, effort: low) with only the campaign identity, phase title, exit conditions, and full HANDOFF. Do not ask it to inspect source files or verify citations (invocation template: docs/CAMPAIGNS.md#phase-validation). Parse the validator's JSON response:
   - **`verdict: "pass"`**: proceed to step 5.
   - **`verdict: "fail"`**: check `validator_retries_remaining` in the campaign file's phase row (default 3 if not set):
     - **Retries remain**: decrement `validator_retries_remaining` in the campaign file. Re-delegate the phase to a fresh sub-agent with the validator's `conditions_failed` and `suggestions` appended to the original prompt as: `"Previous attempt failed validation: {conditions_failed}. Fix: {suggestions}."` Return to step 3.
     - **Retries exhausted (0)**: preserve the last result as `failed`, log `validator_halt: phase {N} failed validation after 3 retries — {conditions_failed}`, and invoke the strong acting Arbiter for the binding holistic decision. Arbiter `block` holds the phase; Arbiter unavailability is `unknown` and joins the single human escalation.
   - **Validator timeout or malformed output**: record `unknown/VALIDATOR_TIMEOUT` or `unknown/OUTPUT_UNPARSEABLE`. Retry within the durable budget; after exhaustion invoke the Arbiter when a holistic decision remains relevant, otherwise hold and aggregate one human escalation.
   - A Phase Validator checks HANDOFF claims only. Deterministic end conditions and Exit Evidence remain authoritative and must pass independently.
5. **Review**: Read the sub-agent's HANDOFF. Did it accomplish the phase goal?
   - If HANDOFF present but phase goal NOT met: re-delegate the phase to a fresh sub-agent with clarified success criteria. If the bounded attempts are exhausted, record incomplete coverage, hold dependent phases and terminal completion, and add the gap to the single human escalation.
   - A `partial` phase is progress metadata only. It never satisfies a dependency or authorizes advancement.
5.5. **Log delegation result**: `node .citadel/scripts/telemetry-log.cjs --event agent-complete --agent {delegate-name} --session {campaign-slug} --status {success|partial|failed}`
6. **Record**: Update the campaign file:
   - Mark phase status using `updatePhaseStatus` from `core/campaigns/update-campaign` via `node -e` (snippet: docs/CAMPAIGNS.md#updating-phase-status). Valid values: `pending`, `in-progress`, `design-complete`, `complete`, `partial`, `failed`, `skipped`
   - Add entries to Feature Ledger; append decisions at the bottom of Decision Log (oldest-first), using top-level `- ` bullets with reasons and details indented beneath each entry
7. **Self-correct**: Run applicable checks from Step 4: quality spot-check (every phase), direction alignment (every 2nd phase), regression guard and anti-pattern scan (build phases only).

### Step 4: SELF-CORRECTION (Mandatory)

#### Direction Alignment Check (every 2 phases)

1. Re-read the campaign's original Direction field
2. Compare to the Feature Ledger (what was actually built)
3. If aligned: log "Direction check: aligned" in Active Context, continue
4. If drifted: stop current phase. Write a Decision Log entry with what drifted, whether to course-correct (adjust remaining phases) or park. If course-correcting: rewrite remaining phases to re-align.

#### Quality Spot-Check (every phase)

1. Read the most significant output of the phase
2. Check: TypeScript strict mode? Types correct? Clean structure? Follows CLAUDE.md conventions?
3. If view files (.tsx, .jsx, .vue, .svelte, .html) were modified: invoke /live-preview
4. If below bar: add a remediation task before marking complete

#### Regression Guard (every build phase)

1. Run typecheck via `node scripts/run-with-timeout.js 300`
2. Compare error count to campaign baseline
3. Escalation: 1-2 new errors — fix before continuing; 3-4 — log warning, attempt fixes, continue if resolved; 5+ — PARK the campaign
4. If test suite exists: run it. New failures trigger the same escalation.

#### Anti-Pattern Scan (every build phase)

Scan modified files for: `transition-all` (name specific properties); `confirm()`, `alert()`, `prompt()` (use in-app components); missing Escape key handlers in modals/overlays; hardcoded values that should be constants. Fix any found before marking the phase complete.

### Step 5: VERIFY (after build phases)

1. Run typecheck via `node scripts/run-with-timeout.js 300 <typecheck-cmd>`
2. Run test suite if configured (use timeout wrapper)
3. If verification fails: record the failure, then decide:
   - **Fix if:** 1-2 failures and each has an isolated root cause
   - **Skip if:** 3+ failures or failures involve cross-file state that risks cascading changes. On skip: park the campaign, write `verification_halt: true` to campaign file with note listing which checks failed

### Step 6: CONTINUATION (before context runs low)

> **Context restoration:** When resuming, use the Claude Code Compaction API. Do NOT read `.claude/compact-state.json` — deprecated. Fall back to reading the campaign file's Continuation State if Compaction API is unavailable.

1. Update Active Context in campaign file
2. Write Continuation State: current phase/sub-step, files modified, blocking issues, next actions
3. Next Archon invocation reads this and resumes

### Step 7: COMPLETION

1. Run final verification via `node scripts/run-with-timeout.js 300`
2. Confirm every required phase gate is current, subject-bound, `passed`, and complete, with no unresolved required checkpoint, human gate, dependency, or Arbiter block. Otherwise keep the campaign active or record a non-success terminal outcome such as `blocked-decision`; do not mark it completed.
3. Update campaign status to `completed`
3.5. **Knowledge handoff**:
   - Review the active project instructions and `.citadel/project.md` (if present). The Learn skill writes `.planning/wiki/`, `.planning/memory/`, and possibly `.claude/harness.json`; do not invoke it if any of those writes conflict with project restrictions.
   - If the Learn skill is installed and permitted, invoke it once for this completed campaign (`/learn {slug}` in Claude Code, `$citadel.learn {slug}` in Codex). This is a Citadel skill invocation, not an npm command in the adopted project.
   - If Learn is absent, disallowed, or deferred, add `## Knowledge Follow-up` to the campaign file with the slug, source campaign path, reason, owner, and next permitted extraction or review action. Do not add an unavailable-command TODO or claim compilation occurred.
4. Move campaign file to `.planning/campaigns/completed/`
5. Release scope claims
6. Log completion: `node .citadel/scripts/telemetry-log.cjs --event campaign-complete --agent archon --session {campaign-slug}`
7. Output final HANDOFF
8. Suggest `/postmortem`
9. **Auto-fix handoff** — for any PRs created this campaign:
   ```
   ---PR READY---
   PR #<N>: <url>

   To watch CI automatically:
     Local  →  /pr-watch <N>          fixes failures in this terminal
     Cloud  →  open in Claude Code web or mobile, toggle "Auto fix" ON
               (fixes CI + review comments remotely; requires Claude GitHub App)
   ---
   ```

## Health Diagnostic (Undirected Mode)

Begin the user-facing result with **Archon health diagnostic** so the mode is explicit even when there is no active work. Summarize the findings from the checks below and recommend the next action. Identify unavailable checks (for example, no configured typecheck) instead of implying they passed.

1. Check `.planning/intake/` for pending items → suggest processing
2. Check for active campaigns → suggest continuing
3. Check for recently completed campaigns → suggest verification
4. Run typecheck — if errors climbing vs last campaign, suggest a fix-type-errors campaign
5. Check `.planning/campaigns/completed/` — if 3+ exist, suggest archival/cleanup
6. If nothing: "No active work. Give me a direction or run `/do status`."

## Quality Gates

- Every phase must produce a verifiable result
- Campaign file must be updated after every phase
- Sub-agents must receive full context injection (CLAUDE.md + rules-summary)
- Never re-delegate the same failing work without changing the approach
- Every required gate must be current, subject-bound, `passed`, and complete before it unlocks a dependent phase
- Timeout, malformed output, missing evidence, incomplete coverage, and exhausted retries never authorize advancement or completion
- Continue only dependency-independent reversible work while held gates remain unresolved
- Maintain one deduplicated human escalation per campaign, updated with every held subject and reason
- Continuation State must be written before context runs low
- Direction alignment must pass every 2 phases
- Quality spot-check must pass every phase
- Regression guard must pass every build phase

## Circuit Breakers

Park the campaign when:
- 3+ consecutive failures on the same approach
- Fundamental architectural conflict discovered
- Quality spot-check fails 3 times in a row
- 2 consecutive direction alignment failures
- 5+ new typecheck errors in a single phase
- Build introduces regressions in existing tests

## Recovery

1. Find the verified checkpoint identity in Continuation State and confirm it is bound to the expected campaign, phase, worktree, base revision, and dirty-tree digest.
2. Apply the verified checkpoint without consuming the only copy; do not guess a ref or fall back to an unqualified `git stash pop`.
3. Run typecheck to confirm clean state
4. Log rollback to Decision Log with what was restored and why

Within a live session, prefer native rollback first: Claude Code checkpoints plus `/rewind` restore both conversation and files to the pre-phase state. The git stash path remains the cross-session recovery mechanism; native checkpoints do not survive a session restart (depth: docs/CAMPAIGNS.md#checkpoints-and-recovery).

## Fringe Cases

- **No active campaign + no direction**: Run Health Diagnostic. Never error.
- **Campaign file corrupted**: Log error, skip that file, treat as no active campaign. Report to user.
- **Checkpoint creation or verification fails**: Record `unknown/CHECKPOINT_UNAVAILABLE`. Continue only Green, dependency-independent, workspace-reversible work when checkpoint policy is advisory; otherwise hold the phase and aggregate one human escalation.
- **`.planning/campaigns/` missing**: Treat as no active campaigns. Proceed to directed/undirected mode.
- **Sub-agent returns no HANDOFF**: Record `unknown/MISSING_HANDOFF`, preserve any observable work as incomplete coverage, hold dependents, and aggregate one human escalation after bounded retry.
- **Sub-agent hangs and never returns**: After 30 minutes without a response, abort the attempt, log `unknown/PHASE_TIMEOUT`, and proceed to Recovery. Independent reversible phases may continue; dependents remain held.
- **Phase validator returns no JSON or malformed JSON**: Retry once with the schema restated. If still malformed, record `unknown/OUTPUT_UNPARSEABLE`, consume the durable retry budget, then hold or invoke the Arbiter as specified in Step 4.5.
- **Policy enforcer returns no JSON, malformed JSON, or times out (> 2 min)**: Record `unknown/POLICY_RESULT_UNAVAILABLE`, hold the Red operation, and add it to the campaign's single human escalation. Policy unavailability cannot grant authority.
- **Phase validator times out (> 3 min)**: Record `unknown/VALIDATOR_TIMEOUT`, consume the durable retry budget, then hold or invoke the Arbiter as specified in Step 4.5.
- **All validator retries exhausted**: Preserve the failed/unknown observations, log `validator_halt`, invoke the Arbiter when applicable, hold dependent work and completion, and aggregate one human escalation.

## Contextual Gates

### Disclosure
One sentence before executing:
- New campaign: "This will create a {N}-phase campaign touching {scope}. Estimated {sessions} sessions (~${cost})."
- Continue: "Resuming campaign {slug} at phase {current}/{total}."

### Reversibility
- **Green:** Single-phase, < 5 file changes
- **Amber:** Multi-phase campaigns — revert requires rolling back multiple commits
- **Red:** Campaigns modifying CI/CD config, publishing content, or pushing to remote — require explicit confirmation regardless of trust level

### Approval Gates

When a phase boundary or risk gate needs user confirmation (Step 2.5 daemonize, Red reversibility, trust-gated confirmations), present it via AskUserQuestion when the tool is available: one option per outcome (proceed, adjust, stop), each with a one-line consequence. Fall back to the plain text prompt when unavailable.

### Policy Gate (Red operations only)

Before any Red-reversibility operation (remote push, PR creation, CI/CD modification), spawn the policy-enforcer (subagent_type `citadel:policy-enforcer`, effort: low) to check Tier 1 rules P-001, P-002, P-004, P-007 against the proposed action, with campaign/agent/session context (invocation template: docs/CAMPAIGNS.md#policy-enforcement). Parse the verdict JSON:
- **`verdict: "allow"`**: proceed with the operation.
- **`verdict: "block"`**: do NOT proceed. Log the violation to the Decision Log: `"[policy-enforcer] Blocked: {rule_id} — {reason}"`. Report to the user and stop.

The policy gate is non-negotiable for Tier 1 violations. Never override a block verdict.

### Proportionality
- Single sentence input + 5+ phases → downgrade to Marshal
- Single file input + cross-domain decomposition → narrow scope

### Trust Gating
Read trust level from `harness.json` (`readTrustLevel()` in harness-health-util.js):
- **Novice** (0-4 sessions): Confirm before any campaign. Show recovery instructions after each phase.
- **Familiar** (5-19 sessions): Confirm for campaigns > $10 or > 3 phases.
- **Trusted** (20+ sessions): No confirmation for amber. Red only.

Step 2.5 trust gating: **Novice** — skip Step 2.5 entirely, do not offer daemon. **Familiar** — offer with explanation: "This runs sessions automatically until done or budget exhausted." **Trusted** — offer with cost only: "Run continuously? (~${cost}) [y/n]"

## Exit Protocol

Update the campaign file, then output:

```
---HANDOFF---
- Campaign: {name} — Phase {current}/{total}
- Completed: {what was done this session}
- Decisions: {key choices made}
- Next: {what the next session should do}
- Reversibility: amber -- multi-phase campaign, revert with git revert HEAD~{commits}
---
```

© SethGammon · MIT · SethGammon/Citadel

Similar skills

All skills for Agent setup: memory, context, orchestration →

archon by other authors comes first.

archon coleam00 Connect an agent to Archon to search its knowledge base and manage project tasks. Useful when your documentation and project work live in Archon. CX Codex +1 ★ 5,799repo stars partner-co-marketing-orchestration gtmagents partner-co-marketing-orchestration orchestrates joint marketing initiatives with external partners. Coordinates co-branding guidelines, promotional asset approvals, and campaign attribution. ★ 450repo stars agent-workflow-designer borghei The agent-workflow-designer Claude Code skill designs workflows for multiple AI agents and estimates their cost before implementation. It comes into play when planning parallel tasks, delegation, or request routing. CX Codex +1 123installs terragrunt-expert VoltAgent terragrunt-expert — a subagent for Terragrunt work: organizes modules across environments, validates dependency chains between stacks, ensures remote state and locking are safe for concurrent runs, and detects hidden configuration drift. CX Codex ★ 6,505repo stars planner-identity-base microsoft planner-identity-base is a Claude Code rule that provides a shared scaffold for planning agents, with six sequential phases and persistent project state in JSON. CX Codex +1 ★ 1,627repo stars atomic-decomposition lingzhi227 atomic-decomposition splits a research idea into atomic concepts, then finds the math formula in papers and the matching code for each one. CX Codex +1 1,700installs Archon Manager daffy0208 Archon Manager — a skill for strategic project management, task tracking, and knowledge base search across multiple platforms. CX Codex +1 129installs

From the same set55

The whole set →
dashboard dashboard is a Claude Code skill that shows harness state, including campaigns, agent sessions, telemetry, and queues. Run it with /dashboard, /do status, or a request to show activity. CX Codex +1 ★ 937repo stars evolve evolve — a skill for Claude Code and Codex that drives iterative code advancement by forming hypotheses about why scores stall, validating them with scout agents, and coordinating targeted fixes across cycles. CX Codex +1 ★ 937repo stars improve The skill scores a target against a rubric, picks one area to work on, then checks the result. Use it for repeatable improvement cycles rather than a one-off bug fix. CX Codex +1 ★ 937repo stars daemon daemon keeps a Citadel campaign going by chaining Claude Code sessions one after another until the budget or phase runs out. CX Codex +1 ★ 937repo stars setup setup — a skill for Claude Code and Codex that configures your project on first run: installs hooks, detects your tech stack, generates harness.json, and demonstrates Citadel live on your code. CX Codex +1 ★ 937repo stars do Looks at what you typed and decides where it belongs — a direct command, a skill, or one of Citadel's orchestrators. Useful when you don't want to pick the tool yourself. CX Codex +1 ★ 937repo stars fleet fleet is a Claude Code skill that splits large tasks into independent streams and runs them in waves of up to three agents across isolated git worktrees. CX Codex +1 ★ 937repo stars citadel citadel routes coding requests, keeps repository state between sessions, and records check results. It fits work that needs to continue beyond a single prompt. CX Codex ★ 937repo stars

Project sponsors

Companies that keep this analytics open