tournament-autoresearch

Runs an autonomous ML research loop where competing agent-proposed changes are judged before each experiment.

Updated Sep 9, 2026
One-click install
npx skills add https://github.com/xlinh2301/EditCTC --skill tournament-autoresearch-xlinh2301
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: tournament-autoresearch
Source: https://github.com/xlinh2301/EditCTC/tree/main/.agents/skills/tournament-autoresearch
Command: npx skills add https://github.com/xlinh2301/EditCTC --skill tournament-autoresearch-xlinh2301

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Open-ended ML experimentation often wastes compute on unvetted ideas, and single-hypothesis loops never compare alternatives before spending a training run. This Skill replaces the hypothesis step with an idea tournament: multiple research agents propose competing architecture changes, a self-calibrating Judge critiques and ranks them against a rubric, and only the winning change is run and measured. ## Core Features & Use Cases - Adversarial idea tournament: Spawn n ResearchAgent proposers per iteration, gate ideas on falsifiable predictions, score them on grounding/impact/feasibility, and rank via de-biased pairwise comparison. - Self-calibrating Judge: The Judge logs predicted vs realized metric deltas in a calibration ledger, tracks its selection hit-rate, and refines its working rubric's weights and anchors from realized outcomes. - Full experiment mechanics: Snapshot or branch isolation, budgeted runs, mandatory analysis plans with real artifacts, keep/revert decisions, and append-only ledgers (results.tsv, calibration.tsv, judge_lessons.md). - Use Case: Point the loop at a training repo (e.g., an OCR recognizer with a train.py entrypoint), set val accuracy as the metric, and let it iteratively propose, vet, run, and analyze one architecture change per iteration until interrupted. ## Quick Start Ask the agent to start the tournament autoresearch loop on this repository with validation accuracy as the metric and the training script as the run command.

Frequently Asked Questions about tournament-autoresearch

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run an autonomous ML research loop on my training repo?▼

Provide the metric to optimize, the run command for one experiment, and the list of editable model/config files. The loop writes loop.run.yaml, initializes a sandbox with ledgers, then iterates: tournament, apply winning change, run, analyze, keep or revert.

What is the difference between tournament-autoresearch and ml-autoresearch?▼

Tournament-autoresearch replaces the single hypothesis step with a competition: multiple agents propose ideas and a Judge picks one winner per iteration. The sibling ml-autoresearch loop runs one uncompeted hypothesis per iteration, which suits pre-decided experiments.

How does the Judge decide which idea to run?▼

The Judge gates ideas on falsifiable predictions, scores grounding, impact, and feasibility 0-5 as a learning signal, then ranks survivors by de-biased pairwise comparison in both orders. Only the rank-1 idea is applied; merging ideas is not allowed.

Does the tournament autoresearch loop work outside Claude Code?▼

Yes. On hosts without subagent spawning, the loop degrades gracefully by adopting the ResearchAgent role inline, producing one proposal at a time instead of parallel agents. The host type is recorded once during setup.

What happens when an experiment crashes or makes the metric worse?▼

The iteration is logged as crash or discard in results.tsv, and the change is reverted via git reset or by restoring the snapshot. The realized outcome still feeds the calibration ledger so the Judge improves future selections.

When should I not use an autonomous experiment loop?▼

Avoid it for analysis-only dataset exploration or when you already know the exact change to make. It is designed for open-ended architecture search where vetting competing ideas before spending compute is worth the overhead.