Independent AI intelligence Two editions daily · ET
Fervor AI

Analysis · November 16, 2026 · repo

Tencent LoopForgemulti-agentagent-harnessclaude-codecodexagent-security

Tencent's LoopForge Puts a Sign-Off Step Between Your Coding Agent and Main

An open-source workspace that turns "ask the agent to fix it" into a repeatable workflow with reviewers, tests and a human approval gate, plus the setup step you should not skip.

Ask a coding agent to fix a bug twice and you can get two different processes. One run writes a plan and tests. The other skips both, reviews its own work and declares victory. Each run is a coin flip on how carefully the work was done, and nobody finds out until review.

That is fine for a weekend project. It is not how a team ships.

LoopForge, a self-hosted workspace from Tencent that showed at #9 on Trendshift's live daily board when we read it on the afternoon of November 16, is built around that complaint. Its README describes the same failure almost word for word: the agent "might skip the plan, forget the tests, review its own code, or stop halfway without anyone noticing."

Its answer is to stop treating each agent run as a one-off conversation. Once a way of working proves itself, you save it as an SOP, a standard operating procedure: a fixed sequence of agent steps, plain scripts and human approval gates that every future request goes through.

The shift is worth naming plainly: the process becomes the product, and the agent becomes a replaceable worker inside it.

What LoopForge is, in plain terms

LoopForge does not replace your coding agent. It wraps the ones you already use. The README lists ten coding-agent command-line tools it can drive, including Claude Code, Codex, CodeBuddy (Tencent's own coding agent), OpenCode, Cursor CLI and DeepSeek Harness. In its own FAQ: "LoopForge doesn't replace them; it orchestrates them."

What it adds is everything around the agent: who does what, in which sandbox, in which order, with which checks, and who signs off.

It is MIT-licensed, had about 2.3k stars on November 16, and its newest published release is v0.3.9-rc.1, a pre-release from November 13. That "rc" (release candidate) matters, and we will come back to it.

There are two ways to use it.

Chat with Main Bot. You describe a task in a chat window. LoopForge opens a Docker sandbox (an isolated container with your repositories checked out), hands parts of the job to project roles and opens a pull request (a proposed change that teammates review before it merges). This is for exploring and quick fixes.

Run an SOP. You pick a saved workflow, and the engine runs its steps in order, each in its own sandbox. This is for work you want done the same way every time.

Both paths link every change back to a tracked requirement, so a fix from chat and a fix from an SOP show up in the same delivery and cost reports.

The building blocks of an SOP

An SOP is made of nodes, and each node type does one job. The README lists five:

  • Agent: a role with its own prompt, coding agent, model, rules, skills and MCP tools. MCP, the Model Context Protocol, is the standard way agents connect to outside tools. One role plans, another implements, another reviews.
  • Script: "A deterministic shell step: build, test, lint, generate a report. No AI where AI is not needed."
  • Human gate: "Pauses the run until someone checks the artifacts and approves, or sends the work back to a step."
  • Sub-SOP: runs another SOP as a step.
  • Preview build: builds a static site and archives it for review.

The built-in bug-fix flow shows how these fit together: clarify, design, implement and review run as agent steps, testing runs as a script, and acceptance is a human gate that can send work back to implementation.

Two design choices here are worth copying even if you never install LoopForge.

Separate roles. The reviewer is a different role from the implementer, with its own prompt and possibly its own model. An agent reviewing its own diff tends to agree with itself.

Scripts where scripts work. Tests and linters do not need a language model. Running them as plain shell steps makes those checks cheap and identical every time.

What a gated run looks like

The README describes one delivery the team ran end to end. Four CodeBuddy roles planned a Python fix, implemented it, reviewed it independently and summarized the delivery. "Three real tests passed; the run waited for human approval, then verified the accepted code had not changed."

That last clause is the clever part. Approving work is only meaningful if the thing you approved is the thing that ships. LoopForge checks that the code did not change between your approval and delivery. The team links a validation record with its own scope and known gaps, so treat this as the project's evidence about its own tool, not an outside benchmark.

At a gate, you get three choices: approve and continue, add context and rerun the step, or send the work back to an earlier step. Every gate waiting on you lands in one "Needs review" inbox.

Put this into practice

You can see the gate in action without an API key. New accounts join a demo project with an SOP made only of a script and a human gate.

The platform needs Docker and Python 3. The installer checks for Docker, Compose, Python 3 and curl, and offers to install what is missing.

git clone https://github.com/Tencent/LoopForge.git
cd LoopForge
./start.sh

Before you open the page, read this. The service listens on 0.0.0.0:8090 by default, which means every network interface, not just your own machine. The first account created becomes the administrator. The deployment guide is direct about it: "Do not expose the first-account setup page to arbitrary Internet clients before the administrator account has been created."

A short lock-down checklist, all from that guide:

  • On a laptop, bind locally with LOOPFORGE_BIND=127.0.0.1.
  • On a cloud server, allow the port only from your own IP in the firewall (the cloud "security group") until you have created the admin account.
  • Before inviting anyone, put an HTTPS reverse proxy in front (a web server such as nginx that handles encryption and forwards traffic), then set AGENTFLOW_SECURE_COOKIES=true and keep AGENTFLOW_SESSION_SECRET stable across restarts.
  • Check self-signup. Per the guide it is on by default (AGENTFLOW_ALLOW_SIGNUP=true), so anyone who can reach the page can register after you. Off a private network, turn it off and invite people instead.

Then try the demo:

  1. Switch to the LoopForge demo project and open Templates.
  2. Open Platform check · script & approval and click Run SOP.
  3. A script writes a report, and the run stops at the approval step.
  4. Approve it from Needs review and watch it finish.

That five-minute run teaches the whole model. Real work needs an API key for the coding agent you pick, and changing an existing repository needs a connected GitHub account. Model usage is not included. You bring your own credentials.

Pin a version. The deployment guide says compose.yaml pins a specific image and that you should "check out a release tag when you install." Running from main gets you whatever is there today. For a team install, check out a tag you have read the notes for.

No server? Try LoopForge Local. If you work alone, the built-in delivery workflows can run inside your existing coding assistant. Run this inside your project for Claude Code:

npx -y loopforge-cli@latest install claude

Then run /start-devflow "<your request>" in Claude Code. The @latest tag pulls whatever version is newest, so for a shared setup, pin a version you have reviewed. Local needs Node.js 20+ and Python 3.8+, supports Claude Code, CodeBuddy, Codex and Cursor in its Classic edition, and saves artifacts under artifacts/{task_slug}/. It runs the built-in workflows only for now; exporting your own platform SOPs to Local is listed as planned.

Honest limitations

It is a pre-release. v0.3.9-rc.1 is marked "Pre-release" on GitHub. Its notes include security fixes such as confining agent CLI config writes to the home directory and keeping credentials out of repository clone URLs. Good fixes, and a sign the project is still hardening.

The defaults assume a trusted network. The FAQ says new installs "listen on all interfaces and target a trusted team." The gate protects your main branch. It does nothing if the wrong person creates the first account.

The chat side is Chinese for now. Management pages are in English and Chinese, but the README says "the chat workbench is Chinese for now." English-only teams can still use SOPs, but chat with Main Bot will be harder.

Not every agent is in the box. The production Docker image bundles CodeBuddy, Codex and DeepSeek Harness. According to the deployment guide, Claude Code, OpenCode, Kimi Code and Pi install from a button after a missing-CLI failure (and on first use in SOP sandboxes), while Cursor CLI and Antigravity use their providers' own installers.

Gates cost time. A human gate is a person's attention on every run. Put gates where a mistake is expensive, like merging to a shared branch, and let scripts handle the rest.

The evidence is the project's own. The four-role demo and validation record come from the LoopForge team.

The real shift

Most talk about coding agents is about which model writes better code. LoopForge bets on a different question: what process should every agent run go through, and where does a person sign off?

That question survives model upgrades. Today's reviewer role might run on one model and next quarter's on another, while the SOP, the scripts and the gate stay the same.

You do not need LoopForge to start. Write down the steps your best agent run actually followed. Make the tests a script. Make review a separate role. Put one human approval right before anything touches main, your shared production branch. Then decide whether you want a tool to enforce it.

Sources: Tencent/LoopForge README and deployment guide (main branch, read November 16, 2026); v0.3.9-rc.1 release notes (pre-release, November 13, 2026); Trendshift daily board (read about 15:15 ET, November 16, 2026); star count from shields.io, November 16, 2026.