LoopForge is Tencent's open-source answer to a problem every team using coding agents hits within weeks: one agent fixes a bug brilliantly, the next one skips the tests, reviews its own code, and stops halfway without anyone noticing. It is a self-hosted workspace that turns coding agents into a repeatable delivery process — describe what you need in chat, and it opens a Docker sandbox, delegates the work to specialised roles, and opens a pull request, with human approval gates built in. It is free to download, runs on your own servers, and gained 737 GitHub stars in a single day. One catch: the README says MIT, but GitHub's own license field says the licence is unrecognised — and the reason is in the licence file itself.
What LoopForge actually is
LoopForge is a self-hosted workspace where a team ships software with coding agents. That is the project's own description, from its README, and it is worth unpacking because every word does work. "Self-hosted" means it runs on your infrastructure — your server, your Docker host, your network — not on Tencent's cloud and not as a hosted service you subscribe to. "Workspace" means it is a web application your team signs into, with projects, members, chat, and a record of every delivery. And "ships software with coding agents" means the agents are the workers, but LoopForge is the process around them: who does what, in which order, in which sandbox, with which checks, and who signs off.
The core idea is simple. You describe what you need to Main Bot in chat. Main Bot opens a Docker sandbox, checks out your repositories, delegates to project roles, and opens the pull request. When a way of working proves itself, you save it as an SOP — a standard workflow of agents, scripts and human gates — so the next requirement is delivered the same way, with review and approval built in. Both paths track the same requirements, so every change, whether made in chat or by an SOP, links back to what was asked for and counts toward delivery and cost reports.
The licence catch: README says MIT, GitHub says NOASSERTION
This is the first thing to get straight, because it is the one fact in this article that most coverage will get wrong. The README carries an "MIT License" badge, the introduction says the work runs "on your own infrastructure under the MIT license", and the Licence section at the bottom of the README reads "MIT". The repository also has a LICENSE file. So the licence is MIT — except GitHub's repository page lists the licence as "Other (NOASSERTION)", which is GitHub's way of saying its detector could not recognise the licence at all.
The reason is in the file itself. The LICENSE file does not contain the standard MIT licence text. It opens with a Tencent preamble — "Tencent is pleased to support the open source community by making LoopForge available" — followed by "Copyright (C) 2026 Tencent. All rights reserved", and then the sentence "LoopForge is licensed under MIT, except for the third-party components listed below, which remain licensed under their respective original terms." The familiar MIT permission and warranty paragraphs do follow, but the non-standard opening is enough for GitHub's detector to decline to classify it. The file was read directly from the repository on 16 November 2026 and runs to 52 lines.
What does that mean in practice? The project's intent is clearly MIT: the README says so three times and the file says "licensed under MIT". But a licence a machine cannot recognise is one a compliance check cannot clear automatically, and "All rights reserved" above the grant is wording that makes a legal review pause. If your company runs automated licence scanning, LoopForge will show up as unclassified until the project replaces the file with the canonical MIT text — a one-commit fix worth watching for. Until then, describe the licence honestly as "MIT as Tencent wrote it", not as a clean MIT grant.
How it works: Main Bot, SOPs, and human gates
There are two ways to work in LoopForge. In the first, you chat with Main Bot: type a request, mention a role, skill, requirement, SOP or repository with @, and pick the executor, model and permission mode per conversation. Main Bot opens a conversation workspace — a Docker sandbox with your repositories checked out — and calls project roles as subagents. You stay in control by queuing or steering messages mid-reply, and by pausing, resuming or taking over a running SOP from chat. The delivery is a pull request or merge request, or a direct merge into a shared branch.
In the second, you run an SOP. The engine runs Agent, Script, Human-gate and Sub-SOP nodes in order, each in its own sandbox, starting a step once its dependencies complete. You stay in control by approving at human gates, sending work back to a chosen step, or retrying or rerunning from any node. The delivery is documents, code or a pull request, plus per-node artifacts and logs.
The human gate is the feature that separates LoopForge from a raw agent run. A run pauses at a gate until someone checks the artifacts and approves, or sends the work back to a chosen step. All waiting gates land in a single "Needs review" inbox, and the run page shows live node status, tool traces, worker logs, per-node artifact snapshots and workspace previews. The README shows a run waiting at a gate with three actions: approve and continue, add context and rerun the step, or send the work back upstream. Nothing merges while a gate is waiting — that is the point.
LoopForge also ran one of its own deliveries as proof: four CodeBuddy roles planned a Python fix, implemented it, reviewed it independently and summarised the delivery; three real tests passed; the run waited for human approval, then verified the accepted code had not changed. The project links a reusable acceptance case and a validation record stating the scope and known gaps. That is the project's own validation, not an independent benchmark — but it is a real run with real tests, and the project publishes the gaps rather than hiding them.
Here is the whole flow at a glance:
The ten executors it orchestrates
LoopForge ships with ten coding-agent CLIs as executors. The list, from the README, is CodeBuddy, Codex, Claude Code, OpenCode, Cursor CLI, Antigravity, Kimi Code, Pi, DeepSeek Harness and ZCode. Built-in roles default to CodeBuddy, and every SOP role can choose its executor independently — so the planning role can run on one CLI and the review role on another, if that is how your team works.
Credentials work the way you would expect for a self-hosted tool: you bring your own. CodeBuddy takes a personal key, or a shared key an administrator configures. Codex and Claude Code take personal keys, and a connected execution machine can use its local login instead. OpenCode, Kimi Code, Pi, DeepSeek Harness, Cursor CLI and Antigravity take personal keys only. ZCode takes a personal key only and is not bundled — install it on the service or execution machine PATH yourself.
There is one asymmetry worth knowing before you plan a rollout. Requirement clarification, AI notification summaries, Bot replies and run evaluations currently use CodeBuddy, so their model pickers list CodeBuddy models only, and the server refuses a model of another CLI instead of switching it to CodeBuddy. Scheduled assistant tasks run on the CLI the task selects. And the seven agent CLIs after Claude Code keep their model and MCP configuration in a private home directory per run, so they always use the responsible user's own key and base URL from personal settings, even on a connected execution machine. In a team rollout, each member configures their own credentials.
| Executor | Credentials | Installation |
|---|---|---|
| CodeBuddy | Personal key, or a shared key an administrator configures | In the Docker image |
| Codex | Personal key; a connected execution machine can use its local login | In the Docker image |
| Claude Code | Personal key; a connected execution machine can use its local login | Installed from npm on first use, then cached |
| OpenCode · Kimi Code · Pi | Personal key only | Installed from npm on first use, then cached |
| DeepSeek Harness | Personal key only | In the Docker image |
| Cursor CLI · Antigravity | Personal key only | Provider installer on first chat use; not installed into SOP sandboxes |
| ZCode | Personal key only | Not bundled; install it on the service or execution machine PATH |
First-use installs need npm or provider access, and native deployments need the CLI for the executor you choose. That is a small detail with a real consequence: if your server has no outbound npm access, the CLIs that install on first use will not arrive, so plan the network rules before you promise the team ten executors.
What an SOP is — and why it matters more than the chat
An SOP is the workflow a delivery follows. Agents, scripts and people take part in the same run, and the SOP designer is a visual canvas where each step picks a role. There are five node types. An Agent node is a role — a prompt, executor, model, rules, Skills and MCP tools — that designs, implements, reviews or tests. A Script node is a deterministic shell step: build, test, lint, generate a report — no AI where AI is not needed. A Human gate pauses the run until someone checks the artifacts and approves, or sends the work back to a step. A Sub-SOP runs another SOP as a sub-workflow. A Preview build builds a static site and archives it for review.
Each node declares its artifacts and dependencies, and the engine starts a step once its dependencies complete. Failed checks can send the work back to an earlier step, and the designer supports validation, version history and publishing, so a workflow can evolve and be versioned like code. Start from a built-in SOP, adapt its roles, rules and environment to your project, and publish versions as it evolves.
Four SOPs ship built in: backend delivery, frontend delivery, bug fix, and product proposal. They are read-only blueprints — copy one into your project to run and edit it. The first SOP a team runs is usually a copy of the bug-fix one, and the first lesson is usually that the review role needs a stricter prompt than the implementation role. Planning, implementation, review and testing each get their own prompt, executor, model, rules, Skills and MCP tools, and a role works as an SOP node or as a subagent in chat.
Requirements are tracked end to end whether shipped by an SOP or straight from chat, with pull request and merge request status tracking, merge detection and direct-branch merges.
Quick start: three commands and a Docker host
Installing LoopForge is deliberately boring, and that is a compliment. Install Git and clone the repository first. The installer checks Docker, Compose, Python 3 and curl, and offers to install missing components — apt, dnf and yum on Linux, Homebrew on macOS, with the Compose plugin supporting x86_64 and arm64 and verifying the official release SHA-256. Ordinary Linux users are supported through Docker group access or sudo, and LOOPFORGE_YES=1 accepts the installation prompts.
git clone https://github.com/Tencent/LoopForge.git cd LoopForge ./start.sh
The start script pulls the GHCR release image pinned in compose.yaml without building locally. It creates the MySQL and platform services, generates configuration and session secrets, and installs the built-in sandboxes, starter SOPs and the welcome project. Host Go and Node.js installations are not required. Open the address printed by the installer and create your account; the first one becomes the administrator. The service listens on 0.0.0.0:8090 by default. On a cloud host, allow the port in your security group or put an HTTPS reverse proxy in front, and restrict access to your own IP until the administrator account exists.
Manage the installation with the same script: ./start.sh logs, stop, restart or pull, and ./start.sh dev to build the checkout from source. If downloads from ghcr.io stall, set MIRROR to a registry host that can stand in for it — the README names ghcr.nju.edu.cn as one such host — and the script pulls from that host and tags the image back to the pinned name. Setting MIRROR trusts that host, because the download is tagged with the official name, and the GitHub Release records the digest so you can verify it afterwards.
MIRROR=ghcr.nju.edu.cn ./start.sh
For GitLab, Gitea, Gogs and other Git hosts, set up Git SSH to check out and push branches with a personal key; pull request, merge request and issue automation needs a hosting API token or a separately configured MCP. To hack on LoopForge itself, bash scripts/dev.sh runs it natively — it needs Go 1.26.11 or newer.
Try it without an API key
The cheapest way to judge LoopForge is the demo project, and it costs nothing — no model key, no repository, no configuration. New accounts join the LoopForge demo project, which includes an SOP made only of a script and a human gate. Switch to the demo project, open Templates, and open "Platform check · script & approval". Click Run SOP. A real script writes a report, then the run waits for you at the approval step. Approve it from Needs review or the run page, and watch the run continue to its final artifact.
For real work, you need an API key for the selected executor to chat, generate documents or start a project, and model credentials plus a connected GitHub repository to change code and open a pull request. GitHub itself is optional: built-in SOPs run without a repository, product SOPs deliver documents, and new projects deliver source files in the task workspace. Bug fixes still need source code and reproduction details — no tool can fix a bug it cannot see.
LoopForge Local: the same workflows inside your own CLI
Do not want to run a server? LoopForge Local brings the built-in delivery workflows straight into the coding assistant you already use. Run the install command inside your target project — for Claude Code, npx -y loopforge-cli@latest install claude — then run /start-devflow "<your request>" in Claude Code. The npm package is loopforge-cli; the latest version on the registry on 16 November 2026 was 0.2.2.
# Run inside your target project, e.g. for Claude Code npx -y loopforge-cli@latest install claude
Local supports Claude Code, CodeBuddy, Codex and Cursor in Classic and Portable editions, and Pi, DeepSeek Harness and Hermes Agent in the Portable edition. It needs Node.js 20 or newer, Python 3.8 or newer, and a coding assistant. Local runs the built-in workflows today; exporting a platform SOP for standalone local execution is planned, so custom SOPs you design on the platform do not travel to Local yet. Evidence in Local is artifacts under artifacts/{task_slug}/, plus an optional local dashboard, rather than the platform's shared run details and approvals.
That split is the honest shape of the project today: the platform is the team product, Local is the solo-developer product, and they share the built-in workflows but not yet the custom ones. One developer inside an IDE or CLI should start with Local; a team that needs shared workspaces, approvals and history needs the platform.
Platform vs Local: which one to pick
| Platform | Local | |
|---|---|---|
| Best for | Teams sharing chat workspaces, SOPs, approvals and history | One developer inside an IDE or CLI |
| Needs | Docker + Python 3 | Node.js 20+, Python 3.8+ and a coding assistant |
| Workflows | Chat with Main Bot + custom SOPs on a visual canvas | Built-in Classic / Portable workflows |
| Evidence | Shared run details, approvals and metrics in the web workspace | Artifacts under artifacts/{task_slug}/ + optional local dashboard |
The decision is usually made by team size. A solo developer gets almost everything from Local — the same workflows, role separation and human gates, inside the assistant they already use, with no server to maintain. A team of three or more gets its value from the platform: shared requirements, a single Needs review inbox, token and cost accounting, and a versioned SOP library.
One practical note: the chat workbench is Chinese for now, while the management pages are in English and Chinese. If your team works in English, the SOP designer, run pages and approvals are usable — but the chat surface where Main Bot lives is Chinese at the time of writing. Check the current state before you promise the team a chat-first workflow in English.
What it costs: the software is free, the models are not
LoopForge itself costs nothing to download and run — the project is published under Tencent's stated MIT terms, there is no paid tier in the repository, and the demo project runs with no API key at all. What costs money is the model usage, and the README is blunt about it: model usage is not included; you bring your own credentials. Every agent step calls a language model you configured, and that provider bills you per token — or, in the case of a CLI with a subscription, through the subscription you already pay for.
That is the same cost shape as every other coding-agent tool, and the right shape for a self-hosted orchestrator: the platform does not sit between you and the model provider, so there is no markup and no second bill. What LoopForge adds is visibility — engineering metrics, business-domain reports with static HTML and SVG export, and token and cost accounting for SOPs and conversations at public list prices. In practice you can see, per requirement, what the planning role spent, what the review role spent, and what the whole delivery cost — the number a team lead needs when deciding whether an SOP is worth running on every requirement or only the risky ones.
The safety fine print: read this before you expose it
LoopForge is built for a trusted team, and the README says so more than once. In the default Compose installation, SOP runs and conversation workspaces both use Docker sandbox containers started through the host Docker socket. Docker socket access grants control of the host daemon, so this setup is for trusted teams — not untrusted multi-tenant isolation. A sandbox that can talk to the Docker socket can, in principle, reach the host. If you run LoopForge for people you do not trust, you need a different isolation design, and the README points to its deployment boundaries documentation for exactly that question.
Accounts and access carry the same warning. New installations listen on all interfaces, signed-in users can read project data across the instance, and teammates can sign up from the login page — turn that off with AGENTFLOW_ALLOW_SIGNUP=false in .env before exposing the instance beyond your team. Restrict access to your own IP until the administrator account exists, put an HTTPS reverse proxy in front, and do not open port 8090 to the internet on a default install.
LoopForge vs the alternatives
The README's FAQ answers the two comparisons everyone asks. Against Dify, n8n and Flowise, the answer is scope: those are general-purpose AI and automation workflow builders, while LoopForge is built for software delivery with coding agents — implementer and reviewer roles, Docker sandboxes with real repositories, GitHub delivery, human acceptance gates and run evidence. If your workflow is "summarise this inbox", LoopForge is the wrong tool and n8n is the right one. If it is "implement this feature, review it independently, run the tests, and wait for a human to approve the pull request", the general-purpose builders cannot express it and LoopForge can.
Against using Claude Code, Codex, CodeBuddy or another coding CLI directly, the answer is orchestration: LoopForge does not replace them. Each agent step and each chat turn runs one of those CLIs. LoopForge adds what surrounds the run — who does what, in which sandbox, in which order, with which checks, and who signs off. A single developer running one CLI in a terminal does not need that. A team that needs the same bug-fix flow to run the same way on the tenth requirement as it did on the first does.
There is a third comparison the README does not make, and it is worth making here because it is the closest relative on this site: Herdr, the tmux-based multiplexer that gives each coding agent its own terminal pane. Herdr organises agents on one machine; LoopForge organises agents into a delivery process with roles, gates and history. They solve different halves of the same problem — Herdr is about running many agents at once, LoopForge is about making sure what they produce is reviewed and approved. A team could reasonably use both, and neither replaces the other.
Who should use it — and who should skip it
LoopForge fits a team that already uses coding agents and has felt the specific pain it solves: inconsistent quality between runs, reviews that never happen, work that stops halfway with no record. If your team ships with CodeBuddy, Codex or Claude Code and wants the same delivery flow on every requirement — plan, implement, review independently, test, human approval, pull request — LoopForge gives you that flow as a versioned artifact instead of a habit that lives in one developer's head.
It also fits a solo developer who wants the built-in workflows without the server: install LoopForge Local into Claude Code, CodeBuddy, Codex or Cursor, run /start-devflow, and get the role separation and the human gate inside the assistant you already use. That is the lowest-friction way to try the idea, and it needs nothing more than Node.js 20, Python 3.8 and a coding assistant.
Skip it if you want a hosted product with support and an uptime promise — there is none, and you are the operator. Skip it if your team does not use coding agents yet; an orchestrator for agents you do not run is a process with no workers. Skip it if you need a general automation builder; Dify, n8n and Flowise are built for that. And if your company's licence policy cannot clear an unclassified NOASSERTION file, wait for the project to ship a canonical MIT licence file — the fix is one commit, but until it lands, the compliance answer is "not yet".
Verdict: a real orchestrator with one paperwork problem
LoopForge is the most concrete answer yet to what comes after "just ask the agent". A coding agent on its own is a brilliant, unreliable worker. LoopForge wraps it in the process a team already knows it needs — separate roles for planning, implementation, review and testing, deterministic script steps where AI is not needed, a human gate before anything merges, and a record of what was spent and delivered. It is self-hosted, supports ten executors, has a local mode for solo developers, and is growing fast: 2,313 stars on 16 November 2026, up 737 in a single day, on a repository created on 28 July 2026.
The licence is the one thing to fix before you bet a company process on it. The README says MIT three times and the licence file says "licensed under MIT" — but the file is not the standard MIT text, so GitHub reports it as unrecognised. That is almost certainly an oversight rather than a trap, and it is fixable in one commit. Until then, describe the licence as MIT as the project states it, unclassified by GitHub's detector. Everything else is ready to try today, and the demo project costs nothing — not even an API key.
Frequently Asked Questions
Is LoopForge really free?
The software is free to download and run — the project states MIT terms and there is no paid tier in the repository. Running it is not free: every agent step calls a language model you configured, and that provider bills you per token, or through the CLI subscription you already pay for. The demo project needs no API key at all, because it runs only a script and a human gate.
Is LoopForge actually MIT licensed?
As the project states it, yes: the README says MIT, and the LICENSE file says "LoopForge is licensed under MIT". But the file is not the standard MIT licence text — it opens with a Tencent preamble and an "All rights reserved" line — so GitHub's detector reports the licence as NOASSERTION (unrecognised). Until the project ships a canonical MIT file, describe the licence as "MIT as stated, unclassified by GitHub", and flag it to your compliance team if you adopt it inside a company.
Do I need GitHub to use it?
No. Chat, documents and new projects run in the task workspace, and all built-in generic SOPs run without a repository. Connect GitHub when you want to change an existing repository or open pull requests. GitLab, Gitea and Gogs work through Git SSH for checkout and push, with an API token or MCP for pull request and issue automation.
Which coding agents does it work with?
Ten CLIs: CodeBuddy, Codex, Claude Code, OpenCode, Cursor CLI, Antigravity, Kimi Code, Pi, DeepSeek Harness and ZCode. Built-in roles default to CodeBuddy, and each SOP role can pick its executor independently. LoopForge does not replace these CLIs — it orchestrates them, adding roles, sandboxes, checkpoints and approvals around their work.
Can I use it without running a server?
Yes — LoopForge Local installs the built-in workflows into the coding assistant you already use, with npx -y loopforge-cli@latest install claude for Claude Code, then /start-devflow "<your request>". It needs Node.js 20 or newer, Python 3.8 or newer, and a coding assistant. Custom platform SOPs cannot yet be exported for standalone local use — the project says that is planned.
Is it safe to expose on the internet?
Not on a default install. New installations listen on all interfaces, signed-in users can read project data across the instance, and open signup is on by default. The project targets a trusted team: put it behind an HTTPS reverse proxy, restrict access to your team's IPs or VPN, set AGENTFLOW_ALLOW_SIGNUP=false, and create the admin account first. Docker socket access gives the sandboxes control of the host daemon, so this setup is for trusted teams, not untrusted multi-tenant isolation.
Sources
- GitHub — Tencent/LoopForge (README, repository details, licence file, releases): https://github.com/Tencent/LoopForge — checked 16 November 2026; 2,313 stars, 357 forks, 10 watchers, 332 commits, 13 releases, created 28 July 2026, licence field Other (NOASSERTION)
- GitHub — LoopForge LICENSE file (Tencent preamble, "licensed under MIT", 52 lines): https://raw.githubusercontent.com/Tencent/LoopForge/main/LICENSE — checked 16 November 2026
- GitHub — LoopForge latest release v0.3.8: https://github.com/Tencent/LoopForge/releases/tag/v0.3.8 — checked 16 November 2026
- npm registry — loopforge-cli (latest version 0.2.2): https://registry.npmjs.org/loopforge-cli — checked 16 November 2026
Note on sources not linked: the npm package page for loopforge-cli (www.npmjs.com) returned 403 on two checks, so it is not linked — the version figure comes from the npm registry API instead, which returned 200. No URL has been guessed. Star and fork counts come from the GitHub repository page (crawled 16 November 2026, 22:41 UTC), because the GitHub API was rate-limited at the time of checking; the morning scan on the same day had recorded 1,576 stars and 279 forks, so the 737-star single-day gain is a same-day comparison against that scan.
Related reading: Herdr: tmux Built for AI Agents — Setup & Limits · Gemini API CLI: the Complete Guide · Claude Fable 5.2: Anthropic's New Model
Tools: asadwebs.com/tools — checked 16 November 2026: no fitting tool exists on the site for coding-agent orchestration or agent workflow management, so no tool is paired with this guide.




Be the first to share a useful question or thought.