Why Industrial Code Agents Choose ReAct Over Plan-Execute, Multi-Agent, CoT, ReWOO, and LLMCompiler

Pinduoduo Interview Question: Code Agent Paradigm Selection

The article originates from a Pinduoduo third-round interview question: What is the mainstream paradigm for Code Agents? Why do industrial Code Agents universally adopt ReAct instead of Plan-and-Execute, Multi-Agent, CoT, ReWOO, or LLMCompiler? The author systematically compares these paradigms, grounding the analysis in real-world constraints of large codebases.

ReAct: The Industrial Standard Loop

ReAct (from ICLR 2023 paper "ReAct: Synergizing Reasoning and Acting in Language Models") breaks the closed-loop internal reasoning of early LLMs by binding reasoning, tool execution, and environment observation into a three-step cycle:

Reason: Model decides next action based on current observations.

Act: Call standardized tools (file read/write, grep, shell, git) in a sandbox.

Observe: Collect errors, file contents, command outputs; update global state; repeat until task completion.

Concrete example — fixing a login 500 error:

Round 1: Suspect auth chain → grep for "login" → locate auth.py.

Round 2: Read auth.py → discover missing null check.

Round 3: Search upstream callers → find unguarded null input.

Round 4: Add null check, run pytest → iterate until all tests pass.

No fixed plan; each decision depends on the previous real observation.

Five Engineering Components Around ReAct

Structured Tool Calling Layer: All file/shell/git ops wrapped as typed Function Calls (e.g., str_replace with path, old_text, new_text) with sandbox permission checks and audit logs.

On-Demand Context Management: Repositories span millions of lines; ReAct naturally supports incremental retrieval (search, read file, view function) instead of loading the whole repo, controlling token usage and mirroring engineer debugging flow.

Lightweight Dynamic Planning: TODO lists assist reasoning but are mutable. Example: adding email registration — initial TODO includes DB field, email logic, API, frontend, tests; if DB field already exists, that task is dropped dynamically.

Verifiable Feedback Loop: Code provides machine-readable objective feedback (compile errors, static analysis, unit/integration tests). TypeError, AttributeError feed directly into next reasoning round, enabling self-correction — a key advantage over general domains.

Human-in-the-Loop Safety: High-risk ops (rm, force push) require manual confirmation.

Clarification: ReAct does not reject planning; it rejects one-shot globally fixed plans . Dynamic TODO is an internal plugin, not the Plan-and-Execute paradigm.

# Structured tool call: safe file modification
function str_replace(file_path: str, old_text: str, new_text: str) -> dict:
    if not sandbox_check(file_path):
        return {"status": "blocked", "reason": "permission denied or illegal path"}
    content = read_file(file_path)
    if old_text not in content:
        return {"status": "fail", "reason": "original text not matched"}
    updated = content.replace(old_text, new_text, 1)
    write_file(file_path, updated)
    return {"status": "success", "preview": updated[:200]}

Why Pure CoT Fails for Industrial Code Agents

Chain-of-Thought (CoT) relies solely on internal stepwise reasoning without external tools or environment interaction. Early "let the model write code" approaches were pure CoT.

Two fatal shortcomings in code scenarios:

Hallucination: Code correctness depends on private repo facts (class names, signatures, dependency versions, historical logic) absent from model weights. Models invent functions, wrong parameters, outdated SDKs; any repo-training mismatch causes failure.

No Corrective Feedback: Reasoning loop is closed; model never sees compile/test errors. Bugs often hide deep in call chains; a single user-reported error is insufficient for internal reasoning to enumerate all possibilities.

CoT works for standalone scripts, algorithm puzzles, short demos where all info fits in the prompt. But for reading existing code, debugging, understanding engineering structure, reliability collapses — it can only augment local reasoning, not drive the main loop.

ReAct's core upgrade: moves reasoning from closed model space to an open loop coupled with the real code environment, using external observation to suppress hallucination and test feedback for self-correction.

# Pure CoT mode: internal reasoning only, no tool calls, direct code output
def generate_auth_code_cot(user_prompt: str) -> str:
    reasoning = f"User needs login endpoint, I should use validate_token from {user_prompt}"
    code = """
def login(request):
    token = request.headers.get('Authorization')
    if validate_token(token):  # hallucinated function, not in repo
        return {'status': 'ok'}
    return {'status': 'fail'}
"""
    return code  # no compile/test verification, hallucination flows to output

Plan-and-Execute, ReWOO, LLMCompiler: Planning Paradigm Boundaries

Plan-and-Execute is a classic two-phase paradigm: (1) decompose task into a complete ordered execution list; (2) execute sequentially without further planning. BabyAGI was an early example; ReWOO and LLMCompiler are iterations.

ReWOO splits planning, tool calling, and result aggregation to reduce LLM calls and token usage.

LLMCompiler emits a DAG of parallelizable subtasks to shorten wall-clock time.

Core pain point: Code information emerges gradually. At planning time the agent hasn't read code or run tests; the information gap is large. Pre-written plans easily diverge from reality. When unexpected structure, dependencies, or errors appear, only two options exist: frequent full re-planning (overhead and latency exceed native ReAct) or blindly follow the stale plan (producing invalid or destructive actions).

Example: Plan to modify UserService for validation; upon reading, discover module refactored to AccountService. Original plan invalid; repeated re-planning essentially degrades to ReAct's stepwise decision mode, rendering the global plan meaningless.

Planning paradigms suit information-rich "construction tasks" (scaffolding, standardized CRUD, template migrations) where paths are fixed and subtasks parallelizable. LLMCompiler's DAG parallelism excels there. SWE-bench confirms: on simple deterministic tasks LLMCompiler matches or beats ReAct; on complex debugging and cross-module root-cause analysis, ReAct wins.

One-sentence boundary: Plan-and-Execute family fits well-informed "build tasks"; ReAct fits unknown-information "diagnostic/debug tasks". Code Agents' daily high-frequency needs (bug fixes, legacy comprehension, incremental changes) are exploratory — hence ReAct dominates.

# Planning paradigm failure: plan becomes stale, triggers re-planning
def plan_and_execute(user_task: str, repo_state: dict):
    plan = llm_generate_plan(user_task)  # one-shot global plan
    for step in plan:
        result = execute_step(step)
        if "UserService" in step and repo_state.get("refactored"):
            # observed UserService refactored to AccountService
            print("Plan invalid: UserService gone, triggering re-plan")
            plan = llm_regenerate_plan(user_task, new_context=repo_state)
            # after multiple re-plans, effectively falls back to ReAct
            return react_fallback(user_task, repo_state)
    return result

Why Pure Multi-Agent Yields Limited Gains

Pure multi-agent approaches (e.g., MetaGPT) assign roles: Architect plans, Coder implements, Tester collects errors, Reviewer audits — with message passing between them.

In tightly coupled codebases, three costs erode benefits:

Context Passing Loss: Understanding code requires vast implicit details (hidden dependencies, compatibility logic, historical quirks). Agents can only pass summaries; critical constraints get lost, causing distorted implementations. Higher coupling → worse distortion.

Debugging Complexity: Single agent traces one ReAct trajectory; multi-agent failures may stem from role division, message loss, timing conflicts, state desync. Locating coordination issues often costs more than fixing the business code.

Diminishing Returns: Current strong models already read, reason, edit, and parse errors. Many tasks close the loop with one agent. Forced role splitting adds rounds, latency, tokens, with minimal accuracy gain.

Industrial compromise: Main ReAct Agent + Temporary Sub-Agents (Claude Code's Sub-Agent pattern). Main agent runs ReAct loop; only for isolated, summarizable tasks (full-repo deprecated API search, bulk analytics tracking) spawn short-lived sub-agents that return summaries and terminate. Sub-agents are essentially special tools inside the ReAct loop, not long-lived peer collaborators.

# Multi-agent context passing distortion
def multi_agent_handoff(task: str, code_context: str):
    architect_plan = architect_agent(task)          # architect produces plan
    summary = compress(code_context, max_tokens=200) # compress context for coder
    # critical details lost in compression: implicit deps, special compat logic
    impl = coder_agent(architect_plan, summary)     # coder implements on fragmented info
    bugs = tester_agent(impl)
    # fix cost > single-agent ReAct loop cost
    return bugs  # information decay causes wrong implementation, coordination debugging extremely hard

ReAct Shortcomings and Hybrid Improvements

ReAct has three core pain points:

Long-task goal drift

Local optima traps

Step explosion

As loops accumulate, history observations flood context; agent gets stuck in detail debugging, forgetting top-level intent; tokens and latency rise. ReAct's greedy decisions lack global view, leading to dead-end exploration branches.

ReCode addresses these by:

Expressing both plans and actions in a Plan-and-Execute style.

Replacing loose natural-language TODOs with structured multi-agent task graphs.

Adding global constraints for long tasks.

It does not replace ReAct but adds a structured planning layer on top — a hybrid paradigm.

Industry consensus: No commercial Code Agent uses a single paradigm. The standard solution is ReAct core + optional front-end planning layer . Mature agents almost never run naked ReAct.

Mainstream hybrid architecture:

Outer dynamic, modifiable planning layer (Plan-and-Execute).

Inner ReAct execution loop.

High-certainty subtasks delegated to LLMCompiler-style multi-agent parallelism.

Bulk retrieval tasks handed to temporary Sub-Agents.

ReAct is the irreplaceable kernel; other paradigms activate as plugins on demand.

# ReCode idea: code DAG replaces natural-language TODO, structured plan recording
class CodeDAGPlan:
    def __init__(self):
        self.nodes = {}   # task nodes: {id: description, status}
        self.edges = []   # dependency edges: (from_id, to_id)
    def add_task(self, task_id: str, desc: str, deps: list = None):
        self.nodes[task_id] = {"desc": desc, "status": "pending"}
        for dep in (deps or []):
            self.edges.append((dep, task_id))
    def get_next_ready(self) -> list:
        # return nodes with no unfinished dependencies, for ReAct loop to execute stepwise
        completed = {k for k, v in self.nodes.items() if v["status"] == "done"}
        return [nid for nid, _ in self.nodes.items()
                if nid not in completed and all(d in completed for d in self._deps_of(nid))]

Mainstream IDE / Code Agent Paradigm Adoption

Commercial products validate the analysis:

ReAct is the universal kernel for GitHub Copilot Agent, Cursor Agent Mode, Claude Code, Cline, Aider.

Plan-and-Execute appears only as optional preview modes (Cursor Plan, Claude Code Plan) — read-only exploration, output diff plan, wait for user confirmation, then execute. Execution phase still dynamically adjusts; underlying loop remains ReAct. Devin uses planner+executor dual models with mid-course re-planning, not fixed one-shot plans.

ReWOO and LLMCompiler rarely surface directly in IDEs. Their ideas are absorbed internally: ReWOO's token savings inform internal optimizations; LLMCompiler's DAG parallelism suits scaffolding, bulk migrations, CI tooling. IDE scenarios have high uncertainty and exploratory branches, making upfront DAG construction impractical for the main flow.

Overall landscape:

No commercial Code Agent relies on a single paradigm.

Industry standard: ReAct core + optional front-end planning layer hybrid.

Plan mode = user-facing diff preview to de-risk large changes.

ReAct loop = execution engine for unknown problems, debugging, dynamic exploration.

ReWOO/LLMCompiler = internal optimization references, not developer-facing IDE paradigm choices.

Interview Answer Framework

For the opening question, a complete high-depth response structure:

State clearly that the mainstream foundation is ReAct; explain the think-act-observe loop.

Present the three core constraints of code tasks (private repo facts, need for environmental feedback, exploratory nature).

Analyze CoT, Plan-and-Execute, Multi-Agent limitations under those constraints.

Describe each paradigm's suitable niche, citing mainstream IDE implementations as evidence.

Conclude that industry uses a hybrid architecture: ReAct as kernel, other paradigms as local enhancement components.