██████╗██████╗ ██╗   ██╗ ██████╗██╗██████╗ ██╗     ███████╗
██╔════╝██╔══██╗██║   ██║██╔════╝██║██╔══██╗██║     ██╔════╝
██║     ██████╔╝██║   ██║██║     ██║██████╔╝██║     █████╗  
██║     ██╔══██╗██║   ██║██║     ██║██╔══██╗██║     ██╔══╝  
╚██████╗██║  ██║╚██████╔╝╚██████╗██║██████╔╝███████╗███████╗
 ╚═════╝╚═╝  ╚═╝ ╚═════╝  ╚═════╝╚═╝╚═════╝╚══════╝╚══════╝

Three models when available. One adversarial workflow. No model vouches for itself.

---

Why Crucible?

A crucible is where metals are tested under extreme heat. Impurities either survive the fire or burn away.

Your code goes in. When Codex plus a Google-family verifier are installed, three AI model families can attack it from independent angles. A bug that Claude misses, Codex might catch. A false positive Codex generates, Gemini or Antigravity/AGY might reject. In degraded mode, Crucible still runs with Claude alone, but it labels that output as unverified. No single model should vouch for itself. That's the point.

Your code / task
      │
      ▼
  Claude (Anthropic)     ← orchestrates, finds issues
      │
      ├──▶ Codex (OpenAI)    ← adversarially verifies each finding
      │
      └──▶ Gemini/AGY (Google) ← independent second opinion
              │
              ▼
         confirmed | disputed | WARNING | CRITICAL

Commands

Command	Pattern	What it does
/crucible:review	P1	Claude finds issues → configured verifier(s) check each one adversarially
/crucible:build	P2	antigravity selects skills → Claude implements → configured verifier(s) check
/crucible:audit	P3	Loop-until-dry: iterates find→verify up to 4 rounds
/crucible:bench	P4	All 3 models propose → all 3 judge each other → best wins
/crucible:ship	P1	Pre-push gate: blocks on CRITICAL, warns on rest
/crucible:discover	—	Detects your stack → recommends skills from marketplace
/crucible:orchestrate	—	Routes to preset workflows: security-audit, architecture-review, build-agent, qa-browser, design-domain
/crucible:config	—	Set verifier model: --verifier codex|gemini|antigravity|both|auto
/crucible:setup	—	Preflight check + enable/disable stop-gate
/crucible:status	—	Show running jobs and last results

Orchestrate routes invoke third-party skills that are not bundled with the plugin (only crucible-companion ships with it). When a route skill is not installed, the command degrades to an equivalent generic Claude sub-agent analysis and reports the substitution.

Install

Crucible ships its own marketplace manifest. Add the marketplace, then install (inside Claude Code):

/plugin marketplace add adi-shay/crucible
/plugin install crucible@crucible

For a manual or development install, clone the repo and point Claude Code at it with --plugin-dir (there is no claude plugin load command):

git clone https://github.com/adi-shay/crucible
claude --plugin-dir /path/to/crucible

Then run /crucible:setup to verify your environment — it uses Crucible's deterministic preflight helper under the hood. See docs/install.md for details.

Quick Start

1. Install the plugin (see above)
2. Run /crucible:setup — verifies Node.js, Codex, Gemini, Antigravity/AGY, and antigravity skills
3. Run /crucible:review — finds issues, adversarially verifies each one

That's it. Crucible works with only Claude installed and gets stronger as you add Codex plus a Google-family verifier (Gemini or Antigravity/AGY).

Requirements

Tool	Role	Required?
Claude Code	Orchestrator	Yes
Node.js >= 18	Runs all four hook scripts	Yes
Codex CLI	Adversarial verifier	Recommended — npm install -g @openai/codex, then codex login
Gemini CLI or Antigravity/AGY CLI	Independent Google-family verifier	Recommended
antigravity skills	Skill pre-selection in /crucible:build	Optional

Crucible degrades gracefully: if only Claude is available, it runs single-model. Each additional model improves verification confidence. Specifically:

• Node.js missing: if node is not on PATH, all four hooks silently no-op — no Codex/Gemini/Antigravity detection, no session status line, no stop-gate. If Crucible seems stuck in claude-only mode with no status line, check that node is on PATH for the environment Claude Code runs in (GUI launches on macOS often have a minimal PATH).
• Codex, Gemini, or Antigravity CLI missing: detected at session start via codex --version, gemini --version, then antigravity --version / agy --version. Commands warn you to run /crucible:setup and proceed with Claude-only findings only when no configured verifier is available.
• antigravity skills missing: "antigravity" skills are a set of four skill directories — antigravity-skill-orchestrator, antigravity-workflows, antigravity-design-expert, antigravity-core — that Crucible detects under ~/.claude/skills/. They are separate from the Antigravity/AGY CLI verifier. Without them, /crucible:build's preflight sends you to /crucible:setup; every other command is unaffected.

The five patterns

#	Name	Use when
P1	Find → Adversarial Verify	Code review, diff review
P2	Plan → Implement → Verify	Feature implementation
P2b	Parallel Codex Implementation	Generate 2 versions in isolated worktrees, pick best
P3	Loop-Until-Dry	Deep audit, security scan — keep going until nothing new
P4	3-Model Judge Panel	Architecture decisions, when you need a real verdict

See docs/patterns.md for full documentation with code examples.

Example: adversarial review

/crucible:review

Claude finds:
  [1] SQL injection risk in user search endpoint (HIGH)
  [2] Missing rate limit on /api/auth (MEDIUM)
  [3] Unused import: lodash (LOW)

Configured verifier(s) check:
  [1] CONFIRMED — injection vector at line 47, unsanitized input
  [2] DISPUTED — rate limiter present in middleware layer (line 12)
  [3] CONFIRMED — safe to remove

Google-family verifier verifies:
  [1] CONFIRMED — also affects /api/users endpoint
  [2] CONFIRMED — middleware rate limiter is per-IP, not per-user

Verdict: 2 confirmed findings (1 critical, 1 medium)

Verifier config

By default Crucible uses Codex plus one Google-family verifier (both). Gemini is preferred when available; otherwise Antigravity/AGY can fill the Google-family slot. Change this per-run or persistently:

# per-run (every command accepts --verifier)
/crucible:review --verifier codex
/crucible:review --verifier gemini
/crucible:review --verifier antigravity

# persistent (loaded at session start)
/crucible:config --verifier codex

Under the hood the persistent form writes a validated CRUCIBLE_VERIFIER= line to ~/.cruciblerc (you can also edit that file directly).

Valid values: codex, gemini, antigravity, both (default), auto (uses whichever CLI is available). The same --verifier flag works everywhere: on /crucible:config it sets the persistent default; on any other command it overrides routing for that run only.

Not to be confused with --codex-model <model>, a separate provider-specific flag that selects which Codex model ID to use (e.g. a specific OpenAI model) — it does not choose the verifier.

Run /crucible:config for interactive config and /crucible:setup to see current state.

Stop-gate (optional)

/crucible:setup --enable-gate enables a Stop hook that has Codex review your working-tree diff before Claude finishes a turn, and blocks once if Codex flags issues.

• The gate consults Codex only — Gemini, Antigravity/AGY, and antigravity skills are never part of the gate decision.
• If the gate is enabled but Codex is unavailable while a diff exists, it prints a one-line notice that the diff was not reviewed — it never fails silently.
• It honors the Stop hook's stop_hook_active flag, so it blocks at most once per stop attempt and can never loop.
• Diffs are read with a 50 MB buffer and truncated to 20,000 characters for review.
• Not supported on Windows yet (CLI detection works on Windows; the gate itself does not).

License

MIT — Crucible contributors