ForgeDock
Turn GitHub issues into reviewed pull requests through an orchestrated coding pipeline.
- Source repo
- RapierCraftStudios/ForgeDock
- Stars
- ★ 119
- Last updated
- today
- License
- AGPL-3.0
- Primary language
- JavaScript
- FA score
- 50/100 · Major gaps
At a glance
- How it runs
- Works with
- Portable with changesClaude CodeClaude API (Partial support)
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- A maintainer using Claude Code or OpenCode who wants GitHub issues advanced into reviewed pull requests.
- Not a fit if
- Teams that do not use Claude Code or OpenCode
- Teams that do not want workflow state and annotations stored in GitHub
- Source review
- 50/100 · Major gaps
What does this agent do, and when should you use it?
ForgeDock is a development pipeline for Claude Code, with documented OpenCode support, that operates on repositories through the GitHub CLI. Its /work-on command handles one issue, while /orchestrate decomposes a milestone and schedules work in parallel according to dependencies and conflicts. The pipeline reads issues, commit history, and related pull requests, then writes structured findings for investigation, build, and review back to GitHub. Workflow labels and an event log track state and support recovery after interruption; users can run interactive commands or use npx forgedock run for headless or CI execution. It requires Node.js, an authenticated GitHub CLI, and Claude Code or OpenCode; the Claude API backend must be enabled explicitly.
After installing the commands, run /work-on <issue> for a single-issue pipeline or /orchestrate <milestone> to decompose a milestone and schedule parallel work. Investigate reads the issue, git blame, and related issues or PRs, then writes FORGE:INVESTIGATOR; Context and Architect add historical findings and an ordered plan; Build creates a branch and commits and records FORGE:BUILDER. Quality Gate runs domain checks. Review invokes specialist agents for areas such as security, databases, and concurrency, and writes structured findings to the PR; completion records FORGE:TRAJECTORY on the issue. For headless runs, forgedock run can use a CLI execution backend, while forgedock run-issue uses the durable engine with an event log, leases, and recovery.
- A maintainer using Claude Code or OpenCode who wants GitHub issues advanced into reviewed pull requests.
- A team shipping a milestone in parallel while scheduling work around file overlap and dependencies.
- A project maintainer who wants later coding agents to read past investigation and review findings.
- An engineering team running the pipeline in CI or headless mode and recovering interrupted work from an event log.
- A team that wants review findings filed as new issues and fed back into the same workflow.
How do you install or deploy this agent?
Requirements are Claude Code or OpenCode, an authenticated GitHub CLI, and Node.js ≥ 18. The quick install places commands in ~/.claude/commands/ and generates a forge.yaml for review. OpenCode has a separate native command installer.
How do you use this agent?
After installing and configuring ForgeDock, start a single-issue workflow in a Claude Code session for the target repository, or pass a milestone name to run parallel orchestration. For headless execution, use npx forgedock run; the durable engine entry point is npx forgedock run-issue. Authenticate the GitHub CLI first. The API backend requires explicit opt-in.
What are this agent's strengths and limitations?
- Stores investigation, context, build, and review results as
FORGEannotations in GitHub so later runs can reconstruct context. /orchestrateschedules parallel waves using file overlap, directory proximity, module fan-in, a low-confidence fallback, and historical co-change data.- The durable engine uses an event log, leases, and bounded retries; the documentation describes reconciling and resuming state after restart.
- Pull requests receive domain-specialist review, with a reproduction gate for findings that lack evidence of a triggering code path.
- The interactive installation and commands target Claude Code; OpenCode has a separate installer and documented parity boundaries.
- It depends on the GitHub CLI, network access, and repository permissions, and stores workflow state and annotations in GitHub.
- The software is free, but model execution uses the user's Claude account; the API backend requires explicit configuration.
- The headless durable engine has shipped, while wiring the interactive path onto the same engine remains in progress.
How does this agent compare with similar options?
The README compares ForgeDock with manual Claude Code workflows and names DeepWiki, AGENTS.md, and Cursor Memories as points of comparison. Its stated distinction is that it stores structured workflow annotations in GitHub and has pipeline stages read them.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| ForgeDock This agent | 50 · Major gaps | CLIFree + model costs | ★ 119 | today | JavaScript | Claude Code |
| Maestro-Flow | 52 · Major gaps | CLIFree + model costs | ★ 568 | 8d ago | TypeScript | Codex · Claude Code · Claude API |
| Kodus | 66 · Some gaps | Hosted serviceFreemium | ★ 1.5k | today | TypeScript | OpenAI API · Claude API |
| PR Lens | 61 · Some gaps | Agent plugin / skillFreemium | ★ 2.2k | today | TypeScript | Codex |
How does FollowAgents rate this agent?
Why each dimension lost points
The docs say installation writes globally to ~/.claude/commands/ and registers a SessionStart hook; the pipeline reads and writes GitHub issues, PRs, and labels, can merge automatically, and supports parallel work. That creates a broad permission and external-effects surface, while narrow authorization scopes and per-action confirmation are not sufficiently shown, so points are deducted. Init presents a configuration review screen, and API execution requires explicit configuration plus an opt-in environment variable, providing some confirmation control. The docs say not to commit credential files and that API execution is not an implicit fallback, but do not sufficiently show secret isolation, dependency auditing, or clear source responsibility. Rollback PRs and resumability are described, but general rollback coverage is unclear.
The docs describe recovery from GitHub state and an event log, bounded retries with escalation to a human, plus diagnosis and troubleshooting guidance. These are useful design signals. README and getting-started material are not fully aligned on configuration, the yq dependency, and install behavior, and dependency version/availability guarantees are limited, so self-consistency and dependency availability lose points. No runtime evidence is available, so actual reliability is not inferred.
The docs cover Claude Code, OpenCode, interactive and CI/headless use, and provide configuration, preview, and backend choices. They also identify OpenCode parity boundaries, an unfinished reproducible cost benchmark, and ongoing engine integration for the interactive path. Global installation and dependencies on Claude/GitHub CLI/yq/Node, along with GitHub workflow assumptions, limit environment fit, so full marks are not warranted.
The supplied repository materials include organized getting-started, configuration, command, troubleshooting, and example content. The AGPL-3.0 LICENSE text is explicit, earning full marks for the license criterion. Configuration references differ in scope and required details; the provided README excerpt is truncated; and command/install evolution makes naming and compatibility somewhat complex. Update and maintenance commands exist, but a maintainer or support commitment is not clearly identified, so the other criteria lose points.
The stated output is concrete: issue-to-PR workflows with structured audit trails, review, recovery, and batch processing. These could add value to an existing GitHub workflow. Cost claims are mainly qualitative, and the docs say a reproducible per-issue cost benchmark remains pending. Automatic merges and global installation can also make misconfiguration costly, so cost-benefit receives only partial credit.
Operational steps, configuration fields, failure symptoms, and remedies are described concretely, and some product claims link to issue/PR examples. However, reported usage, success, and speed figures are self-reported without independent corroboration; configuration coverage differs across docs; and the materials do not consistently distinguish observed facts from product claims. Traceability and cross-source support are therefore partial.
- Before running it, review forge.yaml, GitHub CLI authorization, and the target repository: the docs say the pipeline can write issues and PRs, create branches, and merge automatically, while installation places commands and a hook globally.
- The configuration materials do not fully align on yq, optional configuration coverage, or backend behavior. Check dependencies and settings against the actual install path before enabling automation.
- Throughput, cost, and dogfooding figures are project-reported; the materials say a reproducible per-issue cost benchmark is still pending.
FAQ
Does ForgeDock cost anything to use?
What do I need for a first run?
forge.yaml.Can I use ForgeDock with OpenCode?
npx forgedock opencode install and also describes current parity boundaries for OpenCode.What happens if a run is interrupted?
needs-human.Can it run in CI without a Claude Code login?
execution.agent_backend: api in forge.yaml and FORGEDOCK_ALLOW_API_BACKEND=1. Automatic mode does not silently switch to the paid API.