INQUIRING LINE

If an AI keeps failing at a task, should you rebuild its practice world or reshape the one you trust?

How do diagnose-and-reshape loops compare to building new environments from scratch?

This explores whether it's better to take an existing, trusted training environment and reshape it around where an agent is struggling, or to build a brand-new environment from scratch.


This explores whether you should take an existing, trusted environment and reshape it around where an agent is struggling, or build a new one from scratch. The corpus has one direct example of the reshaping side and nothing that tests it head-to-head against building from scratch. EnvHarness wraps a static environment in a plug-in layer that sits on its reset and step calls. The layer can isolate individual skills, stretch task horizons and calibrate difficulty, all without touching the underlying code. Across five benchmarks it gained up to 9.0 points with 9.8% fewer steps (Can wrapping environments reshape how agents learn without breaking verifiers?). The main advantage is that the original human-built verifiers stay valid. In a new environment the verifier, which decides what counts as success, is usually the hardest part to get right, and you'd have to build and re-trust it.

The same pattern shows up elsewhere in the corpus: change what surrounds the fixed thing and leave the thing alone. Reorganizing a code harness around runtime behavior, rather than rewriting it, raised win rates by 10–19 points and let a weaker planner match stronger models at finding the right code (Can explicit behavior maps help weaker planners compete with stronger models?). Surveys of self-improving agents say recent progress is concentrated in these fast loops, which update prompts, memory and tools rather than model weights, because scaffold changes are cheaper and reversible (Do self-improving agents really split into two distinct loops?). A wrapper has the same property: if the reshaping doesn't help, you remove it. A from-scratch environment is a sunk cost. ModularRSI adds a related point. Harness improvements evolved as separate modules on benchmark-disjoint data carried over to unseen tasks and domains (Can harness modules improve separately from benchmark data?). By analogy, a reusable reshaping layer may travel further than an environment built for one task.

The "diagnose" half matters as much as the "reshape" half. An autoresearch pipeline gained 411% F1 on a memory benchmark, and its bug fixes, architectural changes and prompt rewrites each beat all the hyperparameter tuning combined. The authors' explanation is that it could read the code and reason about how the parts interact, which blind tuning cannot do (Can autonomous research pipelines discover AI architectures that AutoML cannot?). Skill creation shows a similar gap. Skills written inside the agent's running loop, with real feedback, beat skills authored offline, because the offline author never sees the situation where the skill fails (Does creating skills inside the agent loop eliminate mismatches?). Building an environment from scratch is the offline-authoring case, since you guess where agents will struggle before watching them struggle.

The loop has limits. Repeated revision tends to accumulate noise rather than improve, and the fix in one study was compressing memory between rounds (Do iterative refinement methods suffer from overthinking?). The Darwin Gödel Machine handles this by testing every change empirically and keeping an archive of variants instead of trusting one path (Can AI systems improve themselves through trial and error?). A reshaping loop needs the same discipline: measure each change and keep the alternatives. The corpus doesn't say when from-scratch is the right call, such as when no trustworthy verifier exists or when the base environment can't express the skill you want to train. It only shows that where a good verifier already exists, reshaping around it is the cheaper and safer bet.


Sources 8 notes

Can wrapping environments reshape how agents learn without breaking verifiers?

EnvHarness shows that a plug-in layer applied through reset and step can isolate skills, extend task horizons, and calibrate difficulty without modifying underlying code or invalidating trusted human-built verifiers. Across five benchmarks, the approach yielded up to 9.0-point improvements with 9.8% fewer steps.

Can explicit behavior maps help weaker planners compete with stronger models?

A behavior-to-code mapping representation improved win rates by 10–19 points while reducing planner tokens by 8–13%. Weaker planners using this mapping matched stronger models' code localization across all precision and recall metrics.

Do self-improving agents really split into two distinct loops?

A survey framework organizes self-improving agents into two update mechanisms: slow parametric loops updating foundation model weights, and fast non-parametric loops updating prompts, memory, and tools. Recent progress concentrates in the fast loop because scaffold updates are cheaper and reversible than weight updates.

Can harness modules improve separately from benchmark data?

ModularRSI evolves harness modules independently using contrastive trajectories on benchmark-disjoint data, showing consistent gains across unseen tasks and domains. The approach isolates mechanism-level improvements from task-specific adaptation by aggregating evidence across tasks before updating components.

Can autonomous research pipelines discover AI architectures that AutoML cannot?

AUTORESEARCHCLAW achieved 411% F1 improvement on LoCoMo through bug fixes, architectural changes, and prompt engineering—each individually exceeding all hyperparameter tuning combined. This demonstrates a categorical capability gap: autoresearch can read code and reason about system-level interactions; AutoML cannot.

Show all 8 sources
Does creating skills inside the agent loop eliminate mismatches?

MUSE-Autoskill demonstrates that invoking skill creation from within the agent's reasoning loop grounds new skills in exact task context, immediate feedback, and runtime validation. In-loop skills reach 87.94% task accuracy and transfer to other agents with minimal loss, eliminating the situated context problem of offline authoring.

Do iterative refinement methods suffer from overthinking?

Sequential revision methods share the same failure architecture as token-level overthinking: they accumulate noise without guaranteed improvement. Progressive Draft Refinement avoids this by compressing memory between iterations, outperforming longer reasoning traces at matched compute.

Can AI systems improve themselves through trial and error?

DGM replaces formal proofs with empirical benchmarking and maintains an evolutionary archive of agent variants, achieving 2.5× improvement on SWE-bench and 2.2× on Polyglot by discovering capabilities like better code editing and context management.

Papers this line draws on 8

The research behind the notes this line reads — ranked by how closely each paper relates.