Field SOP
Field SOP

LoopForge: Human Gates Guard Your Agent Pipeline

Once a coding agent is wired into a delivery flow, the hard question is rarely whether the model is strong enough. It is whether anyone can say, precisely, who has to sign off, and at which

Published November 17, 20269 min read
<!-- loopforge-self-hosted-agent-workflow-sop | sop | LoopForge: Human Gates Guard Your Agent Pipeline -->

Once a coding agent is wired into a delivery flow, the hard question is rarely whether the model is strong enough. It is whether anyone can say, precisely, who has to sign off, and at which moment. Tencent/LoopForge turns that answer into a pipeline feature: an agent's submission does not land directly; it stops at a Human gate, where a person checks the artifacts, approves, or sends the work back to an earlier step. The repository lives at Tencent/LoopForge — plain address https://github.com/Tencent/LoopForge — and is written in Go. As of November 16, 2026, the GitHub API reports 1610 stars and 282 forks; the repository was created in late July 2026 and has been shipping releases back to back through November 2026, with v0.3.9-rc.1 (2026-11-13) and v0.3.8 (2026-11-12). The official positioning, verbatim: "Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates." In one sentence, it does not promise a stronger model; it encodes who must sign, and when, into the process itself — Human Gates Guard Your Agent Pipeline is a literal description. This SOP stays inside what the official README, docs and LICENSE can verify. Performance baselines, team-size limits and security audit reports are not published, and none are supplied here.

Two ways to work

After installation you can take the Chat with Main Bot route: in a conversation workspace, roles act as subagents on call, with sandboxes provided by Docker. Or you take Run an SOP: an engine walks a delivery flow node by node, each step in its own sandbox, with checkpoints and sign-off points written in advance. Both paths track the same requirements and both feed the delivery and cost reports, so the choice is whether this particular delivery needs fixed sign-off points. This post focuses on the second route, because a human gate only becomes a gate once the work is flow-shaped.

Five node types, one by one

An SOP in LoopForge is built from five node types. The official table is copied verbatim, one type at a time.

Agent: "A role (prompt, executor, model, rules, Skills and MCP tools) that designs, implements, reviews or tests." A role bundles a prompt, an executor, a model, rules, Skills and MCP tools, and owns one kind of work.

Script: "A deterministic shell step: build, test, lint, generate a report. No AI where AI is not needed." The second sentence deserves its own line: No AI where AI is not needed. It is the only outright value statement in the node table, and it sits on the Script row, not the Agent row.

Human gate: "Pauses the run until someone checks the artifacts and approves, or sends the work back to a step." This is the pivot of this post: the agent's submission stops at exactly this node type.

Sub-SOP: "Runs another SOP as a sub-workflow." Long flows can be layered.

Preview build: "Builds a static site and archives it for review." A static site is built and archived for review.

Scheduling follows one official sentence: "Each node declares its artifacts and dependencies, and the engine starts each step once its dependencies complete." The SOP designer also supports rework-on-failure edges, so a failed check can send work back to an earlier step instead of leaving it parked at an error. Read all five types together and you notice there is no node called "the agent finishes everything by itself". On the contrary, Script fences off the places where AI is unnecessary, and Human gate locks down the places where a signature is mandatory.

Role separation and ten CLIs

The agent that writes the code does not review its own code — in LoopForge this is structural, not aspirational. Verbatim: "Planning, implementation, review and testing each get their own prompt, executor, model, rules, Skills and MCP tools." The reviewer and the implementer are different configurations by default, and merging them into one agent is an explicit change you make, not a default that happens to you.

The executor menu is a list of ten CLIs, verbatim: "CodeBuddy, Codex, Claude Code, OpenCode, Cursor CLI, Antigravity, Kimi Code, Pi, DeepSeek Harness and ZCode." Each SOP role picks its own executor, and built-in roles default to CodeBuddy. Installation differs per CLI: CodeBuddy and DeepSeek Harness are built into the image; Claude Code, OpenCode, Kimi Code and Pi install from npm on first use and are cached; Cursor CLI and Antigravity are installed by a provider installer at first chat and stay out of SOP sandboxes; ZCode is not bundled and is expected on the service or execution machine's PATH.

Credential isolation, verbatim: "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." In practice, when rolling them out to a team, each member configures their own credentials. Two fixed rules round this out: requirements clarification, AI notification summaries, bot replies and run evaluation currently use CodeBuddy, and the server rejects models from other CLIs rather than switching automatically.

The official recorded run

The README includes a full walkthrough. Flag it first: this is an officially self-reported record, not an independent benchmark. Verbatim: "A delivery we actually ran: 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." Unpacked: four roles, a Python fix, three passing tests, a pause for human approval, and a post-approval check that the accepted code had not changed. That last step is the most interesting one. Approval is followed by a verification that the code did not change, meaning "what the person approved" and "what actually lands" are matched by the engine, not by trust. The project also ships a reproducible artifact, e2e/api/45-delivery-model.test.mjs, with scope and known gaps documented in docs/validation.md. For a self-hosted tool, handing you a test file you can run yourself is worth more than any slogan.

Deploying from zero: seven steps

The official deployment path is complete enough to follow directly, one step at a time.

  1. Clone: git clone https://github.com/Tencent/LoopForge.git, then cd LoopForge.
  2. Start: run ./start.sh. Per the official text it pulls the GHCR release image pinned in compose.yaml without building locally, creates MySQL and the platform services, generates configuration and session secrets, and installs the built-in sandbox, starter SOPs and a welcome project; the host needs neither Go nor Node.js. The installer checks Docker, Compose, Python 3 and curl, prompting for anything missing, and verifies the Compose plugin against the official SHA-256. Set LOOPFORGE_YES=1 to skip interactive confirmation. Afterwards manage the stack with ./start.sh logs, stop, restart and pull; source-level development goes through ./start.sh dev.
  3. Create the admin: the service listens on 0.0.0.0:8090 by default, and the first registered account becomes the administrator. On cloud hosts the installer reads the public IP from the vendor metadata service; before the admin account exists, the official advice is to allow only your own IP.
  4. Try the demo: no API key required. The demo project ships a "Platform check · script & approval" SOP containing only a script node and a human gate, which is the theme of this post in miniature.
  5. Configure credentials: for real deliveries, set each CLI's personal key and Base URL in the platform settings, one set per role, following the isolation rules above.
  6. Connect GitHub: optional. A built-in OAuth App device-code flow means no manual PAT is needed, and manual PATs still work; GitLab, Gitea and Gogs go through Git SSH.
  7. Run the first SOP: built-in backend, frontend, bug-fix and product SOPs exist, verbatim "Start from built-in backend, frontend, bug-fix and product SOPs." They are read-only blueprints; copy them into your project to run or modify them.

Security boundaries, quote by quote

This section is the core of the post. Every claim below is an official sentence, neither dramatized nor softened.

First, the sandbox starts from the host's Docker socket. Verbatim: "In the default Compose installation, SOP runs and conversation workspaces both use Docker sandbox containers started through the host Docker socket." The boundary judgment is also official: "Docker socket access grants control of the host daemon, so this setup is for trusted teams, not untrusted multi-tenant isolation." If you plan to run this as a public multi-tenant service, the official text says it is not that; do not widen the line on your own.

Second, new installations listen on all interfaces, and signed-in users can read across the instance. Verbatim: "New installations listen on all interfaces (existing bind settings are kept) and are designed for a trusted team: signed-in users can read project data across the instance, and teammates can sign up from the login page (AGENTFLOW_ALLOW_SIGNUP=false in .env turns that off)." The official FAQ repeats the same instruction: "Read the account and access model and set up HTTPS before opening it up." Before exposing the service more widely, read the account and access model documentation and put HTTPS in front.

Third, vulnerability reports go through the private channel in SECURITY.md, not public issues.

Put together, the conclusion is neither "absolutely safe" nor "unusable"; it is the line the project itself draws: a self-hosted tool for teams that trust each other, where network exposure, account registration and HTTPS hardening are the deployer's own checklist.

MIRROR and digest verification

Pulling from GHCR often requires a mirror, and LoopForge ships a MIRROR mechanism while keeping the trust question in plain sight. Verbatim: "Setting MIRROR trusts that host, because the download is tagged with the official name." The GitHub Release records the digest; after pulling, check that the digest after the @ sign matches what the Release page recorded.

text
docker image inspect --format '{{index .RepoDigests 0}}' ghcr.io/tencent/loopforge:<pin>

The documented example is MIRROR=ghcr.nju.edu.cn ./start.sh. One distinction worth keeping: Docker's own registry-mirrors setting (such as docker.nju.edu.cn) only accelerates Docker Hub and does not act as LoopForge's MIRROR; the names look alike, the objects differ.

Licensing: three readings, all reported

Licensing is where LoopForge shows three faces, and this post reports all three rather than picking one. First, the README badge and License section say MIT, verbatim: "MIT. Third-party components keep their own licenses and notices; see THIRD_PARTY_NOTICES.md." Second, the LICENSE file is a Tencent open-source statement, verbatim: "LoopForge is licensed under MIT, except for the third-party components." That is, MIT with third-party components keeping their own licenses. Third, GitHub's automated license detection returns NOASSERTION because of the additional statements in the file. All three coexist and all three belong in an honest summary: not just "MIT", and not a leap from NOASSERTION to "not open source"; the detailed notices live in THIRD_PARTY_NOTICES.md.

LoopForge Local

Besides the self-hosted platform there is a local route: LoopForge Local. Install with npx -y loopforge-cli@latest install claude, then run /start-devflow "<request>" inside Claude Code. The support matrix: Claude Code, CodeBuddy, Codex and Cursor ship in both Classic and Portable editions; Pi, DeepSeek Harness and Hermes Agent ship Portable editions. Requirements are Node.js 20+, Python 3.8+ and one coding assistant; evidence lands in artifacts/{task_slug}/. Exporting a platform SOP for standalone local execution is officially marked planned and not yet shipped, so this post reports it as unannounced and waits for the official release.

FAQ

Q1: Does LoopForge pick the strongest model for me? A1: No. It is not in the model business; it orchestrates. Ten CLIs from CodeBuddy to ZCode are selectable executors, each SOP role chooses its own, and built-in roles default to CodeBuddy. What it governs is who does what, in which sandbox, in which order, through which checks, and who signs off.

Q2: Can I try it without an API key? A2: Yes. The demo project's "Platform check · script & approval" SOP contains only a script node and a human gate, needs no model key, and runs right after deployment — exactly enough to watch a Human gate pause, approve and send work back.

Q3: What security points matter before deployment? A3: Three. The default install starts sandboxes through the host Docker socket, and Docker socket access equals control of the host daemon, so it fits trusted teams only; new installs listen on 0.0.0.0:8090 across all interfaces and signed-in users can read all project data in the instance; the login page allows open sign-up until you set AGENTFLOW_ALLOW_SIGNUP=false in .env, and you should read the account and access model and add HTTPS before exposing the service.

Q4: Is pulling images through a mirror safe? A4: The official wording is blunt: setting MIRROR means trusting that host, because the image is re-tagged with the official name. If you use a mirror, verify with the digest recorded on the GitHub Release; the docker image inspect output must match what follows the @ sign.

Q5: Is LoopForge MIT licensed? A5: Read it in three places. The README badge and License section say MIT; the LICENSE file is a statement that grants MIT except for the third-party components; GitHub's automated detection reports NOASSERTION. The three values coexist as fact, and the details live in THIRD_PARTY_NOTICES.md.

Related reading

This article is AI-assisted and human-edited. Last updated: 2026-11-17

FAQ

Does LoopForge pick the strongest model for me?
No. It is not in the model business; it orchestrates. Ten CLIs from CodeBuddy to ZCode are selectable executors, each SOP role chooses its own, and built-in roles default to CodeBuddy. What it governs is who does what, in which sandbox, in which order, through which checks, and who signs off.
Can I try it without an API key?
Yes. The demo project's "Platform check · script & approval" SOP contains only a script node and a human gate, needs no model key, and runs right after deployment — exactly enough to watch a Human gate pause, approve and send work back.
What security points matter before deployment?
Three. The default install starts sandboxes through the host Docker socket, and Docker socket access equals control of the host daemon, so it fits trusted teams only; new installs listen on 0.0.0.0:8090 across all interfaces and signed-in users can read all project data in the instance; the login page allows open sign-up until you set AGENTFLOW_ALLOW_SIGNUP=false in .env, and you should read the account and access model and add HTTPS before exposing the service.
Is pulling images through a mirror safe?
The official wording is blunt: setting MIRROR means trusting that host, because the image is re-tagged with the official name. If you use a mirror, verify with the digest recorded on the GitHub Release; the docker image inspect output must match what follows the @ sign.
Is LoopForge MIT licensed?
Read it in three places. The README badge and License section say MIT; the LICENSE file is a statement that grants MIT except for the third-party components; GitHub's automated detection reports NOASSERTION. The three values coexist as fact, and the details live in THIRD_PARTY_NOTICES.md.

Related

Field SOP

Build a Game Without Code: A 49-Agent AI Studio

Turn a single Claude Code session into a 49-agent game studio with Claude Code Game Studios (github.com/Donchitos/Claude-Code-Game-Studios, MIT, about 33,837 stars): three-tier directors/leads/specialists, 72 slash commands, and 12 hooks that catch hardcoded values and accidental pushes, with a protocol that keeps every decision in your hands. Includes a five-minute setup, a demo-trimmed workflow, third-party API options, and a fit checklist.

Nov 3, 20269 min read
Field SOP

Solo AI Content Pipeline: Seven AI Employees Run the Whole Line

This breaks a solo content company into seven stages - discover, screen, test, document SOP, generate content, productize, and sales - and marks five as automatable by agents and two as must-do-yourself. It names agents like MarketRadar, WorkflowArchitect, and BrandGuardian, maps seven QA AI roles, and lands on a five-step build (write a spec, set a human checkpoint, ship one before scaling), with the reminder that an agent is not a co-founder and the overseas reference cost is about 38 dollars a month.

Nov 2, 20269 min read