Analysis2026-11-17Updated 2026-11-17

LoopForge: How Tencent Runs Coding Agents 7x24 for a Whole Team (Nov 2026)

TL;DRLoopForge is Tencent Lighthouse's open-source attempt at the team version of a coding agent: the workspace runs in the cloud so long tasks survive a closed laptop, product, design and engineering share one session with a single Main Bot, real iterations run through an SOP pipeline with objective gates, and everyday Issues are fixed and turned into merge requests in the background. Tencent reports 20+ internal businesses and 200+ requirements and tickets a month. The five-stage story moves from a laptop-bound agent to a process that rewrites its own SOPs after every run, which Tencent calls engineering-grade RSI.

By Cameron Voss and West Mao

Adapted from Tencent Lighthouse's engineering retrospective on LoopForge, first published November 17, 2026. Diagrams redrawn for this page.

A single-machine coding agent writes code fast. Put it inside an R&D team and the friction shows up: the stream dies when someone closes a laptop, context splits across people, Vibe Coding quality drifts, ticket watching eats the day, and the same class of mistake comes back a week later. Tencent's Lighthouse team built LoopForge to attack that list. It bundles 7x24 cloud workspaces, multi-role shared sessions, an SOP pipeline with engineering gates, unattended automation and a self-improvement loop the team calls engineering-grade RSI. Tencent says the platform currently serves more than 20 internal businesses and closes 200+ requirements and day-to-day tickets a month.

Requirement issue, ticket, request Human checkpoint Main Bot Driver seat one shared session one cloud workspace product, design, dev Small change edit code, run checks, open the MR Large requirement, sent to an SOP pipeline Clarify gated Design gated Code gated Test gate failed gate, sent back to the node that owns it MR opened tests and checks green Human takes the wheel pause, resume, take over The process runs on its own. People make the calls at the checkpoints that matter.
Requirements go in, merge requests come out. The agent runs the process; people sign off at the checkpoints that matter.

Two days earlier, DeepSeek published Super-agent Design Exploration: Toward a More Autonomous Agent System and open-sourced the research prototype. Its opening names a pain point that anyone who leans on coding agents already feels: a model is strong on a single coding task, but one person can only watch three to five sessions at once. Single-task quality is limited by the model. Team throughput is limited by human attention.

That framing is the useful one, because it moves the question off model capability. LoopForge and the DeepSeek prototype start from the same problem and end in different places:

DimensionDSH Super-agent prototypeLoopForge
Core positioningA prototype for asynchronous ticket scheduling, aimed at individuals or small teamsA cloud platform for multi-person collaboration and engineering delivery, aimed at R&D teams
Interaction and entry pointA shallow Router that dispatches events and does not write codeA Main Bot in the driver seat: small changes are edited and turned into MRs directly, large requirements go to an SOP
Collaboration topologyOne ticket binds to one Worker that sees it through alone. Cross-role collaboration is left openProduct, design and engineering share one session and one workspace, plus a five-layer decoupled multi-role SOP pipeline
Mid-flight takeoverMostly black-box background autonomy. How to intervene mid-flight is left openThe workspace can be paused, resumed or taken over at any time, with online IDE and terminal access
Quality and evolutionExternal Watchdog monitoring plus manual prompt tuning. Long-horizon evolution is left openObjective gates on the inner loop that self-heal on the spot, and engineering-grade RSI on the outer loop that retrospects, writes prescriptions and rewrites SOPs

Building LoopForge (Tencent/LoopForge on GitHub) followed the same route. The architecture did not arrive on day one. Each step answered a problem the team hit in production, and the five thresholds below came in the order they were crossed:

StageWhat brokeWhat LoopForge built
1Long tasks ran on a personal laptop, so closing the lid killed the agentWorkspace and execution environment moved to the cloud, running 7x24
2Everyone chatted with their own Bot, and context travelled by copy-pasteOne shared session, one Main Bot, one cloud workspace
3Free-form Vibe Coding either pretended to finish or drifted off courseAn SOP pipeline with hard gates and takeover at any node
4Routine issues needed a person to trigger, watch and merge each oneScheduled and event-driven automation, starting with Issue auto-fix
5A static process repeated the same mistake on the next requirementEngineering-grade RSI: retrospect, diagnose, rewrite the SOP and the gates

Part 01: from a local agent to 7x24 cloud operation

Whether the tool was Claude Code, Codex or CodeBuddy, everyone started the same way: open a terminal on your own laptop and run the agent there. Writing one small feature felt great. The moment tasks got longer or more numerous, the physical limits of running locally showed up.

  • Closing the laptop cuts the stream. A half-hour refactor or a full test run meant not daring to shut the machine down or drop the network. Going home and closing the laptop simply killed the task.
  • Local environments are heavy and concurrency is limited. Open three to five requirement branches at once and you hit port conflicts, containers that eat all the memory, and a personal machine that cannot carry parallel work.
  • Changing machines loses the scene. Half-edited code, uncommitted branches and environment variables all stayed inside one laptop. Switching device, or asking a colleague to take a look, was not something you could start.

The first step was therefore obvious: move the agent's workspace and execution environment fully into the cloud and let it run 7x24, detached from any personal computer. LoopForge built a three-layer cloud runtime for that.

An isolated cloud workspace, with no local environment to start. Every task gets its own cloud container or secure sandbox workspace. It can pull several front-end and back-end repositories at once and cut the working branches automatically. Coding, compiling, unit tests, integration testing and the merge request all happen in the cloud, so there is no development environment to spin up locally: close the laptop and go home, and the task still runs to the end.

Storage and compute separated, with your own machines one click away. This follows DeepSeek's split between the control plane and the execution environment. A workspace can run in a platform-hosted container, or a team's cloud host or idle development machine can join the platform in one click and take orders online around the clock. The execution layer is decoupled from the coding tool, so Claude Code, Codex and CodeBuddy can be swapped freely. Repository credentials are injected temporarily by the gateway according to identity and wiped when the task ends, which keeps plaintext keys away from the model.

Automatic snapshot and sleep, with a lossless wake-up. Being online 7x24 is not the same as burning compute 7x24. When an idle workspace is reclaimed or moved between machines, the system packages uncommitted changes and branch state into a cloud snapshot. Come back the next day and continue the conversation, and the code scene is restored in full.

Part 02: from individual machines to a shared team context

Once the agent could run in the cloud around the clock, use shifted from personal to team. That is where the second wall stood: if everyone still talks to the agent in their own window, the team's context stays fragmented.

A product manager asked the agent to sort out requirements in one window. A designer produced a draft. By the time the work reached engineering, the background, the branch and the design constraints had to be pasted into a different agent all over again. Single-point coding got faster while the team stayed slow at carrying context across roles. Pulling a pile of Bots into one group chat to fix that brings its own trouble: messages flood, contexts pollute each other, and once write permissions are open in a chat, somebody's casual remark can push the agent into an action nobody authorized.

To let the team share one real scene in the cloud, the team did two things. They dropped the noisy multi-Bot group chat and settled on a rule: one conversation binds to one cloud workspace at a time, and one Main Bot talks to the whole group. Every task maps to a team session. Product, design and engineering walk into the same session and talk to the Main Bot. When the speaker changes, the layer underneath continues the same session context against the same real workspace.

Shared session, checkout-flow everyone types into the same thread one cloud workspace P Product D Design E Engineering Main Bot Product The checkout page copy needs a change. Keep the button label short. Main Bot Opened the workspace, edited the copy, ran the checks: all green. Preview is live for review. MR ready Design Checked the mobile preview. Spacing looks right. Ship it. Engineering Approved. MR opened on the branch, visible to everyone. One session, one Main Bot, one real cloud workspace. Nobody re-pastes context. Small requests: any member says one sentence, the Main Bot edits, verifies and opens the MR. The group sees it live.
Product, design and engineering in the same session, talking to the same Main Bot.

Day-to-day requests such as a line of copy, a style tweak or a small bug fix need one sentence. Any member says it in the shared session, and the Main Bot opens the workspace, changes the code, runs the verification and raises the MR. The whole group sees it as it happens, with no second round of synchronization.

Want to run this solidly, or want API access to a range of open-source models? Our Multi-Model Coding Plan covers DeepSeek V4 Pro and Flash alongside GLM, MiniMax and Kimi.

The second change was permissions. Every write operation used to hit a pop-up, so finishing one task meant a dozen clicks of confirmation, while turning on full automation inside a multi-person conversation risked a casual sentence from someone in the group pushing the agent into a high-risk command. LoopForge splits the difference with three tiers: greetings, read-only code queries and design discussion end in plain language, and anything that changes code, runs a command or submits an MR goes through one of these.

Confirm every time. Every modifying operation produces a pending draft. A human confirms it, and execution continues automatically to the next step.

Smart approval. Before every code change, command or MR, an independent review model with no tools and no credentials weighs the risk of the operation against the authorization intent of the person who started it. Other members' messages and prompt injection are isolated from that judgment, because someone else's words cannot authorize the current operator's action. Routine operations pass. High-risk or unauthorized ones go to a human.

Fully automatic. Within the authorized scope, the whole sequence runs in order. A destructive conflict warning is the one thing that forces an interception and a confirmation.

Routine read, write and verification commands clear in seconds through the review model. Only out-of-scope or high-risk changes reach a person. Product, design and engineering collaborate in one cloud context, and the security line for shared permissions still holds.

Part 03: from free-form conversation to an engineering-grade SOP

Once product, design and engineering could all Vibe Code around the Main Bot in one shared session, small requirements felt smooth. Formal, cross-role, long-chain iteration was where free-form Vibe Coding lost control of quality, in three distinct ways.

Ad-hoc process, work that pretends to be done. In free-form chat each person adds one request, and the agent wanders along the context changing whatever it passes. Nothing standard marks clarification, design, review or testing. The agent says "already fixed" while the compile or the unit tests never ran.

Cross-role handoffs live in chat logs. Long conversations get longer. Boundary conditions agreed upstream drown in dozens of rounds of history, and downstream coding misses changes. DeepSeek's ablation experiments found the same thing: ask an agent to delegate subtasks through prompting alone and it falls back to grinding the work out itself once the long tail turns complex.

Drifting work is hard to take over, and the same pit waits again. When a task drifts halfway, a person forcing their way into the conversation makes a mess. And the environment pitfall that took two hours to fix this time waits unchanged for the next requirement.

Their conclusion: small changes can ride on Vibe Coding and fast hands, but serious delivery needs professional role capability and team engineering standards fixed into an SOP with hard gates. Three designs did that work.

Five decoupled layers that turn expert capability into an asset

Improvised prompts and luck are not a foundation. The team split professional role capability and the SOP process into five independent layers:

LayerWhat it defines
Job rolesRole capability definition. Each role (architect, front-end, back-end, test) carries its own responsibility statement, coding standards, dedicated skills and objective verification gates
SOP flowCross-role topology. Ordering dependencies, parallel branches and failure kick-back paths for the clarify, design, code and test nodes
Execution engineTool adaptation. Claude Code, Codex and CodeBuddy switch freely, because role capability does not depend on the tool
Runtime environmentCloud sandbox foundation. A cloud persistent container, a secure sandbox or the team's own machine, giving every run the same execution environment
Deliverable contractStage handoff standard. Structured artifact requirements between upstream and downstream nodes, with complete version history kept

The accumulated role assets are shared by the whole group. A formal requirement chains into an SOP pipeline and flows on its own, and each node loads only that role's standards and skills, masking the messy personal configuration inside the repository. In everyday conversation a member can @ an expert role for a read-only consultation, collect architecture or review advice and hand it to the Main Bot. Capability is shared; nobody interrupts at the wrong moment.

A three-layer driver and co-pilot order, with takeover on demand

SOPs do not take control away from people. Collaboration collapses into a structure that can move forward or hand back: human, Main Bot, SOP node.

People Product Design Engineering talk to one Main Bot, never to the lower layer directly Main Bot routes work, watches the pipeline, relays a takeover in plain language dispatch large requirements SOP pipeline, live node status Clarify done, gated Design done, gated Code current node Test gate, must be green failed test gate, kicked back to the node that owns it Take the wheel Pause Resume + notes Take over one sentence to the Main Bot Small things: the Main Bot edits and opens the MR. Big things: dispatched to an SOP that can be paused, taken over or resumed, with failed tests kicked back on their own. The online IDE and terminal stay available for direct edits.
Small things are edited and turned into MRs by the Main Bot. Big things go to an SOP that can be paused, taken over or resumed, and a failed test is kicked back on its own.

While an SOP runs, the node pipeline sits above the shared session and updates in real time. Click any node to read its thinking and its execution log. If the direction drifts, there is no need to shout into the lower layer. Besides editing in the online editor or the terminal, one sentence to the Main Bot triggers a controlled takeover in one of three modes.

Pause and intervene. The pipeline stops safely at the current node. The Main Bot or an engineer edits files and runs command verification directly.

Resume and continue. Changes go back with a note, and the remaining nodes finish testing and delivery.

Take over directly. The rest of the pipeline stops. The finished work in the workspace is yours, and the Main Bot pushes to the original branch to open or update the MR.

Engineering-grade RSI: gates that heal, retrospectives that rewrite

RSI, or recursive self-improvement, is a familiar research direction. Retraining model weights is neither realistic nor fast for a working team. What LoopForge does is engineering-grade RSI: execution traces feed back into the SOPs, role standards and verification gates, forming a loop of execute, verify objectively, diagnose in retrospect, rewrite the process, and run better next time.

Engineering- grade RSI Execute Objective check Retrospective diagnosis Rewrite SOP + roles Sharper next round TWO RUNS, ONE PRESCRIPTION Run 1 Reworked twice two failed gates 55 / 100 health Prescription Add a lint gate, tighten the review checkpoint, append the pitfall to the role standard. Run 2 Passed on the first attempt 96 / 100 health The inner loop fixes the code within one run. The outer loop strengthens the process across runs.
Run 1 was reworked twice and scored 55. The retrospective wrote a prescription and added a gate. Run 2 passed first time at 96.

The inner loop, inside one run. Agents used to claim "already fixed" on a feeling, and when something errored a person pasted the log back so it could try again. Each SOP node now carries objective gates: compile, unit tests, code standards. Nothing passes without them, and the agent takes the real error into a correction loop and fixes it on the spot, with a retry cap so it cannot spin forever. Low-level mistakes die inside the node.

The outer loop, across runs. A traditional pipeline is static, so the pit from last time is still there next time. In LoopForge, every finished run sends the retrospective engine back through the full trace: time per node, failed gates, wasted retries, causes of rework. It produces a health score from 0 to 100, and the agent writes a structured improvement prescription for the SOP and the roles.

PrescriptionWhat it rewrites
Evolve the flow topologyWhere a step gets stuck or spins idle, adjust the retry cap, the failure fallback path and the repair strategy
Accumulate mistake-proofing memoryThe lesson and the boundary constraints from this pitfall are appended to the corresponding role standard
Tighten the acceptance checkpointsFor defect types that got through, add or upgrade an objective verification gate and close that class of problem

A person reviews the prescription and clicks one button. The system rewrites the SOP or the role asset and generates a new version. The inner loop gets the code right within a run. The outer loop makes the process stronger across runs, so the pits the team steps in today become the default instinct of the pipeline tomorrow.

Part 04: scheduled jobs and end-to-end Issue automation

After three stages, a team working on a key requirement had a cloud workspace, shared sessions and a decent SOP pipeline. Any system in fast iteration also produces a steady stream of online bugs, UX blemishes, technical debt and scattered Issues, big and small, every day.

Handling those Issues burned time and people. No single one looked large, but the numbers were high and they arrived in fragments. Engineers spent a large part of every day reading tickets, claiming them, cutting branches, locating the fault, running tests and raising MRs. Even with SOPs in place, dozens of scattered Issues still needed a person to create a session for each one, trigger it, watch the progress and untangle merge conflicts. The core engineers' flow state did not survive that.

The question they asked: if the SOP can already repair and verify to a standard, why can't the system inspect the backlog itself, queue the fixes itself, and merge the finished code itself? Pushing a large volume of everyday Issues all the way to automatic handling ran into three blockers.

  • Watching and dispatching tickets by hand costs too much. Defect reports and UX problems sit across the requirement platform and the repository. Human inspection plus manual context copying is itself heavy mechanical work.
  • Parallel fixes collide. A dozen bug tickets finish in the background at once, then merge into the same target branch and hit code conflicts, which pulls engineers back to resolve them by hand.
  • One stuck ticket blocks the line. In a batch run, one or two complex Issues sitting at a gate and waiting for human confirmation hold background resources, and the tickets behind them stop moving.

The fourth stage built scheduled inspection and end-to-end Issue automation, so a large volume of everyday bugs and scattered requests becomes a background pipeline nobody has to watch.

Scheduled ticket pulling with two-way sync. Scheduled jobs connect the requirement platform and the repository in both directions. On a timer, the system inspects the backlog for new bugs and Issues, matches a repair SOP by label, brings up a cloud workspace and starts locating the fault. Stage status and the final MR link are written back under the original ticket, so nobody creates tickets, dispatches them or moves status around by hand.

Automatic integration merging with conflict self-healing. When several Issues from the same batch are finished in parallel, the system merges them into the integration branch in order. On a conflict, engineers do not get called back to fight the fire locally. The system extracts the conflict context, sends it back to the SOP's repair and verification node, untangles it there and re-runs the compile and unit-test gates, then produces one consolidated MR.

Proactive health checks with non-blocking approvals. Beyond fixing tickets on arrival, teams can configure scheduled inspections such as a daily code-health scan, a dependency security check or an automatic look at build failures. When the agent finds a hidden risk it writes the repair plan. And any ticket that needs a human decision releases its background resource the moment it enters the "waiting for my confirmation" queue, so the volume of everyday Issues behind it keeps moving. A large volume of small tickets clears quietly in the background around the clock, and a person clicks final acceptance between coffee breaks.

Summary: a five-step crossing from personal tool to self-evolving organisation

Borrow the L1 to L5 levels of autonomous driving and use them to measure how deeply a team has landed agents. LoopForge's five steps trace a clear progression.

L1 Q&A tool L2 Local assistant environment bound to one laptop L3 Cloud + shared team space stages 1 & 2 7×24, one session, review model L4 Engineering SOP + automation stages 3 & 4 hard gates, takeover, unattended delivery L5 Self-evolving R&D org stage 5, RSI retrospect every run, write the fix back into the SOP engineering maturity of agent adoption From a local single-machine tool to cloud sharing, SOP autonomy and a self-evolving organisation.
From a local single-machine tool towards cloud sharing, SOP autonomy and a self-evolving organisation.
LevelWhat it means
L1 Q&A toolAsk a question, get an answer. Code travels by copy-paste, and closing the window ends it
L2 Personal local assistantIt can change code in a local IDE or CLI, but the environment and context stay inside the personal computer. Close the laptop and the stream dies
L3 Cloud operation and a shared team space (stages 1 and 2)The workspace moves to the cloud and runs around the clock. Product, design and engineering talk to the same Main Bot in the same session, with an independent review model approving routine operations
L4 Engineering-grade SOP and a scheduled automation pipeline (stages 3 and 4)Standardized SOPs, takeover at any moment and objective quality gates replace disorderly Vibe Coding. Scheduled ticket pulling and automatic conflict resolution on the integration branch deliver unattended work
L5 Self-evolving R&D organisation (stage 5, engineering-grade RSI)After every run the system tallies R&D efficiency and traces the root cause of rework, then writes the improvement prescription back into the SOP and the role definitions in one click. The process gets smarter the more it runs

The biggest lesson in the whole exercise: an agent becomes a reliable colleague not by writing a longer prompt and not by assembling a livelier multi-Bot chat, but by converting the team's engineering experience into the system's operating rules.

In the single-machine era, AI was a handy co-pilot and the reward was the instant thrill of a well-written function. Once it enters a team's engineering work, the bottleneck moves off "can the model write code" and onto whether the environment survives, how context is aligned, how quality is guaranteed, and how people get out of scheduling work.

Each of the five steps turned a dependence on people into a mechanism. The cloud workspace removed the laptop as a physical constraint. Shared sessions and delegated approvals closed the communication gap across roles. SOPs with objective gates brought free-form Vibe Coding back under control. Scheduled automation made the background unattended. Engineering-grade RSI let the system rewrite itself across runs. When every lesson from every pitfall settles automatically into the gates and standards of the next run, what a team ends up with is not a few Bots that write code. It is a delivery system that belongs to the team and improves every day.

Where to find it

LoopForge is open source. The repository is Tencent/LoopForge on GitHub, and the project publishes the full implementation of cloud workspace scheduling, multi-person Main Bot sessions, five-layer SOP orchestration, objective-gate self-healing, scheduled and end-to-end Issue automation, and the RSI retrospective loop. The project site and a live demo of the platform interface and delivery records are linked from the repository.

If you have been annoyed by an agent skipping the tests again, or you want your team's AI work to take less repeated briefing and keep more of what it learns, the demo is worth an hour. The repository ships an install script, bash scripts/install.sh, that brings up an instance for your own team.

Frequently asked

What is LoopForge?

LoopForge is an open-source cloud platform from Tencent Cloud Lighthouse for running coding agents as a team rather than as one person's local tool. It combines 7x24 cloud workspaces, shared sessions around a single Main Bot, an SOP pipeline with objective quality gates, unattended automation for Issues, and a retrospective loop Tencent calls engineering-grade RSI. Tencent says it serves more than 20 internal businesses and closes 200+ requirements and tickets a month.

Why does a local coding agent stop when the laptop closes?

Because the agent process and its workspace live on that machine. LoopForge runs each task in an isolated cloud container or secure sandbox, so coding, compiling, unit tests, integration testing and the merge request continue while the laptop is shut. Idle workspaces are packaged into cloud snapshots with uncommitted changes and branch state, and restored on the next session.

What is the Main Bot in LoopForge?

One bot bound to one conversation and one cloud workspace at a time. Product, design and engineering all talk to it in the same session, so context stays in one place instead of being carried between private windows. It edits small changes itself and dispatches large requirements to an SOP pipeline.

What are the three permission tiers for write operations?

Confirm every time, where each modifying operation produces a pending draft for a human. Smart approval, where an independent review model with no tools and no credentials weighs the operation against the initiating person's intent and passes routine commands automatically. Fully automatic, which runs the authorized sequence in order and stops only for a destructive conflict warning.

What does engineering-grade RSI mean in LoopForge?

Self-improvement without retraining model weights. Inside a single run, each SOP node has objective gates such as compile, unit tests and code standards, and the agent fixes real errors on the spot under a retry cap. Across runs, a retrospective engine reviews the full trace, scores the run from 0 to 100, and writes a prescription that rewrites SOP nodes, role standards or gates.

How does LoopForge handle many Issues in parallel?

Scheduled jobs pull new tickets from the requirement platform, match a repair SOP by label and start a cloud workspace. Finished fixes merge into the integration branch in order, and a conflict is sent back to the repair and verification node to resolve and re-run the compile and unit-test gates. A ticket waiting for human approval releases its background resource immediately, so the queue behind it keeps moving.