LoopForge: Deliver software by orchestrating CodeBuddy and other coding agents with SOPs
A self-hosted workspace for software teams that puts Codex and other CLIs into traceable, approval-based SOPs.
GitHub Tencent/LoopForge Updated 2026-11-15 Branch main Stars 913 Forks 211
Go JavaScript Python Coding-agent delivery Docker GitHub SOP

🧭 Decision Guide

Try it if you

  • You want Codex, Claude Code, or CodeBuddy to execute planning, implementation, review, and testing through a fixed SOP.
    The README sections “Why LoopForge” and “Separated roles” state that these stages can have separate roles, executors, models, and tools.
  • Your team needs to work on real repositories in Docker sandboxes and add a Human gate before PR/MR delivery.
    The README “Features” sections “Conversation workspaces,” “Requirement → delivery,” and “Runs & approvals.”
  • You want a self-hosted deployment and can provide Docker, GitHub authorization, and a model API key.
    The README “Quick start” says the service runs on your own infrastructure and requires model API keys and GitHub authorization after startup.
  • You have stabilized a delivery method and want every requirement to reuse the same checks and review steps.
    The README FAQ “Should I use chat or an SOP?” recommends putting fixed reviewers, tests, and sign-off into an SOP.

Skip it if you

  • You only want to use Claude Code, Codex, or CodeBuddy directly and do not need role orchestration, sandboxes, or approvals.
    The README FAQ says LoopForge does not replace these CLIs; it orchestrates them.
  • Your environment cannot run Docker and you cannot use the README's connected local execution machine alternative.
    The README “Quick start” requires Docker; “Execution environments” additionally lists a connected local execution machine.
  • You cannot configure HTTPS and access controls when exposing the service to the internet.
    The README FAQ “Is it safe to expose on the internet?” requires reading the access model and configuring HTTPS before internet exposure.
  • You need complete chat and agent execution without external model credentials.
    The README FAQ says the demo SOP needs no API key, but chat and agent steps require a key for the selected executor.

Requirements

  • Install Git first; the installer checks Docker, Compose, Python 3, and curl.
  • Package and image downloads require internet access.
  • macOS needs working Python 3 and Docker Desktop.
  • Ordinary Linux users need Docker group access or sudo.
  • Configure model API keys and GitHub authorization after startup.
  • The service listens on 0.0.0.0:8090 by default; cloud hosts need the security-group port allowed or an HTTPS reverse proxy configured.

First step (verbatim from README)

git clone https://github.com/Tencent/LoopForge.git

Watch out

  • When ghcr.io downloads stall, MIRROR is trusted and the image is retagged with the official name pinned in compose.yaml.
    The README “Quick start” explanation of MIRROR.
  • Docker registry-mirrors only accelerate Docker Hub and must not be used as the value of MIRROR.
    The README “Quick start” explicitly distinguishes registry-mirrors from MIRROR.
  • The first account created becomes the administrator; access should be restricted to your own IP before that account exists.
    The README “Quick start” says the first account is the administrator and recommends restricting access before administrator creation.
  • Built-in backend, frontend, bug-fix, and product SOPs are read-only blueprints and must be copied into a project before they can be run or edited.
    The README “Features” statement about Built-in SOPs.
  • The chat workbench is currently Chinese, while management pages support English and Chinese.
    The README “Team-ready” language statement.

Alternatives

  • Use Claude Code, Codex, or CodeBuddy directly:Better when you only need a single coding-agent CLI to execute tasks and do not need LoopForge's SOPs, Docker sandboxes, or Human gates.
    README FAQ: How is this different from using Claude Code, Codex, CodeBuddy or another coding CLI directly?
  • Dify, n8n, or Flowise:Better when you need general-purpose AI or automation workflows rather than coding-agent delivery around real repositories and PR/MR workflows.
    README FAQ: How is this different from Dify, n8n or Flowise?

Not stated in the README

  • The README does not specify minimum CPU, memory, or disk requirements for Docker, MySQL, or platform services.
  • The README does not provide a version-compatibility matrix for the 10 executors, including CodeBuddy, Codex, and Claude Code.
  • The README does not specify model API-key providers, pricing, or the supported-model list.
  • The README does not explain MySQL data migration, backup, or rollback procedures during upgrades.
  • The README does not fully describe the account access model, permission granularity, or multi-tenant boundaries.
  • Repository metadata lists the license as Other while the README states MIT; the final license file and scope should be verified.

💡 Deep Analysis

6
No I only want to generate a one-off script quickly with Cursor CLI or Claude Code. I do not need Docker, SOPs, PRs/MRs, or human approval. Is LoopForge worth deploying?
For: A lightweight developer who only wants one-off code generation with Cursor CLI or Claude Code and does not need Docker, Git delivery, or human review

No. LoopForge’s value is in self-hosted software delivery orchestration, not in replacing Cursor CLI or Claude Code for one-off code generation.

  • The README describes a self-hosted workspace where Main Bot opens a Docker sandbox, checks out a repository, delegates to project roles, and opens a PR. Those steps add complexity for a one-off script.
  • “Why LoopForge” emphasizes repeatable SOPs, separated roles, human approval, and observable, resumable execution—capabilities your stated workflow does not require.
  • Quick start requires Git, Docker, Compose, Python 3, and curl, and creates MySQL and platform services. This is not the lightweight path of a standalone CLI.
  • The project insight explicitly says it is not suited to users who only want one-off code completion, lightweight script generation, or a platform requiring no operations.

Deployment becomes more defensible only if your needs expand to repository checkout, testing, review, branch delivery, or recoverable multi-stage execution.

  • Project description: "Self-hosted workflows for coding-agent delivery"
  • README introduction: "it opens a Docker sandbox, checks out your repositories ... and opens the PR"
  • Why LoopForge: "Repeatable," "Separated roles," "Human in the loop," and "Observable and resumable"
  • Quick start: the installer checks "Docker, Compose, Python 3 and curl" and creates "MySQL and platform services"
  • Project insight: not suited to one-off code completion, lightweight script generation, or users wanting no operations
Not stated in the README:The README does not provide a minimal path that uses LoopForge Local with an existing Cursor CLI or Claude Code without deploying the full platform.;The README does not quantify the CPU, memory, or disk overhead of the platform compared with a single CLI.
Yes We already use Claude Code, Codex, and CodeBuddy, but each requirement currently depends on one conversation and often misses testing or code review. If our team also needs human approval, is LoopForge a good fit?
For: A software delivery team already using Claude Code, Codex, or CodeBuddy that wants to turn planning, implementation, testing, and review into repeatable SOPs

Yes, because LoopForge is designed to orchestrate the planning, testing, review, and approval steps around coding-agent CLIs.

  • In “Why LoopForge,” planning, implementation, review, and testing can use separate roles, each with its own executor, model, rules, Skills, and MCP tools.
  • “SOP designer” provides Agent, Script, Human gate, Sub-SOP, and Preview nodes, plus rework-on-failure edges, version history, and publishing.
  • “Runs & approvals” records node status, tool traces, worker logs, and artifact snapshots. Reviewers can approve a gate or send work back to a selected step.

LoopForge therefore complements rather than replaces Claude Code, Codex, or CodeBuddy. You still need to supply model credentials and Git permissions, and the quality and availability of the external CLIs remain dependencies.

  • Why LoopForge: "Separated roles. Planning, implementation, review and testing each get their own prompt, executor, model, rules, Skills and MCP tools."
  • SOP designer: "Agent, Script, Human gate, Sub-SOP and Preview nodes"
  • Runs & approvals: "Live node status, tool traces, worker logs, per-node artifact snapshots"
  • Project data: topics include agent-orchestration, human-on-the-loop, and sdlc
git clone https://github.com/Tencent/LoopForge.git
cd LoopForge
./start.sh
Not stated in the README:The README does not provide a compatibility matrix for specific coding-agent CLI versions.;The README does not quantify the maximum concurrent tasks or Worker resources supported by an SOP.
Yes I already have Python 3 and Docker Desktop on macOS, but I do not yet have a model API key. Can I run LoopForge’s no-key demo first to decide whether it is worth connecting a real repository?
For: A developer on macOS with Docker Desktop and Python 3 who wants to try LoopForge without an API key before connecting a real model

Yes. The README explicitly provides a script-plus-human-approval demo that does not require an API key, and the macOS prerequisites are Python 3 and a working Docker Desktop installation.

  • Quick start says the installer checks Docker, Compose, Python 3, and curl. On macOS, working Python 3 and Docker Desktop are required; Go and Node.js on the host are not required.
  • The README includes a “Try it without an API key” section, and the project insight states that this demo validates deployment, accounts, and the basic workflow.
  • After startup, you can create an account and use the built-in sandboxes, starter SOPs, and welcome project. Real work then requires model API keys, GitHub authorization, and repository configuration.
  • Built-in SOPs are read-only blueprints and must be copied into a project before they can be run and edited.

This is suitable for validating installation and approval flows, but the no-key demo cannot represent real model quality, token cost, or repository delivery behavior.

  • Quick start: "macOS needs a working Python 3 and Docker Desktop"
  • Quick start: "Host Go and Node.js installations are not required"
  • README section: "Try it without an API key"
  • Quick start: "installs the built-in sandboxes, starter SOPs and welcome project"
  • Features: "Built-in SOPs are read-only blueprints; copy one into your project to run and edit it."
git clone https://github.com/Tencent/LoopForge.git
cd LoopForge
./start.sh
Not stated in the README:The README does not specify which nodes and scripts are covered by the no-key demo.;The README does not state whether the demo creates or modifies content in an external Git repository.
Yes We require repositories, model API keys, execution environments, and run records to remain on our infrastructure, with human approval before production release. Is LoopForge more suitable than using a cloud coding-agent service directly?
For: A software organization that wants to run agents on its own servers with its own model credentials and repositories, while requiring human approval for high-risk delivery

Yes, but LoopForge is a self-hosted control layer, not an out-of-the-box enterprise security platform. The organization still owns network, credential, and permission governance.

  • The README describes LoopForge as a self-hosted workspace. It supports Docker sandboxes or an organization’s own machine as the runtime, while coding CLIs and models are supplied by the user.
  • “Human in the loop” provides approval gates at important stages; a reviewer can approve or return work to a selected step, which fits a pre-release control.
  • Quick start says the service listens on 0.0.0.0:8090 by default and recommends restricting access and placing an HTTPS reverse proxy in front for public deployment.
  • The platform includes password accounts, projects, members, OpenAPI, and MCP APIs, but users remain responsible for Git credentials, model keys, sandbox isolation, backups, and upgrades.

It is therefore a strong fit for data and runtime ownership. However, the README does not establish that it provides vendor-managed compliance certifications, enterprise IAM, or complete secret management.

  • Project description: "Self-hosted workflows for coding-agent delivery"
  • Why LoopForge: "Your stack, your servers" and "Docker sandboxes or your own machine as the runtime"
  • Why LoopForge: "Human in the loop. Approval gates where they matter."
  • Quick start: "The service listens on 0.0.0.0:8090 by default" and "put an HTTPS reverse proxy in front"
  • Project insight: self-hosting does not automatically provide enterprise-grade security
git clone https://github.com/Tencent/LoopForge.git
cd LoopForge
./start.sh
Not stated in the README:The README does not document SSO, LDAP, OIDC, fine-grained RBAC, or audit-export capabilities.;The README does not document formal backup, disaster-recovery, key-rotation, or security-response procedures.
Yes We already have backend, frontend, and bug-fix SOPs. We want scheduled agent tasks with full workspace and MCP access, plus token-cost and engineering metrics. Is LoopForge suitable for this automation layer?
For: An engineering manager with backend, frontend, and bug-fix processes who wants to schedule recurring agent tasks and measure cost and engineering impact

Yes. LoopForge provides scheduled dispatch, SOP reuse, MCP access, and cost analysis as product capabilities, although the organization remains responsible for resource usage and workflow maintenance.

  • “AI scheduled tasks” supports recurring agent tasks with full workspace, SOP, and MCP access. It also provides versioned, parameterized task templates and automatic SOP dispatch for new requirements.
  • “Insights & cost” provides engineering metrics, business-domain reports, static HTML/SVG export, and token/cost accounting for SOPs and conversations.
  • Built-in SOPs cover backend, frontend, bug-fix, and product work, but they are read-only blueprints and must be copied into a project before running and editing.
  • The project insight warns that multiple agents, models, and MCP tools increase token consumption, execution time, and concurrent resource demand; the platform still depends on external CLIs and model services.

It is therefore suitable for fixed, measurable recurring work. Metrics and cost reports should not be treated as proof that generated code is correct; testing, review, and human approval remain workflow responsibilities.

  • Features: “AI scheduled tasks” supports “Recurring agent tasks with full workspace, SOP and MCP access”
  • Features: “Insights & cost” provides “Engineering metrics” and “token/cost accounting”
  • Features: “Built-in backend, frontend, bug-fix and product SOPs”
  • Project insight: multiple agents, models, and MCP tools increase token consumption, execution time, and concurrent resource demand
git clone https://github.com/Tencent/LoopForge.git
cd LoopForge
./start.sh
Not stated in the README:The README does not specify the minimum schedule interval, concurrency limits, or automatic retry policy for scheduled tasks.;The README does not define the engineering metrics, data-retention period, or report-calculation methodology.
It depends Our code is hosted on GitLab and Gitea. Agents must check out repositories in Docker sandboxes, push branches, and track PRs/MRs. Can LoopForge meet these delivery constraints?
For: A software engineering team maintaining GitHub, GitLab, or Gitea repositories and requiring agents to deliver branches and PRs/MRs from Docker sandboxes

It depends. LoopForge’s delivery model matches these requirements, but Git-host authorization and PR/MR automation require additional configuration; creating a LoopForge account alone is not sufficient.

  • The Quick start says Main Bot opens a Docker sandbox, checks out repositories, and opens the PR.
  • “Requirement → delivery” tracks requirements, branches, PR/MR status, merge detection, and direct-branch merges.
  • For GitLab, Gitea, Gogs, and other non-GitHub hosts, the README requires Git SSH setup. PR/MR and Issue automation additionally require a hosting API token or a separately configured MCP.
  • “Execution environments” supports platform Workers, Docker sandboxes, and a connected local execution machine.

Thus, the fit is good if the team can provide SSH keys, API tokens, or MCP integration. If branch-push or hosting API permissions are unavailable, the end-to-end delivery loop will be limited. The README does not document detailed feature differences between Git hosts.

  • Quick start: "it opens a Docker sandbox, checks out your repositories ... and opens the PR"
  • Requirement → delivery: "PR/MR status tracking, merge detection and direct-branch merges"
  • Quick start: "For GitLab, Gitea, Gogs and other Git hosts, set up Git SSH"
  • Quick start: "PR/MR and Issue automation requires a hosting API token or a separately configured MCP"
git clone https://github.com/Tencent/LoopForge.git
cd LoopForge
./start.sh
Not stated in the README:The README does not specify feature differences between GitLab, Gitea, and GitHub for PR/MR, Issue, and merge detection.;The README does not define the Docker sandbox boundaries for privileged operations, internal-service access, or custom network policies.

✨ Highlights

  • Supports 10 coding-agent CLIs including CodeBuddy, Codex, and Claude Code
  • SOPs include Agent, Script, Human gate, and Sub-SOP nodes
  • Docker sandboxes centralize node status, logs, and tool traces
  • Supports human approval, failure retries, and reruns from any node
  • The latest release is still LoopForge v0.3.9-rc.1

🔧 Engineering

  • Main Bot checks out repositories in Docker sandboxes and delegates to project roles
  • The SOP designer supports version history, publishing, and rework-on-failure edges
  • The Runs page provides node status, worker logs, and artifact snapshots
  • Requirement flows track PR/MR status, merge detection, and direct-branch merges

⚠️ Risks

  • Quick start depends on Docker, Compose, Python 3, curl, and network downloads
  • New installations listen on 0.0.0.0:8090; the README requires HTTPS before internet exposure
  • Chat and agent steps require the selected executor's API key; model usage is not included
  • Repository metadata says Other for the license, while the README states MIT license

👥 For who?

  • Software delivery teams needing fixed review, testing, and sign-off workflows
  • Engineering teams already using Codex, Claude Code, or CodeBuddy
  • Teams with Docker and GitHub repositories seeking a self-hosted execution environment
  • Multi-role teams needing PR/MR tracking, human gates, and run evidence