PaperlayerView exact revision on arXiv

Source-linked AI summary

The Optimizer Is the Agent: Reasoning-Driven Search across Prompts, Programs, and ML Workflows

Junbo Li, Boyi Liu, Canwen Xu, Yite Wang, Yuxiong He, Zhangyang Wang, Qiang Liu, Zhewei Yao

arXiv:2608.06714v1cs.AI

TL;DR

Existing optimization systems rely on explicit outer-loop search controllers for prompts, programs, and ML workflows. ReASearch instead lets one tool-using agent reason through the optimization loop, matching or outperforming specialized baselines across 14 tasks with gains of 2% to 40%.

  • Problem

    Prior methods typically delegate search over textual artifacts to external meta-heuristics such as evolutionary algorithms, bandits, or textual-gradient methods.

  • Method

    ReASearch uses a shared tool-using agent that autonomously evaluates, analyzes, edits, verifies, reverts, and stops across prompts, programs, and ML workflows.

  • Results

    2% to 40% gains over strong domain-specific baselines across 14 diverse tasks, with some solutions surpassing prior human best-known results.

  • Takeaways & Limitations

    The results suggest that tool-using agents can internalize substantial search logic previously delegated to explicit controllers.

Abstract

from arXiv · show

Recent systems for optimizing prompts, programs, and ML workflows typically rely on explicit outer-loop controllers such as evolutionary search, bandits, or textual-gradient methods. We ask a fundamentally different question: how much of this search policy can be internalized by a single tool-using agent? We present ReASearch, a unified framework for reasoning-driven optimization in which the agent autonomously decides what to evaluate, how to diagnose failures, which edits to make, and when to verify or restart. Rather than serving only as a proposal generator guided by hand-designed heuristics, the agent actively analyzes outcomes, allocates budget, and refines its strategy over long horizons through persistent memory. With a shared agent loop and domain-specific tools, ReASearch instantiates the exact same scaffold to optimize prompts, programs, and ML workflows. Across 14 diverse tasks, it is competitive with and mostly better than specialized optimization systems, achieving gains of 2% to 40% over strong domain-specific baselines, and in some cases discovering solutions that improve on prior human best-known results. Crucially, we observe that complex search behaviors, which are typically implemented by explicit controllers, emerge naturally from the agent's reasoning process.

1 Introduction

ReASearch asks how much optimization search policy can be internalized by a single tool-using reasoning agent rather than delegated to an external controller. Across prompts, programs, and ML workflows, one shared agent scaffold matches or outperforms specialized systems across 14 tasks while exhibiting optimizer-like behaviors that are not hard-coded.

  • Motivation: Traditional methods struggle with text-based optimization because they search large discrete spaces without rich semantic access to natural language and code.This motivates using LLMs as semantic optimizers that propose structured edits from execution feedback.
  • Motivation: Prior systems typically assign candidate selection, evaluation, budget allocation, and stagnation recovery to external algorithmic controllers, leaving LLMs to provide semantic edits.These approaches include score-history prompting, textual gradients, planning, evolution, and adaptive controllers.
  • ReASearch: ReASearch places a tool-using LLM agent fully in charge of the optimization loop through domain-specific evaluation, analysis, editing, and memory tools across three settings.It is presented as a controller-light framework with a single shared agent design for prompts, programs, and ML workflows.
  • Results: The agent’s trajectories exhibit double-verification, reuse of similar past failures, deliberate reverting, and adaptive exploration without these behaviors being hard-coded.These recurring optimizer-like behaviors emerge in rich-feedback environments through the agent’s reasoning process.
  • Results: 14 tasks: ReASearch matches or outperforms strong domain-specific baselines by 2% to 40% within the same budgets, sometimes surpassing prior human best-known results.The benchmark spans three distinct domains and uses the same agent scaffold.

2 Method

ReASearch formulates optimization over textual artifacts and uses a task-agnostic, tool-using code agent to search them through reasoning, execution, and memory. Domain-specific tools support adaptive evaluation, diagnosis, verification, editing, and refinement across prompts, programs, and ML workflows.

  • General objective: The objective is to find a textual artifact z that maximizes expected reward over task instances x ∼ D and outputs Y ∼ P(· | x, z).For task-free optimization, the expectation over D vanishes and the goal becomes maximizing the artifact’s expected reward.
  • Agent architecture: The core loop is task-agnostic: the agent receives domain guidance and optimization state, reasons over interaction history, and selects tools through interfaces AT and a task-specific system prompt.The implementation provides file I/O, Python/Bash execution, and a lightweight memory module.
  • Agent architecture: Persistent memory and context compression support long-horizon optimization by recording lessons about what worked and failed and summarizing interaction history when needed.The agent maintains a persistent lessons.md file that it is periodically prompted to read or update.
  • Prompt optimization: Prompt optimization exposes training and validation evaluation as tools, allowing the agent to choose minibatches and evaluation steps adaptively according to its reasoning and remaining budget.This replaces prior pipelines that repeatedly sample random training minibatches, revise prompts, and validate proposals through a fixed procedure.
  • Prompt optimization: The agent rechecks promising prompts, analyzes score trajectories and failure modes, probes edge cases, and selects or synthesizes a final prompt from the full evaluation history.These behaviors emerge from reasoning over evaluation history rather than hand-designed algorithmic components.
  • Domain-specific tools: Program and ML workflow optimization use tools for evaluation, code editing, verification, experiments, and Python-based analysis to diagnose bottlenecks and refine targeted modifications.Program edits are routed to a separate subagent, while ML changes can target hyperparameters, schedules, regularization, architectures, or optimizers.

3 Experiments

Across 14 tasks in three categories, ReASearch is evaluated against strong domain-specific baselines under comparable budgets and minimal task-specific tuning. It consistently outperforms GEPA, surpasses Claude Code on most ML tasks while using fewer tokens, and benefits from persistent memory, Python execution, and coarse validation feedback.

  • Experimental setup: ReASearch is evaluated on 14 diverse tasks across three categories, using comparable budgets, minimal task-specific tuning, and three independent runs per setting.Results are reported as averages across the independent runs.
  • Prompt optimization: ReASearch consistently outperforms GEPA across all evaluated prompt-optimization tasks at the same student-model-call budget and under $20 in API usage per full run.Standard caching makes the cost comparable to GEPA’s reported cost.
  • Program optimization: On EPLB, diagnosing a 120-turn plateau and relaxing a replica-donation restriction lifted the score from 0.21 to 0.23.The intervention allowed an expert to give up its last replica, enabling beneficial intermediate states.
  • Program optimization: On ARC-AGI-2, analysis before coding and cell-level evaluator feedback produced a 4× test-accuracy gap over the comparison method.The agent interrogated training pairs with Python before coding and diagnosed errors cell by cell after submission.
  • ML workflow optimization: ReASearch is statistically indistinguishable from Claude Code on NanoGPT but performs better on the remaining ML tasks while using far fewer tokens.NanoGPT results are 0.976 ± 0.008 versus 0.974 ± 0.010.
  • Ablations: Ablations show that memory and Python execution both matter, with memory most important for long prompt trajectories and Python execution most important on ARC-AGI-2.A simple what worked / what did not / what to try next schema transfers across runs, while aggregate validation metrics avoid overfitting.

4 Conclusion · A Related work

ReASearch frames optimization as a reasoning problem, using agentic tool-based reasoning to optimize prompts, programs, and ML workflows. Related systems instead commonly rely on external heuristics, single-domain orchestrations, or agents not architected for budget-constrained optimization loops.

  • 4 Conclusion: ReASearch replaces hand-designed search logic with agentic reasoning over tools.The framework treats optimization itself as a reasoning problem.
  • 4 Conclusion: ReASearch provides one system for optimizing prompts, programs, and ML workflows.The conclusion describes this unified framework as producing strong empirical gains.
  • 4 Conclusion: The framework positions reasoning as an engine for open-ended search, not only task solving.This is presented as a broader implication of the proposed approach.
  • A Related work: Prior LLM-based text optimization methods typically use curated external heuristics to govern the overall optimization pipeline.The passage lists APE, OPRO, ADAS, DGM, AlphaEvolve, CodeEvolve, PACEvolve, DeltaEvolve, AHE, and SimpleTES as examples.
  • A Related work: Autonomous ML-agent frameworks are closer in spirit to ReASearch but primarily remain single-domain proof-of-concepts for ML training pipelines.The passage names AutoResearch and notes these systems often rely on closed-source orchestrations such as Claude Code.
  • A Related work: Existing autonomous ML agents often obscure their underlying search dynamics through closed-source orchestration.Claude Code is given as an example of such orchestration.
  • A Related work: Code agents provide file editing, code execution, and terminal access for multi-step reasoning over software codebases.Examples include Cursor, Claude Code, OpenCode, and Codex.
  • A Related work: These code agents are not inherently architected for rigid, budget-constrained optimization loops.The passage contrasts open-ended development capabilities with optimization-loop requirements.

B Extended qualitative analysis of prompt optimization

The prompt optimizer reasons through failures, verifies changes before costly validation, and navigates candidate branches while calibrating against overfitting. Persistent memory lets it reuse prompt-specific lessons and select a final prompt from the full optimization history.

  • Structured task understanding: On HotpotQA, the agent categorized all 126 baseline failures into overlapping error modes before generating prompt variants.The taxonomy included 57 verbosity cases and shaped subsequent prompt design.
  • Structured task understanding: On HotpotQA, the dominant verbosity diagnosis led to minimum-phrase framing that drove accuracy to 66.0%.The agent also checked previously failing example ID 260 after adding a rule distinguishing people from organizations.
  • Candidate navigation: On Terminal-Bench, validation dropped by 3 points after Candidate #4 extended Candidate #3’s 63.6% strategy-first prompt, prompting the agent to revert toward a known-good ancestor.The agent independently maintained candidate lineage and decided when to restart without an external backtracking controller.
  • Overfitting calibration: On AIME, training accuracy rose from 60% to 66.7%, but validation fell to 50.2% below the 51.1% baseline, so the agent removed complexity instead of adding heuristics.It recorded that domain-specific additions hurt validation generalization even when they helped training.
  • Persistent memory: The agent stored prompt-specific lessons in lessons.md, including helpful or harmful elements, failed modifications, and structural properties of instruction processing.These accumulated lessons directly guided later optimization decisions.
  • History-based selection: On AIME, a synthesized but unvalidated prompt scored 52.0% on the 150-example test set after combining useful strengths with targeted fixes and removing overfitting additions.The final choice used the full optimization history rather than only the highest-scoring prompt.

C Ablation studies

The ablations show that ReASearch depends on both memory and tool use, while memory can transfer reusable optimization knowledge across runs. Coarser validation feedback also outperforms detailed per-example trajectories, which induce overfitting.

  • Component attribution: Removing either the memory mechanism or Python execution tool reduces performance, although their relative impact varies across prompt-optimization and program-evolution tasks.The ablation removes lesson summaries and the search tree, or Python execution, while keeping all other settings unchanged.
  • Memory design and transfer: Initializing a new NanoGPT run with lessons.md raises its starting baseline from about 0.998 to 0.977, indicating that memory captures reusable optimization knowledge.The source lessons came from a run achieving 0.969 bpb, and the new agent automatically updates its baseline.
  • Validation feedback granularity: 52% to around 50%: on AIME, exposing detailed per-example validation trajectories lowers performance relative to providing only the aggregate validation metric.The detailed trajectories lead to clear overfitting during prompt optimization.

D Open-source backbones

ReASearch generalizes beyond proprietary optimizers: open-source backbones GLM-5 and Kimi-2.5 support prompt and ML workflow optimization. They produce substantial gains on a challenging benchmark and clear baseline improvements, though ML workflow performance is slightly weaker than Claude/GPT-based agents.

  • Model generality: ReASearch is not tied to proprietary models and was evaluated with GLM-5 and Kimi-2.5 for prompt and ML workflow optimization.Performance generally scales with the capability of the underlying model.
  • Prompt optimization: 15% and 8%: ReASearch with GLM-5 and Kimi-2.5, respectively, lifts Terminal-Bench 2.0 performance from a near-zero baseline.The setting uses GPT-OSS-120B as the student model.
  • ML workflow optimization: Open-source backbones are slightly weaker than Claude/GPT-based agents on ML workflow optimization but still show clear improvements over the baseline.The comparison is reported as expected relative to Claude/GPT-based agents.

E Component ablation on Heilbronn triangle

On the Heilbronn triangle program-evolution task, removing Python execution slightly harms performance more than removing memory. This supports the importance of short-horizon analysis and verification in program evolution.

  • Component ablation on Heilbronn triangle: Removing the Python execution tool has a slightly larger effect than removing memory.The result matches the ARC-AGI-2 ablation.
  • Component ablation on Heilbronn triangle: The ablation result is consistent with program evolution relying on short-horizon analysis and verification.These capabilities explain why execution-tool removal has the larger effect.
  • Component ablation on Heilbronn triangle: The Heilbronn triangle objective is minimum triangle area, with higher values considered better.Table 11 reports the component ablation for this program-evolution task.

F Claude Code baseline details and comparison analysis … H.1 Prompt optimization

ReASearch matches Claude Code’s optimization instructions but improves search by re-emitting state and guidance each turn, while exposing shared, memory-enabled tools plus domain-specific interfaces across optimization settings. The prompt-optimization experiments use bounded student-model evaluation across several datasets, with separate training, validation, and test procedures where specified.

  • F Claude Code baseline details and comparison analysis: ReASearch and Claude Code receive matched optimization instructions, so the comparison does not attribute the score gap to extra rules given only to ReASearch.Both specify the same goal, edit constraint, time budget, keep/discard loop, simplicity rule, and NEVER-STOP behavior.
  • F Claude Code baseline details and comparison analysis: ReASearch’s key architectural difference is re-emitting the current best, recent experiments, lessons, stagnation warnings, and search-tree structure into the system prompt every turn.Claude Code instead uses a fixed conversation-start system prompt and agent-invoked information surfaces, making search state available rather than unavoidable.
  • G.1 General tools: The shared scaffold provides file I/O, Python and Bash execution, context compaction, status access, and lessons.md persistence across compressions and optionally across runs.Automatic compression replaces the transcript with an authoritative state snapshot, conversation summary, and lessons.md contents.
  • G ReASearch details: Across task families, ReASearch adds domain-specific tools for sampling and evaluating prompts, editing and scoring programs, and editing, running, and versioning ML training workflows.Each domain exposes interfaces tailored to its optimization artifact and evaluation process.
  • G.2.1 Prompt optimization: Prompt optimization samples minibatches, tests prompt drafts on customized subsets, and validates candidates using only aggregate validation metrics.Each student-model call consumes budget equal to the number of student-model calls it makes.
  • G.2.2 Program evolution: Program evolution lets the agent read solve.py, request an LLM-generated full-file edit from an instruction, and evaluate the resulting code against the task score.The separate editing call allows concise change descriptions instead of inline full-program generation.
  • G.2.3 ML workflow optimization: ML workflow optimization lets the agent read and edit train.py, run time-bounded experiments returning related metrics, and use Git commands in the task repository.The editing interface similarly converts concise instructions into a full modified training file.
  • H.1 Prompt optimization: Prompt-optimization experiments allocate student-model budgets of 1000 on AIME, 5000 on HotpotQA, and 5000 on GSM8K, with dataset-specific train, validation, and test splits.AIME repeats validation and test evaluations 5 times; HotpotQA uses exact match; GSM8K uses the official 1,319-example test split.

H.2 Program evolution … I.2 Program evolution

ReASearch applies a shared agent-driven optimization scaffold across program evolution, ML workflows, and prompt optimization. The supplied experiments span diverse tasks and show that iterative strategy refinement, verification, and persistent lessons support measurable improvements over baselines.

  • H.2 Program evolution: Program evolution covers circle packing, Heilbronn triangle, EPLB load balancing, transaction scheduling, and ARC-AGI-2 under task-specific baselines, evaluation timeouts, and budgets.Circle packing, Heilbronn triangle, and transaction scheduling use maximum budgets of 500; EPLB uses a composite balancedness-speed score, while ARC-AGI-2 reports pass@2 accuracy.
  • H.3 ML workflow optimization: ML workflow optimization targets validation bits per byte, image-classification accuracy, Atari reward, MuJoCo reward, and crypto-market validation correlation from established baselines.The workflows include NanoGPT, ResNet-18 on IMG-100, PPO on Q*bert, SAC on HalfCheetah, and a 6fold cross-validation crypto baseline ranking 36th on Kaggle.
  • I Optimization artifacts and agent lessons: Persistent lessons.md files preserve what worked, what failed, and what to try next across context compression and optimization runs.The artifacts include full before-and-after prompts for ReASearch and GEPA and summarized agent-written lessons across task categories.
  • I.1 Prompt optimization: 51.1% validation accuracy was achieved by the AIME baseline, while candidate prompt changes demonstrated that domain-specific additions can harm generalization.Candidate #3 reached 66.7% on train, but candidate #7 fell to 45.8% validation and candidate #2 to 48.9%; the lessons identify the baseline as near-optimal for this student model.
  • I.1 Prompt optimization: 68.0% validation accuracy was reached on HotpotQA after adding explicit answer-type mismatch checks to the verification step.The progression rose from 8.8% for the baseline to 66.0% with minimum-phrase framing and verification, then to 68.0% with type checks.
  • I.1 Prompt optimization: 90.8% validation accuracy was achieved on GSM8K after refining structured reasoning, pitfalls, verification, and error correction.After seven pitfalls, adding more consistently hurt across 13+ attempts; all 13 modifications to the final candidate also degraded performance.

I.2.1 Circle packing (n=29, max-sum)

For n=29 max-sum circle packing, the 2.84267 solution is identified as the likely global optimum, surpassing the AlphaEvolve target and exhibiting a rigid 5×6 contact structure. Optimization methods consistently reached this solution or lower local optima, with hexagonal initialization and progressive penalties providing reliable convergence.

  • Optimization behavior: Hexagonal initialization with L-BFGS-B and progressive penalties converges reliably to 2.8369 (score 0.9982), while random perturbations found the 2.8427 solution.Variable radii are essential, and vectorized gradients provide a 7x speedup.
  • Known optima: 2.84267 is reported as the global optimum with score=1.0002, ahead of the 2.83688 and 2.83418 local optima.The three known optima are listed in descending quality.
  • Solution structure: 70 active contacts make the 5×6 arrangement hyperstatic and rigid, with four small circles and larger corner radii.The four small circles have r˜0.067, while corner circles have r˜0.11–0.12.
  • Optimality evidence: 2.842669 is likely globally optimal because all optimization methods converge to it, every LP direction has negative gradient, and the second derivative is strongly negative (-19949).The solution exceeds the 57-contact isostatic threshold, further supporting its rigidity.
  • Comparison: 2.84267 (score=1.0002) beats the AlphaEvolve target of 2.842.The supplied comparison reports the ReASearch solution as exceeding that target.

I.2.2 Heilbronn triangle (n=12)

For n=12, the optimal Heilbronn configuration has D4 symmetry, reducing the problem to two parameters. Its exact solution achieves minimum area 0.032598858692, and the verified D4 configuration is globally optimal.

  • Symmetry reduction: D4 symmetry makes the optimal N=12 configuration 8-fold symmetric, with four rotations and four reflections.This symmetry reduces the optimization from 24 variables to two parameters: boundary x-coordinate a and interior y-coordinate b.
  • Exact solution: 2 parameters define the configuration, constrained by (b-0.5)^2 = a(1-a), with v = 1-a = 0.884646177119316....The exact optimum is the real root of 2v^3 - v - 0.5 = 0.
  • Exact solution: 0.032598858692 is the minimum area, with ratio = 0.999965 to known best and 20 minimum triangles sharing that area.The result was verified with mpmath 50-digit precision.
  • Resolution: <1ms is sufficient to return the hardcoded D4 configuration with score 1.0000; no optimization can improve it because it is globally optimal.The workflow found the D4 configuration after multi-stage L-BFGS-B optimization with a log-sum-exp smooth surrogate.

I.2.3 EPLB … I.3.1 NanoGPT

Across EPLB, transaction scheduling, ARC-AGI-2, and NanoGPT, compact reasoning-driven strategies outperformed more complex alternatives, while NanoGPT reached a val_bpb of 0.969591 through targeted architectural and optimization choices.

  • I.2.3 EPLB: EPLB improved expert balancedness by switching to flat global replication with greedy refinement and a slight concavity of gamma ˜ 0.825.A local refinement budget of ˜48-52 iterations balanced balancedness and runtime.
  • I.2.3 EPLB: EPLB degraded when using temporal smoothing, Hamilton apportionment, water-filling, mandatory replicas, or over-tuned concavity.These alternatives respectively harmed balancedness, quality, speed, feasibility, or robustness.
  • I.2.4 Transaction scheduling: Transaction scheduling reduced combined makespan to ˜238 using conflict-graph presignals, true-cost insertion, adjacent swaps, and targeted reinsertion.True eval_cost verification was essential; graph heuristics alone produced worse quality.
  • I.2.4 Transaction scheduling: Under the 16s budget, complex global search operators consumed time with little gain, favoring limited adjacent-swap local search.Beam search, ruin, simulated annealing, segment reversal, and broad windowed searches were not competitive with compact reinsertion.
  • I.2.5 ARC-AGI-2: ARC-AGI-2 used two correct training solutions that differed in tie-breaking, with centroid centers of 18.5 and 18.0 covering both cases.The output bounding-box-center criterion did not distinguish the alternatives, so the current solution was considered optimal.
  • I.3.1 NanoGPT: NanoGPT’s current best configuration achieved val_bpb=0.969591 with DEPTH=9, dim=640, 80.9M parameters, and TOTAL_BATCH_SIZE=2ˆ17.The configuration also used DEVICE_BATCH_SIZE=64, WARMDOWN_RATIO=0.66, WINDOW_PATTERN=SSSSL, and a Muon momentum ramp over 500 steps.
  • I.3 ML workflow optimization: NanoGPT optimization improved val_bpb from 0.992894 to 0.969591 through sequential changes to batch size, depth/dimension, window pattern, learning rates, weight decay, and Muon ramp.The reported trajectory records intermediate values including 0.984637, 0.981951, 0.977265, and 0.970577.

I.3.2 IMG-100 … I.3.5 Market prediction Agent lessons.

Across IMG-100, Atari, MuJoCo, and market prediction, systematic agent-led ablations identified sharp configuration sweet spots, substantial reward or accuracy gains, and domain-specific failure modes. The lessons emphasize matching model complexity and schedules to budget, exploration and parallelism choices, and sensitivity to seemingly small hyperparameter changes.

  • I.3.2 IMG-100: 81.12% was achieved on IMG-100 with ResNet-18, OneCycleLR, and CutMix(60%)+Mixup(35%), improving from the 64.28% starting configuration.The progression also included wider channels, label smoothing, and weight decay adjustments.
  • I.3.2 IMG-100: With a 5 min budget, ResNet-18 reaches approximately 40 epochs, while larger or heavier augmentation choices underperform because they need more epochs to converge.OneCycleLR and max_lr=0.2 were identified as key, while EMA, AMP, torch.compile, and vertical-flip TTA were harmful or unsuitable.
  • I.3.3 Atari (Q*bert) Agent lessons.: 5000 reward was reached on Atari by combining 32 environments, 512 steps, 32 minibatches, and an IMPALA-style ResNet CNN.This configuration substantially exceeded the 475-reward starting setup, with more environments producing a major jump and the IMPALA CNN outperforming the Nature DQN CNN.
  • I.3.3 Atari (Q*bert) Agent lessons.: Atari results were very noisy, but 32 environments, 512 steps, four PPO epochs, entropy=0.01, and linear learning-rate annealing formed the reported sweet spots.Nearby settings, including 16, 40, 48, or 64 environments and 256 or 1024 steps, performed worse.
  • I.3.4 MuJoCo (HalfCheetah) Agent lessons.: 7622 reward was achieved in MuJoCo after increasing exploration with INIT_ALPHA=0.5 and LOG_STD_MAX=4, following improvements from normalization, Huber loss, and delayed policy updates.The starting configuration produced 3512 reward, while TD3 reached 7487 and remained slightly below SAC.
  • I.3.4 MuJoCo (HalfCheetah) Agent lessons.: MuJoCo training was highly sensitive: LR=1e-3, HIDDEN_DIM=512, and GAMMA=0.99 were critical, while many alternatives caused catastrophic failures or lower performance.Lower learning rates, larger or smaller hidden dimensions, altered gamma, clipping, normalization, alternative activations, and deeper networks were reported as harmful.
  • I.3.5 Market prediction Agent lessons.: val_corr=0.109111 was the best reported market-prediction result after sequentially tuning Ridge, MLP, noise, learning rates, loss weights, Huber loss, AdamW, and warmup.The progression began with RIDGE_ALPHA=65000.0 yielding val_corr=0.093776 and included APPROACH2_WEIGHT=0.20 yielding val_corr=0.098713.
  • I.3.5 Market prediction Agent lessons.: Market prediction depended on sharp hyperparameter sweet spots: disabling the AutoEncoder reduced performance to 0.081, while CORR_CLUSTER_THRESHOLD=0.5 caused 0.028.EMA decay=0.995 and Ridge feature standardization were also substantially worse, and approximately 45 failed experiments were documented.
Loading 2608.06714v1…