Autonomous Optimization (AO) Problem

• Autonomous Optimization is a formal framework where an agent autonomously searches and refines candidate solutions without human intervention.
• It enforces strict separation between development and held-out test evaluations to prevent overfitting and ensure robust validation.
• The approach leverages a hypothesis tree and modular coordination to integrate experimental outcomes, driving state-of-the-art performance across diverse tasks.

Autonomous Optimization (AO) Problem

Autonomous Optimization (AO) denotes a formal paradigm in which an agent autonomously searches for and iteratively improves candidate solutions to a well-specified optimization problem, subject to explicit operational constraints and with no step-level human supervision. AO encompasses domains spanning artifact refinement, code synthesis, model training, system identification, and mixed algorithmic–physical pipelines, and is characterized by its generality and the strict enforcement of development–test separation during adaptive experimentation (Jin et al., 10 Jun 2026).

1. Formal Definition and Problem Statement

Autonomous Optimization is rigorously defined by the 4-tuple: $$\mathcal{P} = (M_0,\, O,\, E_{\mathrm{dev}},\, E_{\mathrm{test}})$$ where:

• $M_0 \in \mathcal{X}$ is the initial artifact in artifact space $\mathcal{X}$ (e.g., code, model weights, configuration).
• $O$ is the single-scalar optimization direction, specifying higher/lower is better.
• $$E_{\mathrm{dev}}: \mathcal{X} \rightarrow \mathbb{R}$$ is the development evaluator accessible in all developer loops.
• $$E_{\mathrm{test}}: \mathcal{X} \rightarrow \mathbb{R}$$ is a held-out evaluator strictly reserved for final validation.

The operational protocol is:

• The agent explores adaptively over $E_{\mathrm{dev}}$ only, generating a finite candidate set $\mathcal{A} \subset \mathcal{X}$.
• The optimal artifact is selected by

$$M^\star = \arg\max_{M' \in \mathcal{A}} S_{\mathrm{test}}(M')$$

where $S_{\mathrm{dev}}(M) = E_{\mathrm{dev}}(M)$ and $M_0 \in \mathcal{X}$0.

• Crucially, $M_0 \in \mathcal{X}$1 must not influence any hypothesis formation or action selection during search; it is invoked exclusively at held-out merge gates.

The performance metric for cross-task comparison is the normalized held-out gain: $M_0 \in \mathcal{X}$2 where $M_0 \in \mathcal{X}$3 is score-oriented and $M_0 \in \mathcal{X}$4 prevents division by zero.

This operational formalism distinguishes AO from classical reinforcement learning or black-box optimization paradigms, mandated by the separation between exploration (development) and exploitation (test) and the prohibition of test-leakage (Jin et al., 10 Jun 2026).

2. Architectural Principles: Coordinator, Executors, and Hypothesis-Tree

The Arbor framework, designed to instantiate AO at scale, organizes the problem into three tightly coupled architectural modules:

1. Long-Lived Coordinator:

Maintains a dynamic hypothesis tree $M_0 \in \mathcal{X}$5 composed of nodes $M_0 \in \mathcal{X}$6:

• $M_0 \in \mathcal{X}$7: Verifiable hypothesis (e.g., "Changing layer normalization to RMSNorm will lower dev loss").
• $M_0 \in \mathcal{X}$8: Abstracted insight, summarized from experimental results and reusable across branches.
• $M_0 \in \mathcal{X}$9: Metadata, including node status, dev-score $\mathcal{X}$0, factual execution logs, and implementation refs (e.g., git branch $\mathcal{X}$1).

The coordinator implements a persistent global research strategy via a six-stage control loop (Observe, Ideate, Select, Dispatch, Backpropagate, Decide), and upholds strict dev/test separation with a held-out test merge gate.

2. Short-Lived Executors:

Each executor is bound to a single leaf $\mathcal{X}$2 and performs minimal, isolated edits to the current best artifact. The executor:

• Inherits contextual insights and branch metadata.
• Realizes the mutation, runs $\mathcal{X}$3, debugs only implementation errors, and returns a tuple $\mathcal{X}$4.
• Cannot mutate the global tree or access $\mathcal{X}$5.

3. Hypothesis-Tree Refinement (HTR):

Simultaneously encodes:

• The prospective search frontier (active leaves).
• Long-term memory of experimental outcomes: all hypotheses (accepted and falsified) and their condensed insights.
• An auditable trace of evidence, mapping accepted branches to both their empirical support and theoretical framing.

The HTR loop enables evidence-driven abstraction, where localized experimental outcomes are propagated upward (TreePropagate), converting leaf-level findings into global priors and constraints.

3. AO Algorithmic Workflow

The canonical Arbor AO-Hypothesis-Tree workflow is as follows (Algorithm 1, (Jin et al., 10 Jun 2026)):

$\mathcal{X}$7

This algorithmic structure enforces cumulative, insight-driven, and auditable optimization, guaranteeing that no branch merges occur without strict held-out validation.

4. Experimental Evaluation and Metrics

AO via Arbor is validated across six research tasks in three domains, as summarized in the table below (Jin et al., 10 Jun 2026):

Task Type	Example Task	Initial Artifact	Dev/Test Metric
Model Training	Optimizer Design (NanoGPT-Bench Muon)	Muon optimizer	Steps ↓ (avg of 2 seeds)
Model Training	Architecture Design (autoresearch)	Default LLM code	Final loss ↓ (avg of 2 seeds)
Harness Eng.	Terminal-Bench 2.0	Terminal agent code	Pass rate ↑
Harness Eng.	BrowseComp	ReAct search harness	Accuracy ↑
Data Synthesis	Search-Agent QA Synthesis	QA pipeline	Mean(pass@4−pass@1) ↑
Data Synthesis	Math-Reasoning Synthesis	Math problem pipeline	Mean(pass@4−pass@1) ↑

Key performance indicators include the held-out gain (in both native metric and normalized $\mathcal{X}$6), resource cost (48h wall-clock, equal token and call budget), and robustness to overfitting.

Arbor achieves the strongest held-out result on all six tasks, with 2–4x higher gains than Codex (GPT-5.5) and Claude Code, and >86% Any Medal rate on the MLE-Bench Lite with GPT-5.5—a new state-of-the-art under identical computational constraints.

5. Principles: Cumulative Learning and Development-Test Separation

AO critically externalizes all state relevant to search into the persistent hypothesis tree, converting independent experimental attempts into a cumulative, evidence-constrained research process. The cumulative learning effect is manifested through insight backpropagation: local outcomes inform global research priorities and future hypothesis formation.

The explicit dev/test separation, enforced via the merge gate and constraint on evaluator access, is essential. This prevents overfitting to exploratory feedback, ensuring robust generalization and scientifically valid artifact acceptance (Jin et al., 10 Jun 2026). Ablation studies confirm that removal of either the hypothesis tree structure or the insight propagation mechanism significantly degrades final test-set performance, validating their necessity.

6. Limitations and Future Directions

Current instantiations of AO via Arbor are constrained to single-scalar objectives and domains with strict dev/test evaluation protocols. The limitations identified include:

• Absence of multi-objective AO workflows (scalarization protocols, Pareto-based validation).
• Limited coverage of domains beyond code and ML artifacts; extension to broader scientific and engineering benchmarks represents future work.
• Hypothesis formulation and insight abstraction are currently predicated on scalar optimization; richer (e.g., structural, compositional) hypotheses remain out of scope.
• Cost management for high-frequency iterators and automatic integration of specialized tools or knowledge-bases for hypothesis generation are open directions.

Proximate future research includes architectural generalization to multi-objective and multi-modal AO, advances in knowledge infusion into hypothesis formation, and domain-expansion to physical and mixed human–machine optimization regimes (Jin et al., 10 Jun 2026).