Harnesses and self-improvement: which layer changes?¶
简体中文 · English
Agents / 188 questions · 47 papers
Try answering each question before opening the explanation. The bank grows as papers and questions are added.
Read this topic's comparisons, analysis, and cross-paper Q&A
188 questions · 47 papers
Agents / Harnesses and self-improvement: which layer changes?
Basics
Does Strategist accumulate model parameters, the current answer, or another cross-task asset?
Strategist: Evolving Reasoning with Agents
Show answer and example
Answer: It freezes executor models and represents reasoning programs as Python blueprints with one execute interface. After evaluation, they enter a cross-task library with measurement cards and training-trace experience. Task prompts are separate from structure; later tasks can compose or reuse structures. This is neither gradient training nor merely editing the current answer.
Illustrative example: Teaching example: a discovered procedure that creates three candidates and reviews them independently can be retested with new prompts in another domain. Saving one problem's final number is not reusable blueprint accumulation.
Sections in the Chinese source: 背景与主要改动, 代码映射. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Do exactly two percentage points of accuracy gain and exactly 2% lower cost automatically satisfy Strategist's win rule?
Strategist: Evolving Reasoning with Agents
Show answer and example
Answer: No. Improvement requires more than two percentage points or a cost ratio strictly below 0.98; the other metric must remain within its tolerance band. The candidate must win on validation and hidden, then ranks by hidden accuracy gain and cost ratio. The default rule is not a confidence test, even though standard errors are computed.
Illustrative example: Teaching example: d=0.02 and cost ratio 0.98 are ties. d=0 and ratio 0.97 can be a cost win, but a three-percentage-point hidden accuracy loss still prevents selection.
Sections in the Chinese source: 核心公式, 数据协议与实现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Both Strategist and EvalAlloc inspect candidate measurements. Do they optimize the same object?
Strategist: Evolving Reasoning with Agents
Show answer and example
Answer: No. Strategist proposes and composes executable reasoning strategies, retaining structures and experience for later tasks. EvalAlloc mainly determines which SEARCH evaluation cells to execute, how shared references estimate fitness, and how final confirmation works. Cheap observations or high predicted scores do not generate better strategies, and library admission does not establish held-out success.
Illustrative example: Teaching example: evaluating 100 fewer items changes the observation budget. Replacing direct answering with a reusable decomposition-and-review program changes strategy structure. They can be combined, but costs and real held-out success need separate records.
Sections in the Chinese source: 背景与主要改动, 本地结果与负控, 高成本完整实验. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why do passing AST, DAG, and paired-pick tests not establish a complete Strategist or Evolve integration?
Strategist: Evolving Reasoning with Agents
Show answer and example
Answer: The module calls no designer or executor model; retrieval scores and candidate evaluations are supplied externally. Explicit prompt elision is only a structural fingerprint, not proof about helper semantics or dynamic dependencies. Paired-pick does not isolate hidden data within a Python process. Actual proposal, execution, retrieval, and information-flow isolation require separate acceptance. The present CPU diagnostic is not promotion-eligible capability.
Illustrative example: Teaching example: synthetic arms with accuracy 0.7 and costs 10 and 8 verify ratio 0.8 and fallback behavior. No model has answered a question, and cross-task search has not been demonstrated.
Sections in the Chinese source: 数据协议与实现边界, 本地结果与负控, 代码映射. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does RSI-Opt improve optimization methods instead of only optimizing one fixed model?
RSI-Opt: Recursive Self-Improvement Optimizer Agents For Model Training
Show answer and example
Answer: An update that works now may fail on other models or stages. RSI-Opt treats the updater as the evolving object, evaluates controlled runs, and decides what to keep. Distinguish inner optimization from outer method selection. Candidate prose or one strong score does not establish broad gains.
Illustrative example: Example: Train a small model with one rule, then compare rules under equal budgets rather than retain one run's best weights.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why hide final metrics from the inner agent while letting the outer loop evaluate strategy with them?
RSI-Opt: Recursive Self-Improvement Optimizer Agents For Model Training
Show answer and example
Answer: The inner agent edits an updater from training loss and diagnostics. Final metrics would let it tune directly against evaluation. The outer loop compares fixed strategy outcomes and has a different selection role. Inherited prompts, libraries, and cadence make it recursive; normalized rankings are not unseen-task generalization.
Illustrative example: Example: Tune update rules from training loss; compare strategies after execution rather than inspect test scores for every edit.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why fix model, data order, and update budget across candidates rather than only seed?
RSI-Opt: Recursive Self-Improvement Optimizer Agents For Model Training
Show answer and example
Answer: Changing architecture, loss, or duration confounds updater effects. A fixed contract controls the optimization problem, and failed updater trials can roll back. Multiple seeds do not repair systematic protocol differences or make training-suite scores generalization.
Illustrative example: Example: A gets ten thousand steps and B gets a thousand. The same seed does not attribute their score difference to the updater.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
What are the evidence limits of archiving low-score descendants and removing exposed branches?
RSI-Opt: Recursive Self-Improvement Optimizer Agents For Model Training
Show answer and example
Answer: Archive evaluated low-score strategies to preserve failed exploration rather than fake monotonic progress. Removing a branch exposed to held-out descriptions may not remove summaries read by other descendants. The paper leaves that provenance issue open. Z-score aggregation is not significance testing.
Illustrative example: Example: Deleting a contaminated policy while retaining summaries based on it can still leak to descendants.
Sections in the Chinese source: 核心公式, 本地复现. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why do fixed original requirements matter more than increasing a five-axis average?
ImageRSI: Verification-Driven Recursive Self-Improvement for Agentic Image Generation
Show answer and example
Answer: Repair must meet original counts, relationships, wording, and identity constraints. It cannot discard difficult conditions or average away failures. Five dimensions diagnose issues; hard vetoes govern acceptance. A high score does not guarantee image facts.
Illustrative example: Example: Beauty cannot compensate for two cups when three and correct text were required. Do not change the request to two or three.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can't a high in-loop image score automatically activate an extracted strategy?
ImageRSI: Verification-Driven Recursive Self-Improvement for Agentic Image Generation
Show answer and example
Answer: A judge that guides repairs and scores their gains can amplify its biases. Compare with and without experience at matching request, configuration, and seed; calibrate with independent blinded judgments and admit on a held-out set. Hard constraints cannot be averaged away. Returning a fallback is not acceptance.
Illustrative example: Example: A strategy improves composition to please the judge but misses the required person count. Independent matched tests and vetoes expose this.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why separate experience extraction from independent paired admission?
ImageRSI: Verification-Driven Recursive Self-Improvement for Agentic Image Generation
Show answer and example
Answer: A strategy inferred from a trajectory is only a candidate. Compare with and without it under matched request, input, configuration, and seed, then blind-calibrate and use independent holdout. In-loop judges may favor their own guidance; test verdicts must not guide generation.
Illustrative example: Example: Stronger spatial wording works on one image. Pair on new requests to see if it harms other relations or styles before admitting it.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does returning the highest-scoring fallback after two repairs mean accepted?
ImageRSI: Verification-Driven Recursive Self-Improvement for Agentic Image Generation
Show answer and example
Answer: No. The best of the initial image and up to two repairs may be returned even if all fail hard constraints. Judge SFT/GRPO updates between collection rounds, not within one evaluation request. Local generation, semantic judging, and training are unimplemented, so formulas are not system verification.
Illustrative example: Example: If all three images misspell required text, the prettiest fallback still fails the checklist.
Sections in the Chinese source: 核心公式, 本地复现. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why can another model call after tool feedback repeat an already completed decision in HarnessMM?
HarnessMM: Recursive Self-Improvement for Harness Token Efficiency
Show answer and example
Answer: The prior turn can decide a later command while waiting for a prerequisite. Once a guard holds, another reasoning call may add nothing. HarnessMM reuses committed decisions to avoid slow calls, but genuinely new interpretation goes back to the model. Reuse is not arbitrary future prediction.
Illustrative example: Example: If a specified test should follow successful file creation, trigger it from the receipt. An unexpected error needs new reasoning.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why do closed arguments and true guards not prove a skipped model call was correct and actually avoided?
HarnessMM: Recursive Self-Improvement for Harness Token Efficiency
Show answer and example
Answer: They show an action can be reused, not that it completes the task; the original evaluator still judges semantics. Execution certificates must bind exact arguments, predecessor receipts, and tool outputs, and audit that the registered slow call did not occur. Theoretical savings differ from actual calls; include failures and recovery.
Illustrative example: Example: Directly run a saved test command, keep the receipt, and verify no extra slow model request before counting a saving.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does reusing a fixed action differ in online freedom from planning a new action?
HarnessMM: Recursive Self-Improvement for Harness Token Efficiency
Show answer and example
Answer: Reuse is limited to previously resolved actions with complete arguments and satisfied guards. It cannot invent steps or fill parameters from new evidence. Planning interprets observations and constructs actions. Reuse saves repetition only where covered; otherwise abstain. Structural success is not semantic correctness.
Illustrative example: Example: A saved test command can trigger on success. A new dependency conflict cannot be fixed by guessing a command in the reuser.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why include failures, fallbacks, and development in HarnessMM cost accounting?
HarnessMM: Recursive Self-Improvement for Harness Token Efficiency
Show answer and example
Answer: An episode counts all real input and output tokens: structure generation, selection, extra context, recovery, and final synthesis, including cached input. Record development separately and amortize over deployments. One fewer slow call does not guarantee lower total tokens, latency, or energy.
Illustrative example: Example: Saving one main-model call but adding two selection/recovery calls requires counting all. Amortize graph construction over actual reuse.
Sections in the Chinese source: 核心公式, 本地复现. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why use inheritable harness classes for specialization across tasks?
Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design
Show answer and example
Answer: A generic flow may not suit every task, while copying whole implementations loses shared verified logic. Classes express reusable behavior and overrides, then route tasks to suitable variants. Inheritance organizes code and does not add runtime agents or guarantee universal improvement.
Illustrative example: Example: A browsing subclass reuses recovery and changes search. Selecting it executes one flow, not parent and child separately.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why doesn't inheriting a parent harness method mean running several ancestor agents?
Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design
Show answer and example
Answer: Inheritance reuses code: one instance invokes a non-overridden parent method, without separate ancestor trajectories. A subclass changes only needed hooks; deployment selects one frozen class. Cluster gains do not guarantee global gains, and self-confidence ablations are not calibrated success probability.
Illustrative example: Example: Override the search prompt while retaining the parent's terminal implementation. That is one agent, not two parallel collaborators.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What is the trade-off between strict target-cluster admission and one global mean?
Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design
Show answer and example
Answer: The target cluster must strictly beat its current specialist and pass extra checks, so a global mean cannot hide a local regression. This does not guarantee gains elsewhere. Routing uses public tasks and observed base traces, not test grader scores. Self-reported 0.7 is uncalibrated.
Illustrative example: Example: Validate a spreadsheet-specific change on spreadsheets. Gains on an easier unrelated cluster cannot mask no improvement there.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why must a specialized class start in the same initial environment, whereas selecting Base can reuse its result?
Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design
Show answer and example
Answer: Base runs before routing, so its existing result can be used if it is ultimately selected. A specialized class must reset through tool_factory so that it does not inherit Base's progress. Real external effects are not guaranteed to roll back. Trusted local Python classes and allowlisted data isolation are not a security sandbox, and a scripted actor does not demonstrate LLM capability.
Illustrative example: If Base has already created half the files, letting a specialist continue would make it look more successful. A fair comparison starts from the same initial file state.
Sections in the Chinese source: 核心公式, 本地复现, 成本与复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
How does evolving the interface differ from accumulating skills composed from existing tools?
Show answer and example
Answer: Skills generally combine procedures over a fixed action and observation interface. S4 lets a Meta-Agent change interface code and usage knowledge, changing what the task agent can see and do. The task model and harness are held fixed to isolate the interface effect, but a new interface still needs execution on real tasks; renaming the repository version is not enough.
Illustrative example: Replacing cell-by-cell editing with bulk operations over a region changes the interface. Recording that cells should be sorted before editing is usage knowledge for the existing tool.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why retain a temporarily low-scoring child interface repository in the population rather than keeping only changes that strictly improve on their parents?
Show answer and example
Answer: Evolutionary search may have to pass through local valleys or combine different changes. Retaining descendants lets later mutation and crossover reuse their structure. Validation scores guide parent selection, but validation traces and labels are not exposed to the Meta-Agent. What evolves is the action and observation interface itself; the search is not greedy acceptance of the best patch in each round.
Illustrative example: An interface change may perform modestly on its own but work well with observation compression from another lineage. Immediately discarding all low-scoring children eliminates that opportunity.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How do single-parent mutation and two-parent crossover differ in where they get their changes?
Show answer and example
Answer: Mutation modifies the interface and usage knowledge of a single parent. Crossover combines structures or experience from two different parents. Both construct candidates from unlabeled training traces; private validation outcomes are used only for population selection, not handed to the Meta-Agent as answers. Crossover broadens the available combinations but can introduce incompatibilities, so freeze the resulting child before independently evaluating it.
Illustrative example: One parent improves screenshot observations and another improves bulk editing. Crossover can attempt both, whereas single-parent mutation works from just one current repository.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why does BuilderContext omit validation diagnostics, and why does low-score pruning retain lineage?
Show answer and example
Answer: Validation is used only to select parents. Passing diagnostics would turn a protected selection set into development feedback. Pruning revokes parent eligibility while retaining audit history and final candidates, including failures. The local controller uses trusted callbacks and synthetic tasks; it neither executes arbitrary interface source nor demonstrates improvement in a real GUI.
Illustrative example: If the Meta-Agent sees filenames from validation failures and fixes them directly, it is no longer developing from the permitted training traces. Deleting low-scoring records would also conceal the cost of search.
Sections in the Chinese source: 核心公式, 本地复现, 成本与复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why should aptamer design repeatedly connect computational proposals to real experimental feedback?
Aptamers as a sandbox for lab-in-the-loop agentic molecular discovery
Show answer and example
Answer: A computational model estimates candidate properties from existing data; actual molecular behavior may depend on factors it did not model. This work uses real measurements to test proposals and inform the next round, making experimentation rather than a predicted score the decisive feedback. Changing candidates and selection conditions across rounds means progress in the loop does not automatically demonstrate stronger performance on a fixed test set.
Illustrative example: If a candidate favored by the model performs modestly when measured, use the counterexample in the next round. Raising its predicted score does not alter the physical measurement.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can't high computational-proxy scores replace real experimental feedback, or be compared across rounds as fixed-test gains?
Aptamers as a sandbox for lab-in-the-loop agentic molecular discovery
Show answer and example
Answer: Computational scores can disagree with physical measurements. The point of the loop is that new measurements can refute predictions and preserve evidence of failures. Candidates and strategies differ across rounds, and hit rates depend on the selected distribution, so these are not directly comparable machine-learning scores on the same test set. The work assesses research orchestration and does not imply specific laboratory procedures.
Illustrative example: If one round tests only the proxy's favorite candidates and the next focuses on exploration, different hit rates may reflect selection rather than improved generalization.
Sections in the Chinese source: 背景与主要改动, 核心机制与评测. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What information is added by a new physical measurement versus repeated reanalysis of existing experimental records?
Aptamers as a sandbox for lab-in-the-loop agentic molecular discovery
Show answer and example
Answer: Reanalysis may improve interpretation or candidate selection but creates no new physical observation. A new measurement tests a previously unverified candidate and may expose model omissions. Both can support research, but recomputation is not an independent experiment and a simulated proxy cannot replace the experimental endpoint. For cross-round comparisons, preserve changes in candidates and measurement conditions.
Illustrative example: Reranking ten existing results still leaves ten measurements. Testing an eleventh candidate adds a genuinely new piece of external feedback.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why doesn't the local record replace the physical endpoint with simulated measurements or predicted scores?
Aptamers as a sandbox for lab-in-the-loop agentic molecular discovery
Show answer and example
Answer: Real experiments can falsify the computational proxy, a defining feature that would disappear if they were replaced. The local entry documents research orchestration and cost only; it includes no model, GPU receipt, capability metric, or Evolve integration. A numeric fixture cannot stand in for a specialized laboratory or feedback that takes days, and no experimental operating procedure is provided.
Illustrative example: Randomly generating a 'measurement passed' label can test a messaging interface, but does not establish physical efficacy or complete an experimental loop.
Sections in the Chinese source: 核心机制与评测, 本地复现与成本决策. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why do long terminal-agent tasks present a harder reinforcement-learning feedback problem than single-turn answers?
Terminal-RSI: Recursive Self-Improving Terminal Agents via Recursive Self-Rewrite and Policy-Refine
Show answer and example
Answer: Terminal tasks include commands, long observations, and state changes across turns. Success is often known only at the end, making it hard to assign credit to early actions; failure may also come just short of completion. Terminal RSI structures rewards and advantages around this interaction to support continued training. Partial progress is not completion, and observation length is not a direct measure of interaction time.
Illustrative example: An agent fixes the code but never runs the final test. A terminal failure label alone hides useful earlier actions; training should use evidence of progress without relaxing the completion standard.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why does TB-GAE decay by interaction turn rather than observation text length?
Terminal-RSI: Recursive Self-Improving Terminal Agents via Recursive Self-Rewrite and Policy-Refine
Show answer and example
Answer: Longer tool output does not imply more elapsed decision steps. Treating a long observation as many recurrence nodes would arbitrarily over-discount credit for earlier actions. Recurrence runs only over generated tokens, with no decay within a turn and discounting across turns. Chunk continuation requires both value and advantage; a computational boundary is not an environment termination.
Illustrative example: Two commands can produce the same outcome with ten lines or a thousand lines of logging. Verbosity alone should not reduce earlier actions' reward credit.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why do SPR and the plain partial-score FDR method rank outcomes differently?
Terminal-RSI: Recursive Self-Improving Terminal Agents via Recursive Self-Rewrite and Policy-Refine
Show answer and example
Answer: FDR scales partial scores by a family divisor and has no fixed upper bound, so a high-partial-score failure can outrank a success. SPR adds strict success and constrains the partial component below one, keeping failures below strict successes. This ranking property is not a proof about policy-gradient variance or potential invariance, and the paper's overall training gains cannot be attributed to this formula alone.
Illustrative example: A high-scoring incomplete attempt can exceed one with FDR. With SPR, it stays below the minimum score of any strict success.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why isn't a value bootstrap alone enough when GAE is computed in chunks?
Terminal-RSI: Recursive Self-Improving Terminal Agents via Recursive Self-Rewrite and Policy-Refine
Show answer and example
Answer: A chunk boundary does not terminate the environment. Pass both the next value and next advantage to retain the tail of the trace; emit terminal reward only once. Observations are excluded from the recurrence. The local implementation is a numeric operator without actor, critic, RSR, or real terminal training. Equivalence in the unit-clock case does not show that TB-GAE was deployed online.
Illustrative example: If the tail advantage is reset after splitting at the eleventh generated token, credit from later rewards no longer propagates backward equivalently, even with a correct next value.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射、成本与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does RSIFlow first diagnose what kind of object is responsible when automated research fails?
RSIFlow: Adaptive Self-Improvement Workflows with an Evolving Meta-Agent
Show answer and example
Answer: Poor results can stem from the model, the execution process, or a defect in the current artifact. Always editing prompts or always retraining would misallocate resources. RSIFlow uses execution evidence to select an intervention related to the failure. Both the diagnosis and the candidate need actual verification: choosing a branch does not show that its bottleneck was resolved.
Illustrative example: Fix the artifact if its output file has the wrong format; change the harness if the tool flow repeatedly omits verification. Neither necessarily requires retraining model weights.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why must all RSIFlow candidates start from the same frozen parent?
RSIFlow: Adaptive Self-Improvement Workflows with an Evolving Meta-Agent
Show answer and example
Answer: If the first candidate's changes leak into the second, improvements cannot be attributed to the selected Model, Harness, or Artifacts intervention. A shared parent and task batch provide a paired baseline. Only valid, strictly improving candidates are accepted; after a failure, retry from the original parent. Skills may come from training experience, but report-set scores must not leak into maintenance.
Illustrative example: Evaluate a prompt change and a model replacement separately against the same parent, rather than attributing the cumulative improvement of the second run to the model alone.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What layer of future execution does each Model, Harness, or Artifacts intervention change?
RSIFlow: Adaptive Self-Improvement Workflows with an Evolving Meta-Agent
Show answer and example
Answer: Model interventions target the model; Harness interventions change how execution is organized; Artifacts interventions act on deliverables. Their scopes and inherited state differ. Comparisons must state what changed: a one-off file fix is not general policy learning, and out-of-scope changes cannot be mixed into the designated branch. The local variant uses trusted callbacks and skill memory.
Illustrative example: Fixing one report changes only that artifact. Changing a check that runs on every task may affect future tasks, but transfer still needs verification.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does a CPU controller with trusted callbacks demonstrate that full RSIFlow is integrated with Evolve?
RSIFlow: Adaptive Self-Improvement Workflows with an Evolving Meta-Agent
Show answer and example
Answer: No. The callbacks and structural evidence verify parent protection, paired acceptance, failure retention, and separation of training from reporting. There is no built-in LLM, arbitrary program execution, or six-benchmark training. Declared edit scopes and high numerical fixture scores cannot replace real candidate execution and promotion evaluation, and the in-process interface is not a sandbox for malicious code.
Illustrative example: A scalar proposer that changes one number and improves a score shows that a controller branch is reachable. It does not show that real model parameters or a harness were updated as in the paper.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射、成本与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does AutoSFT make the selection and organization of training data an object of automated research?
AutoSFT: An Agentic System for Automated Data Research in Supervised Fine-Tuning
Show answer and example
Answer: Different data contents, quality levels, and combinations can produce different capabilities from the same base, while manually trying many recipes is costly. AutoSFT proposes and tests data hypotheses rather than changing a training hyperparameter once. To understand a data change, control training conditions and isolate evaluation; rising development scores do not establish final generalization.
Illustrative example: If formatting errors may stem from a shortage of examples, add those examples and compare from the same base. Reusing previous-round weights introduces extra training history.
Sections in the Chinese source: 背景与主要改动, 核心公式：固定训练合同的形式化. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why is retraining from the same base each round important for attributing the effects of data research?
AutoSFT: An Agentic System for Automated Data Research in Supervised Fine-Tuning
Show answer and example
Answer: This makes cross-round changes primarily attributable to the data pool, mix, and order, rather than cumulative learning from the previous round's weights. Fix the trainer and budget and register intervention hypotheses to compare whether the predicted mechanisms appear. Proposals from different analytical views are not completed experiments, and predictions must not be rewritten after seeing the scores.
Illustrative example: If round two repairs examples with incorrect answers, retrain from the same base. Continuing from round one's weights would confound the change with extra optimization steps.
Sections in the Chinese source: 背景与主要改动, 核心公式：固定训练合同的形式化. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How do four analytical views differ from a single agent adjusting only dataset proportions?
AutoSFT: An Agentic System for Automated Data Research in Supervised Fine-Tuning
Show answer and example
Answer: Data, failures, training signals, and past research provide different evidence. Execution subagents return traceable artifacts and the Meta Agent chooses interventions beyond changing the mixture. The authors' six action categories were identified retrospectively rather than used as a fixed menu; a table of rule-based options is not open-ended data research.
Illustrative example: Failure analysis may suggest correcting answers, while training signals point to ordering. Compare the two proposals using evidence, rather than increasing one category's share by five percentage points every round.
Sections in the Chinese source: 背景与主要改动, 核心公式：固定训练合同的形式化. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why preregister hypotheses before training, and why retain an independent external holdout after decontamination?
AutoSFT: An Agentic System for Automated Data Research in Supervised Fine-Tuning
Show answer and example
Answer: Record the change, control, expected direction, and evidence in advance to prevent rewriting predictions after the fact. Repeatedly using the same evaluation failures and choosing the best score can adapt to that evaluation even without direct n-gram duplication. Only a separate, frozen holdout offers a distinct test of generalization. The local project did not run the eight-H800 training or the paid research campaign and supplies no simulated training metrics.
Illustrative example: If the score increases but the predicted evidence does not appear, report that the hypothesis was not confirmed. Do not revise the earlier prediction to match the outcome.
Sections in the Chinese source: 核心公式：固定训练合同的形式化, 成本决策与本地状态. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
What is the role of separating the research agent from the asynchronous training and evaluation service?
Athanor: An Agent-Native System for Autonomous Post-Training Research
Show answer and example
Answer: The agent selects data, algorithms, and stages. The service trains, decontaminates, runs frozen evaluation, and saves checkpoint lineage, connecting proposals to real artifacts. Separation also helps restrict access to the final held-out set. Development scores returned by the service remain noisy and are not the true performance of every proposal.
Illustrative example: After the agent proposes self-distillation, wait for the service to complete and record the new checkpoint and evaluation. A proposal saying 'expected to improve' is not an outcome.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why does an independent training service also need frozen evaluation and checkpoint lineage?
Athanor: An Agent-Native System for Autonomous Post-Training Research
Show answer and example
Answer: Asynchronous experiments produce many combinations of data, algorithms, and stages, which filenames alone cannot identify. Lineage makes parent-child relations traceable, frozen evaluation limits drift as search progresses, and a final held-out set isolates the researcher's selection. A single highest development score can be noise, not evidence of robust capability gains.
Illustrative example: For a model that underwent SFT, merging, and then self-distillation, missing parent checkpoints make it difficult to explain which intervention changed the score or to reproduce the candidate.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
If external teachers are prohibited, how does self-distillation differ from using a stronger commercial teacher?
Athanor: An Agent-Native System for Autonomous Post-Training Research
Show answer and example
Answer: Self-distillation uses permitted models and existing data within the system. An external teacher introduces additional capability, cost, and data provenance, violating the research contract. A commercial model may power the research agent, but its answers must not be slipped into training labels. Keep research control separate from supervision of the model being trained.
Illustrative example: A commercial agent may plan the next round, but adding its high-quality solutions directly to the dataset no longer satisfies the no-external-teacher setting.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why can't the highest development score found during search serve as the final formal result?
Athanor: An Agent-Native System for Autonomous Post-Training Research
Show answer and example
Answer: Selecting the maximum over repeated proposals on a noisy development set introduces selection bias. Formal comparisons must distinguish the campaign, submitted multi-seed averages, and reevaluation under consistent decoding; the final held-out set is hidden from researchers. The local entry is a literature and cost review only, with no automated research run, model execution, or GPU receipt.
Illustrative example: One chance high score in a hundred evaluations does not establish a checkpoint's expected ability. Freeze selection and reevaluate under an independent protocol.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why might a real-time agent reason better but still act incorrectly because it responds too slowly?
The World Won't Wait: Evaluating and Teaching Agents Under a Live Clock
Show answer and example
Answer: The environment keeps changing during inference, so an action based on an old observation can be stale by execution. TORSI studies improving a small execution policy under real-time constraints without putting all high-quality guidance on the online critical path. Account for offline learning and online response separately; static accuracy is not effective action in a live environment.
Illustrative example: A model spends a long time choosing a correct action for a moving target's old position and misses when it acts. Both response speed and observation freshness matter.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why shouldn't response latency and action age be combined into one metric?
The World Won't Wait: Evaluating and Teaching Agents Under a Live Clock
Show answer and example
Answer: Response latency ends when the model returns; action age also includes queuing and applying the action. A live environment keeps changing, so a fast response can still be obsolete when applied. A slow teacher may practice and refine guidance from feedback only between attempts, and independent validation decides whether to replace it. It cannot peek at future live-test states to correct actions.
Illustrative example: The model decides to jump within one second, but the command is queued for another two seconds and the obstacle is already gone. The three-second action age explains the failure better than one-second response latency alone.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does slow-teacher online takeover differ from TORSI's offline guidance between attempts?
The World Won't Wait: Evaluating and Teaching Agents Under a Live Clock
Show answer and example
Answer: Online takeover places the slow model in real-time control, where delay can make its decisions obsolete. TORSI has the slow teacher analyze feedback and practice between attempts; guidance is then frozen and the fast student executes independently. The teacher cannot revise from test data. Guidance is accepted only for strictly positive gains on independent validation, and replay practice is not live execution.
Illustrative example: A teacher can explain a failed tracking run offline. In the next live run, the student must choose actions quickly on its own rather than pausing the world for step-by-step answers.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does TORSI accept new guidance on a validation tie, and what was tested locally?
The World Won't Wait: Evaluating and Teaching Agents Under a Live Clock
Show answer and example
Answer: No. Complete pairs with identical task IDs must show a strictly positive mean gain, and feedback, validation, and test remain separate. Timestamps must be finite and ordered. The local tests cover timing and numeric selection contracts only, with no game engine, Jev, or teacher run. Fixture differences in action age are not improvements in game progress.
Illustrative example: If old and new guidance earn the same validation score, do not replace the old one because the new explanation is longer. Nor can you select it retroactively because its test score was slightly higher.
Sections in the Chinese source: 核心公式, 本地复现, 成本与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why not combine functionality and safety into an unconstrained average first?
Harmony Harness: Multi-Objective Self-Evolution of Agent Harnesses
Show answer and example
Answer: Better functionality might come from relaxed checks, and an average can let a high functionality score offset serious safety regression. Harmony keeps both objectives and searches through preference subproblems and neighborhood replacement so deployments account for each. It is not a proof of safety against all attacks, and separate marginal rates are not joint success on the same trajectory.
Illustrative example: A trajectory can finish the task while leaking protected data. Mark functional success and safety failure rather than averaging it into a passing result.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why isn't min(functional success rate, safety success rate) the joint success rate?
Harmony Harness: Multi-Objective Self-Evolution of Agent Harnesses
Show answer and example
Answer: The two marginal rates can come from different trajectories. Joint success requires both criteria to be met in the same execution. Multiobjective search uses preferences and neighborhood replacement to maintain trade-offs rather than increasing functional scores by weakening safety. Final selection and held-out reporting sets also need to remain separate, or reporting environments become search feedback.
Illustrative example: In ten executions, eight can be functionally successful and eight safe while their failures do not overlap. Joint success can then be only six, so taking the minimum marginal count of eight overstates it.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does weighted Chebyshev differ from fixed linear weighting when retaining candidates?
Harmony Harness: Multi-Objective Self-Evolution of Agent Harnesses
Show answer and example
Answer: Chebyshev uses the largest weighted deviation from the ideal point, emphasizing the weakest objective. Different preference vectors maintain separate harnesses; replacements require strict improvement in the neighborhood, with at most two per step. A fixed linear sum can let a large gain on one objective offset losses on another. The selection geometries differ, but both depend on reliable evaluation.
Illustrative example: For a candidate with 90% functional success and 30% safety, maximum deviation highlights the safety weakness, whereas a simple average may still beat a more balanced option.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Can the final max-min selection choose the best harness on held-out OOD tasks?
Harmony Harness: Multi-Objective Self-Evolution of Agent Harnesses
Show answer and example
Answer: No. Select the final harness by max-min over functionality and safety estimates from the search set, leaving held-out ID and OOD for evaluation. Joint success requires both criteria on the same trajectory. Locally there is no MOEA/D, real Docker environment, or exploit evaluation; a scalarization formula does not validate complete self-evolution.
Illustrative example: If the marginal rates are 80% functional and 70% safe, joint success is not necessarily 70%. Failures may occur on different tasks, so intersect successes trajectory by trajectory.
Sections in the Chinese source: 核心公式, 本地复现与成本判断. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does a world model's prediction still need external validation feedback?
RSI-Anything: Unlocking Recursive Self-Improvement with World Models
Show answer and example
Answer: A prediction can screen consequences in advance but can be wrong; external tools or the environment supply actual evidence. RSI-Anything uses feedback to update persistent policy or workflow and updates the predictor only if reliability is insufficient and adaptation data and budget are adequate. A high predicted score is not verified task success.
Illustrative example: A programmatic layout predicted to be valid still needs a trusted geometry checker. If the result conflicts, record the prediction error instead of using the prediction as verification.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why check policy–predictor pair compatibility after each component passes its own checks?
RSI-Anything: Unlocking Recursive Self-Improvement with World Models
Show answer and example
Answer: The policy may depend on the old predictor's state or assumptions. A new predictor can be accurate in isolation but incompatible with it. Test the behavior of both together and revert to the known pair if it fails. Predictor adaptation also requires insufficient reliability and enough data and budget. Automatic retraining each round or isolated component passes do not establish system improvement.
Illustrative example: If a predictor changes the action encoding order and the policy still expects the old order, both unit tests may pass while integration fails. Roll back the combination rather than just recording two passes.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What is the trade-off between updating only the policy and adapting the world model too?
RSI-Anything: Unlocking Recursive Self-Improvement with World Models
Show answer and example
Answer: A fixed predictor gives a stable evaluator but may mislead persistently. Adaptation can address distribution shift, yet costs more and can alter interfaces the policy depends on. The framework gates adaptation by reliability, data, and budget and runs component and paired checks. Lower predictor loss does not by itself establish a better overall policy.
Illustrative example: The old workflow may read the wrong field once the predictor learns a new feedback format. Check the pair rather than just verifying that both components can run in isolation.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
When may the predictor adapt, and why not update it after every failure?
RSI-Anything: Unlocking Recursive Self-Improvement with World Models
Show answer and example
Answer: Adaptation is triggered only when world-model reliability is insufficient, adaptation data are sufficient, and the remaining update budget covers the estimated cost. Failures do not necessarily come from the predictor, and updating on too few samples can chase noise. External verification does not remove the need for version attribution and pair compatibility checks. A short local run does not establish long-term self-improvement.
Illustrative example: A single erroneous prediction suggests unreliability, but without enough adaptation data or remaining budget, do not force training and call the resulting noisy update learning.
Sections in the Chinese source: 核心公式, 本地复现, 结果、验证与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Harness² study improving agent workflows without reference answers or scoring rubrics?
Harness²: Recursive Agent Harnessing for an Open World
Show answer and example
Answer: Many real tasks specify a deliverable without providing a callable correctness oracle. Execution probes can still expose workflow weaknesses. Harness² studies constructing a better harness through proposal, probing, and composition. Observed changes or high self-ratings do not show that an answer is correct; final artifacts need selection and checks separate from generation.
Illustrative example: An open-ended research report has no unique answer. Probe source collection and organization and then inspect anonymized artifacts rather than trusting the author's self-assessment.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Without answers or rubrics, how does Propose–Probe–Compose avoid treating self-scores as a correctness oracle?
Harness²: Recursive Agent Harnessing for an Open World
Show answer and example
Answer: Candidates are actually executed before composing them using public tasks and behavioral differences. Evidence comes from traces and artifacts rather than hidden answers. Anonymize artifacts during selection to reduce preference based on harness identity. This open-ended improvement procedure does not guarantee correctness; selector, reflection, and probe calls must count toward cost, not just final executions.
Illustrative example: A general proposal may strengthen verification and a domain proposal may improve retrieval. Combine useful parts after running them rather than assuming that a self-declared winner completed the task correctly.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why do parallel independent compositions and sequential recursive improvements have different candidate dependencies?
Harness²: Recursive Agent Harnessing for an Open World
Show answer and example
Answer: The parallel mode proposes general and domain candidates separately, then forms independent composites. Each sequential step reads the preceding harness and the within-task history, so it depends on earlier results. Both use 4k executions and 3k proposals; selectors and reflection are counted separately. Less waiting from parallelism does not reduce call cost.
Illustrative example: With k=2, parallel execution yields two independent final composites, whereas the second sequential attempt builds on the first. Candidate dependencies are therefore different.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why can the final selector only inspect anonymized artifacts, rather than harness identities or rewriting answers?
Harness²: Recursive Agent Harnessing for an Open World
Show answer and example
Answer: Anonymity reduces preference based on proposal origin. The selector can only choose from final artifacts actually executed, without reference answers, proposal intermediates, or newly generated answers. At k=1, take the sole result directly. Trusted local scripted probes verify the execution accounting, not open-ended LLM performance, and outer arithmetic checks cannot feed back into the editor or reflector.
Illustrative example: If the selector knows which output came from an 'advanced' plan, it might favor that identity. If it edits the answer, it is no longer choosing from completed artifacts.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Memento 3 learn environmental rules for planning from black-box interaction?
Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks
Show answer and example
Answer: A new environment may not publish its transition rules. An agent sees actions and outcomes and can repeatedly err by guessing plans in language alone. Memento 3 organizes observations into a rulebook, compiles it into an executable model, and checks it with history and new actions so planning can occur in the model first. Learned rules are revisable hypotheses; agreement with history does not guarantee correctness in unseen states.
Illustrative example: After a button changes an object's orientation, propose a rotation rule and check other observed transitions. Revise the rule when new observations contradict it rather than ignoring the counterexample.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why must historical replay avoid resetting simulated state from the next real observation at every step?
Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks
Show answer and example
Answer: Per-step resets hide accumulation of world-model errors and can make an incorrect model appear to match history. Continuous replay initializes from the first observation only, then generates subsequent states solely through model transitions, testing whether the rulebook really explains the trajectory. Semantic fidelity is checked separately; fitting finite history does not show general correctness.
Illustrative example: If the first transition predicts the wrong door position, feeding the real screenshot at the second step erases the error. Continuous replay exposes its downstream consequences.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does uniform sampling over complete-plan equivalence classes differ from voting by model member?
Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks
Show answer and example
Answer: Several models may propose exactly the same action sequence. Sampling by member gives duplicates more probability. Group nonempty complete sequences and sample their classes uniformly to emphasize behavioral diversity rather than model counts. Follow the selected plan until completion, mismatch, or replanning; do not randomly switch paths at every step.
Illustrative example: If three models propose left-left and one proposes right-up, member sampling has 3:1 odds, while the two plan classes each get one-half probability. Duplicates do not amplify a route.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why must new world-model code pass both semantic fidelity and historical execution checks?
Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks
Show answer and example
Answer: Code might fit some observations without expressing the current rulebook, or faithfully implement an incorrect rule. The semantic check verifies that the compiled model matches the rules; historical replay checks that it recreates observed transitions. They constrain representation and behavior separately. Mismatches on new actions still trigger repairs, and a GPU execution receipt does not establish general rule correctness.
Illustrative example: A rulebook specifies clockwise rotation, but the code hardcodes an output image. Passing one example by chance is not a faithful implementation of the rule.
Sections in the Chinese source: 核心公式, 本地复现, 结果与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why collect trajectories separately for frozen-weight search and subsequent SFT?
Recursive Self-Improvement through Multi-Agent Self-Supervision
Show answer and example
Answer: Search for workflows first without confounding exploration with parameter changes. Then generate and rank fresh trajectories, train on better samples, reserve one for validation, and only then update the shared model. The same model executes, proposes, and evaluates, but that does not make self-scoring unbiased. Self-generated validation loss is not independent task accuracy.
Illustrative example: A promising workflow during search still needs separately collected execution trajectories for training. An accidental high score from the same search trace is not independent validation.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why remove the orchestrator's initial workflow prompt before training but retain worker role assignments?
Recursive Self-Improvement through Multi-Agent Self-Supervision
Show answer and example
Answer: The initial prompt contains the searched workflow. Retaining it directly could teach the model to rely on an external instruction rather than internalize useful collaboration. Worker roles preserve the execution structure and supervision applies to assistant tokens. Bradley–Terry ranking filters trajectories but self-ranked outcomes do not establish independent task capability.
Illustrative example: If the search prompt specifies retrieval then verification, remove that initial prompt so the model learns from successful execution, but keep the actual retriever and verifier turns.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does holding out the Kth Bradley–Terry-ranked trajectory differ from using all top trajectories for SFT?
Recursive Self-Improvement through Multi-Agent Self-Supervision
Show answer and example
Answer: After frozen-weight search, MASS independently collects trajectories and builds a BT ranking from pairwise comparisons. The first K−1 train the model and the Kth is for validation. The holdout separates training and checking targets, but the validation signal still comes from the chosen evaluator, not independent real-task success. Search traces cannot double as both training and generalization evidence.
Illustrative example: Use the top two of three ranked trajectories to train and the third to validate. If the third also contributes to gradients, the validation loss no longer measures a true holdout.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
What do two actual local LoRA rounds and lower validation loss establish?
Recursive Self-Improvement through Multi-Agent Self-Supervision
Show answer and example
Answer: They show the shared-checkpoint execution, proposal, ranking, and update chain ran, including real parameter training in a constrained two-worker text workflow. The data were self-generated trajectories, with one seed and few steps. There were no arbitrary workflow graphs or research-file tools, so lower loss does not establish stronger independent research capability.
Illustrative example: Round two may imitate its own validation text more easily and lower loss without ever testing whether its conclusions on unseen research tasks are correct.
Sections in the Chinese source: 核心公式, 本地复现, 验证与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why is continuing or stopping after Partial more flexible than an immediate Full/Discard decision?
EvoAlloc: A Self-Evolving Resource Allocation Agent for Efficient Program Evolution
Show answer and example
Answer: Partial evaluation offers cheaper initial evidence before paying full cost, avoiding exhaustive evaluation of clearly bad candidates and premature discarding of potential winners. The task needs a trustworthy Partial signal; do not invent a score for an environment that does not support one.
Illustrative example: A quick program constraint check followed by a lengthy performance evaluation can be useful, but Circle26's current interface has no Partial, so the local path supports only Full or Discard.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why should some discarded candidates still receive counterfactual evaluation?
EvoAlloc: A Self-Evolving Resource Allocation Agent for Efficient Program Evolution
Show answer and example
Answer: If only selected programs are evaluated, the allocation policy cannot see high-quality candidates it missed and may become overly confident in its own preferences. Random counterfactual checks reveal the risk of missing a new best, and shadow policies need shared evidence. Those Full calls consume budget; do not exclude exploration or warmup to make savings look larger.
Illustrative example: A filter may discard an unfamiliar implementation that an occasional full evaluation reveals to be superior. That evidence corrects selective feedback that equates unfamiliarity with low quality.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does prioritizing missed new bests before cost differ from minimizing Full evaluations?
EvoAlloc: A Self-Evolving Resource Allocation Agent for Efficient Program Evolution
Show answer and example
Answer: Saving evaluations alone can miss the actual best candidate. Lexicographic ranking first protects search quality, then saves Full and Partial evaluations when missed-new-best counts tie. Random counterfactual checks of discarded candidates mitigate selective feedback, and shadow policies share evidence. Do not evaluate an allocator on accepted candidates alone.
Illustrative example: If A avoids ten evaluations but misses a new champion, while B pays for two more evaluations and retains the champion, A should not advance merely for being cheaper.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why charge warmup, the shadow union, and counterfactual Full evaluations to the budget, and what did the short GPU run not trigger?
EvoAlloc: A Self-Evolving Resource Allocation Agent for Efficient Program Evolution
Show answer and example
Answer: They actually consume resources and are not free administrative work. Shadow promotion also requires two observed disagreements. The best of four real local Full evaluations did not beat the initial program. Warmup was insufficient and no promotion occurred. Partial and the two-disagreement case were covered only by contract tests, not triggered in the real run.
Illustrative example: If a shadow policy requests a Full evaluation of a program discarded by the primary policy, charge it even if it never changes the primary champion.
Sections in the Chinese source: 核心公式, 本地复现, 验证与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Sentry specifically address stalls, repeated actions, and formatting errors during agent execution?
Sentry: Learning to Recover from LLM Agent Failures at Test Time
Show answer and example
Answer: Long-horizon agents can fail not just from missing knowledge but from loops, repeated ineffective actions, or invalid calls. Sentry detects such faults during execution and uses prior experience to support recovery. Resuming locally is not the same as ultimately answering correctly; the real local control comparison had a negative result.
Illustrative example: If an agent repeats an ineffective search, detection can trigger related advice. Even if it starts reading new pages, the final answer still needs to be checked.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why add recovery advice to the playbook only after it is verified by observable later progress?
Sentry: Learning to Recover from LLM Agent Failures at Test Time
Show answer and example
Answer: Advice proposed after failure is a hypothesis; saving it immediately can poison the playbook with bad remedies. An external verifier checks whether subsequent behavior actually recovers without reading task rewards to supply answers to the actor. Experiences are retrieved by failure class. Format errors follow hard repair, keeping mechanical correction distinct from semantic recovery.
Illustrative example: If 'refresh login' still leads to repeated errors, do not store it. Progress through subsequent steps provides evidence that can be reused for similar failures.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What are the information trade-offs between retrieving recovery advice by failure class and keeping all experience in context?
Sentry: Learning to Recover from LLM Agent Failures at Test Time
Show answer and example
Answer: Conditional retrieval supplies relevant categories and tags only after detecting a matching failure, reducing input during normal execution. Always-on advice requires no trigger but adds irrelevant suggestions more readily. Conditional intervention depends on detection and matching: missed failures lose help, and false positives can disrupt a working policy. Less context alone does not imply more success.
Illustrative example: After a network timeout, retrieving connection recovery is more focused than carrying format and loop repair guides at each step. Misreading normal waiting as a timeout can still make the intervention harmful.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why can't the local three-seed HotpotQA result be presented as improvement or as 24 independent tasks?
Sentry: Learning to Recover from LLM Agent Failures at Test Time
Show answer and example
Answer: Three generation seeds repeat the same eight questions. The mean was below baseline, and the extra manager and verifier calls added cost: this is a negative result. Memory is frozen after construction, holdout questions do not retune the detector, and a holdout derived from official validation is not the official test. A positive difference in one seed cannot override the overall decline.
Illustrative example: Seed 43 answers one more question correctly, but the other two perform worse. Report all paired outcomes to show instability rather than advertising only the best run.
Sections in the Chinese source: 核心规则与原文结果, 本地复现, 复现边界与失败记录. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does SEER consider available external events in addition to numerical time series?
SEER: Self-Evolving Event Reasoning and Retrieval for Time Series Forecasting
Show answer and example
Answer: Prices and demand can respond to news or policy that historical numbers alone cannot explain. SEER retrieves relevant events and improves filtering and knowledge from prior forecasting experience while keeping predictor weights fixed. Extra text can introduce noise and look-ahead risk, so check what was actually available at forecast time.
Illustrative example: An already announced holiday schedule may explain a demand shift. A sales report published afterward cannot be given to an earlier forecast, however clearly it explains the outcome.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why must reflection wait for forecast outcomes to mature, with memory and causal knowledge frozen during testing?
SEER: Self-Evolving Event Reasoning and Retrieval for Time Series Forecasting
Show answer and example
Answer: Future ground truth is unavailable at forecast time. Using it early to update retrieval or filtering leaks outcomes; updating memory from test errors also turns reporting into training feedback. Keeping retrieval memory, screening memory, and knowledge separate helps localize faults, but verify event time and actual availability independently.
Illustrative example: In a forecast of next week's sales, weekend news cannot be inserted into Monday's inputs. Sales learned after the test cannot be used to rewrite retrieval for that same test.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does fixing the forecasting model while updating retrieval and screening experience differ from fine-tuning its weights?
SEER: Self-Evolving Event Reasoning and Retrieval for Time Series Forecasting
Show answer and example
Answer: The former changes how external evidence is expanded, filtered, and organized, leaving predictor weights fixed so context evolution can be studied. Fine-tuning changes the internal mapping. The two memories and knowledge play different roles; a handwritten causal rule or new query template does not automatically teach the numerical model new dynamics.
Illustrative example: Retrieval memory can suggest checking holidays, and screening memory can exclude irrelevant news, without changing the time-series model's parameters.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
How do event occurrence and information availability jointly limit what a forecaster can read?
SEER: Self-Evolving Event Reasoning and Retrieval for Time Series Forecasting
Show answer and example
Answer: An event may already have occurred while reports or database entries become public later. Forecast inputs must satisfy the target-time and information-availability boundaries. The date on a story is not enough; check whether its contents were obtainable at the time. Memory can be compressed when capacity is limited, but compression cannot inject future conclusions into past contexts, and test-time reflection is forbidden.
Illustrative example: An event occurs Monday but is disclosed Wednesday. Tuesday's forecast must not use Wednesday's story, even if the headline is relabeled with Monday's date.
Sections in the Chinese source: 核心公式, 本地复现与成本判断. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does FrugalEvo want cheaper models to implement strong-model research ideas repeatedly?
FrugalEvo: Towards Cost-Aware LLM-Guided Program Evolution
Show answer and example
Answer: Using a strong model for every generation and execution step is costly, while a weaker one may lack good strategies. FrugalEvo joins stronger strategy proposals with cheaper repeated implementation to find useful programs within a budget. Evaluate actual costs and quality over the whole search, not just the final best score or a cheap individual call.
Illustrative example: A strong model suggests a direction and a weak model tries several code variants. If repeated failures still consume substantial budget, the division of labor may not pay off.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why follow an expensive model's strategy proposal with repeated cheap execution, and assess the full best-so-far curve?
FrugalEvo: Towards Cost-Aware LLM-Guided Program Evolution
Show answer and example
Answer: Strategic planning and local code iteration require different capabilities and costs. Hierarchy reserves expensive calls for direction setting. Failures add feedback while retaining the parent program; improvement re-anchors search, and an island archive protects diversity. The best-so-far curve over the budget reflects how early useful solutions emerge, not just a lucky final score.
Illustrative example: A strong model proposes vectorization and a smaller model tests several equivalent implementations. Finding a useful speedup earlier under the same budget is more informative than one chance best at the end.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How should a costly strategy model plus cheap implementer be fairly compared with weak-model-only search?
FrugalEvo: Towards Cost-Aware LLM-Guided Program Evolution
Show answer and example
Answer: Start both from the same program, budget, and call caps, but actual costs can differ when different limits bind first. Larger models are not necessarily stronger; report actual tokens, strategy trials, and refinement. The architecture does not imply collaboration always wins, and overall local results did not support that conclusion.
Illustrative example: If the weak model hits its 30-call cap with budget left and the collaboration consumes more tokens, report 'same caps,' not 'same actual cost.'
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why retain the parent after a generated program fails and reject fallback to bare exec?
FrugalEvo: Towards Cost-Aware LLM-Guided Program Evolution
Show answer and example
Answer: Use failure feedback for the next revision without replacing a verified parent with invalid code. Actual generated code requires Linux isolation and resource limits; fail closed if the sandbox does not start. Do not trust model-reported scores: a trusted checker verifies bounds and non-overlap. Do not dress up a negative local result by deleting failed calls or relaxing security boundaries.
Illustrative example: An invalid radius counts as a failed proposal and costs a call. Do not substitute the parent's answer and mark the candidate successful, or run it on the host when the sandbox is unavailable.
Sections in the Chinese source: 公式与原文结果, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why is it hard to decide which role to improve if a multi-agent workflow gets only a terminal result?
It Takes Workflows to Evolve Better Workflows
Show answer and example
Answer: Success depends jointly on roles and dependencies. Giving everyone the same reward hides who moved the workflow forward or held it back. FlowRight organizes role credit using workflow structure to support improvements at different scopes. Structural weights are an attribution rule, not direct measurements of each role's causal contribution.
Illustrative example: A retriever finds good evidence but a writer misreads it. Identical failure scores could lead subsequent updates to damage a useful retrieval habit as well.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why does topology-aware role credit use workflow structure instead of averaging terminal reward across all roles?
It Takes Workflows to Evolve Better Workflows
Show answer and example
Answer: Roles occupy different positions and affect different downstream steps. Equal credit can conceal a bad node or a critical upstream role. Topological weights incorporate validity and successors, supporting both single-role changes and upstream/downstream collaboration in one framework. This is an attribution rule, not identification of causal contributions; use execution comparisons to test it.
Illustrative example: If a retriever's error reaches three downstream roles, repairing it may matter more than polishing the final paragraph. The topology shows the propagation range instead of dividing reward by headcount.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Which participants change in single-role evolution, upstream–downstream collaboration, and joint multi-role evolution?
It Takes Workflows to Evolve Better Workflows
Show answer and example
Answer: A single-role update fixes the other participants to isolate a local change. Upstream–downstream collaboration targets the dependency interface. Joint changes can improve coordination across roles, but their effects are harder to attribute. FlowRight expresses those scopes with a common workflow and credit representation. Success at one scope does not guarantee every joint update works.
Illustrative example: Changing just the writer and changing both retriever and writer may require different validation. The pair may adapt to a new evidence format, so gains cannot be attributed entirely to writing.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
What should an implementation of valid_i(1+children_i) check, and what was not completed locally?
It Takes Workflows to Evolve Better Workflows
Show answer and example
Answer: Invalid roles get zero weight. Normalize over all valid weights, verify conservation of credit, and handle the no-valid-item case. The local path only executes this allocation operator; it does not generate workflows, train Qwen3.5, or run DataWright. Passing structural tests does not establish improvement from multi-agent co-evolution.
Illustrative example: An invalid node with ten children should receive no credit. When all nodes are invalid, handle the case explicitly rather than dividing by zero.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
With a limited repair budget, why does ActiveSaddler choose which failures to expose next?
ActiveSaddler: Automated Curriculum Learning for Agent Harness Optimization
Show answer and example
Answer: A harness cannot repair all scenarios equally deeply at once, and repeatedly testing familiar problems misses new weaknesses. ActiveSaddler treats the training curriculum as a dynamic decision based on existing failures and repair feedback. Selecting a difficult scenario only creates a learning opportunity; it does not establish a repair, and scheduling counts are not real capability gains.
Illustrative example: File-editing failures have been fixed repeatedly, while browser recovery issues just appeared. The curriculum must choose whether to keep verifying old behavior or budget exploration for the new fault.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why must failure modes treated as nonstationary bandit arms allow discovery of new scenarios and revisiting old weaknesses?
ActiveSaddler: Automated Curriculum Learning for Agent Harness Optimization
Show answer and example
Answer: A harness repair changes the payoff of previous failures. A fixed curriculum may keep testing solved problems while missing newly exposed faults. The controller allocates budget using value and exploration terms, periodically introducing unseen scenarios to support both discovery and verification. Counts or priorities are curriculum signals, not model capability metrics.
Illustrative example: After fixing timeouts, practice them less often but occasionally retest for regressions while exploring previously uncovered permission errors.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Do fixed hard-task sampling and dynamically reprioritizing failures after repairs face the same stationary rewards?
ActiveSaddler: Automated Curriculum Learning for Agent Harness Optimization
Show answer and example
Answer: Fixed sampling generally follows preset difficulty or frequencies. Repairs change the value of prior failures: formerly frequent problems may no longer deserve repeated investment, while new ones appear. Dynamic scheduling should update with this nonstationary feedback. Historical failure rates are not permanent estimates of current reward, and revisits may yield no new information.
Illustrative example: After a parser fix, old hard examples consistently pass. Filling the curriculum with them wastes budget; newly observed authentication issues may deserve more attention.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does the local dynamic arm scheduler run AutoSaddler's real repair chain?
ActiveSaddler: Automated Curriculum Learning for Agent Harness Optimization
Show answer and example
Answer: No. It creates failure arms, explores and exploits, and updates priorities. It does not call AutoSaddler or run real GAIA2 or Terminal-Bench tasks. Observation counts and selection weights verify scheduling, not harness repair from synthetic feedback. Account for real rollout costs separately.
Illustrative example: If lowering an arm's synthetic reward reduces its selections, the controller responds to changes. It does not show that any actual tool failure was resolved.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does RuleEvolve treat coding rules as development experience that can be tested and revised?
Self-Evolving Coding Rules for AI Coding Agents
Show answer and example
Answer: Coding-agent rules affect recurring search, editing, and testing behavior, and one manually written tip might not fit the task distribution. RuleEvolve selects variants with behavioral evidence so experience can be revised. More detailed wording is not better execution; use isolated validation rather than the generator's confidence to update rules.
Illustrative example: After adding 'check callers before editing,' test whether it helps repair the same development tasks, not just whether it sounds sensible.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can't a mutator write back a coding rule based only on its own assessment?
Self-Evolving Coding Rules for AI Coding Agents
Show answer and example
Answer: A plausible rule may fit only a few examples or damage old behavior. An isolated validation evaluator measures the candidate pool and variants consistently and selects what to write back, separating proposals from acceptance evidence. Selection data are development feedback; do not expose final tests to repeated mutator tuning.
Illustrative example: A new rule that retries every function sounds robust but can repeat non-idempotent operations. Independent validation can reveal this regression.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does retaining a rule candidate pool differ from immediately overwriting the only rule, for search and rollback?
Self-Evolving Coding Rules for AI Coding Agents
Show answer and example
Answer: A pool compares multiple versions under one evaluation protocol and retains old rules as baselines or candidates. Immediate overwrite makes the proposal active and can lose a usable baseline after failure. A pool does not supply a correct judge by itself; it still needs an isolated evaluator. Candidate counts are not actual performance on tool tasks.
Illustrative example: Keep both a retrieval-focused rule and a testing-focused rule for comparison. If each generation immediately overwrites the rule, it is hard to tell which change caused a regression.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does local selection after mutation establish that LLM rule evolution ran?
Self-Evolving Coding Rules for AI Coding Agents
Show answer and example
Answer: No. It checks validation selection among mutated candidates but does not call an LLM mutator or full coding agent. Correct argmax over supplied scores is control-flow evidence; if scores come from fixtures, they do not indicate code quality. Retain old rules and failed candidates for audit.
Illustrative example: Choosing the largest of three preset scores verifies the selector. Without a model proposing rules and actually fixing code, it does not verify the whole self-evolution path.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why might a video agent need to improve evidence collection rather than just use a stronger answer prompt?
Video-RSI: Recursive Self-Improvement of Video Understanding Agents via Harness Evolution
Show answer and example
Answer: Long video spans many moments and details. The failure may occur during frame selection, localization, reading, or organizing evidence, rather than composing the final answer. Video RSI uses execution to improve the video-task harness so limited cost is spent on relevant evidence. A changed workflow alone is not better understanding; check both accuracy and actual cost.
Illustrative example: If the question asks what someone did before leaving and the agent samples only the start and end, rewording the final prompt will not reveal the key middle action. Improve evidence gathering first.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can reading only a failed trace be insufficient to diagnose evidence collection in a video agent?
Video-RSI: Recursive Self-Improvement of Video Understanding Agents via Harness Evolution
Show answer and example
Answer: A trace records only what the old harness chose to observe; unseen keyframes cannot be recovered from that log. Revisit training video to gather observations and test whether evidence was omitted or reasoning was wrong, then change the interface. Acceptance retains accuracy and cost gates so a weighted total cannot hide a clear regression in either.
Illustrative example: If the old policy sampled only the opening while the key action came at the end, the trace omits it. Revisiting the original training video verifies that sampling rather than wording needs to change.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What do dual accuracy and cost gates protect compared with a single weighted score?
Video-RSI: Recursive Self-Improvement of Video Understanding Agents via Harness Evolution
Show answer and example
Answer: A candidate must not lower accuracy or increase cost, and at least one measure must strictly improve. This prevents large gains on one objective from hiding deterioration on the other. Declare tolerances before selection rather than relaxing them to accept a candidate. Dual gates still require the same measurement protocol and do not guarantee generalization.
Illustrative example: A candidate that loses ten accuracy points while halving frame count could win a weighted sum but violates the no-regression requirement and should be rejected.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why isn't a passing local Pareto gate registered as an executable Evolve operator?
Video-RSI: Recursive Self-Improvement of Video Understanding Agents via Harness Evolution
Show answer and example
Answer: There is no real video decoding, code-rewriting sandbox, or cross-generation stopping condition, so the controller cannot fully execute and evaluate a candidate. The gate only checks acceptance relations over supplied metrics. Fixture scores do not establish video-agent improvement, and a registry name or three-seed rule check is not end-to-end evolution.
Illustrative example: Two sets of numbers suffice to calculate dominance, but without obtaining them by running a candidate harness on video there is no capability evidence for promotion.
Sections in the Chinese source: 核心公式, 本地复现与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Meta-Skills focus on transferable experience about configuring how an agent works?
Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI
Show answer and example
Answer: Similar tasks can share planning, evidence collection, or verification routines. Keeping only individual answers forces the next task to redesign the workflow. Meta-Skills makes procedural experience reusable through retrieval that guides the harness. Experience needs applicability conditions; a prompt that helped one question should not be applied everywhere.
Illustrative example: Building an evidence table before comparing numbers across sources is procedural knowledge. The actual numbers belong to the original task and should not be reused as new answers.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why specify when, provide, and use in a meta-skill rather than just 'verify more in future'?
Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI
Show answer and example
Answer: When gives the trigger, provide specifies the resource, and use describes integration. Together they turn generic advice into retrievable design knowledge. Freeze the library after development and retrieve only to construct the harness in testing. If test results revise the library, the test no longer measures transfer of fixed skills to unseen tasks.
Illustrative example: 'When tool output is incomplete, provide access to raw logs and inspect them before retrying' can become a concrete runtime component more readily than 'be more careful.'
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does frozen-library retrieval during testing differ from writing experience back while testing?
Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI
Show answer and example
Answer: Freezing tests transfer from development. Writing back from test feedback lets later tasks exploit evaluation results and changes the test information contract. Allowed observations in the current task can inform its harness, but private test scores cannot revise the long-term library or reselect reported results.
Illustrative example: Adding a rule tailored to a failed test1 and rerunning test1 is not frozen-library generalization. Report it under a separate learning protocol.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
How do local development refinement and frozen retrieval limit the conclusions?
Learning Meta-Skills for Agent Harness Design in Test-Time AI4AI
Show answer and example
Answer: Local checks verify that the library accepts development feedback, freezes against write-back during retrieval, and maintains related state invariants. Fixture rewards are not the AI4AI benchmark. Without a real harness proposer and task model, matching a when field neither establishes generalizable design learning nor reproduces reported paper gains.
Illustrative example: Finding a meta-skill tagged 'long text' tests routing. It does not test whether the skill improves real long-context tasks.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why should branches maintain different development subsets and proposal policies?
Mixture of Self-Improving Branches for Agent Harness Optimization
Show answer and example
Answer: When all branches see the same examples and use the same proposals, they can converge to redundant harnesses. Distinct subsets and strategies preserve specialization that the router can select by input. Additional branches also increase development cost; do not hide total search budget when comparing with one branch.
Illustrative example: One branch can specialize in tool formats and another in long-horizon verification, giving routing meaningful alternatives rather than copies under different names.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why remove development examples solved by every branch while retaining examples that distinguish branches?
Mixture of Self-Improving Branches for Agent Harness Optimization
Show answer and example
Answer: Shared solved examples provide little information about branch differences and can dilute weaknesses while consuming budget. Each branch retains a discriminating subset and proposal strategy, and a deployment router picks a development champion by input. An adaptive development set is not an independent final test; routing cannot use test labels to choose a winner.
Illustrative example: If all branches solve simple sorting but graph search distinguishes two strategies, devote more curriculum budget to the latter rather than repeatedly testing common strengths.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What assumption differs between routing across specialist branches and always running one global champion?
Mixture of Self-Improving Branches for Agent Harness Optimization
Show answer and example
Answer: A global champion assumes one harness covers all inputs. Branch mixtures allow workflows to specialize and choose among them from public input features. Specialization may improve fit but adds routing errors and maintenance cost. Routing must use deployment-visible information, not current test gold scores.
Illustrative example: Code and browsing tasks can have different development champions. Routing by task features is deployable; reading both branches' gold scores on the current test before choosing is not.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
May a deployment router read branches' true scores on the current test item to pick the winner?
Mixture of Self-Improving Branches for Agent Harness Optimization
Show answer and example
Answer: No. Use input features to select a development champion without test labels or future execution scores. The local implementation provides subset diversification and linear routing, not LLM-generated harnesses or SWE-bench runs. Correct branch choice on fixtures does not show real mixture gains.
Illustrative example: Running all branches and selecting the hidden judge's best result is an oracle ensemble, not deployment routing based on request inputs.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Harness Learning treat tool protocols, memory, and planning as learnable objects?
Harness Learning Enables Generalizable Test-Time Adaptation
Show answer and example
Answer: With the same weights, the external workflow still controls what the model sees, when it calls tools, and how it recovers. Harness Learning uses feedback to revise executable organization rather than attributing every weakness to the base model. Workflow adaptation is a distinct scope and does not imply new capability learned in model parameters.
Illustrative example: Add testing before every submission without changing the base model. Outcomes may change because execution was organized differently, not because weights were trained.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
How can test-time adaptation occur with frozen task-model weights?
Harness Learning Enables Generalizable Test-Time Adaptation
Show answer and example
Answer: Adaptation changes executable components outside the model, such as verification, interpreters, retrieval, and retry protocols. Execution feedback changes that scaffolding and therefore later behavior of the same model. This is not fine-tuning and cannot route hidden answers through the interface to a proposer. Local classification-policy updates are not the paper's full LLM adaptation chain.
Illustrative example: Keep the model fixed, but add shell-output truncation and error localization after a failure. The next attempt can process the output better without any neural-weight change.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does within-group relative-reward training of the revision policy differ from fixed hand-written rules?
Harness Learning Enables Generalizable Test-Time Adaptation
Show answer and example
Answer: Locally, subtract the group's mean execution score from each candidate score to form advantages and apply REINFORCE to revision logits. Feedback can change proposal preferences; fixed rules learn no parameters. The small classification proposer is not the paper's general harness learner, and a formula alone does not establish safe arbitrary component changes.
Illustrative example: A revision that performs better within its group gets positive advantage and becomes more likely, instead of being predetermined by a rule author.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why do external callbacks not establish integration with a general agent runner or Evolve?
Harness Learning Enables Generalizable Test-Time Adaptation
Show answer and example
Answer: A trusted callback is an execution interface. A general system must safely run arbitrary harnesses and isolate validation. That full chain is missing. Adaptation inputs allow only scores and failure categories, not gold data or hidden verifier fields. Mini-suite success is not open-ended agent capability.
Illustrative example: A callback that returns a preset high score can test loop control, but without real candidate execution it supplies no promotion evidence.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does AgentX-Model need to connect each research choice to actual experiments?
Advancing Model Research in AgentX: Long-Horizon Autonomy for Industrial Recommender Systems
Show answer and example
Answer: Automated research must choose what to try and obtain new evidence through implementation and evaluation, not just generate proposals. Research and model execution roles exchange proposals so search history reflects attempted candidates. Historical replay only reenacts revelation and selection of existing outcomes; it does not rerun training locally.
Illustrative example: After a proposal to change the loss, the implementer returns results only after training. A replay should likewise reveal a score only after selecting the candidate, without peeking at future outcomes.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why connect the Research Agent and Model Agent through proposals instead of sharing full experiment logs?
Advancing Model Research in AgentX: Long-Horizon Autonomy for Industrial Recommender Systems
Show answer and example
Answer: Proposals specify the question, constraints, and approved direction. The model implementer runs iterative experiments under fixed business inputs and prediction tasks, preventing mutual context overload. Return interim bests, negative results, and unresolved questions for the next research decision. The interface carries evidence, not just one appealing final score.
Illustrative example: Researchers can propose a long-history compression hypothesis. The model agent reports the best version and when it fails, allowing the next hypothesis without showing every compilation log.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why does improvement over a parent differ from setting a new best over the entire ancestral path?
Advancing Model Research in AgentX: Long-Horizon Autonomy for Industrial Recommender Systems
Show answer and example
Answer: If a parent regressed, its child can recover some performance without beating an older champion. Track both the parent delta and comparable ancestral delta to avoid presenting recovery as a breakthrough. Diagnose actions primarily reduce uncertainty and should not be ranked by the same immediate AUC objective as improvement actions.
Illustrative example: If an ancestor has AUC .80, parent .75, and child .78, the child gains .03 over its parent but is still .02 below the path best. Report both.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
When are candidate outcomes revealed in historical replay, and how does local data avoid future leakage?
Advancing Model Research in AgentX: Long-Horizon Autonomy for Industrial Recommender Systems
Show answer and example
Answer: A child can be selected only after its parent, and the candidate's result is revealed only after selection. MovieLens holds out the last two chronological interactions for validation and test; training statistics cannot read future events, and champions use validation only. A rule-based selector and logistic-regression replay are not the paper's LLM research agent or an online A/B replication.
Illustrative example: Even if the logs contain a high score from another branch, the selector cannot read it before deciding to try that branch. Otherwise it has a future-metric oracle.
Sections in the Chinese source: 本地复现, 可执行路径与防泄漏边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does ScienceBuddy put tool interaction and policy learning into one continuing process for scientific tasks?
ScienceBuddy: Recursive-in-Recursive Self-Improvement for Interactive Scientific Agents
Show answer and example
Answer: Scientific tasks involve proposing actions, using tools, interpreting observations, and adjusting plans. A fixed prompt is unlikely to handle ongoing feedback. ScienceBuddy studies improving workflows and policies together during interaction. Track the two levels separately; simulated state updates are not evidence of a real scientific environment or model training.
Illustrative example: A search finds the original hypothesis lacks evidence, so the workflow can require source checks first. Whether the policy learned that judgment needs validation on subsequent real tasks.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can't inner harness evolution and outer policy updates be reduced to repeatedly rewriting a prompt?
ScienceBuddy: Recursive-in-Recursive Self-Improvement for Interactive Scientific Agents
Show answer and example
Answer: The two levels change different objects. The inner loop optimizes interaction, while the outer loop uses successful trajectories to update the scientific agent's parameterized policy, which affects the next inner search. Actual execution, filtering, and training must close the loop to demonstrate recursion within recursion. Reference gates or synthetic statistics cannot replace the models and environments involved.
Illustrative example: Find a better experimental checking process, then train the agent on successful trajectories so it uses that process better next time. Rewriting the prompt three times has no second-layer update.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What trade-offs arise from two-level feedback versus single-level training with a fixed harness?
ScienceBuddy: Recursive-in-Recursive Self-Improvement for Interactive Scientific Agents
Show answer and example
Answer: Two levels can improve both data generation and policy, but simultaneous changes complicate attribution and introduce nonstationarity. Record versions, trajectory provenance, and updates separately. A fixed harness is easier to control but can constrain exploration. Mechanism comparisons do not replace scientific-task or experimental outcomes.
Illustrative example: A higher outer-loop score might come from better tool feedback or from new parameters. Without versions, the contributions are hard to distinguish.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does the local double-state reference include a lab and real scientific policy learning?
ScienceBuddy: Recursive-in-Recursive Self-Improvement for Interactive Scientific Agents
Show answer and example
Answer: No. It runs a reference two-level state update and gate, without a real laboratory, full scientific tasks, or paper-scale training. Three-seed intermediate values verify branches and information flow, not reproducible scientific discovery rates. Counts of state updates do not validate full recursive learning.
Illustrative example: Two inner changes and one outer update show control-state movement. Without real trajectories and gradients, they do not show that the policy learned a task.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does MAPLE aim to retain optimization knowledge across consecutive solves?
MAPLE: Memory-Augmented Planning with Language and Evolution
Show answer and example
Answer: Related tasks often share structure. Starting each proposal from scratch makes verified program improvements hard to accumulate. MAPLE uses executable solutions as persistent research state and explores subsequent problems from accepted programs. Inheritance can carry stale assumptions, so verify the new constraints rather than treating executability or historical success as proof of current optimality.
Illustrative example: Reuse a scheduling program that already resolves resource conflicts, but implement and test the new time-window constraint.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can starting subsequent problems from an accepted program accumulate optimization knowledge better than reprompting from scratch?
MAPLE: Memory-Augmented Planning with Language and Evolution
Show answer and example
Answer: Program state preserves verified executable structure and trade-offs. The next task can modify it rather than reconstruct details from language. Acceptance prevents unexecuted ideas from overwriting a reliable parent. Cross-problem evolution still needs to account for task differences: a specialized program for one instance is not universally best.
Illustrative example: If the previous problem already has reliable parsing, change its objective for the next task rather than regenerate a blank script and repeat format mistakes.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does accepting an executable program differ from accepting an optimization description that sounds better?
MAPLE: Memory-Augmented Planning with Language and Evolution
Show answer and example
Answer: A description conveys intent. A program must run and pass the relevant comparison before becoming evolvable state. Executability does not imply improvement: validity and benefit are separate gates. A one-time gain does not generalize to all future tasks, and failed proposals should not be inherited unconditionally.
Illustrative example: 'Reduce redundant search' is advice. Accept the optimization only after it changes the call logic and verifies that required evidence was not missed.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
How does local validation of nonempty named-operation plans differ from the authors' solver?
MAPLE: Memory-Augmented Planning with Language and Evolution
Show answer and example
Answer: The local path accepts public plans made of nonempty named operations and checks reuse. It has no author solver, trained model, or external tools. Structural execution contracts can be tested, but perfect mini-suite scores are not paper-level optimization or general program evolution. A missing solver cannot be substituted with a registry name.
Illustrative example: Nodes named 'search' and 'verify' pass the nonempty structural check, but do not demonstrate that a real search algorithm outperforms its predecessor.
Sections in the Chinese source: 本地复现与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Ecdysis ask whether failures are occasional model behavior or shared runtime defects?
Ecdysis: Efficient and Effective Training of Runtime Harnesses for LLM Agents
Show answer and example
Answer: Failures across tasks can be individual misunderstandings, or recurrent effects of tool wrapping, context, and recovery. Ecdysis looks across executions for repairable harness defects so changes target shared causes. Recurrence is a diagnostic clue, not a completed fix without execution and verification.
Illustrative example: If several tasks lose evidence because tool output is truncated, suspect a common interface. A single task that misreads content does not justify immediately changing every workflow.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why aggregate similar failures across tasks to diagnose a systemic harness defect?
Ecdysis: Efficient and Effective Training of Runtime Harnesses for LLM Agents
Show answer and example
Answer: A single failure may be due to randomness or a particular prompt. A recurring pattern more strongly suggests a shared execution interface problem. Multi-role diagnosis turns the evidence into a testable repair specification instead of changing global behavior after each failure. Correlation is not sufficient causal proof; compare affected behaviors after repair.
Illustrative example: Many tasks losing error codes when logs are truncated gives stronger reason to inspect the output interface than one bad guess. Target truncation rather than generally replacing the model.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Where do a repair specification and direct execution of a harness patch sit in the improvement chain?
Ecdysis: Efficient and Effective Training of Runtime Harnesses for LLM Agents
Show answer and example
Answer: FDCR's multi-role diagnosis organizes failure evidence into a discussable repair specification describing what to change and why. Execution still requires a concrete patch, runtime integration, and verification. A diagnosis is not a changed system; gate triggers or counts of repair suggestions do not indicate task-success gains. This boundary is especially important for the local reference.
Illustrative example: A specification says 'preserve tool error fields.' Check the patch and execution logs separately to see whether the code actually changed and worked in later tasks.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does triggering the local FDCR repair gate mean a harness patch was generated or executed?
Ecdysis: Efficient and Effective Training of Runtime Harnesses for LLM Agents
Show answer and example
Answer: No. The local path aggregates signatures from public observations and triggers a bounded repair gate. It does not generate or execute code or run paper-scale training. A trigger shows the statistics satisfy a condition, not correct diagnosis or actual repair. Three-seed counts cannot be converted into paper speed or accuracy.
Illustrative example: A 'needs repair' state after three similar failures is a scheduling signal. Without a patch and rerun, the defect is not resolved.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why can't COBRA-Skills give each candidate the same number of trials as the skill pool grows?
COBRA-Skills: Contextual Bandit-Guided Evolution for Agent Skill Optimization
Show answer and example
Answer: Evaluating skills consumes execution budget while the number and quality of candidates change. Equal allocation can waste trials on clearly useless or duplicate entries. COBRA-Skills combines current context with past feedback to direct limited trials. Selectors may only use available evidence, not presume effects of unexecuted candidates.
Illustrative example: Ten similar skills have repeatedly failed and a newly generated one may deserve limited exploration. Running every candidate a hundred times is not feasible on a tight budget.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why use a budgeted contextual bandit for dynamic skill candidates rather than ranking historical best scores alone?
COBRA-Skills: Contextual Bandit-Guided Evolution for Agent Skill Optimization
Show answer and example
Answer: Skill payoff depends on the current task, and new or revised candidates lack history. A contextual bandit balances exploiting known gains and exploring informative candidates under an evaluation budget, then evolves from execution feedback. Historical maxima can favor early lucky skills and ignore context and uncertainty about untested candidates.
Illustrative example: If an old skill excels at files but new tasks are web-based, giving new candidates a few trials may be more informative than repeatedly testing the old champion.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why separate proposing a skill variant from measuring its execution reward?
COBRA-Skills: Contextual Bandit-Guided Evolution for Agent Skill Optimization
Show answer and example
Answer: A proposal uses existing experience to describe potentially better behavior but does not establish usefulness on this task. Only execution supplies feedback for budget allocation and evolution. The space may grow dynamically, but membership does not imply positive reward. COBRA-Skills bandit selection must distinguish measured payoff from uncertainty rather than fill missing results with proposal self-assessment.
Illustrative example: A more detailed skill can be scheduled for a trial. Only actual execution shows whether it helps; 'expected improvement' is not a successful sample.
Sections in the Chinese source: 背景与主要改动, 核心公式或操作. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does local contextual-UCB allocation cover actual LLM skill evolution?
COBRA-Skills: Contextual Bandit-Guided Evolution for Agent Skill Optimization
Show answer and example
Answer: No. It executes a reference allocator and feedback admission gate, with no external LLM or six environments. Candidate indices, confidence terms, and budget can be checked independently, but actual skill-text generation and task execution did not occur. Fixture feedback is not actual cost savings or capability gain.
Illustrative example: Selecting a numeric arm after its UCB grows checks the bandit formula. It does not demonstrate that the corresponding natural-language skill works on web tasks.
Sections in the Chinese source: 核心公式或操作, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
What does a procedure–relation–procedure graph add beyond storing skill snippets?
Procedural Graphs: Self-Evolving Execution Structures for LLM Agents
Show answer and example
Answer: A graph explicitly represents dependencies and compositions, so new experience can change a local execution structure rather than add similar prose. Correct relations matter for downstream paths. Validate edits on an independent holdout before permanent write-back, not just because a trace succeeded once.
Illustrative example: 'Query after authentication' is an ordering relation and 'refresh credentials if the query fails' is recovery. Two separate text snippets might not express those links.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why localize experience as a graph edit before a held-out gate?
Procedural Graphs: Self-Evolving Execution Structures for LLM Agents
Show answer and example
Answer: Procedural relations affect multiple paths, and overwriting them with whole episodes can contaminate unrelated skills. Local edits identify the affected node or relation; held-out verification tests whether the change goes beyond incidental success in the originating trace. A pass supports only its evaluation scope, not global reliability inferred from coherent training traces.
Illustrative example: Add only a recovery edge to refresh a token after authentication failure. Check independent tasks for redundant authentication rather than rewriting the whole upload graph.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What trade-offs arise from a local graph edit versus rewriting the entire procedure graph?
Procedural Graphs: Self-Evolving Execution Structures for LLM Agents
Show answer and example
Answer: Local changes reduce unrelated effects and ease attribution and rollback. Whole-graph rewrites allow more freedom but can break old interfaces and valid paths. Locality does not guarantee safety: one central node can affect many downstream procedures. Check independent behavior, not just graph format.
Illustrative example: Replacing a query node can change all downstream inputs. Despite editing one node, check whether its dependent routes still work.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does preserving the first and last nodes locally constitute full held-out capability verification?
Procedural Graphs: Self-Evolving Execution Structures for LLM Agents
Show answer and example
Answer: No. The local deterministic edit gate requires existing routes to retain endpoints and tests acceptance and rejection without real tools. It checks a structural condition but cannot establish semantic correctness of middle steps or generalization of the edited graph. The policy must not see hidden plans or answers.
Illustrative example: A graph can retain start and end while deleting required authentication and still pass structurally. That contract cannot replace real task-success evaluation.
Sections in the Chinese source: 本地复现与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does HarnessLens treat validation cost as a bottleneck for harness search?
Verify Smarter, Evolve Further: Efficient Harness Evolution through Behavior-Aware Verification
Show answer and example
Answer: Fully running a fixed validation set for each candidate consumes many rollouts, and its mean can hide regressions in a few affected behaviors. HarnessLens focuses validation on behavior actually touched by a change, making evidence more targeted under a budget. State local coverage; saving evaluation does not justify skipping attribution or expanding quality claims.
Illustrative example: Rerunning every unrelated math problem after changing browser recovery can waste effort. Find matching behavior tasks, while noting that other behaviors have no new coverage.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why is behavior-aware paired validation better than a fixed validation-set average at finding local regressions?
Verify Smarter, Evolve Further: Efficient Harness Evolution through Behavior-Aware Verification
Show answer and example
Answer: A change affects only some behaviors. Unrelated tasks dilute differences and waste rollouts. Compare parent and child on affected tasks and require attribution to the change, distinguishing actual repair from noise. State the scope of a local pass; one behavior's improvement does not establish that every task improved.
Illustrative example: If only retry behavior changes, pair timeout and recovery tasks. Many easy successes could hide a retry loop in an overall mean.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does passing a local behavior acceptance gate differ from proving overall agent improvement?
Verify Smarter, Evolve Further: Efficient Harness Evolution through Behavior-Aware Verification
Show answer and example
Answer: The local gate requires positive paired gains on target behavior and evidence they are attributable, answering whether the particular change is worth accepting for that behavior. Overall capability includes uncovered tasks, other behaviors, and resource effects. Neither Δ_b nor A_b generalizes automatically. Retain the validation set and change scope rather than relabeling a local pass as broad validation.
Illustrative example: Improvements on five recovery cases can support limited acceptance. They do not show better code generation, mathematics, or all browsing tasks.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why is A_b required in addition to Δ_b>0?
Verify Smarter, Evolve Further: Efficient Harness Evolution through Behavior-Aware Verification
Show answer and example
Answer: A positive difference may come from random retries or environmental changes; A_b requires evidence attributable to the candidate. The local project has a real tool-feedback protocol without answer/guide but did not run the paper's four complete benchmarks. Local success cannot replace reported held-out gains, and structural labels do not prove causality.
Illustrative example: If two runs differ randomly and the candidate behavior was never checked for activation, do not credit the entire positive difference to the patch.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Jit-Agent generate a workflow for the current task rather than choose only a fixed prompt?
JIT-Agent: Scaling Harness Intelligence via Just-in-Time Harness Evolution
Show answer and example
Answer: Tasks need different memory, planning, action protocols, and tools. A universal harness can be heavy or lack key support. Jit-Agent composes a workflow when a task arrives so execution organization matches the request. Instant generation still needs quality constraints and frozen evaluation. Complete modules do not guarantee an advantage over fixed workflows.
Illustrative example: One-step arithmetic may not need long-term memory, whereas organizing several pages can need evidence collection and progress tracking. Task features should guide which modules are used.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why separate memory, planning, action protocol, and tools when generating a harness per task?
JIT-Agent: Scaling Harness Intelligence via Just-in-Time Harness Evolution
Show answer and example
Answer: Task bottlenecks vary by layer. Modules make proposals and repairs target the right object and let configuration archives yield transferable patterns. Just-in-time generation still needs validation; each module must meet its execution contract. Editing prompt text without generating matching tools or state interfaces does not implement all four modules.
Illustrative example: A long task may need new memory, whereas short arithmetic needs only a calculation tool. Do not rebuild everything or mix incompatible protocols.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What are the trade-offs between on-demand generation and reusing one fixed harness?
JIT-Agent: Scaling Harness Intelligence via Just-in-Time Harness Evolution
Show answer and example
Answer: On-demand configuration fits diverse tasks, and an archive can help transfer. Generation and repair add development cost and possible instability. A fixed harness is easier to maintain but can be overly generic. Count candidate generation and actual failures rather than cherry-picking the final successful configuration and ignoring exploration cost.
Illustrative example: Long retrieval may need citation checking, whereas simple calculation may not. Task-specific generation distinguishes them, but an unnecessary checker may slow the easy task.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why separate local training-time route repairs from frozen test execution?
JIT-Agent: Scaling Harness Intelligence via Just-in-Time Harness Evolution
Show answer and example
Answer: Training tasks can write repair experience. After freezing, validation and test use only public observations, tool metadata, and real feedback, not answers or reference plans. Report low controlled success rates and real ToolRoute results under their own protocols. Without the original model and full DeepSearchQA, do not import author scores.
Illustrative example: A test error may be handled using a frozen recovery rule. Adding the hidden correct route to the archive and then calling it successful adaptation is invalid.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why is a Loop Policy more than a system prompt?
Show answer and example
Answer: Observation, planning, memory, action, verification, and recovery assets jointly shape long-horizon behavior. Version both components and combinations. Prompt changes may miss the real bottleneck; executable versions, comparison, and monitoring make evolution traceable. Complete files do not imply effective behavior.
Illustrative example: A prompt may say 'retry after failure,' but if recovery middleware cannot identify timeouts, the actual loop may still not recover.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why are release monitoring and rollback needed in addition to Champion–Challenger evaluation?
Show answer and example
Answer: An offline candidate that beats the champion may still be unstable after deployment or over long interactions. Monitoring must allow traceable restoration of the old version when regressions appear. Version observations, planning, memory, verification, and recovery assets rather than only model names. Release governance is part of the evolution loop, not replaced by one passing candidate test.
Illustrative example: A challenger saves calls during development but loops on permission errors in production. Monitoring should identify its version and roll back instead of allowing unbounded trial and error.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does Champion–Challenger differ from overwriting the current policy each round?
Show answer and example
Answer: Keep the champion as a verified baseline, compare challengers before release, and roll back under runtime monitoring if needed. This reduces persistent contamination by unverified changes. A release gate needs actual evaluation and version evidence rather than favorable self-assessment; online monitoring does not authorize arbitrary external deployment.
Illustrative example: If a recovery policy validates well but regresses after release, you should be able to restore a specific old version rather than having only an overwritten configuration.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Do local version and rollback states demonstrate real long-term online self-evolution?
Show answer and example
Answer: No. Deterministic local PlanBench verifies mechanism branches, version state, and reporting, with no real browser, service, or YC-Bench. Proxy costs, release flags, and rollback counts are control evidence, not online risk or success metrics. Do not present the paper's online or offline results as local measurements.
Illustrative example: Rules can change a state from challenger to champion. Without running actual models and tools, this does not establish deployment of a stronger agent.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does the four-stage loop put failure traces in the experiment knowledge base too?
AgentX: Towards Agent-Driven Self-Iteration of Industrial Recommender Systems
Show answer and example
Answer: Failures reveal implementation limits, guardrail risks, and unsupported hypotheses. Recording only successes creates survivorship bias and encourages repeated mistakes. Brainstorm, Developing, Evaluation, and SGPO connect evidence, code, online checks, and knowledge updates. Distinguish the authors' production system from local control flow.
Illustrative example: If a feature improves offline scores but hurts online latency, recording the failure and conditions can prevent repeating the high-risk proposal.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why can a guardrail violation veto release after significant improvement in the primary metric?
AgentX: Towards Agent-Driven Self-Iteration of Industrial Recommender Systems
Show answer and example
Answer: Recommendation systems must jointly satisfy target gains and key constraints. A single gain can come at the expense of stability or other important experience. The Evaluation Agent uses online evidence and guardrails to veto release, records both successes and failures, and learns from full traces rather than selecting winners and creating optimistic bias.
Illustrative example: A higher click-through rate does not justify release if critical latency violates its limit. Record the failure cause for the next proposal.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What conclusions do offline implementation checks and production A/B tests support in AgentX?
AgentX: Towards Agent-Driven Self-Iteration of Industrial Recommender Systems
Show answer and example
Answer: Offline checks find code, data, and runtime-contract problems before safe traffic exposure. Online A/B tests measure the primary metric and guardrails in a business environment. The tasks and risks differ, so offline success cannot replace release evaluation. Local small episodes or update counts are not the authors' production evidence.
Illustrative example: Unit tests can establish that recommendation code is ready for further experimentation. User behavior and latency effects require a controlled comparison on corresponding traffic.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Do policy-update counts from 120 local episodes demonstrate large-model SGPO training?
AgentX: Towards Agent-Driven Self-Iteration of Industrial Recommender Systems
Show answer and example
Answer: No. They verify four-stage execution, asset management, and reuse without Kuaishou's repositories, user traffic, or SGPO training. Average proxy cost is not human efficiency, revenue, or user time. Production gains are author-reported; deterministic perfect scores do not replicate industrial recommendation iteration.
Illustrative example: 108 experiment-knowledge reuses are a local workflow count. Without actual A/B tests, they cannot be converted to annual revenue or production value.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Scientist-One make research claims independently traceable and checkable?
ScientistOne: Towards Human-Level Autonomous Research via Chain-of-Evidence
Show answer and example
Answer: Automated research can generate code, charts, and conclusions whose reported numbers lack actual execution or do not match source definitions. Scientist-One connects claims, evidence, and run records so readers can inspect their origin. This chain is an audit entry point, not proof by hash; still check contents, units, and experiment stage.
Illustrative example: An accuracy gain should trace to the corresponding split and run. Finding a hashed file does not show the value inside is accuracy.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why check metric, stage, unit, and direction even when the source and logs exist?
ScientistOne: Towards Human-Level Autonomous Research via Chain-of-Evidence
Show answer and example
Answer: A log can contain training, ablation, and formal evaluation values that are not interchangeable. Match each claim to evidence with consistent identity and protocol, then check recomputability and method–code consistency. Provenance rate is empty when there are no quantitative claims, not perfect. A source's existence does not show it supports the claim.
Illustrative example: A log may record lower training loss while a report claims higher test accuracy. Traceability to a number is not matching evidence.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why are numeric CPR and scholarly citation authenticity different issues?
ScientistOne: Towards Human-Level Autonomous Research via Chain-of-Evidence
Show answer and example
Answer: CPR checks whether quantitative claims trace to numerically matching execution logs with consistent metric, stage, unit, and direction. Citation verification separately requires retrieval and semantic disambiguation. A number can match while a citation is fabricated, and a real paper may not support the claim. Neither check replaces the other.
Illustrative example: Training loss cannot support test accuracy even if the numbers happen to match. A real paper with the same title does not show it reported the claimed result.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
How should five zero-mean recomputations, no quantitative claims, and tied votes be handled?
ScientistOne: Towards Human-Level Autonomous Research via Chain-of-Evidence
Show answer and example
Answer: For a deterministic zero mean, require exact zero without a loose epsilon. CPR is null without quantitative claims, not perfect. No majority or abstention leaves the result unverified. I1 uses population standard deviation for tolerance. Trusted evaluation and log provenance are ensured upstream, and fixtures do not verify the whole study.
Illustrative example: A draft with no numbers does not earn CPR=1 from a zero denominator. Opposing votes from two reviewers do not default to majority approval.
Sections in the Chinese source: 核心公式, 本地复现, 结果与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does HyperAgents edit both task solutions and the program that generates the next solution?
Show answer and example
Answer: A fixed improver searches with the same proposal and reflection routines, whose limitations can block progress. HyperAgents makes the task and meta programs editable to study whether improvement methods evolve through experience. Self-modifying code is harder to validate; a new archived version does not establish actual performance or sustained gains.
Illustrative example: If one version always suggests similar changes, try editing the proposer itself. Then verify that the new proposer actually produces more effective candidates.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why does parent sampling consider both performance and existing offspring count?
Show answer and example
Answer: Selecting only top scores repeatedly expands the same branch and reduces diversity. Penalizing offspring count gives viable, less explored parents opportunities. Both the task agent and its modification mechanism are editable, allowing the improvement process itself to evolve. Sampling probability allocates budget; it does not accept every child or guarantee monotonic gains.
Illustrative example: A champion with twenty children may get fewer chances than a slightly weaker parent tried once, opening other improvement paths rather than polishing one branch indefinitely.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
How does fixing the meta-agent versus making it editable change the search space?
Show answer and example
Answer: A fixed improver generates variants only in the task-solution space. Editing the meta-agent can also change candidate generation and improvement procedures. The extra freedom adds failure and attribution challenges, requiring separate execution and evaluation. Local archive operations generate or run no arbitrary source, so lineage is not full program self-modification.
Illustrative example: Changing a sorting function is task-level. Changing how functions are selected for trials is meta-level, and the extra freedom may not help.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does the local archive step execute model-generated source or shell commands?
Show answer and example
Answer: No. It calculates parent distributions and maintains a bounded structured archive. Generated code and shell execution are prohibited, so the path does not validate self-referential program modification. Probabilities summing to one and correct lineage updates are search-control evidence, not task- and meta-agent behavior evaluation.
Illustrative example: Editing one field tests the archive, but without running the changed program we cannot know whether it breaks the task or improves search.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does noisy optimization easily mistake a lucky high score for a good solution?
POLCA: Stochastic Generative Optimization with LLM
Show answer and example
Answer: Random batches, execution, and evaluation vary the score of one candidate. Keeping only observed maxima favors luck. POLCA uses evaluation history and global experience while limiting redundant proposals. More history does not eliminate bias: use consistent evaluation and budgets, and do not replace actual observations with expected outcomes of untested proposals.
Illustrative example: Configuration A may score high on an easy batch while B is stable across batches. Comparing only maxima can choose wrongly; keep full histories to check.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why maintain a history-based mean and use a semantic epsilon-net to limit redundancy?
POLCA: Stochastic Generative Optimization with LLM
Show answer and example
Answer: Random data and evaluators introduce noise, so one high score may be accidental. Repeated observations stabilize candidate comparisons. Semantic distance constraints prevent budget waste on near-duplicates; recompute distances after adding candidates. Keep empirical-mean rules distinct from theoretical UCB, and don't interpret rankings as statistical significance.
Illustrative example: Semantic filtering can avoid evaluating ten prompts differing only in punctuation. Combine a lucky first score with later evaluations rather than making it a permanent champion.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why distinguish empirical-mean priority in the POLCA main text from the theoretical UCB variant?
POLCA: Stochastic Generative Optimization with LLM
Show answer and example
Answer: Empirical mean ranks candidates by their observed average reward; UCB explicitly adds an exploration bonus for uncertainty. They can prioritize rarely evaluated candidates differently and change budget use and selection history. Describe implementation and theoretical rules separately; properties do not transfer to an unimplemented variant by name.
Illustrative example: A candidate evaluated once might not rank high by mean. UCB can give it another trial because uncertainty is high, producing a different next round.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
How are untested proposals and observations completed before failure recorded after the metric budget is exhausted?
POLCA: Stochastic Generative Optimization with LLM
Show answer and example
Answer: Charge each actual call before making it and keep observations completed before failure. Mark unevaluated proposals deferred_budget and omit them from observed-reward statistics. Old and new candidates use the same with-replacement batch. There is no mock LLM fallback; deep-copy callback inputs and outputs to protect history. Local tests do not demonstrate real generative optimization.
Illustrative example: If the last budget evaluates one new proposal, the other three are neither zero scores nor default successes. They have no observations and must remain separate from evaluated candidates.
Sections in the Chinese source: 核心公式, 本地复现, 代码映射与边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Design–Split–Implement first produce a modular repository?
MARS: Modular Agent with Reflective Search for Automated AI Research
Show answer and example
Answer: Research changes touch several components. Defining design and module boundaries before implementation lets branches improve locally and reuse debugging experience instead of rewriting everything. Interfaces can still be incomplete; actual training establishes behavior, not tidy structure or small diffs.
Illustrative example: Separate loading, model, and evaluation so a branch can replace only the model under an unchanged evaluation entry point, without confounding data changes.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why should research-search node value include both performance and runtime?
MARS: Modular Agent with Reflective Search for Automated AI Research
Show answer and example
Answer: Under a fixed training budget, an equally good but slower option crowds out later exploration. MARS normalizes execution metrics, adds a time penalty, and bounds improvement or debugging. Reflection uses code diffs and real results, not the model's predicted performance in place of node measurements.
Illustrative example: If two options reach similar validation scores but one takes ten times longer, prioritize the faster one to test more structural hypotheses.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What do the new, improve, and debug search actions change?
MARS: Modular Agent with Reflective Search for Automated AI Research
Show answer and example
Answer: New explores a different research proposal; improve builds on a valid node; debug repairs a candidate that cannot execute validly. They produce different evidence: fewer errors are not higher metrics, and executability does not justify more search. MARS selects by execution status and budget and caps debugging and descendants. Estimated scores for failures are not measurements.
Illustrative example: Debug an import error before measuring performance. Improve a valid but promising score; create a new branch to try a wholly different approach.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
What boundaries apply to identical node metrics, debugging, and experience capacity?
MARS: Modular Agent with Reflective Search for Automated AI Research
Show answer and example
Answer: If the metric range is zero, normalize to 0.5 rather than divide by zero. The paper caps search at ten debugging attempts, two improvement children, and thirty recent experiences. There is no local implementation or training. Author code and released traces do not establish a fully reproducible controller, and copying a reward formula is not research capability.
Illustrative example: If all AUC values tie, do not produce NaN or assign an arbitrary candidate a very high score. The common midpoint leaves factors such as time active.
Sections in the Chinese source: 核心公式, 本地复现与成本判断. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why treat an output as a draft that can be improved against specific requirements in Self-Refine?
Show answer and example
Answer: Open-ended generation may require correctness, completeness, clarity, and style; one attempt may meet only some. Self-Refine generates, diagnoses shortcomings, and revises without extra parameter training. The loop needs actionable feedback, and mistaken feedback can make later drafts worse; more rounds do not imply better quality.
Illustrative example: A correct first explanation lacks an example. Point out the gap before revising; 'make it better' may not identify what to change.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why generate explicit feedback separately when the same model writes both draft and feedback?
Show answer and example
Answer: Explicit feedback converts unmet constraints into actionable edits, avoiding mere random resampling. Generation, feedback, and refinement play distinct roles, and stopping still depends on the model. No extra training does not make feedback correct, and repeated polishing is not independent fact-checking.
Illustrative example: A draft omits units. Feedback to add units to each number gives a concrete target that 'write it better' does not.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Compared with Reflexion's cross-trial episodic memory, what loop does Self-Refine emphasize?
Show answer and example
Answer: Self-Refine revises the current draft through feedback. Reflexion saves failure experience in bounded memory for a later trial. They can be combined but use different state. Refinement does not automatically form long-term memory, and repeated rewriting is not parameter RL.
Illustrative example: Revising one email three times is Self-Refine. Saving 'check recipients first' for tomorrow's email involves cross-trial memory.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does stopping under a deterministic local critic demonstrate reliable real-LLM self-evaluation?
Show answer and example
Answer: No. A controlled critic verifies generation, feedback, revision, and stopping states, without a general LLM or the seven original benchmarks. Stopping verifies the contract, not reliable recognition of factual correctness on open tasks. Local perfect scores cannot stand in for human preferences.
Illustrative example: A rule can stop once text length is sufficient even when facts are wrong. Real self-assessment can be satisfied too early and needs independent evidence.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Why does Reflexion retain failure lessons between attempts rather than just resample?
Show answer and example
Answer: Repeatedly trying the same task by resampling may repeat errors. Reflexion converts execution evaluation into readable experience so feedback survives across trials. Storing a lesson does not establish accuracy or transfer. Distinguish external reward from text reflection; neither automatically updates model weights with RL.
Illustrative example: If the first search stalls on an irrelevant page, reflection can advise checking sources and expanding the query. Restarting without the lesson can follow the same route.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why is verbal reinforcement not reinforcement-learning updates to model parameters?
Show answer and example
Answer: Feedback becomes natural-language experience in bounded episodic memory. The next attempt sees a different context without gradient updates to weights. Reflection can communicate more than binary success but can be wrong. An Evaluator must still judge execution rather than treating reflection's claims as learning evidence.
Illustrative example: Remember 'check the file path before editing' after failure. Reading that note changes behavior next round even with identical weights.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What does actionable reflection add over saving a binary failure reward?
Show answer and example
Answer: Binary reward only says the attempt failed. Reflection proposes a cause and actions to try or avoid, supplying actionable context. That inference may be wrong and needs actual next-trial feedback. Do not place the hidden reference plan into reflection and credit later success to autonomous learning.
Illustrative example: 'Failure' does not locate the problem. 'The date parameter needs ISO format' is useful, but must come from a visible error rather than a gold route.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why interpret the mini-suite score of 0.9 separately from isolated ToolRoute results?
Show answer and example
Answer: The mini-suite deterministically fails the first attempt in each family and then reuses feedback, with fixed reflection templates and evaluator. ToolRoute is a different tool environment without a reference-policy interface. Neither is HumanEval pass@1. Bounded append and failure retention can be checked, but scores cannot rank across protocols or replace the paper.
Illustrative example: One deliberately failed task in each of twelve families sets the aggregate rate, unlike natural model errors across 120 independent coding problems.
Sections in the Chinese source: 核心公式, 本地复现, 复现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
If an agent can already edit its harness, why update the rubric too?
When the Critic Falls Behind: Co-Evolving Rubrics and Harnesses for Continual Agent Self-Improvement
Show answer and example
Answer: A repaired harness changes its failure distribution. Fixed criteria may track resolved faults and miss new ones. RuHarness reevaluates criteria against current trajectories while keeping the task objective fixed, then uses criteria that still diagnose weaknesses to guide edits.
Illustrative example: Example: Initially it forgot search; later it searches but submits with insufficient evidence. Rewarding any search call misses the new failure.
Sections in the Chinese source: 背景与主要改动. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why compute discrimination, coverage and predictiveness from one six-cell posterior?
When the Critic Falls Behind: Co-Evolving Rubrics and Harnesses for Continual Agent Self-Improvement
Show answer and example
Answer: They are correlated because they come from the same success/failure × Violated/Satisfied/N/A table. Add 0.5 to each cell, draw 2,000 joint Dirichlet samples, recompute all three for each draw and take the 0.2 utility quantile. Independent draws would discard correlations. Trajectory-set N and Red are fixed during sampling.
Illustrative example: Example: Two observed violations both fail, giving a high point estimate. A lower posterior quantile reflects that two hits are not hundreds of stable observations.
Sections in the Chinese source: 核心公式, 数据协议与实现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Does better rubric compliance automatically promote the next harness?
When the Critic Falls Behind: Co-Evolving Rubrics and Harnesses for Continual Agent Self-Improvement
Show answer and example
Answer: No. Rubrics diagnose weaknesses and guide proposals, not task outcomes. Candidates must pass external verification and compete with the current harness on independent validation. Only the top-scoring candidate whose improvement strictly clears the threshold replaces it. Final test is excluded.
Illustrative example: Example: A candidate adds many evidence-check lines but does not improve validation success. Keep the current harness rather than promote prettier self-check logs.
Sections in the Chinese source: 核心公式, 数据协议与实现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Does outcome-blind judging conflict with later use of success/failure labels?
When the Critic Falls Behind: Co-Evolving Rubrics and Harnesses for Continual Agent Self-Improvement
Show answer and example
Answer: No. The judge sees behavior only when assigning rubric labels, avoiding hindsight. A separate statistical layer then joins those labels with outcomes to form the six-cell table. The component accepts both inputs but cannot prove an external judge was blinded or claim full evaluation integration.
Illustrative example: Example: Seal the label for whether the target file was checked before revealing test success; don't reinterpret an ambiguous check after learning the run failed.
Sections in the Chinese source: 背景与主要改动, 数据协议与实现边界, 本地结果与负控. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
Does CROP optimize model parameters, individual answers or the system prompt?
CROP: Token-Efficient Reasoning in Large Language Models via Regularized Prompt Optimization
Show answer and example
Answer: It freezes model weights and iterates the system prompt offline. The model generates; task and length critics identify accuracy and redundancy problems; a meta-optimizer rewrites the prompt. Deployment uses the selected prompt for one generation. This is neither hard truncation nor RL weight updates.
Illustrative example: Example: Iteratively changing “explain every step” to “keep the combined calculation and remove repetition” is prompt optimization; cutting any reply after 50 tokens is not.
Sections in the Chinese source: 背景与主要改动, 原论文关键图. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Why threshold the length critic, and how are the two textual gradients combined?
CROP: Token-Efficient Reasoning in Large Language Models via Regularized Prompt Optimization
Show answer and example
Answer: Section 3.3 runs length criticism only when generation strictly exceeds the threshold. Eq. 3 concatenates task critique, newline and length critique per sample for the meta-optimizer, rather than averaging numeric losses. Gradually remove narrative redundancy while keeping required calculations.
Illustrative example: Example: Threshold 40 does not trigger at 40 tokens but does at 41. “Check unit conversion” and “remove the repeated intro” cannot be replaced by scalar 0.7.
Sections in the Chinese source: 核心公式, 数据协议与实现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
What does CROP add beyond accuracy-only prompt tuning, and are token savings lossless?
CROP: Token-Efficient Reasoning in Large Language Models via Regularized Prompt Optimization
Show answer and example
Answer: It adds length feedback and selection by output-token cost. Table 3 includes accuracy drops: Gemini2Flash on ObjectCounting goes 96.0%→94.8% while mean tokens go 101.2→19.6. Report both sides of the tradeoff, not universal losslessness.
Illustrative example: Example: At equal 0.9 accuracy a 50-token prompt can beat a 100-token one. If the short prompt is less accurate, do not report only length.
Sections in the Chinese source: 背景与主要改动, 论文离线与线上效果, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
How does local selection avoid test data or a final unevaluated prompt, and what do callbacks establish?
CROP: Token-Efficient Reasoning in Large Language Models via Regularized Prompt Optimization
Show answer and example
Answer: Selection requires fixed validation revision/IDs matching the frozen CoT length baseline, disjoint training IDs, and no train/test scoring for selection. Each round validates the current prompt before proposing the next, so the final unevaluated one cannot win. Deterministic model/critic fixtures verify gating, concatenation and selection, not real LLM improvement.
Illustrative example: Example: Measured A=0.8 and B=0.9; last proposal C has no validation. Return B, not newest C.
Sections in the Chinese source: 数据协议与实现边界, 本地结果与负控, 高成本完整实验. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Basics
If cheap search feedback is sufficient, why spend extra on final confirmation?
Where Should the Evaluation Budget Go in LLM-Driven Agent Scaffold Evolution?
Show answer and example
Answer: Search needs comparable low-cost guidance; final selection must separate near-tied candidates. EvalAlloc uses sparse shared-core search and paired confirmation that reuses cache, with real observations for the final prefix rather than perpetual imputation.
Illustrative example: Example: A predicted difference of 0.01 can guide exploration but should not decide the champion by itself.
Sections in the Chinese source: 背景与主要改动, 核心公式. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Core mechanism
Can partial credit 0.9 add 0.9 to an item's acquisition success count?
Where Should the Evaluation Budget Go in LLM-Driven Agent Scaffold Evolution?
Show answer and example
Answer: No. Acquisition counts only full credit a_i and uses a Beta posterior for conservative p(1−p) informativeness. Partial grades are not full successes there but remain scores for the response model. Mixing the stages changes the shared core.
Illustrative example: Example: Ten 0.9 scores yield a=0, n=10, not a=9; 0.9 still enters model fitting and final scores.
Sections in the Chinese source: 核心公式, 本地结果与负控. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Method comparison
Why aren't equally sized independent random item sets equivalent to a shared core?
Where Should the Evaluation Budget Go in LLM-Driven Agent Scaffold Evolution?
Show answer and example
Answer: Common items supply paired covariance, helping when candidates agree on most items and set difficulty varies. Frozen item model and prior put successive generations on one scale. Refitting per candidate breaks comparability. This benefit depends on candidate correlation, not guaranteed variance reduction.
Illustrative example: Example: A faces hard items and B easy ones. A common informative core is more comparable than merely requiring 60 items each.
Sections in the Chinese source: 核心公式, 数据协议与实现边界. The example illustrates the mechanism.
Agents / Harnesses and self-improvement: which layer changes?
Implementation details
Why retain the search-cache union and check candidate IDs in cross-fitting?
Where Should the Evaluation Budget Go in LLM-Driven Agent Scaffold Evolution?
Show answer and example
Answer: Already executed cells need not be paid for again; fill missing common-prefix items and retain candidate-specific observations. Separate two-fold refit predictions prevent candidates from training their own correction. The correction is zero when all items are observed.
Illustrative example: Example: Keep A's cached item 4 even if prefix is 0/1/2. If a round needs four new cells and only three remain, reject the round; never read hidden complete scores to select a winner.
Sections in the Chinese source: 核心公式, 数据协议与实现边界, 本地结果与负控. The example illustrates the mechanism.
Topic guide and reading order
Start with this question¶
After a failure, should the system revise one prompt, save a lesson, or change the entire task workflow?
Takeaway¶
Distinguish retrying the current answer, storing language experience across attempts, and changing tool orchestration or the harness. Reflexion saves feedback for the next attempt without updating weights. Full research systems also propose, implement, evaluate, and track lineage. Each change needs its own acceptance criteria; editing a workflow is not evidence of capability gains. CROP mutates the system prompt offline. EvalAlloc allocates evaluation across candidates and estimates fitness. Token objectives and evaluation-cell budgets are different mechanisms.
Example¶
After forgetting to verify dataset versions, save the lesson in the next plan or add version and split checks to the workflow. Evaluate on tasks not used to make the change, compare success and calls to the old process, and report same-case recovery as such. It does not establish generalization.
Common pitfall¶
Separate development feedback from held-out evaluation. Keep hidden answers and scoring plans out of the evaluated system. Papers like AgentX involve actual research or industrial loops; local mini-suites, callbacks, and references do not reproduce them. Do not reopen expensive closed runs merely because a paper is grouped under self-improvement.
Reading order¶
Read Reflexion for cross-attempt experience, Self-Refine for revision within an attempt, and AgentX for the complete proposal–evaluation–workflow-update loop and the local subset.
- Reflexion · Original paper
- Self-Refine · Original paper
- AgentX: Towards Agent-Driven Self-Iteration of Industrial Recommender Systems · Original paper
Check your understanding¶
If we add a reminder to a prompt after one failure and weights stay unchanged, did the model learn through RL?
Show suggested answer
No. The change is to prompting, memory, or execution. It may improve behavior, but report it at that layer and test on held-out tasks. Model training claims require collecting a learning signal and updating policy parameters.