Autonomously improve a real artifact (code, training recipe, agent harness, data pipeline, prompt) against an objective and an evaluator, using Hypothesis Tree Refinement (HTR) from the Arbor paper. Use this whenever someone wants to iteratively optimize something over many experiments without overf

Arbor — Autonomous Optimization via Hypothesis Tree Refinement Overview This skill runs an Autonomous Optimization (AO) loop: starting from an existing artifact and a measurable objective, improve it through many rounds of experiment and evaluation — without step by step human supervision, while checking for overfitting to the development signal. It's the right tool when the bottleneck isn't writing one good change, but organizing dozens of trials so that lessons accumulate instead of evaporating. It implements Hypothesis Tree Refinement (HTR) from Arbor (Jin et al., 2026). The key idea: keep the research state in a persistent hypothesis tree rather than in conversation history. Each node binds a hypothesis, the distilled insight it produced, and a pointer to the artifact version that realizes it. You play the long lived coordinator that owns this tree and decides where to search; short lived executor subagents test one hypothesis each in isolated git worktrees and report back. A held out merge gate admits a change only when it improves on a test evaluator executors do not optimize against. This is what turns trial and error into cumulative, auditable research. Use the scripts/tree.py state manager for all the bookkeeping (creating nodes, writing evidence, propagating insights, pruning, the merge gate, the Observe projection). It records scores and decisions; it does not run evaluators, create worktrees, verify Git refs, or merge Git branches. Only the coordinator writes shared state, serially; executors return evidence. The helper has no multi writer locking. Its JSON schema is separate from upstream Arbor checkpoints. When to use this skill Reach for Arbor when the task is iterative improvement of a concrete artifact under an evaluator : Model training: optimizer/architecture/recipe changes to lower loss or hit a target in fewer steps. Harness/agent engineering: raising pass rate or accuracy of an agent loop, search harness, or tool use scaffold. Data synthesis: improving a generation/filtering pipeline judged by downstream model behavior. Benchmark optimization: MLE bench / Kaggle style "improve the submission" tasks. Prompt/system optimization where you can score outputs automatically. The distinguishing signals: there's an artifact you can modify , an objective , a way to score candidates, and you expect to run many experiments . If the user only wants a single fix or a one shot answer, this is overkill — just do the work directly. If they want open ended ideation with no evaluator, use hypothesis generation or scientific brainstorming instead. The AO setup — pin this down first Before any experiments, establish the task tuple (M 0, O, E dev, E test) . Record the resolved setup, using the user's existing instructions; clarify only missing decisions: M 0 — initial material : the artifact to improve (a repo, a script, a config, a prompt). Make sure it's under git and currently runs. O — objective : the natural language goal and the metric direction (maximize accuracy? minimize loss/steps?). E dev — development evaluator : a command you can run freely during search to score a candidate. Fast, repeatable. E test — held out test evaluator : a separate evaluation protocol (held out examples or predeclared independent seeds) used only at the merge gate. It must not be used as a search oracle — that's the whole point. Freeze the evaluator, dataset split, and metric before search, and record their versions with each score. Repeated merge decisions on the same held out set can still adapt the search to that set; a fresh worktree prevents file contamination, not statistical leakage. Keep a final untouched evaluation set for the final claim, or disclose that the reported result was selected using repeated gate feedback. If the user hasn't given you a clean dev/test split, construct one and say so . The dev/test separation is the mechanism that catches overfitting: a candidate that wins on dev but not on test isn't a success, it's a warning that you're exploiting the feedback signal. A larger run on the same examples is not an independent holdout. If no defensible holdout exists, label results as development only. Set ARBOR TREE to the absolute path of this skill's scripts/tree.py , then work from the experiment project directory. The following commands illustrate one run; evaluator commands, scores and refs must be replaced with actual measured evidence. Initialize the run: Evaluate M 0 on the fixed gate protocol before search and record its commit and score: The coordinator is responsible for freezing protocols and evaluating the baseline; these are procedural steps, not automated checks. The baseline command only records evidence supplied by the coordinator, once. merge refuses an unscored baseline and non finite scores. Existing runs with no incumbent need this step; start a new run if the baseline/evaluator changes. Keep raw evaluator output, seeds, split IDs and evaluator version alongside .arbor/ . branching is how many sibling hypotheses you propose per parent; max depth 2 keeps directions at depth 1 and concrete interventions at depth 2 (the paper's default); budget is the number of coordinator cycles. Start small (10–20 cycles). These helper settings are advisory: branching is recorded, depth overruns warn, and the cycle counter can exceed the budget. The coordinator must enforce the agreed stopping limits. The coordinator loop You run repeated cycles of six steps. This is the heart of HTR; do not collapse it into ad hoc editing. Run python "$ARBOR TREE" cycle once per cycle to track the budget. 1. Observe Begin every cycle by re grounding in the tree, not in your memory of the conversation: This prints the objective, global insights, the active frontier (selectable hypotheses), executed nodes with their evidence, pruned lessons (negative constraints), and the current best artifact. Treating the tree as the source of truth is what keeps you coherent over a long run, after context compression has thrown away the details. 2. Ideate Pick a promising parent and propose a few child hypotheses under it. Condition on the tree's evidence — this is the difference between Arbor and random search: Validated insights are assumptions you can build on. Pruned nodes are dead ends to avoid. A "half right" result is a starting point for a sharper hypothesis , not a reason to abandon the direction. Each hypothesis should be a falsifiable claim about how changing the artifact will move the metric , not a vague intention. Depth 1 nodes are broad directions ("the search harness loses correct answers it already retrieved"); depth 2 nodes are concrete, executable interventions ("run K=5 independent rollouts and aggregate by evidence dossier instead of majority vote"). 3. Select Choose which pending leaves to run next. Selection is not pure score maximization — pick a hypothesis because it has strong prior evidence, because it would resolve an ambiguity its siblings exposed, or because its failure would clarify an important assumption. Frontier control under delayed feedback rewards informative experiments, not just promising ones. 4. Dispatch Run each selected hypothesis as an executor subagent in an isolated worktree (use the host's supported isolation facility, or create distinct worktrees with git worktree add ). Isolation matters: parallel experiments must not clobber each other or the current best, and exploratory changes stay quarantined until they pass the merge gate. Dispatch siblings in parallel (through the host's available subagent tools) when they're independent — comparative evidence within one direction is exactly what makes later pruning and abstraction possible. Give each executor a tight, hypothesis bound brief. See references/executor brief.md for the full template. The contract that makes HTR work: the executor may not change the hypothesis when the metric stalls. It repairs its own code and reruns, but h n is fixed — otherwise the returned score is no longer evidence about the assigned node and the tree's semantics break. The executor returns exactly four things: dev score — a finite dev evaluator result (for selection), or null for an execution failure; result — a factual summary of what happened; insight — the distilled, reusable lesson ( why the result supports, weakens, or bounds the hypothesis); branch ref — the git branch/commit/worktree path holding the artifact. Mark a node running before dispatch ( tree.py set status node n2 status running ) so the Observe projection stays accurate. 5. Backpropagate When an executor returns, write its report into the node, then abstract the lesson upward : This is the step that makes the tree more than a log. A leaf level observation ("data interface mismatch") should become a direction level constraint and, if it generalizes, a global prior that shapes future ideation. Insight propagation was critical in the reported ablation — in the paper's MLE Bench Lite ablation with Claude Opus 4.6, a tree without insight feedback scored even lower than a flat experiment queue with no tree at all (54.5% vs. 63.6% any medal, against 81.8% for the full system). Hierarchy alone isn't enough: the semantic memory is what matters. So spend real thought on the abstraction; don't just copy the leaf insight upward verbatim. 6. Decide Decide what to do with the new evidence: keep expanding a direction, prune a falsified subtree, or attempt to merge a candidate. Prune dead ends, recording why — the reason becomes a negative constraint: Merge gate — promote a candidate to the new best only if it improves on E test . Run the test evaluator on the exact candidate commit in a fresh worktree to prevent uncommitted development artifacts from affecting the result, then: A passing command changes bookkeeping only; it does not verify evaluator output or the supplied artifact ref. Preserve the verified candidate on a named branch, and perform any authorized Git promotion separately; re evaluate the resulting commit if integrating it changes the artifact. The helper compares strict improvement, without a noise model or significance threshold, so agree on repetitions and the acceptance rule before search. If the gate rejects it, that's informative: a high dev / low test candidate is evidence the direction may be exploiting the dev signal rather than producing a transferable improvement. Record that lesson; don't quietly promote it anyway. Repeat until the budget is spent, the frontier is exhausted, or progress has clearly stalled. Finishing the run When you stop, produce a short report (see references/report template.md ) covering: the final best artifact, its test score, and its delta over M 0 ; the tree ( python "$ARBOR TREE" status ) as the audit trail of what was tried; the main hypothesis shifts — how task understanding deepened across the run (early nodes test broad mechanisms; later nodes find their limits; ancestor insights compress these into the constraints behind the final design); merged vs. explored: many nodes improve dev, far fewer pass the test gate — report that gap honestly rather than overstating dev wins. Always leave M best as a real, runnable artifact on a named branch, and tell the user how to check it out. Principles that make this work (not rote rules) These come from the paper's analysis; understanding why matters more than following them mechanically. The tree is the memory; conversation is not. Over a long horizon your context gets compressed. Re Observe each cycle so decisions rest on durable evidence, not a lossy summary. Structured search, not more sampling. Arbor's gains come from how the budget is organized — maintaining competing hypotheses, comparing siblings, carrying lesso