autobeta

name

autobeta

description

Enhanced autoresearch skill with an escape harness that prevents local minima and scans the conceptual landscape. Use instead of /autoresearch when you want deeper search through parallel threads, adaptive axes, and crossover recombination. Same invocation pattern as autoresearch, but runs three parallel search threads with tournament selection, basin detection, and domain-configurable fingerprinting. Trigger: /autobeta, "use autobeta", "run autobeta on", or any autoresearch task where the user explicitly wants the enhanced harness. Beta status: this skill is still in beta. Cost: ~$15–25/run versus ~$2–5 for basic autoresearch.

AutoBeta Skill

Enhanced autoresearch with escape harness. Same oracle-design pattern as autoresearch — but instead of single-thread hill-climbing, runs 3 parallel threads with landscape scanning mechanisms to find solutions pure hill-climbing would never reach.

When to use: Complex problems where the solution space has many distinct conceptual regions. Writing, strategy, thesis framing, product positioning, investment theses. Not for quick polish tasks where basic /autoresearch is sufficient.

Cost: ~$15–25/run. Always flag this to the user before starting.

Typical iteration range: 20–50 iterations, depending on how many distinct regions the search uncovers.

---

Invocation

/autobeta "problem statement" [--oracle-hint "what matters"] [--iterations N] [--auto]

Same flags as autoresearch. Default: always show oracle + harness config for approval before starting.

---

Phase 0 — Landscape Coverage Survey (~$0.38 overhead)

Before oracle design, run the landscape coverage survey (v6 mechanism):

S0a — Seed 4 initial claim types (haiku, fast draft) S0b — Adversarial challenge (haiku): flag pairwise overlaps, propose more extreme replacements S0c — Apply revisions (2 adversarial rounds max) S0d — Structural extremity pass (sonnet): push each surviving type to its logical extreme on its distinctive property; haiku safety check for new overlaps S1 — Generate 1 sketch per extreme type (haiku, batched) S2 — Structural verification (check for drift) S3 — Score each sketch on 2 dimensions (plausibility × resolution potential) S4 — Cluster into 3 non-overlapping regions with mandatory pairwise non-overlap audit S5 — Seed Thread 1/2/3 from highest-scoring sketch per cluster

Store survey_result in global state (cluster map, seeds, structural signatures — used by gate throughout run).

---

Phase 1 — Setup (identical to autoresearch)

Follow the same oracle design and persona selection process as the autoresearch skill:

• Read references/oracle-design.md → design 3–4 scoring dimensions
• Read references/personas.md → select 3 judge personas
• Generate experiment_v0.md

Additional harness config to show for approval:

HARNESS CONFIG — [task slug]
Threads: 3 (parallel, independent)
Tournament interval: every 15 iterations
Fingerprint check: every 5 iterations
Escape: basin crossover (trigger: 3 consecutive escapes within 2% of best)
Crossover: recombine top-3 historical bests
Estimated cost: ~$15–25 per run

FINGERPRINT VOCABULARY (domain-derived):
Dim 1 — [label]: [options]
Dim 2 — [label]: [options]
Dim 3 — [label]: [options]

Reply ✅ to start.

Derive fingerprint vocabulary before showing config:

• Classify problem domain (writing/thesis, investment/strategy, product/design, technical)
• One short sonnet call: "Given this problem statement, infer 3 structural signature dimensions with 4–6 label options each that would be meaningful trip-wires for detecting structural convergence in this domain. Be specific, not generic."
• Freeze vocabulary — immutable for entire run

---

Phase 2 — Thread Initialisation

Spawn 3 threads. Each thread has:

• Its own current-best candidate (all start from experiment_v0.md)
• Its own axis pool (3 non-overlapping starting axes — verify orthogonality with opus before starting)
• Its own escape trigger counter
• Its own run log

Default axis seeds (adapt to domain):

• Thread 1: central frame / primary claim
• Thread 2: causal mechanism / evidence type
• Thread 3: epistemic register / resolution mode

Run orthogonality check on all 9 starting axes (3 per thread) before iteration 1.

---

Phase 3 — The Loop (per thread, sequential within session)

Each iteration across all 3 threads:

Iteration agent (Sonnet-class model)

• Input: program.md + current best for this thread + axis pool state
• Output: ONE changed version + 3-element structural signature [dim1_label, dim2_label, dim3_label]

Pre-generation: Exploration directive (uses survey_result, zero cost)

• UNEXPLORED cluster: no directive
• ACTIVE cluster: inject contrastive constraint — "Generate a candidate structurally distinct from your current cluster on ≥2 of: [dim1/dim2/dim3]. Your candidate must differ on those dimensions." After generation, G1c verifies compliance (haiku, ~$0.001). Fail → regenerate once → SAME_CLUSTER flag if still failing.
• EXHAUSTED cluster: hard redirect — inject full structural seed of least-explored cluster: "You are being redirected. Do not generate variations of previous candidates. Aim at this territory: [seed]"

Evaluator agent (Opus-class model)

• Input: evaluate.md + new version + previous best score
• Output: FINAL SCORE, KEEP/DISCARD, WEAKEST ELEMENT, SUGGESTED DIRECTION

Route result

First assign the candidate back into the survey map, then apply the gate threshold for that cluster before deciding KEEP or DISCARD.

G1 cluster assignment + gate threshold (uses survey_result)

• G1: haiku call assigns candidate to nearest cluster (~$0.001). BOUNDARY_CASE → assign to less-explored cluster.

• G2: classify cluster status — UNEXPLORED (no candidates assigned yet) / ACTIVE (1+ candidates, still improving) / EXHAUSTED (3+ consecutive non-improvements from this cluster)

• G3: apply threshold: 0.65 (unexplored) / 0.80 (active) / 0.90 (exhausted). SAME_CLUSTER candidates use ACTIVE threshold.

• KEEP → save as new vN, update thread current-best, append signature to fingerprint log

• DISCARD → increment counter, log direction hint

---

Phase 3b — Escape Mechanisms (fire when triggered)

Axis-based escape (trigger: 10 consecutive discards)

1. Dissect current-best into structural axes
2. Derive antipodal candidate on each active axis
3. Run 5-iteration mini-sprint per antipodal candidate (Sonnet-class model)
4. Evaluate each sprint winner (Opus-class model)
5. Regression gate: winner must score ≥ current-best × 0.80
6. PASS → promote as new thread current-best, reset counter to 0
7. FAIL → reset counter to 5 (not 0 — keeps pressure on)

Adaptive axis discovery (trigger: 2+ consecutive regression gate failures — i.e. escape candidates scoring below 0.80 × current-best):

1. Read evaluator feedback on failed seeds
2. Generate 2 new axes (sonnet) from evaluator's weakness language
3. Orthogonality check each against all active axes (probe seed + opus comparison)
4. ORTHOGONAL → add to pool. OVERLAP → regenerate (1 retry) → drop if still overlapping
5. Retire axes with 3+ consecutive failures (keep probe seeds in permanent store)

Basin crossover (trigger: 3 consecutive escape events where best seed scores within 2% of current-best)

1. Retrieve top-3 historical best candidates across this thread's history
2. Decompose each into structural element inventory (sonnet)
3. Generate 3 hybrid candidates — recombine elements across sources, maximise structural distance
4. Novelty check each hybrid: probe sketch → opus comparison against source probe sketches → NOVEL or BLEND
5. BLEND → regenerate with "maximise structural distance" instruction (1 retry) → if still BLEND, use maximum-distance fallback (take single most distinctive element from each source, combine exactly those 3)
6. Run 5-iteration mini-sprint per verified-novel hybrid
7. Regression gate (same as axis escape: ≥0.80 × current-best)
8. Reset basin counter after crossover fires (pass or fail)

---

Phase 4 — Tournament (every 15 iterations)

1. Structural divergence check (Step SD) — BEFORE retirement:

   • Compare all 3 thread current-bests pairwise (opus, single call)
   • CONVERGED pair (same framing approach, same epistemic register) → lower-scoring thread flagged for re-diversification
   • Re-diversification: retire current-best to history, assign new non-overlapping axis seed (orthogonality-verified against all active threads), reinitialise from global best as starting candidate
   • Re-diversification fires before tournament retirement cycle

2. Score comparison — rank all 3 thread current-bests

3. Promote global best — highest scorer becomes the canonical best

4. Retire lowest — spawn new thread from global best with fresh non-overlapping axis seed

5. Global history — all thread bests added to global history pool (available for future crossover)

---

Phase 4b — Inter-Tournament Monitoring (every 5 iterations)

After each iteration batch of 5:

1. Compare most recent structural signatures across all 3 threads
2. If ANY two threads share ≥2/3 fingerprint elements → early convergence warning
3. Warning → fire full Step SD check immediately
4. SD confirms CONVERGED → re-diversify per above
5. SD returns DISTINCT (false positive) → log, resume
6. Suppress fingerprint check within 2 iterations of a scheduled tournament

---

Phase 5 — Convergence

Stop the loop when:

• 10 consecutive non-improvements across ALL threads (not just one) — global convergence
• Iteration budget exhausted (--iterations N)
• User says stop

Post convergence report:

/autobeta [task] CONVERGED

Best candidate: [experiment]_vN.md (thread X)
Final score: X.XX
Score history: [trajectory]
Threads at convergence: [T1: X.XX | T2: X.XX | T3: X.XX]
Winning mechanisms (kept changes, ranked by score lift):
  1. +X.XX — [what changed]
  2. +X.XX — [what changed]
What didn't move: [discarded directions]
Files: [project-dir]/[task-slug]-autobeta/
Cost: ~$15–25
Run log: run-log-[date].md (per thread)

Recommend: review [experiment]_vN.md and decide if score is sufficient or restart with modified oracle.

---

Key rules (never violate)

• Change ONE element per iteration per thread — the loop only works if changes are atomic
• The oracle is frozen for the duration of a run — never modify evaluate.md mid-run
• Evaluator must be strong — always use a strong model (Opus-class) for evaluation
• Direction: always bolder — discard changes that hedge or qualify the claim
• Log everything — keep run logs per thread and post summaries wherever your workflow expects progress updates
• Oracle quality = convergence quality — spend time on oracle design; a vague oracle produces vague search

---

Reference files

• references/oracle-design.md — oracle patterns by problem type
• references/personas.md — persona library guide + selection logic
• ../skills-autoresearch/templates/ — program, evaluate, experiment_v0 templates (shared with autoresearch)

---

Notes for beta testing

This skill is in beta. Known gaps:

• Thread management is sequential within a single agent session (true parallelism requires multiple sub-agents coordinated externally)
• The harness instructions are complex — if a step fails or produces unexpected output, fall back to the simpler autoresearch skill

Stable production skill: autoresearch (single-thread, proven, ~$2–5/run)