# Tencent LoopForge: Self-Hosted SOPs That Orchestrate Claude Code, Codex and CodeBuddy

> Source: <https://explainx.ai/blog/tencent-loopforge-self-hosted-sop-coding-agents-claude-codex-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-11-14 00:00:00+00:00

**Tencent published [LoopForge](https://github.com/Tencent/LoopForge?ref=explainx) as a self-hosted control plane for coding-agent delivery** — chat with Main Bot for exploratory work, or run **SOPs** (standard operating procedures) that chain agent roles, shell scripts, and human gates in Docker sandboxes. The repository trended with **roughly 700+ stars** and **174 stars gained in a day** as of November 14, 2026, per GitHub counters.

LoopForge sits in the same problem space as [Plannotator’s local review surface](https://explainx.ai/blog/plannotator-plan-code-review-workspace-coding-agents-claude-code-codex-github-trending-2026) and [Agent Autoloop’s background hub](https://explainx.ai/blog/agent-autoloop-claude-code-codex-background-hub-cron-github-issues-approval-cards-github-trending-2026), but Tencent’s angle is **team-scale delivery**: published workflows, shared requirements, token-cost reports, and a web console — not only a single-developer CLI plugin.

## TL;DR

| Question | Answer (per Tencent README, Nov 2026) | 
|---|---|
| License | MIT | 
| Default install | `./start.sh` pulls pinned`ghcr.io/tencent/loopforge` image | 
| Agent CLIs | Ten executors including Claude Code, Codex, CodeBuddy | 
| Sandboxes | Docker containers with repository checkouts | 
| Human gates | Pause runs until approval or send work upstream | 
| Local edition | `npx loopforge-cli@latest install` for Claude, Codex, CodeBuddy, Cursor | 
| GitHub | Optional OAuth for PR delivery; not required for document SOPs | 

## Why a coding agent still needs a delivery layer

Asking an agent to “fix this bug” once is easy. Asking the **same team** to ship **the same way every time** — plan, implement, test, review, approve — is not. LoopForge’s README frames the gap explicitly: demos skip tests, agents review their own diffs, and nobody notices when a run stalls.

LoopForge adds **roles** (planner, implementer, reviewer, tester), **scripts** for deterministic steps, and **human gates** where a person signs off or sends work back to an earlier node. That matches how enterprises already run [Claude for manufacturing plugins](https://explainx.ai/blog/claude-for-manufacturing-plugin-17-skills-infor-netsuite-autodesk-fusion-approvals-2026) and [AWS Bedrock agent routing](https://explainx.ai/blog/aws-bedrock-litellm-nemo-switchyard-coding-agent-routing-2026), but here the orchestration is **yours** on **your Docker host**.

## Two paths: chat with Main Bot or run an SOP

| Mode | Best for | How it runs | 
|---|---|---|
| Main Bot chat | Exploration, quick fixes, steering mid-reply | Opens a conversation workspace (Docker sandbox) on demand | 
| SOP | Repeatable delivery with fixed stages | Engine runs Agent, Script, Human-gate, Sub-SOP, and Preview nodes in order | 

Both paths attach to the same **requirements** object, so whether code ships from chat or a SOP, history and cost roll up together — closer to ITSM than a one-off `/loop` in the terminal.

Human approval gates pause agent delivery until a teammate signs off

SOP nodes, per the README:

| Node | Role | 
|---|---|
| Agent | A configured role with prompt, executor, model, rules, Skills, MCP tools | 
| Script | Shell build, test, lint, or report generation | 
| Human gate | Blocks until someone approves or rejects upstream | 
| Sub-SOP | Nested workflow | 
| Preview build | Static site archive for review | 

Failed checks can **rework** to earlier steps — the designer shows this with the built-in bug-fix SOP.

## Install and first run

Tencent documents a **Compose-first** path that does **not** require Go or Node on the host:

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

`./start.sh` checks Docker, Compose, Python 3, and curl, pulls the release image pinned in `compose.yaml`, seeds built-in sandboxes and starter SOPs, and listens on **0.0.0.0:8090** by default. The **first registered account becomes administrator**.

Try without any model key: open the **demo project**, run the **Platform check · script & approval** SOP, approve the human gate, and watch a script-only path complete — useful for proving the engine before you paste API keys.

For air-gapped or slow `ghcr.io` regions, the README documents `MIRROR=ghcr.nju.edu.cn ./start.sh` to pull through a mirror and retag the official digest — verify with `docker image inspect` against the pinned digest in `compose.yaml`.

Developers hacking on LoopForge itself use `bash scripts/dev.sh` with **Go 1.26.11+**, per the repository docs.

Self-hosted Docker installs keep sandboxes and approval history on your hardware

## Executors, GitHub, and sandboxes

**Executors** are the actual coding CLIs. CodeBuddy and Codex ship inside the image; Claude Code, OpenCode, Kimi Code, and Pi install on first use via npm and cache afterward. Cursor CLI and Antigravity use provider installers on chat first use but **are not preinstalled in SOP sandboxes**, the README warns — pick executors your sandbox can actually run.

**GitHub** is optional: generic product SOPs can deliver documents without a repo; bug-fix and backend SOPs need source. OAuth device flow is built in; SSH keys work for GitLab, Gitea, or Gogs with manual PR tooling.

**Sandboxes** talk to the host Docker socket — powerful and appropriate for **trusted teams**, not multi-tenant hostile users. That is the same trust model as [Chrome DevTools MCP](https://explainx.ai/blog/chrome-devtools-mcp-chrome-devtools-for-agents-55k-stars-setup-skills-guide-2026) driving a real browser: convenience trades off against isolation.

## LoopForge Local for single developers

Teams that want SOP ideas **inside** an existing CLI can install the portable edition:

```
npx -y loopforge-cli@latest install claude
```

Then invoke `/start-devflow "<your request>"` in Claude Code. Source lives under `local/` in the main repository. Platform SOP export to standalone local runs is **planned**, not shipped — check the local guide before you depend on it.

## How this compares to other orchestration stacks

| Product | What it optimizes | 
|---|---|
| [Dify / n8n / Flowise](https://explainx.ai/blog/what-is-a2a-agent2agent-protocol-mcp-comparison-guide-2026) | General AI automation graphs | 
| LoopForge | **Software delivery** with real repos, coding CLIs, PR evidence | 
| [Plannotator](https://explainx.ai/blog/plannotator-plan-code-review-workspace-coding-agents-claude-code-codex-github-trending-2026) | Rich human review of one plan or diff | 
| [Cognition Devin Apps](https://explainx.ai/blog/cognition-devin-apps-private-ai-built-web-tools-november-2026) | Hosted private micro-apps from agents | 

LoopForge is closer to **CI plus agent roles** than to a chat UI skin. If you already standardized on [Addy Osmani’s agent-skills packs](https://explainx.ai/blog/addy-osmani-agent-skills-production-pack-github-trending-2026), LoopForge gives those skills **stage boundaries** and **approval cards** in a shared inbox.

## Token economics and observability

The README advertises **token and cost accounting** for SOPs and conversations at public list prices, plus engineering metrics exports. That matters when [coding-agent bills](https://explainx.ai/blog/track-and-cap-amazon-bedrock-spend-per-iam-principal-cur-2-0-aws-budgets-deny-policy-guide-2026) surprise finance — LoopForge makes spend visible per requirement, not only per API key.

Runs expose **node status, tool traces, worker logs, and per-node artifacts**. When an agent step fails, you can **retry** or **rerun from any node** instead of replaying an entire chat from scratch — the operational difference between a toy demo and something a release manager will trust.

## Security and governance notes

Report vulnerabilities through Tencent’s published security policy on the repository. For production:

- Treat Docker socket access as **root-equivalent** on the host.
- Restrict signup with `AGENTFLOW_ALLOW_SIGNUP=false` when you do not want open registration.
- Put HTTPS in front before exposing beyond a VPN.

LoopForge adds **process** around agents that already pass your CLI policies; it does not replace dangerous-tool guardrails inside each executor. Pair organizational SOPs with tool restrictions the way [shadcn’s agent skill audit guidance](https://explainx.ai/blog/shadcn-improve-agent-skill-audit-expensive-execute-cheap-2026) recommends: expensive execute, cheap review.

## HTTP API, MCP, and scheduled agent tasks

Beyond the browser console, LoopForge documents an **OpenAPI-described HTTP API** and **MCP exposure** so external systems can open requirements, enqueue SOP runs, or poll gate status. That matters when your incident bot already lives in Slack: the approval card can be a webhook into LoopForge’s **Needs review** inbox instead of a second chat thread nobody audits.

**AI scheduled tasks** reuse the same workspace machinery: recurring agent jobs with parameterized templates, versioned like SOPs, with full MCP and repository access when credentials allow. For teams comparing [Cursor’s proactive Projects coordinator](https://explainx.ai/blog/claude-code-projects-proactive-coordinator-november-2026), LoopForge is heavier ops but offers **shared** history — every teammate sees the same run graph.

## Built-in SOPs and the validation record

Tencent ships **read-only blueprint SOPs** for backend, frontend, bug-fix, and product flows. Copy one into your project before you edit nodes — the README warns that built-ins are templates, not drop-in production paths. The repository links a **validation record** and **acceptance matrix** describing a real four-role CodeBuddy run (plan, implement, review, summarize) with three passing tests and a human gate — useful as a realism check, not a guarantee your repository will pass unchanged.

If you maintain internal “definition of done” docs, map each DoD bullet to a **Script node** (lint, unit tests, SBOM) so agents cannot skip checks by “forgetting” a prompt line.

## Cost reporting and model selection per role

LoopForge’s insights pages aggregate **token usage at public list prices** per requirement and per SOP version. That is not the same as invoice truth — your enterprise discount may differ — but it beats flying blind when [Gen Z stacks AI subscriptions](https://explainx.ai/blog/gen-z-ai-subscriptions-utility-bill-bank-of-america-2026) beside corporate API keys.

Per-role executor choice is deliberate: a planner might run an expensive model while the implementer uses Codex on a smaller tier. The README notes that **requirement clarification, notification summaries, and scheduled assistant tasks** currently pin to **CodeBuddy-only model pickers** on the server — mixing CLIs on those subsystems is rejected rather than silently swapped. Read that constraint before you standardize on Claude Code everywhere.

## Ops checklist before you trust production delivery

| Step | Why | 
|---|---|
| Pin compose digest | Mirrors can retag; verify `RepoDigests` after pull | 
| Restrict port 8090 | Default binds all interfaces | 
| Disable open signup | `AGENTFLOW_ALLOW_SIGNUP=false` for private teams | 
| Scope GitHub OAuth | Limit repositories per project | 
| Snapshot volumes | Re-running installer keeps data, but backups are still yours | 
| Test ZCode/Cursor paths | Not all CLIs exist inside SOP sandboxes | 

## When LoopForge is worth the ops cost

**Choose LoopForge** if multiple developers share coding agents, you need **auditable** delivery (gates, artifacts, rerun history), and you can host Docker on a trusted machine.

**Skip it** if one developer already lives entirely inside Claude Code with personal git hooks — [Worktrunk](https://explainx.ai/blog/worktrunk-git-worktree-cli-parallel-ai-agents-claude-code-2026) or Plannotator may be lighter.

**Watch the mirror docs** if you deploy in regions where GHCR pulls stall; digest pinning is only meaningful if the pull actually completes.

## Related reading

Sources: [Tencent LoopForge repository](https://github.com/Tencent/LoopForge?ref=explainx), [LoopForge product site](https://loopforge.cn/?ref=explainx)