v3.1.0 — Role Customization in Guided Onboarding

Agent Triforge

A core trio of AI coding CLIs forging production-grade code together. Claude Code leads a six-CLI builder pool — Antigravity CLI, Codex CLI, and an optional tier (OpenCode, Kimi, Cursor) — plus 19 specialized subagents, coordinated through a roster, per-task leases, portable skills, and parallel review swarms.

0 Agents
0 Skills
0 Commands
0 Hooks
claude — agent-triforge
agent-triforge main claude v3.1.0
$
>
Phase 0 Antigravity analyzing codebase ···
agy · Gemini 3.1 Pro 1M context window 47 files mapped
Phase 1 Planning with shadow paths ···
shadow-path-tracing 23 paths enumerated 12 error states mapped
Phase 1.1 Ambiguity check — 0 corrections ···
plan-checker agent 0 blockers approved on first pass
Phase 2 Building via wave orchestration ···
wave-orchestrator 4 waves 7 builders in parallel
Phase 3 7 reviewers dispatched in parallel ···
antigravity codex security-sentinel performance-oracle simplicity-reviewer convention-enforcer architecture-strategist
Phase 5 Codex TDD — 47 tests, all green ···
codex gpt-5.6-sol RED → GREEN → REFACTOR 47 / 47 passing
All gates passed. Shipping.
>
Ready 0.0s Press R to replay

v3.1.0 — The Roster Is Yours to Shape

/setup now walks role assignment — keep the shipped posture, customize any role's CLI · model · effort, or restore the defaults — with validated writes, a content-level roster guard, and model overrides that reach every external-CLI lane. Built on the v3.0.0 builder-pool foundation below.

WasRole assignment — hand-edit ops/roster.toml
Now/setup role step — keep · customize · restore, validated writes
WasRoster model advisory on the Codex review/test lane
Overrides reach every external-CLI lane — CODEX_MODEL joins its siblings
WasSingle-writer rule — only Claude edits code
NowSix-CLI builder pool — any roster member builds
WasGemini CLI — hosted service cut 2026-06-18
Antigravity CLI (agy) — Gemini 3.1 Pro by default, Flash opt-in
Wasship-loop Stop hook + <promise>DONE</promise> gate
Native /goal + ops/.sprint-complete sentinel
WasHard-coded model + agent assignment
ops/roster.toml — role → CLI + model + fallback
WasManual prerequisite probing of each CLI
/setup onboarding + /cli-watch · /repo-watch
WasCodex gpt-5.4, free-text review output
Codex gpt-5.6-sol — --output-schema structured verdicts

A Complete Multi-Agent Development System

Every model does what it does best. Claude leads and builds. Antigravity analyzes. Codex tests. Any roster member can build. Knowledge compounds across sessions.

6

CLIs

Core trio + optional tier

19

Agents

Opus/Fable, max effort

13

Skills

Portable workflows

7

Reviewers

Parallel review swarm

Six-CLI Builder Pool

Claude Code leads; Antigravity (1M-token analysis), Codex (sandboxed tests), and optional OpenCode/Kimi/Cursor are eligible builders. Each role is assigned from ops/roster.toml; every build is leased and cross-reviewed.

Specialized Agents

Security sentinel, performance oracle, architecture strategist, test-gap analyzer, findings synthesizer — each with restricted tools and focused expertise.

Portable Skills

Model-agnostic workflow modules injected into any agent — TDD, systematic debugging, wave orchestration, shadow-path tracing, knowledge compounding.

Parallel Review Swarm

Up to 7 reviewers analyze code simultaneously — Antigravity + Codex + 5 Claude specialist agents — then merged with confidence tiering.

Knowledge Compounding

Every non-trivial solution is documented in ops/solutions/. A learnings-researcher automatically searches these before planning new work.

File-Based Coordination

All agents coordinate through shared markdown in ops/ — AGENTS.md, GOALS.md, TASKS.md, MEMORY.md, CHANGELOG.md, STATE.md. Auditable, git-friendly, no databases.

How Six CLIs Build Safely in Parallel

The single-writer rule is retired. Safety no longer comes from restricting who writes — it comes from leasing every task, isolating it in its own git worktree, and requiring a pinned non-author reviewer to approve before anything merges.

Builder-pool flow: the roster assigns a builder, which claims a per-task lease in an isolated git worktree, gets cross-reviewed by a pinned non-author reviewer, then squash-merges onto the sprint integration branch before a gated promote to main.

Every build is leased, isolated in a worktree, cross-reviewed by a pinned non-author, and squash-merged onto the sprint integration branch before a user-gated promote to main.

01

Lease

Every implementation task — lead-authored included — claims a per-task lease in ops/leases.toml before touching a single file.

02

Worktree

The lease runs in an isolated git worktree, confined by a per-adapter environment allowlist. Builders never share the main tree.

03

Cross-review

A pinned non-author reviewer must approve. No agent self-merges — the builder can never be its own reviewer.

04

Integrate

Each approved task lands as exactly one squash commit on the sprint integration branch, keeping history legible.

05

Promote

lease_promote gates the merge to main on a protected-path set plus a user-approval knob.

Lease lifecycle: a task lease moves through claim, build, review, and merge, then releases; a stale or repeatedly-failing lease is reclaimed and reassigned to a fresh builder.

A lease moves claim → build → review → merge → release. A stale lease, or one that hits the same error three times, is reclaimed and reassigned to a fresh builder.

Six CLIs, One Config

A single CLI-neutral file — ops/roster.toml — maps each role to a CLI, model, and effort. Fallback chains degrade gracefully and always terminate at the core trio, which can never be disabled.

Roster map: builder, reviewer, tester, analyst, and documenter roles each resolve to a CLI, model, and effort, with fallback chains that terminate at the core trio of Claude, Antigravity, and Codex.

Roles are the task types — builder, reviewer, tester, analyst, documenter — so choosing model and effort per task type is this file's native grain.

CL
Claude Code
claude
Core

Lead agent and default builder — plans, builds, and coordinates every other CLI.

Builder · lead Fable 5 → Opus 4.8 → Sonnet 5 effort: max
AG
Antigravity
agy
Core

Analyst and documenter — 1M-token Phase 0 scans, architecture reviews, and docs.

Analyst · Documenter Gemini 3.1 Pro (High) Flash opt-in
CX
Codex
codex
Core

Reviewer and tester — structured --output-schema verdicts and sandboxed TDD.

Reviewer · Tester gpt-5.6-sol effort: xhigh
OC
OpenCode
opencode
Optional

Eligible builder and reviewer once enrolled — skipped cleanly in every fallback chain when absent.

enroll via /setup glm-5.2 (OpenRouter)
KI
Kimi Code
kimi
Optional

Eligible builder once enrolled — a decline persists as a flag flip, nothing else to restore.

enroll via /setup kimi-k3
CU
Cursor
cursor-agent
Optional

Eligible builder once enrolled — the model is pinned explicitly, never the Auto router.

enroll via /setup grok-4.5 (pinned)

From Goal to Ship in 7 Phases

Run /ship for fully autonomous execution, or invoke each phase individually with dedicated commands.

Phase
What Happens
Agent(s)
Command
0
Codebase Analysis
Antigravity CLI
/plan
1
Planning
Claude + writing-plans skill
/plan
1.1
Ambiguity Resolution
Claude (user confirmation)
/plan, /ship
1.5
Plan Validation
plan-checker agent
/plan
2
Build (Wave Orchestration)
Claude subagents / team-lead
/build
3-4
Parallel Review + Synthesis
Antigravity + Codex + 5 agents
/review
5
TDD Testing
Codex CLI + test-gap-analyzer
/test
6
Ship (Knowledge Compound)
Claude + knowledge-compounding
/wrap

19 Specialized Agents

Each runs in its own context window with restricted tools and focused expertise.

Core Workflow

plan-checker

Validates task plans for completeness, assignments, dependencies

findings-synthesizer

Merges review outputs with deduplication and confidence tiering

integration-verifier

Runs build, tests, lint between waves

learnings-researcher

Searches solutions and decisions for relevant patterns

team-lead

Orchestrates agent team workers with file ownership

research-synthesizer

Merges parallel research outputs into unified analysis

continuous-reviewer

Per-task quality gate during team builds

Review Specialists

security-sentinel

SQL injection, XSS, auth bypass, OWASP Top 10

performance-oracle

O(n²) loops, N+1 queries, memory leaks

code-simplicity-reviewer

Over-engineering, YAGNI violations, unnecessary abstraction

convention-enforcer

Naming, file organization, code style consistency

architecture-strategist

SOLID principles, coupling/cohesion, module boundaries

test-gap-analyzer

Untested code paths, missing edge cases, weak assertions

Research & Verification

best-practices-researcher

Industry patterns, anti-patterns, tradeoff analysis

framework-docs-researcher

Current docs for specific frameworks and libraries

git-history-analyzer

Code evolution and architectural decisions via git

bug-reproduction-validator

Validates bugs are reproducible before fixes begin

deployment-verifier

Post-deployment health checks and smoke tests

pr-comment-resolver

Reads GitHub PR comments and implements changes

13 Model-Agnostic Workflow Modules

Skills are markdown files that any agent can consume. Injected into Antigravity or Codex agent definitions, with prompt-prefix fallback via $(cat skills/SKILL.md).

SkillConsumerWhat It Teaches
codebase-mappingAntigravity (Phase 0)Full-repo analysis: structure, data flow, patterns, debt
writing-plansClaude (Phase 1)Task decomposition with shadow paths, error maps, interface context
shadow-path-tracingClaude (Phase 1)Enumerate every failure path alongside the happy path
wave-orchestrationClaude (Phase 2)Dependency-grouped parallel execution with integration checks
test-driven-developmentCodex (Phase 5)RED-GREEN-REFACTOR: no production code without failing test
systematic-debuggingCodex, ClaudeError taxonomy, assumption tracking, bisection, circuit breaker
iterative-refinementClaude (Phase 4)Review-fix-review loops with convergence modes (max 3 cycles)
review-synthesisClaude (Phase 4)Merge multi-reviewer findings with confidence tiering
verification-before-completionAll agentsEvidence-based completion checklist — no "done" without proof
knowledge-compoundingClaude (Phase 6)Document solutions to ops/solutions/ for future sprints
session-continuityClaudeSave and resume via STATE.md across sessions
scope-cuttingClaudeSystematically cut scope by unblocking value and risk
watch-cycleClaude (lead)CLI/repo watch cycle: primary-source research, gap table, adopt/defer ADR

7 Reviewers in Parallel

Two external CLIs and five Claude specialist agents analyze the same code simultaneously through different lenses, then a findings-synthesizer merges everything.

Confidence Tiering

HIGH — verified in codebase. MEDIUM — pattern match. LOW — heuristic only, can never be P1. Prevents wasting time on phantom issues.

Suppressions

Each reviewer has a "Do Not Flag" list — readability-aiding redundancy, documented thresholds, sufficient assertions, consistency-only style changes.

Iterative Convergence

Max 3 review cycles. P1 fixed immediately, P2 this cycle, P3 logged for later. Escalate to user if not converged after 3 rounds.

Six Non-Negotiable Checkpoints

Enforced at every stage of the pipeline. No shortcuts.

1

Plan validated before build

No build without a validated plan plan-checker — max 3 iterations

2

Failing test before implementation

No production code without a failing test test-driven-development

3

Root cause before fixes

No fix without diagnosis systematic-debugging

4

Evidence before completion

No "done" without proof verification-before-completion

5

Code review before shipping

No merge without review review-synthesis — max 3 cycles

6

Circuit breaker on debugging

3-attempt ceiling per issue, then escalation report systematic-debugging

Seven Defense Layers

Long sprints don't die to context limits or silent failures.

Completion Gating

Native /goal checklist gates each session; completion is signaled only by the ops/.sprint-complete sentinel after the verification checklist passes

Outer Loop

coordinate.sh spawns fresh sessions with clean context, notifies on completion via webhook or OS notification

PreCompact Hook

Auto-checkpoints STATE.md before context compaction — prevents state loss during mid-sprint compaction

Analysis Paralysis Detection

context-monitor.sh warns at 8+ consecutive reads without writes — breaks the reading loop

Tool Failure Monitor

Tracks and warns on accumulated tool failures — 5 consecutive or 10 total triggers alert

Subprocess Timeouts

Watchdog pattern on all external-CLI calls — SIGTERM after timeout, SIGKILL after 5s grace

Risk Scoring

Per-subagent risk accumulation — halt at >20% risk or 50+ file changes

Install in One Command

Hooks, agents, skills, and commands register automatically. No manual configuration needed.

Step 1 — Install the plugin
bash
claude plugin add https://github.com/Ninety2UA/agent-triforge
Step 2 — Start a sprint
claude
/ship add user authentication with JWT
Prerequisites — run /setup (core trio + optional tier)
bash
# Guided onboarding — gates the core trio, enrolls the optional CLIs /setup # Core trio (what /setup automates) claude --version agy --model "Gemini 3.1 Pro (High)" -p "Respond with only: READY" codex exec "Respond with only: READY" # Python 3 (used by hook handlers for JSON parsing) python3 --version
Autonomous mode — with context recovery
bash
./scripts/coordinate.sh "add user auth" --max 5 --team

Version Floors

/setup gates the core trio live before any sprint runs. The optional tier enrolls the same way and is skipped cleanly in every fallback chain when absent.

CLIBinaryTierMinimumNotes
Claude CodeclaudeCore2.1.212Lead + builder; Fable 5 → Opus 4.8 → Sonnet 5 ladder
AntigravityagyCore1.1.3Tested 1.1.4; pins Gemini 3.1 Pro by default — still the latest Pro (Flash opt-in via roster, e.g. Gemini 3.6 Flash)
CodexcodexCore0.144.0Reviewer + tester; --output-schema structured verdicts
OpenCodeopencodeOptional1.18OpenRouter provider connected (glm-5.2)
Kimi CodekimiOptional0.15OAuth device-code or API key (kimi-k3)
Cursorcursor-agentOptionaldate-versionedPin grok-4.5, never the Auto router

Python 3 is required for the hook handlers. Every CLI answers a headless READY probe — /setup runs them for you and writes the result to ops/roster.toml.

19 Slash Commands

CommandWhat It Does
/ship <goal> fullFully autonomous end-to-end sprint, gated to completion by /goal + sentinel
/coordinate <goal> fullFull lifecycle with context-exhaustion recovery
/plan <goal> phaseAnalyze codebase, plan with shadow paths, validate
/build phaseWave orchestration build. --team for agent team mode
/review phaseParallel review + synthesis. --full for all 7 reviewers
/test phaseGap analysis + Codex TDD. --gaps-only to just identify gaps
/wrap phaseCompound knowledge, archive reviews, write STATE.md, git trailers
/quick <change> utilChanges touching < 3 files. Skips heavy machinery
/debug <bug> utilStructured debugging: reproduce, diagnose, fix
/deep-research <topic> util5 parallel research agents + research-synthesizer
/status utilSprint overview: phase, tasks, blockers
/pause utilQuick checkpoint to STATE.md
/resume utilContinue from STATE.md checkpoint
/compound utilDocument a solved problem or decision
/analyze <url> utilDeep compatibility analysis of an external repo
/resolve-pr <#> utilRead GitHub PR comments and implement changes
/setup utilGuided roster onboarding — gate the core trio, enroll/decline each optional CLI
/cli-watch utilWatch the six CLIs vs primary sources — gap report + adopt/defer ADR + re-probe. Schedulable monthly via /schedule
/repo-watch utilMine external repos for adoptable patterns — prioritized recommendations (recommends only). Schedulable monthly via /schedule

Frequently Asked Questions

Yes. The framework installs as a Claude Code plugin — it's additive and doesn't modify your existing code. On first session, it bootstraps an ops/ directory with AGENTS.md, GOALS.md, MEMORY.md, and CHANGELOG.md templates.
The core trio (Claude, Antigravity, Codex) is the supported baseline — run /setup to get them live. The optional tier (OpenCode, Kimi, Cursor) is genuinely optional: enroll any subset via /setup, and an absent one is skipped cleanly in every roster fallback chain. Claude alone still runs the pipeline (degraded — you lose the multi-model review/test/analysis benefits).
Skills are instructions that guide behavior — methodology documents. Agents are separate subprocesses dispatched via the Agent tool, each with their own context window. Skills can be injected into any agent (including external ones like Antigravity and Codex).
Agent Teams spawn multiple Claude Code instances that collaborate through a shared task list and messaging. Unlike review swarms (read-only analysis), teams are peers that divide file ownership and coordinate builds. Best for 5+ interdependent tasks.
No. Use /quick for changes touching fewer than 3 files. It skips Phase 0, plan validation, and the full review swarm.
Two layers. Inside a session, Claude Code's native /goal gate holds completion until the checklist passes — signaled only by the ops/.sprint-complete sentinel after verification. Outside a session, coordinate.sh spawns fresh Claude processes with clean context windows, detecting completion via that sentinel. A PreCompact hook auto-checkpoints STATE.md before context compaction.
After solving a non-trivial problem, /compound saves it to ops/solutions/. Future /plan commands automatically search this directory before starting new work — so every sprint gets smarter. Each sprint should make the next sprint easier.