Forge ⚒️

Turn Claude Code into a disciplined dev team — not one sprawling chat.

A PM agent orchestrates specialized agents that implement, review, test, and ship. Roles are mechanically enforced, memory lives in plain files, and state survives context compaction. No service, no vector DB, no infra to host.

• One giant Claude session drifts. It forgets decisions after a compaction, loses the thread on long runs, and edits whatever file it feels like.
• "Agent framework" tools (AutoGen, CrewAI, AutoGPT) want you to write Python orchestration, stand up a vector DB, and babysit infra — just to coordinate a few roles.
• Role boundaries that live only in prompts get ignored the moment the model is confident enough to "just fix it."

Forge fixes this inside Claude Code itself — with hooks that actually enforce the rules, flat files instead of services, and a pipeline that scales to the task.

git clone https://github.com/ajadi/forge.git

# install into your project (pick a preset)
bash forge/install.sh /path/to/your/project --preset solo        # 13 core agents
bash forge/install.sh /path/to/your/project --preset full        # 37 agents

# then open the project in Claude Code and run:
/f-start

Prefer it everywhere? bash forge/install-global.sh installs the agents/commands/skills into ~/.claude/, then /f-setup-project wires any folder.

You give the PM agent a task. It assesses complexity and routes it through the matching pipeline — no full ceremony for a typo, full rigor for a feature.

flowchart TD
    U([You: a task]) --> O[Orchestrator · Claude Code]
    O --> PM{{PM agent — routes by complexity L1–L4}}
    PM --> DEV[Developer · implements]
    PM --> CR[Code Reviewer]
    PM --> SEC[Security Analyst]
    PM --> RC[Reality Checker · final gate]
    PM --> ARCH[Architect · L3–L4 design]
    DEV --> MEM[(memory/*.md · flat-file memory)]
    CR --> MEM
    SEC --> MEM
    RC ==> CM([✓ commit])
    MEM -. grep before guessing .-> PM

Four things keep it from drifting, leaking, or running up cost:

• Mechanically enforced roles — a Write|Edit guard hook stops the PM and read-only agents from editing source. Boundaries are enforced, not just documented.
• File-based memory — project knowledge lives in memory/*.md; agents grep before they guess, append after tasks, mark superseded facts ~~strikethrough~~. No service, no embeddings, nothing to install.
• Token economy — large non-source reads are delegated to a cheap model; noisy shell output is trimmed before it reaches context. The reasoning model stays on code.
• Long-session durability — state is dumped before compaction and rehydrated exactly once after, so long runs don't lose the thread.

Forge is v2.4, MIT-licensed, and used in real multi-agent builds.

• ✅ Complexity-routed pipeline (L1–L4) with 13 core + 24 extension agents
• ✅ Hook-enforced role boundaries, commit/push guards, production-safety stop
• ✅ Flat-file memory protocol + repo-access modes (private/shared/public)
• ✅ Long-session durability (pre-compact dump + one-shot rehydrate), token economy
• ✅ Autopilot — run a backlog end-to-end, halt only on questions/regressions/deploys
• 📋 Roadmap — richer memory via Ember (see below)

Forge's built-in memory is flat Markdown files — zero-config and perfect for most projects. For semantic recall across sessions and machines, pair it with Ember — a local-first MCP memory server (SQLite + on-device embeddings + tiered retrieval). Forge ships an optional capture adapter that feeds pipeline events (PM steps, reality-checks, decisions, retrospectives) straight into Ember. Use either alone, or both together.

scripts/switch-repo-access.sh public --commit

Pipeline ideas (autonomy ladder, stop rules, handoff contracts, Ralph Loop, escalation matrix) inspired by alexeykrol/coursevibecode.

MIT © 2026 David Sandler