LoopForge: Tencent's Self-Evolving AI R&D Platform – From Local Agents to Team Automation
Tencent open-sources LoopForge, a cloud-native platform that evolves from local coding agents to a team-level self-improving R&D system with shared workspaces, SOP pipelines, automated issue resolution, and recursive self-improvement, serving 20+ internal projects with 200+ monthly automated deliveries.
Introduction: From Single-Developer Agents to Team-Level Automation
Single-machine coding agents write code quickly, but once adopted by a team, issues like laptop sleep interrupting long tasks, isolated multi-user contexts, uncontrolled "vibe coding" quality, manual ticket tracking, and repeated mistakes keep teams stuck in "individual efficiency, global waste." To solve this, Tencent's Lightweight Cloud team built and open-sourced LoopForge — a cloud-native self-evolving R&D platform integrating 7×24 cloud workspaces, multi-role shared sessions, engineering-grade SOP pipelines, unattended automation, and Recursive Self-Improvement (RSI). The platform currently serves 20+ internal business lines, automatically completing 200+ requirements and routine tickets per month. This article retraces the five-stage engineering evolution behind LoopForge, referencing DeepSeek's latest Super-agent exploration.
Comparison: DeepSeek Super-agent Prototype vs. LoopForge
Core Positioning: Super-agent targets individuals or lightweight teams with async ticket scheduling; LoopForge targets multi-person collaboration and engineering delivery for R&D teams.
Interaction & Entry: Super-agent uses a shallow router for event dispatch only; LoopForge uses a Main Bot co-pilot model — small changes directly edit code and submit MRs, large requirements dispatch SOPs.
Collaboration Topology: Super-agent binds one ticket to one independent worker (cross-role collaboration left open); LoopForge provides a shared workspace for product, design, and engineering plus a five-layer decoupled multi-role SOP pipeline.
Mid-Task Takeover: Super-agent relies on black-box background autonomy (mid-task intervention open); LoopForge allows pause/resume/direct takeover anytime in the shared workspace with online IDE and terminal access.
Quality & Evolution: Super-agent uses external watchdog monitoring and manual prompt tuning (long-term evolution open); LoopForge implements inner-loop objective gate self-healing and outer-loop engineering-grade RSI that auto-retrospects, prescribes fixes, and rewrites SOPs.
Stage 1: From Local Agent to 7×24 Cloud Execution
Running agents locally (Claude Code, Codex, CodeBuddy) hits physical bottlenecks: closing the laptop kills long tasks; local environments are heavy and concurrency-limited; switching machines loses the entire context (uncommitted code, branches, env vars). LoopForge moves the workspace and execution environment to the cloud with a three-layer foundation:
Isolated Cloud Workspaces: Each task gets an independent cloud container or secure sandbox that pulls multiple repos, sets up branches, and handles coding, compilation, unit tests, integration debugging, and MR submission entirely in the cloud — no local dev environment needed; tasks continue after the laptop is closed.
Storage-Compute Separation & BYO Machine: Workspaces run on platform-managed containers or can attach team-owned cloud hosts/idle dev machines with one click. The execution environment is decoupled from coding tools (supports switching between Claude Code, Codex, CodeBuddy). Repo credentials are injected temporarily by a gateway per identity and erased after the task; the model never sees plaintext secrets.
Auto-Snapshot Hibernate & Lossless Resume: 7×24 uptime doesn't mean burning compute 24/7. Idle workspaces are snapshotted (uncommitted changes + branch state) and restored instantly when the user returns.
Stage 2: From Isolated Windows to Shared Team Context
After cloud execution, usage shifted from solo to team. If everyone still chats with agents in isolated windows, context remains fragmented: PMs brief agents on requirements, designers produce specs, engineers re-paste background, repo branches, and design constraints — single-task coding is faster but the team is still slow at cross-role context transfer. Dumping multiple bots into a group chat causes message flooding, context pollution, and permission risks.
1. Shared Session + Main Bot + Cloud Workspace
LoopForge abandons noisy multi-bot chats and enforces "one conversation bound to one cloud workspace, one Main Bot serving the whole team." Each task maps to a team-shared session; PM, designer, and engineer all enter the same session and talk to the same Main Bot. When speakers change, the underlying context continues seamlessly, operating on the same real workspace.
For daily tweaks (copy changes, style adjustments, bug fixes), any member tells Main Bot in the shared session; it opens the workspace, edits code, runs verification, and submits an MR — visible to all instantly, no re-sync needed.
2. Independent Review Model Approval + Three-Tier Permission Gates
To avoid mechanical "confirm" clicks while preventing stray messages from triggering dangerous actions, LoopForge uses three modes:
Confirm Every Time (Safe & Controlled): All write operations generate a pending draft; human confirmation auto-continues execution.
Smart Auto-Approval (Risk Self-Review): Before code edits, commands, or MR submission, an independent review model (no tools, no credentials) evaluates operation risk and the current speaker's authorization intent — strictly isolating other members' messages and prompt injections. Routine ops auto-approve; high-risk or unauthorized ops escalate to human confirmation.
Fully Automatic (High-Throughput): Within authorized scope, steps execute sequentially unattended; only destructive conflict warnings force a confirmation stop.
Result: routine reads/writes and verification commands are auto-approved in seconds; only out-of-scope or high-risk changes require human sign-off — enabling fluid cross-role collaboration in a single cloud context while maintaining a permission safety floor.
Stage 3: From Free-Form Chat to Engineering-Grade SOP
With shared sessions, small vibe-coding tasks feel smooth. But formal cross-role, long-chain iterations expose quality control gaps:
Pain Point 1 — Ad-Hoc Process, "Fake Done": Free chat lacks mandatory clarify/design/review/test gates; agents claim "done" without passing compilation or unit tests.
Pain Point 2 — Cross-Role Handoff via Chat Logs: Long conversations bury upstream alignment details; downstream coding misses changes. DeepSeek's ablation experiments confirm that relying on prompts for spontaneous sub-task delegation degrades into the agent doing everything itself on complex long-tail tasks.
Pain Point 3 — Mid-Course Correction Hard, Same Pits Repeated: Forced human interjections mid-run corrupt the scene; environment pits or spec violations fixed in one task reappear identically in the next vibe-coding session.
Realization: Small changes can ride vibe-coding speed, but serious delivery must codify professional role capabilities and team engineering norms into SOPs with hard gates. LoopForge upgrades free vibe-coding to an engineering-grade SOP pipeline via three core designs:
1. Five-Layer Decoupled Standards: Freezing Expertise as Assets
Instead of relying on ad-hoc prompts, LoopForge architecturally separates professional roles and SOP processes into five independent layers:
Role Definitions: Encapsulate responsibilities, coding standards, exclusive skills, and objective verification gates for Architect, Frontend, Backend, QA, etc.
SOP Process: Define node dependencies (clarify → design → code → test), parallel branches, and failure rollback paths.
Execution Engine: Swap coding tools (Claude Code, Codex, CodeBuddy) freely; role capabilities decoupled from specific tools.
Runtime Environment: Bind to persistent cloud containers, secure sandboxes, or team-owned machines for consistent execution.
Delivery Contracts: Specify structured artifacts exchanged between upstream/downstream nodes with full version history.
These role assets are shared team-wide: formal requirements string together into auto-flowing SOP pipelines (each node loads only its role's standards and skills, auto-filtering repo noise). In daily shared chats, members can @expert-role for read-only consultation — getting architecture or review advice synced to Main Bot for coordination — achieving "expertise shared, never interrupts casually."
2. Three-Layer Co-Pilot Order: Autopilot with Anytime Takeover
Introducing SOPs doesn't remove human control. Collaboration converges into a controllable "Human ↔ Main Bot ↔ SOP Node" three-layer co-pilot structure :
While an SOP runs, the shared session shows a real-time node pipeline; clicking any node reveals its reasoning and execution logs.
If direction drifts, no need to inject raw commands at the bottom layer. Besides direct file/command edits in the online IDE/terminal, a single message to Main Bot enables three controlled takeover modes:
Pause & Intervene: Safely halt the pipeline at the current node; Main Bot or engineer edits files, runs verification.
Resume & Continue: After fixes, resume with change notes; downstream nodes pick up and complete test/delivery.
Direct Takeover: Terminate remaining pipeline, assume workspace results, finish edits, and have Main Bot push to the original branch to create/update the MR.
3. Engineering-Grade RSI: Gate Self-Healing + Retrospective Self-Evolution
Frontier AI explores RSI (Recursive Self-Improvement), but retraining model weights is impractical and slow for real teams. LoopForge implements Engineering-Grade RSI — feeding execution trajectories back into the system's own SOPs, role specs, and verification gates , forming an "Execute → Objective Verify → Retrospect Diagnose → Rewrite Process → Next Run Smarter" flywheel:
Inner Loop (Objective Gate Self-Healing per Run): Previously agents subjectively claimed "code ready"; errors required humans to paste logs back for rework. Now every SOP node embeds objective verification gates (compile, unit test, lint) — no pass, no pass-through. The agent receives real errors and enters an auto-correction loop on the spot (with retry caps to prevent infinite loops), eliminating low-level errors inside the node.
Outer Loop (Cross-Run Recursive Retrospective & Asset Evolution): Traditional pipelines are static; this run's pits become next run's repeats. In LoopForge, when an SOP finishes, the retrospective engine automatically traces the full trajectory (per-node duration, failed gates, futile retries, rework causes), scores health 0–100, and lets the agent itself write structured "improvement prescriptions" for SOPs and roles :
Evolve Process Topology: Adjust retry limits, fallback paths, and repair strategies for sticky/spinning nodes.
Distill Anti-Pattern Memories: Append lessons and boundary constraints from this run to the relevant role definitions.
Tighten Acceptance Gates: Add or upgrade objective verification gates for defect types that slipped through, blocking recurrence.
Humans only review prescriptions in the UI and click "Apply Once"; the system rewrites the corresponding SOP or role assets and versions them. Inner loop fixes code per run; outer loop strengthens process across runs — every pit the team hits today becomes the default instinct of the entire pipeline tomorrow.
Stage 4: Scheduled Tasks & End-to-End Issue Automation
After three stages, major features have cloud workspaces, shared sessions, and high-quality SOP pipelines. But real systems in rapid iteration also generate a constant stream of production bugs, UX polish items, tech debt, and scattered Issues. Handling these manually consumes massive effort: each issue seems small but volume and fragmentation are high — developers spend hours daily checking pools, claiming, branching, diagnosing, fixing, testing, and submitting MRs. Even with SOPs, manually triggering dozens of issues, tracking progress, and resolving merge conflicts still fragments core developers' flow.
Core question: Since SOPs already standardize fix & verify, why not let the system self-schedule, self-queue bug fixes, and self-merge clean code for human review? Three engineering hurdles had to be cleared:
High Manual Triage/Dispatch Cost: Defects scattered across requirement platforms and repos; manual polling and context copying to start agents is heavy mechanical labor.
Parallel Fix Conflicts: Dozens of bugs fixed simultaneously in background; merging into the same target branch causes frequent code conflicts, dragging developers back to manual branch surgery.
Stalled Items Blocking the Pipeline: In batch automation, a couple of complex issues waiting at key gates for human approval can occupy backend resources, blocking the entire queue of routine issues.
Stage 4 builds a Scheduled Polling & End-to-End Issue Automation System turning massive daily bug/issue digestion into a "background unattended pipeline":
01 Scheduled Auto-Pull & Bi-Directional Sync: Cron jobs integrate with requirement platforms and repos, periodically scanning new Bugs/Issues, auto-matching fix SOPs by labels, spinning up cloud workspaces for diagnosis/fix. Execution status and final MR links auto-write back to the original ticket — no manual ticket creation, dispatch, or status ferrying.
02 Integration Branch Auto-Merge & Conflict Self-Healing: When a batch of issues completes in parallel, the system merges sequentially. On conflict, it auto-extracts conflict context, routes back to the SOP's fix & verify nodes to self-resolve conflicts and re-pass compile/unit-test gates , then produces a consolidated MR.
03 Proactive Health Patrols & Approval Suspension with Zero Blocking: Beyond reactive fixes, teams configure scheduled patrols (daily code health scans, dependency security checks, build failure auto-diagnosis) so agents generate fixes on detection. Any pipeline item needing human sign-off instantly releases backend execution resources upon entering the "Awaiting My Confirmation" queue , never blocking subsequent high-volume routine issues — achieving "massive daily small tickets silently zeroed 7×24; humans just tap final acceptance over coffee."
Summary: Five-Step Leap from Personal Tool to Self-Evolving Organization
Mapping LoopForge's evolution to autonomous driving levels L1–L5 yields a clear engineering maturity path for teams adopting agents:
L1 Q&A Tool: Ask-answer, copy-paste code, session ends when window closes.
L2 Local Personal Assistant: Edits code in local IDE/CLI, but environment & context locked to personal laptop; closing laptop breaks flow.
L3 Cloud Execution & Team Shared Space (Stages 1 & 2): Workspace moves to cloud 7×24; product, design, engineering share one session with one Main Bot, aided by independent review model for efficient collaboration.
L4 Engineering-Grade SOP & Scheduled Automation Pipeline (Stages 3 & 4): Standardized SOPs, co-pilot takeover, objective quality gates replace chaotic vibe-coding; scheduled pull + auto-merge + conflict self-healing enable unattended delivery.
L5 Self-Evolving R&D Organization (Stage 5 · Engineering-Grade RSI): Post-run auto-measures productivity, root-causes rework, one-click writes prescriptions back into SOPs and role definitions — organizational process gets smarter every run.
Key takeaway: Making agents reliable team teammates never comes from longer prompts or lively multi-bot chats, but from converting "human engineering experience" into "system running order." In the solo era, AI was a handy co-pilot chasing instant gratification of pretty code. Once inside the team engineering scene, bottlenecks shift from "can the model code?" to "will the env survive? how to align context? how to guarantee quality? how to free humans from tedious scheduling?" These five steps essentially repeatedly沉淀 "dependence on people" into "engineering mechanisms": cloud workspaces untether from laptop physics; shared sessions + independent approval dissolve cross-role communication gaps; SOPs with objective gates contain vibe-coding risks; scheduled automation achieves background unattended operation; engineering-grade RSI cross-run retrospectives let the whole system self-evolve. When every team lesson auto-solidifies into next-run gates and norms, the outcome is not just a few code-writing bots, but a truly team-owned, daily self-evolving R&D system.
Open Source & Getting Started
LoopForge is now open source. The complete implementation — cloud workspace scheduling, multi-user Main Bot shared sessions, five-layer SOP orchestration, objective gate self-healing, scheduled & issue end-to-end automation, and engineering-grade RSI retrospective evolution — is publicly available as a ready-to-use, customizable engineering foundation for peers exploring team-level AI R&D adoption.
Explore the live platform UI and delivery records: https://loopforge.cn/demo/ Clone and deploy your team's LoopForge: bash scripts/install.sh GitHub repository: https://github.com/Tencent/LoopForge Official website:
https://loopforge.cnSigned-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
