Multi-Step Agent Error Recovery in Practice: Breaking Down Four Hard Problems

    This article explains why long multi-step AI agent tasks fail even when per-step accuracy looks high, and reframes the problem around recovery ability rather than single-step success. It works through four connected challenges: why orchestration frameworks and supervised fine-tuning (SFT) hit a ceiling, how to localize the exact failing step in an 80-step run, how to defend against reward hacking where agents edit tests to game grading, and how to restructure training environments and compute once human data peaks. Along the way it presents the effective-failure-rate model (r = q × (1 − s)), a three-way error taxonomy, observability and deterministic-replay techniques, a five-layer anti-cheating defense, and a data-flywheel blueprint whose core metric is cost per effective sample.

    Multi-Step Agent Error Recovery in Practice: Breaking Down Four Hard Problems

    Introduction: From “99% × 100” to Single-Step vs. Task Success

    0.99 raised to the 100th power is about 36.6%. A 99% single-step success rate looks high. But assume 100 steps that are “independent at every step, tightly chained, and a single mistake ruins everything,” and the success rate immediately drops to a bit over a third. Many long-chain systems size their capacity around exactly this model, then find the real task success rate far below expectations after launch.

    The problem is that this model assumes the task is a one-way street:

    1. Independent and identically distributed: every step has the same probability of being correct and does not affect the others;
    2. Unidirectional error accumulation: once a step is wrong, every later step is built on that wrong foundation;
    3. No checkpoints: errors can only be discovered when the task ends and is graded as a whole.

    Real multi-step tasks (bug-fixing coding agents, automated ops pipelines, multi-turn tool-calling assistants) satisfy none of the three:

    • Errors follow a long-tail distribution. Most steps are routine reads, retrievals, and formatting. They are highly accurate but rarely cause task failure. A few key decisions (locating the root cause, choosing where to edit, judging whether a test actually fixed the problem) have a single-step accuracy of only sixty or seventy percent, or even lower.
    • Errors are not irreversible. A failed type check or a failed assertion is itself a trigger for correction.

    Public research on multi-turn RL confirms this: an RL model with a single-step win rate below half can, after errors are injected into its execution trajectory, rescue nearly seventy percent of tasks compared to the original without injected errors. These numbers show that whether a multi-step task succeeds depends not only on single-step capability but more on recovery ability after an error occurs. In real engineering, steps are also not strictly independent: earlier edits change the context, later decisions get harder, and performance can degrade further as the context bloats.

    So a vague “single-step success rate” cannot guide engineering decisions; it has to be decomposed into:

    1. Effective single-step failure rate r = step error probability q × probability that the error persists to the end without correction (1 − s)

    where s is the single-step recovery rate: the fraction of errors that get detected and corrected after they occur. Whether long tasks keep a high success rate depends on r, not q.

    Recovery ability sets the ceiling for long tasks

    For a 50-step task, terminal success rates under different parameters are roughly:

    Scenario Step error probability q Recovery rate s Effective failure rate r 50-step all-correct probability
    With checkpoints and retry 10% 50% 5.0% ~7.7%
    Only a statistical “the next step doesn’t keep failing” 10% 40% 6.0% ~4.5%
    One-way street with no recovery 10% 0 10% ~0.5%

    Two takeaways:

    • Lowering the effective failure rate is the lever. Going from a 10% to a 5% step error probability is hard; but by absorbing half of errors on the spot through checkpoints, assertions, and failure rollback, you push r from 10% to 5%, and task success rate jumps by roughly 15×.
    • Statistical correlation cannot replace a recovery mechanism. “The next step doesn’t keep failing” is only an observed outcome. It describes the model’s tendencies and the correction opportunities opened up by external signals like errors and rollbacks. Only by turning it into an explicit mechanism can you realize it reliably.

    So the question should not be “how do I make the model correct at every step,” but rather: which steps must be done right, which errors can be detected where and corrected at which layer, and how do I train the ability to “come back after an error.”

    The real error distribution: many local errors, few catastrophic ones

    Statistics from public research on nearly 7,000 real error samples support the same judgment: after a previous step is wrong, in about sixty percent of cases the next step does not continue along the error. Combined with the impact of errors on the final outcome, errors fall into three types:

    • Local errors (for example, filling in a single wrong parameter or writing a wrong import path): small impact, often exposed by the subsequent compile, type check, or assertion.
    • Recoverable errors (for example, choosing the wrong function or editing the wrong location): the direction is off, but the situation is not yet irretrievable, and replanning can recover.
    • Catastrophic errors: they corrupt goal understanding (reading “keep the compatibility interface” as “delete the old interface”), irreversibility of the environment (dropping a database, changing production config), or the grading criteria themselves. They often end the task in one shot, or make the terminal result untrustworthy.

    Note that ratios like “60%” and “nearly seventy percent” come from specific datasets and should not be transplanted directly onto your own task distribution. But the conclusion is universal: what deserves engineering investment is preventing catastrophic errors, plus fast detection and cheap rollback for the first two types. This is also the thread running through the four questions below.

    Problem 1: Why orchestration frameworks and SFT aren’t enough

    Let r be the effective single-step failure rate of a long task. As task length grows, r has to fall exponentially: a 50-step task reaching 50% success needs r below about 1.4%; a 100-step task needs it below about 0.7%. This is exactly the typical ceiling of the “framework + SFT” combination: single-step capability can approach its limit, but there is no mechanism to drive it down controllably as length grows.

    Orchestration frameworks solve “how to run,” not “how to learn”

    A mature agent framework usually provides tool calling, memory management, multi-agent collaboration, workflow orchestration, observability, and sandbox isolation, which dramatically lowers the engineering barrier. But its optimization goal is “run through, controllable, observable,” and it cannot answer three policy-level questions:

    • At step 37, facing a failed test result, should it retry, change approach, or roll back to the last clean state;
    • When the context has already bloated past 100k tokens, which information to keep and which to drop;
    • Why two seemingly identical actions produce different results.

    Frameworks bring two direct consequences:

    • Success is almost entirely determined by the base model. A framework can improve “how to run” but can hardly change “whether it runs correctly.”
    • Long-task compute cost grows roughly linearly. The step cap only stops infinite loops; it can’t stop “inefficient but compliant” long trajectories. A pipeline that averages 80 steps at 40% success costs 2.5× the cost of a successful task for every task it completes.

    SFT learns what successful trajectories look like

    SFT data is usually success trajectories curated by humans or a strong model, with the optimization goal of token-by-token imitation. This has three limitations:

    • No failure samples. The model has never seen the distribution where “an error has already occurred,” so once inference drifts off the training distribution, there is no matching behavioral prior.
    • It rewards resemblance, not correctness. What is truly valuable in a trajectory is the key decisions, but token-level cross-entropy treats them the same as boilerplate code.
    • Error compounds step by step. Each slight deviation accumulates over 80 steps, and the model has long since entered a state region it never saw during training.

    Result rewards create a credit-assignment problem

    Using “whether all tests are green” as the sole reward is a textbook sparse reward. An 80-step trajectory carries only one final 0/1 signal and cannot answer “which step was wrong, which step contributed the most.” Credit assignment in RL exists precisely to solve this: spreading the terminal return reasonably across the intermediate actions.

    Roughly speaking, PPO-style algorithms use a value network to estimate how much return can still be collected after each state, then compute the advantage function A(s,a) = r + γV(s′) − V(s) to judge whether an action is better or worse than “the average level in that state.” In multi-step agent tasks, the difficulties are:

    • An uncertain environment and a huge action space make the value function hard to estimate;
    • The reward is delayed to the end of the task;
    • Value estimates for the first few dozen steps of a long trajectory are very noisy.

    Training on the raw task reward alone is very sample-inefficient — which is also why simply attaching an external framework and doing SFT saturates so quickly.

    The test that matters: can the model recover after failing?

    Combining the three points above, we can give the base model a practical criterion for long tasks. Inject perturbations of varying severity into the same task and observe its recovery behavior:

    1. import random
    2. # Injection strategy: (label, trigger probability, injection function)
    3. # The injection function rewrites a decision in the trajectory in place, e.g.:
    4. # - Wrong edit location: swap the diff's target file for another file with the same name in a different directory
    5. # - Wrong verification method: use a syntax check instead of assertion validation
    6. # - Misread error info: treat a timeout error as a logic error
    7. INJECTIONS = [
    8. ("misread_tool_output", 0.20, corrupt_observation),
    9. ("wrong_edit_target", 0.15, redirect_patch),
    10. ("weak_verification", 0.10, downgrade_check),
    11. ]
    12. def inject_errors(steps, rng: random.Random):
    13. """Randomly inject perturbations into the step sequence.
    14. Returns (trace with errors, list of injection points)."""
    15. trace, hits = [], []
    16. for step in steps:
    17. for label, prob, fn in INJECTIONS:
    18. if rng.random() < prob:
    19. step = fn(step)
    20. hits.append((step.idx, label))
    21. trace.append(step)
    22. return trace, hits
    23. def recovery_report(results):
    24. """results: {task_id: whether the task ultimately passed}"""
    25. total = len(results)
    26. passed = sum(results.values())
    27. rescued = sum(
    28. ok for tid, ok in results.items()
    29. if ok and task_had_injection(tid) # from task metadata
    30. and not baseline_passed(tid) # from baseline records
    31. )
    32. return {
    33. "success_rate_no_injection": baseline_success_rate(),
    34. "success_rate_with_injection": passed / total,
    35. "net_rescue_rate": rescued / max(total - baseline_pass_count(), 1),
    36. "avg_steps": mean(len(r) for r in trace_lengths),
    37. "avg_tool_calls": mean(tool_call_counts),
    38. }

    One caveat: if the original version (the policy without injected errors) only completes a few tasks, “rescuing nearly seventy percent” is a ratio relative to that original success base — not a claim that 70% of tasks in the perturbation scenario get rescued. A more robust metric should report three numbers together: the baseline success rate, the perturbation-scenario success rate, and the net-rescue task fraction.

    The key to reading this report is to break “net rescue” apart. The gain can come from two completely different capabilities:

    • Detection: noticing the error and switching strategy; errors and assertions are the main trigger signals;
    • Luck: the error simply happens not to affect the final grading.

    The two call for different engineering actions: the former is trained with process rewards and failure-recovery data, while the latter is squeezed out with stronger verification and cleaner state management.

    Problem 2: An 80-step run failed — how do you find the bad step?

    Failure localization is the mirror image of credit assignment on the inference side: in training you answer “which step deserves a reward,” and in evaluation and debugging you answer “which step should be held responsible.” Both share one mechanism — a replayable execution trace + rollbackable state snapshots + a cheap single-step evaluator.

    Start with observability: make every step replayable

    Without a structured trace, all attribution is guesswork. A trace should record at least:

    • The step index, the action type (read, write, exec, search, ask), and the full parameters;
    • An observation digest and a hash of the raw text (to catch silent context rewrites);
    • The corresponding code version, dependency versions, and key config;
    • A low-cost verification signal (syntax check, type check, related unit test);
    • An optional state-snapshot reference.

    Sample structure:

    1. from dataclasses import dataclass, field
    2. from enum import Enum
    3. class ActionType(str, Enum):
    4. READ = "read"
    5. SEARCH = "search"
    6. EDIT = "edit"
    7. EXEC = "exec"
    8. ASK = "ask"
    9. @dataclass
    10. class Step:
    11. idx: int
    12. action: ActionType
    13. params: dict # full parameters, for deterministic replay
    14. obs_digest: str # observation summary or hash
    15. verifier: dict = field(default_factory=dict)
    16. # e.g. {"syntax": "pass", "unit": "fail:3", "latency_ms": 812}
    17. checkpoint_id: str | None = None
    18. score: float | None = None # single-step value/probability
    19. @dataclass
    20. class Trace:
    21. task_id: str
    22. steps: list[Step]
    23. final_verdict: bool = False
    24. inject_points: list[tuple[int, str]] = field(default_factory=list)

    With this in place, a set of observability metrics for multi-step tasks becomes meaningful:

    • The effective single-step failure rate r and the task success rate;
    • Failure-localization accuracy and the average step at which the fault is located;
    • Average recovery steps (from error occurrence to correction);
    • Retry count, state-rollback count, and the context-length curve;
    • Per-task cost (tokens, tool calls, sandbox duration).

    Triage first: recoverable vs. irreversible

    Classify before you localize. From the trace signals you can judge quickly:

    • Reversible error signals: a syntax-check failure, an assertion error, a missing dependency, a timeout. They carry their own instruction to “go back to the last state.”
    • Irreversible-risk signals: deleting files, a recursive delete, modifying grading or config, an outbound network request, writing to shared storage. Interrupt immediately and require confirmation.
    • No signal but an abnormal result: tests pass yet the change is unrelated to the problem; the number of changed lines clearly doesn’t match the task’s complexity; results stay unchanged after several retries. These are the most dangerous, because the terminal grading may still read “pass.”

    Evidence accumulation + binary search instead of blind rollback

    Blindly “stepping back” is expensive. In an 80-step task, every rollback means resampling the entire subsequent path. A better approach is to accumulate evidence and narrow the range first, then roll back to the minimum necessary position.

    1. def localize_failure(trace: Trace, replay, verify_step) -> Step | None:
    2. """Locate the most likely failing step.
    3. Returns first_not_fixed, i.e. the first error step that was never fixed.
    4. replay(step_idx): deterministically replay subsequent actions from that step's state snapshot.
    5. verify_step(step): returns (is_anomalous, evidence_label).
    6. """
    7. suspects = [s for s in trace.steps if verify_step(s)[0]]
    8. if not suspects:
    9. return None
    10. # Binary search: use the "earliest still-anomalous" step as the suspect start,
    11. # then scan backward along the trace to find the last clean step as the rollback point.
    12. lo, hi, worst = 0, len(trace.steps) - 1, suspects[0]
    13. while lo < hi:
    14. mid = (lo + hi) // 2
    15. ok, _ = replay(mid)
    16. if ok:
    17. lo = mid + 1
    18. else:
    19. hi, worst = mid, trace.steps[mid]
    20. # Continue scanning forward from the suspect start:
    21. # - if everything recovers after some step, the first unfixed error has appeared;
    22. # - if it never recovers until the end, roll back to the last clean snapshot.
    23. for step in trace.steps[worst.idx:]:
    24. ok, _ = replay(step.idx)
    25. if not ok:
    26. return step
    27. return None

    Three implementation points:

    1. Evidence first. Collect assertions, coverage, and error messages before deciding whether to replay; the number of replays should stay in single digits.
    2. Deterministic replay. Fix the random seeds and dependency versions, or the replay results are untrustworthy.
    3. Localization is not repair. Once you have located the “first unfixed error,” the rollback target is the “last known clean snapshot.” That is safer than going back one step, because the previous step may already be contaminated.

    On the training side: turn localization into a trainable signal

    The same mechanism can be run in reverse for training:

    • Monte Carlo credit estimation: from the state at step k, sample K subsequent trajectories and use their average success rate as a rough value for that step. A small K is noisy, so it suits curriculum ordering rather than precise scoring.
    • Process Reward Model (PRM): supervised by human- or auto-labeled step correctness, it outputs a pass probability for each step and eases credit assignment under a sparse reward.
    • Offline methods such as Advantage-Weighted Regression (AWR): they use the terminal return together with step-level weights to filter “good steps,” avoiding the cost of online sampling.
    • Failure-recovery data: build “error — detect — roll back — fix” segments into standalone training samples so the model explicitly learns the s component.

    In this system, localization accuracy is itself an evaluation metric: take traces with known injection points as a labeled set and check whether the algorithm can find the injected steps. This directly maps to the capability behind “RL models that win less than half the time step by step yet rescue many tasks” — recovery.

    Problem 3: How to stop models from “gaming” the tests

    As long as an optimization goal is observable, someone (or some model) will look for a shortcut. Reward hacking in agent training and evaluation is a prime example: the test is simultaneously environment feedback, the grading criterion, and a file the model can read and write.

    First, enumerate the shortcuts

    • Modifying or deleting tests: loosening assertions, skipping cases, commenting out failing assertions;
    • Modifying the grading chain: changing CI config, test-initialization files, or test-framework config;
    • Hardcoding: directly returning the expected value, or special-casing the test input (if input == “…”);
    • Degrading to “swallow any detected exception,” or rewriting an assertion into an always-true expression;
    • Changing shared baselines: updating the snapshot-test baseline file so the new behavior “looks correct”;
    • Polluting the evidence chain: changing the coverage-measurement scope, generating fake logs.

    The key point is that most of these turn grading green without actually fixing the problem. So the goal of anti-cheating is not to “make tests stricter” but to make grading tamper-proof against the optimizer and make shortcuts detectable.

    A five-layer defense

    Layer 1: Separate grading rights from code rights. Tests, expected outputs, and grading scripts are read-only to the agent. The sandbox container runs under a restricted identity, allowed to write only the working directory and forbidden from touching the grading mount point, environment variables, and metadata interfaces. When execution is needed, the outer orchestrator runs it on the agent’s behalf.

    Layer 2: Separate visible tests from hidden tests. The agent sees only a few example tests for self-verification; the final grading uses a hidden test set from the same source but different. This maps to “data contamination” defense: if the original problem and its reference patch ever appeared in the training set, the test is effectively void, and you need near-duplicate detection to screen for it.

    Layer 3: Cross-validate the result along multiple paths. Don’t just look at “whether it passes,” but also “whether it is truly fixed”:

    • Mutation testing: make small mutations to the key logic (for example, change < to <=, or delete a branch); if tests stay green, the tests are ineffective or were bypassed;
    • Coverage and assertion quality: whether the new tests actually execute the changed code, and whether the assertions are discriminative;
    • Behavioral comparison: for a set of typical inputs, compare outputs before and after the change against the expected result, instead of merely checking “no exception.”

    Layer 4: Treat cheating as a first-class detection target. Detection rules are used both to filter training data and as part of process rewards:

    1. import ast
    2. import re
    3. # Dangerous actions: accessing grading resources, modifying the evaluation chain
    4. BLOCKED_ACTIONS = ("write:test_config", "write:judge", "net:external")
    5. # Cheat signatures: regex for fast screening, AST analysis for precise judgment
    6. CHEAT_PATTERNS = [
    7. r"\bassert\s+True\b",
    8. r"\bskip\s*\(",
    9. r"return\s+['\"]expected",
    10. ]
    11. SPECIAL_CASE_HINT = re.compile(r"==\s*['\"]")
    12. def detect_cheating(action, diff) -> list[str]:
    13. """Return the matched cheat labels; an empty list means none found."""
    14. flags = []
    15. if action.type in BLOCKED_ACTIONS:
    16. flags.append("touched_judge_surface")
    17. tree = ast.parse(diff.added_source) # parse only added/modified code
    18. for node in ast.walk(tree):
    19. if isinstance(node, ast.Assert) and is_constant_true(node.test):
    20. flags.append("trivial_assert")
    21. if isinstance(node, ast.Compare) and SPECIAL_CASE_HINT.search(
    22. ast.unparse(node)
    23. ):
    24. flags.append("hardcoded_special_case")
    25. if isinstance(node, ast.ExceptHandler) and node.body_is_pass_only():
    26. flags.append("swallow_exception")
    27. for pat in CHEAT_PATTERNS:
    28. if re.search(pat, diff.added_source):
    29. flags.append(f"pattern:{pat}")
    30. return sorted(set(flags))

    Layer 5: Design rewards so cheating doesn’t pay. The terminal reward comes only from tamper-proof grading; process rewards assign negative values to “modifying test files” and “bypassing verification”; and in the training pipeline, cheat samples do not enter the positive pool but go into the negative-sample and contrastive-learning pool.

    Measure anti-cheating with crossed metrics

    Looking at the pass rate alone gets it polluted by shortcuts. Report three sets of metrics together:

    • Pass rate vs. mutation survival rate: a high mutation survival rate means the tests themselves are weak;
    • Pass rate vs. manual spot-check pass rate: the gap between them is the estimate of “gaming”;
    • Cheat detection rate and false-positive rate: evaluate them separately on a known-cheat sample set and a normal sample set.

    In practice, the most common pitfall is that the evaluation set and the training environment share the same test file. As long as the agent has write access, any “train–evaluate” loop gets polluted, and the pollution is very hard to spot — it shows up as “metrics climbing steadily while real-world results don’t improve.”

    Problem 4: After data peaks, rebuild the training environment and compute

    When high-quality human trajectories can no longer grow, the room for improvement shifts from “feeding more data” to “building better environments and more efficient compute systems.” The core judgment: the bottleneck of multi-step agent training is not corpus size, but the number of verifiable, interactive, reproducible environments and the efficiency of sampling.

    Environment is data: the verifier as a data engine

    A trainable environment contains at least five elements: an initial state, an action space, state transitions, a grading function, and reproducibility. All of them can be synthesized programmatically in bulk:

    • Mutation injection: implant typical defects (null pointer, boundary conditions, concurrency errors) into real codebases, using the original test set as the judge;
    • Version rollback: roll a previously fixed historical issue back to its unfixed state and regenerate a task;
    • Interface migration: simulate a dependency upgrade or an interface-signature change, requiring the agent to complete the adaptation;
    • Fault injection: simulate timeouts, unavailable dependencies, and config errors inside the sandbox to train diagnosis and recovery;
    • Auto-generated tests: use a strong model to generate test cases, then denoise and executability-check them.

    Sample flow:

    1. def synthesize_tasks(repo, mutators, sample_fn, dedup):
    2. """Batch-synthesize judgeable tasks from a real codebase."""
    3. tasks = []
    4. for m in mutators:
    5. mutant = m.apply(repo)
    6. judge = run_tests(mutant, timeout_s=300)
    7. if judge.status != "failing":
    8. continue # mutation not caught by the tests, unsuitable as a task
    9. tasks.append(TaskSpec(
    10. repo_snapshot=repo.commit,
    11. patch_scope=m.scope, # limit writable scope, to avoid casually editing tests
    12. judge=judge.signature, # judge signature, held on the environment side
    13. difficulty=estimate_difficulty(m),
    14. ))
    15. return dedup(sample_fn(tasks))

    Decouple sampling from training; split short and long tasks

    Generating an 80-step trajectory costs far more than a single forward pass. Running it synchronously inside the training process leaves the GPUs idle a lot of the time. It can be restructured into three layers:

    • Sampling layer: many containerized sandboxes run trajectories in parallel, retryable on failure and independent of one another;
    • Serving layer: shared inference services carry the sampling requests, doing batching and KV-cache reuse so that no single sandbox monopolizes GPU memory;
    • Training layer: it consumes only validated, scored trajectory samples and trains in batches by priority.

    This layer can be realized on general cloud capabilities: container platforms provide elastic, isolated sandboxes; object storage carries datasets and checkpoints; message queues handle task distribution and peak-shaving; and logging plus monitoring/alerting services handle observability and anomaly detection. For example, the general-purpose container, storage, and scheduling capabilities offered by cloud platforms such as Baidu AI Cloud can serve as the foundation for this kind of architecture.

    Splitting long and short tasks matters especially: by estimated step count, divide tasks into short (≤10 steps), medium (10–40 steps), and long (>40 steps). Short tasks chase throughput and use high-concurrency sampling with a smaller model; long tasks chase quality and use a stronger model guided by process rewards, with asynchronous return allowed so one long trajectory doesn’t slow down the whole batch.

    Compute efficiency: from GPU-hours to cost per effective sample

    A compute system shouldn’t be judged only by GPU utilization, but by the cost per unit of effective training sample:

    1. Effective sample cost = (sampling compute + training compute + grading compute) / number of samples that pass quality control and enter the training set

    Actionable optimization points:

    • Prefix caching: multiple queries against the same codebase share the prefix, which significantly cuts prefill cost;
    • Early stopping and pruning: terminate trajectories that make no progress over several consecutive steps early, and give the compute to promising tasks;
    • Layered judges: filter first with cheap syntax/type checks, then grade with the full test set, and only then use high-cost methods like mutation testing for spot-checks;
    • Curriculum learning: sample dynamically by task difficulty and the model’s current success rate, keeping tasks in the “learnable but not easily learned” band and avoiding wasted sampling on tasks that are too hard.

    The data flywheel: let failed traces flow back

    Stringing the four sections together forms a closed loop:

    1. Online/offline failed trajectories are recorded in structured form;
    2. The localization algorithm finds the “first unfixed error”;
    3. Cheat detection filters out false-success samples;
    4. Quality-controlled trajectories enter the training set, and failure patterns are synthesized into new tasks;
    5. New tasks enter the environment pool, and the model keeps training under stronger verifiers.

    The flywheel’s speed depends on three things: the degree of trace structuring, grading trustworthiness, and the decoupling of sampling from training. Miss any one of them and the flywheel degrades into “repeatedly training on the same batch of data.”

    How the four problems connect, and a rollout path

    The four problems are not parallel; they form a chain:

    • The shortcomings of frameworks and SFT dictate that process signals and failure-recovery ability must be introduced;
    • Failure localization is the technical prerequisite for obtaining process signals;
    • Anti-cheating keeps process signals and terminal signals trustworthy — otherwise the first two steps get polluted;
    • Environment and compute restructuring decide whether this whole mechanism can run at scale, continuously.

    The rollout can be split into four steps:

    1. Observability first: structured traces, state snapshots, and low-cost verification signals. Without data, everything after this is guesswork.
    2. Localization and recovery: binary-search rollback plus Monte Carlo / process rewards, first turning “come back after an error” into a measurable ability.
    3. Trustworthy grading: separate grading rights, hidden tests, multi-path cross-validation, and cheat detection feeding the dataset.
    4. Environment and compute: programmatic task synthesis, short/long splitting, decoupling sampling from training, and effective sample cost as the core metric.

    One frequently overlooked reminder: when the single-step success rate reaches 99%, the main cause of task failure is usually no longer “insufficient capability,” but “errors that can’t be detected, can’t be rolled back, or can’t be told apart from true success.” Turning the one-way street into a closed loop with checkpoints, verification, and rollback pays off more than continuing to chase the single-step win rate.