Ship with a whole agent team.
Forge is a host-global TypeScript CLI that gives your Claude Code sessions a full engineering team: an architecture advisor surfaces risks first, a tech lead decomposes the plan into file-independent steps routed to the right specialist (frontend, backend, security, platform), and parallel adversarial red agents block the gate if the diff fails review — all running as ephemeral Docker containers against your project directory. You describe what you want in plain English; the orchestrator block forge installs in your CLAUDE.md classifies the request, dispatches the pipeline, and presents each gate with a recommendation. SQLite is the durable blackboard — runs survive reboots mid-pipeline, and every agent output is stored at ~/.forge/runs/<run-id>/ for replay or audit.
Adversarial reds block bad code at the gate
Up to five parallel red agents (wide, narrow, frontend, backend, security) run read-only against every build diff. Authoritative reds set the task to blocked_by_red on failure — the gate literally won't advance until you force-override with a written rationale, creating an immutable audit trail.
Full pipeline, not a single agent shot
Every feature runs architect → tech-lead (plan) → specialist engineers (parallel fanout) → QA, each phase gated for human review before the next begins. Not a single LLM call — a sequenced workflow with structured JSON outputs at every step.
Orchestrator-led: just talk to Claude Code
`forge init` installs a RACI-driven orchestrator block into your project's CLAUDE.md. Open `claude` in your project, describe what you want — the orchestrator classifies the request, calls `forge new feature` or `forge invoke`, watches the gates, and reports back. You never type a forge command yourself.
Discipline-based specialist routing, automatically
The tech-lead's plan assigns a discipline (frontend / backend / infosec / platform / general) to each step. Forge fans out one Docker container per step, routing to frontend-specialist, backend-specialist, security-advisor, or agentic-platform-builder based on discipline — up to four parallel specialists per build phase.
Host-global state; one install, every project
One ~/.forge/forge.db SQLite blackboard tracks runs across every project on the machine. Runs survive reboots mid-pipeline; `forge status` scopes to your current workspace, `forge status --all` surveys all projects. The web dashboard reads the same DB and renders all agent outputs as markdown cards.
Demo coming soon — asciinema cast of a full feature run, gate by gate.
Key Concepts
- Run
- a single workflow invocation (one feature, one investigation), tracked from creation through completion in SQLite with a unique id like run-add-login-7c2a91.
- Phase
- an ordered step in a workflow — architect, plan, build, verify — each with its own agent role, optional red agents, and a gate that must be cleared before the next phase begins.
- Gate
- the decision point that advances a phase — human (you type `forge gate <id> advance`), verdict (red agents decide; authoritative fails block automatically), or auto (advances on completion with no input).
- Red agent
- an adversarial reviewer that runs read-only against a phase's output; with authority:authoritative and gate_on_verdict:true, a failing red sets the task to blocked_by_red and halts the pipeline until force-overridden with a written rationale.
- Orchestrator
- the Claude Code session in your project, configured by the block `forge init` installs in CLAUDE.md, that classifies prompts against a RACI table and routes them to `forge invoke` (single agent) or `forge new` (full pipeline) on your behalf.
In-house tooling for Harebrained Apps client work. Powers the engineering pipeline behind everything we ship.
How It Differs
Unlike LangChain, CrewAI, or generic YAML workflow configs, Forge is purpose-built for software-engineering pipelines: every feature runs through a fixed architect → plan → build → verify sequence with adversarial red agents that actually block the gate on failure (not advisory warnings), and the entire thing is driven through your existing Claude Code sessions via a RACI-based orchestrator block — no new UI to learn, no cloud backend, no separate agent-framework SDK to import.