Forgeo Software Factory

Schedules backlog work, runs a coding agent, and commits the result.

Stars
★ 30
Last updated
4d ago
License
MIT
Primary language
Python

At a glance

Works with
Universal · cross-platformCodex · Claude Code
You'll need
Git repositoryAgent CLIPython 3.11+ for pipx installationShell / CLILocal filesystem
Typical use
A solo maintainer with a small Git project can feed JSON tasks to Codex, Claude Code, or another CLI and have completed changes committed automatically.
Main limitation
Adoption means granting an agent CLI permission to change a Git worktree and create commits; the default main-line workflow raises the cost of weak agent output or overly broad repository permissions.
Source review
76/100 · Some gaps

What does this agent do, and when should you use it?

Forgeo is a scheduled software factory that selects backlog tasks, invokes a coding-agent CLI, and commits the resulting repository changes. It supports a plain JSON backlog as well as GitHub, GitLab, Jira, and HTTP providers, with progress exposed through files and a web dashboard. Its execution interface is provider-neutral: any CLI that reads FORGEO_TASK can participate, and the supplied material explicitly names Claude Code, Codex, aider, and custom scripts. By default, it runs one dependency-ready or scheduled task at a time and performs a refactoring pass when no backlog work remains. Tasks can move through COMPLETED, REVIEW, BLOCKED, and FAILED paths, backed by retries, file-backlog snapshots, BLOCKER.md, and Telegram or webhook notifications. It is a self-hosted repository automation tool that requires a terminal, a Git repository, and an independently supplied agent CLI.

Forgeo reads forgeo.yaml and the configured backlog provider, then selects the oldest runnable OPEN task whose dependencies are COMPLETED or whose run_at schedule is due. It passes that task to the configured agent CLI through FORGEO_TASK, lets the agent modify the current repository, and commits and, where configured, pushes the result. The normal path targets the main line; with review_mode: branch, it commits to a branch such as forgeo/review/TASK-001, marks the task REVIEW, pushes it, and waits for a human merge before completion. An empty backlog triggers a refactoring pass. Failed work can follow a retry policy, while work requiring a decision becomes BLOCKED and uses BLOCKER.md; file backlogs are snapshotted to backlog.json.bak before a run and restored if corrupted. forgeo web supplies a multi-instance dashboard and HTTP API, while forgeo status, once, run, start, stop, and restart control execution.

  1. A solo maintainer with a small Git project can feed JSON tasks to Codex, Claude Code, or another CLI and have completed changes committed automatically.
  2. A team with overnight or time-based maintenance work can combine run_at scheduling with the background daemon.
  3. A team that requires approval before integration can enable review_mode: branch and hold completed agent work in REVIEW until a human merges it.
  4. A developer maintaining several repositories can give each one independent backlog, log, and lock state, then manage them through the instance registry and aggregate dashboard.
  5. A security-conscious operator can place the agent in a Docker sandbox with no network by default and selected credential directories mounted read-only.
  6. A team already tracking work in GitHub, GitLab, or Jira can use those issues as the backlog and monitor blocked, failed, and retry states from the dashboard.

How do you install or deploy this agent?

Provide a terminal, a Git repository, and an installed agent CLI. Choose one documented installation route: brew install lucaGazzola/forgeo/forgeo; curl -fsSL https://forgeo.org/install.sh | bash; or, with Python 3.11 or newer, pipx install forgeo-cli. From the project root, run forgeo init; the wizard creates forgeo.yaml and .forgeo/, then asks for a file, github, gitlab, jira, or http backlog provider and the agent command. Issue providers require either a PAT or OAuth authentication through forgeo auth login, with tokens stored under ~/.config/forgeo/tokens/. GitHub repository detection is automatic when possible; Jira additionally asks for its URL and JQL.

How do you use this agent?

For the file provider, populate .forgeo/backlog.json; for another provider, configure it in forgeo.yaml. Run forgeo validate first to check configuration, repository state, backlog, agent, and locks. Use forgeo once for a foreground trial cycle or forgeo start to launch the background daemon. forgeo status reports counts, the next task, daemon state, and the last outcome; forgeo run --task TASK-012 immediately runs a specified OPEN task. Start the dashboard with forgeo web at http://0.0.0.0:8790; on a shared host, use forgeo web --token for bearer authentication. Control the daemon with forgeo stop and forgeo restart.

What are this agent's strengths and limitations?

Pros
  • The agent contract is limited to reading FORGEO_TASK, allowing Claude Code, Codex, aider, or a custom CLI instead of locking execution to one model provider.
  • Its auditable workflow covers one-at-a-time selection, dependency checks, schedules, task states, and Git commits.
  • It offers both direct integration and an optional REVIEW-branch path, so teams can choose between unattended throughput and human approval.
  • BLOCKED and FAILED states, retries, BLOCKER.md, and file-backlog recovery address several common unattended-run failure modes.
  • Multiple backlog providers, independently configured repositories, an aggregate dashboard, and optional Docker isolation broaden deployment choices.
Limitations
  • Adoption means granting an agent CLI permission to change a Git worktree and create commits; the default main-line workflow raises the cost of weak agent output or overly broad repository permissions.
  • Users must obtain, install, and configure their own coding-agent CLI; Forgeo does not supply a model service or document the agent's usage cost.
  • GitHub, GitLab, Jira, and remote HTTP backlogs add network, credential, and external-service configuration requirements.
  • In branch review mode, dependants remain blocked until a human merges the reviewed task, which can pause autonomous throughput.
  • Docker isolation requires an image containing both the agent CLI and sh; agents that need internet access also require changing the default no-network sandbox setting.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Stars Updated Language Full support on
Forgeo Software Factory This agent 76 · Some gaps ★ 30 4d ago Python Codex · Claude Code
amux Agent Control Plane 77 · Good ★ 492 1d ago Rust Codex · Claude Code
Smart Ralph 73 · Some gaps ★ 548 21d ago Shell Codex · Claude Code
Code Assistant 70 · Some gaps ★ 181 7d ago Rust Claude.ai · OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
Why not a higher tier: Trust & safety is 17/29, below the 18/29 needed for “Good”; the tier is lowered because risk is not averaged away.
76/ 100 5-point scale 3.8 / 5
Trust 17/29
Reliability 12/14
Adaptability 15/18
Convention 14/18
Effectiveness 12/13
Verifiability 6/8
Why each dimension lost points
Trust17 / 29 · 2.9/5

The evidence shows a Docker sandbox with networking disabled by default and read-only auxiliary mounts, plus optional review branches, file-backlog snapshots, a token directory, and token-protected web mode. The README also discloses major effects such as running an agent, modifying the repository, committing, and pushing. Deductions apply because the default workflow commits directly to main, human review is optional, host-mode agents retain repository write access, networking can be enabled, and the web console binds to 0.0.0.0 by default. Secrets can be forwarded through the agent environment, but redaction, rotation, and log-leak protections are not demonstrated. Dependencies use broad lower bounds, Actions are referenced by mutable major tags, and no lockfile, dependency audit, or supply-chain pinning is shown. Git history, review branches, and backlog.json.bak provide useful recovery, but comprehensive restoration of pushed code or remote issue-provider changes is not established. Licensing, repository links, and contributor attribution are clear, although ownership remains generic.

Reliability12 / 14 · 4.3/5

The README, package metadata, CI, and tests strongly agree on task selection, dependency blocking, scheduling, exit-code semantics, timeouts, process-tree cleanup, bounded output, and state persistence, justifying full self-consistency. Missing commands, unavailable Docker, timeouts, and nonzero exits receive explicit handling and messages, so failure messaging is also thorough. Dependency availability is adequate rather than complete: several installation paths and a Python-version CI matrix are supplied, and missing binaries are detected, but operation still depends on Git, an external agent CLI, optional Docker, and remote backlog services without a fully evidenced degradation or offline strategy.

Adaptability15 / 18 · 4.2/5

Developer audiences and routine scenarios are documented clearly, including daily commands, multiple repositories, file and remote backlog providers, interchangeable agent CLIs, and per-task overrides. Selection order, dependency eligibility, run_at priority, and lifecycle behavior are precisely constrained by documentation and tests, supporting a high trigger-precision score. Deductions apply because the boundary on what agents may edit or execute, the limits of idle refactoring, and remote-provider permission scope are not comprehensively stated. Python 3.11+, platform binaries, and Docker are addressed, but some behavior is POSIX- or Docker-dependent and no complete platform-limit matrix is included.

Convention14 / 18 · 3.9/5

The README has a clear progression through quickstart, daily operation, sandboxing, multi-repository use, and indexed topic documentation. Installation paths and development quality gates are concrete, while the MIT text agrees with package metadata. Naming is mostly stable across package, command, and documentation, but the package description contains the apparent phrase error “software forgeo,” and the project is classified Alpha. Examples are plentiful but there is no actual FAQ. Several limitations are disclosed indirectly, including shared-host authentication and sandbox/platform prerequisites, but there is no comprehensive known-limitations section. Version 1.12.1 and a release process extracting CHANGELOG.md are shown, yet the changelog itself is absent from the supplied evidence. An issue tracker and contributor attribution provide an update path, but named maintainers, support expectations, and responsibility are unclear.

Effectiveness12 / 13 · 4.6/5

Results are delivered through Git commits, task states, BLOCKER.md, persisted failure reasons and agent responses, logs, notifications, and a dashboard, making outputs directly usable in a development workflow. Scheduling, dependency handling, retries, isolation, and multi-provider synchronization offer substantial marginal value over manually invoking coding agents. Cost-benefit is reduced because periodic agent runs and idle refactoring can consume continuing compute or model budget, while direct commits and pushes may impose review and recovery costs; no budget controls, quota guidance, cost estimates, or resource ceilings are evidenced.

Verifiability6 / 8 · 3.8/5

Core claims are traceable across the README, package metadata, CI configuration, and focused tests covering scheduling, persistence, sandbox behavior, timeouts, and error mapping. Deductions apply because only part of the test suite and little core implementation are supplied, while the detailed documentation, CHANGELOG, and release-artifact verification are absent, limiting comprehensive cross-source corroboration. Promotional claims such as “handles failure gracefully” and “only interrupts you” are not consistently separated from verified behavior, design intent, and boundary conditions.

Risks and how to mitigate them
  • The default mode lets the agent modify the repository and commit or push directly to main; enable review branches, protection rules, and recoverable backups before using it on important repositories.
  • The web console listens on 0.0.0.0 by default. On shared or routable hosts, require the bearer token and add firewall or reverse-proxy restrictions where appropriate.
  • Environment variables and read-only credential mounts remain readable by the agent process and may be emitted in output; use least-privilege short-lived tokens and inspect logs and persisted agent_response data.
  • Dependencies and CI Actions are not precisely pinned, and the supplied material shows neither vulnerability scanning nor a lockfile; independently audit and pin the supply chain before deployment.
  • Idle refactoring and scheduled execution may create unexpected code changes and continuing model costs; constrain triggers, budgets, timeouts, and writable paths first.
Evidence confidence: Low Reviewed Sep 24, 2026 Reviewed revision bf18d58f77c7
See the full review method →

FAQ

Does Forgeo include a coding model or agent?
No. It schedules and records the work, but the operator supplies a CLI that reads FORGEO_TASK. The source explicitly mentions Claude Code, Codex, aider, and custom scripts.
Will it write directly to the main branch?
The normal workflow commits the agent's result to the main line. Teams needing approval can set review_mode: branch, which uses a branch such as forgeo/review/TASK-001 and leaves the task in REVIEW until a human merge.
What happens when an agent fails or needs a decision?
A failed run becomes FAILED and can use the configured retry policy. Work requiring human input becomes BLOCKED and records the issue in BLOCKER.md; Telegram and webhook notifications are also supported.
Is network access mandatory?
The local file-backed workflow does not document network access as mandatory, and Docker sandbox networking defaults to none. Pushes, OAuth login, notifications, and GitHub, GitLab, Jira, or HTTP backlog providers require the relevant network connectivity.
Is the web dashboard safe to expose on a shared host by default?
forgeo web listens on 0.0.0.0:8790 by default. The documented shared-host setup is forgeo web --token, which enables bearer authentication.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents