open-agents-ai 0.43.0 → 0.44.0

package/README.md

@@ -37,6 +37,7 @@ An autonomous multi-turn tool-calling agent that reads your code, makes changes,
 - **Sub-agent delegation** — spawn independent agents for parallel workstreams
 - **Ralph Loop** — iterative task execution that keeps retrying until completion criteria are met
 - **Dream Mode** — creative idle exploration modeled after real sleep architecture (NREM→REM cycles)
+- **Autoresearch Swarm** — 5-agent GPU experiment loop during REM sleep: Researcher, Monitor, Evaluator, Critic, Flow Maintainer autonomously run ML training experiments, keep improvements, discard regressions
 - **Live Listen** — bidirectional voice communication with real-time Whisper transcription
 - **Neural TTS** — hear what the agent is doing via GLaDOS or Overwatch ONNX voices, with personality-driven expressiveness
 - **Personality Core** — SAC framework-based style control (concise/balanced/verbose/pedagogical) that shapes agent response depth, voice expressiveness, and system prompt behavior
@@ -293,6 +294,47 @@ Each cycle expands through all four stages then contracts (evaluation, pruning o
 
 All proposals are indexed in `.oa/dreams/PROPOSAL-INDEX.md` for easy review.
 
+### Autoresearch Swarm — 5-Agent GPU Experiment Loop
+
+When a GPU is detected and the model tier is "large", the REM stage of Dream Mode activates the **Autoresearch Swarm** instead of the standard multi-agent creative exploration. This is a 5-agent system inspired by [Karpathy's autoresearch](https://github.com/karpathy/autoresearch) that autonomously runs ML training experiments.
+
+The swarm operates in four phases:
+
+| Phase | What Happens |
+|-------|-------------|
+| **Phase 0: Load** | Reads autoresearch memory (best config, experiment log, failed approaches, hypothesis queue, architectural insights) + detects GPU specs |
+| **Phase 1: Hypothesis** | Critic generates 5-8 hypotheses; Flow Maintainer plans experiment ordering and round budget |
+| **Phase 2: Experiment** | Sequential rounds (up to 3): Critic pre-screens → Researcher modifies train.py + runs → Monitor watches GPU → Evaluator keeps/discards → Flow Maintainer decides continue/stop |
+| **Phase 3: Summary** | Flow Maintainer writes consolidated summary to memory + dream report to `.oa/dreams/` |
+
+#### The 5 Agent Roles
+
+| Role | MaxTurns | Temp | Purpose |
+|------|----------|------|---------|
+| **Researcher** | 25 | 0.4 | Modifies train.py, runs experiments via `autoresearch` tool |
+| **Monitor** | 5 | 0.1 | Watches GPU utilization, reports status (detachable between rounds) |
+| **Evaluator** | 12 | 0.3 | Compares results to best val_bpb, calls keep/discard, writes insights to memory |
+| **Critic** | 8 | 0.5 | Generates hypotheses, pre-screens before GPU time is spent |
+| **Flow Maintainer** | 10 | 0.3 | Orchestrates rounds, manages hypothesis queue, writes final summary |
+
+#### Bidirectional Memory
+
+The swarm maintains persistent memory in `.oa/memory/autoresearch.json` with five keys:
+
+- **best_config** — best val_bpb and what train.py changes produced it
+- **experiment_log** — chronological list of experiments with hypotheses, results, and verdicts
+- **architectural_insights** — patterns learned (what architectures work, what doesn't)
+- **failed_approaches** — things NOT to try again (with reasons)
+- **hypothesis_queue** — pending ideas for future experiments
+
+Memory flows bidirectionally: the swarm reads all 5 keys at startup (Phase 0) and writes results back after each experiment. The DMN's gather phase naturally discovers autoresearch learnings when searching all memory, and DMN proposals with category `"autoresearch"` execute through the normal agentic loop.
+
+#### Monitor Detachability
+
+The Monitor agent can be "detached" between experiment rounds by the Flow Maintainer. When detached, the monitor receives a sub-task (e.g., "analyze GPU memory patterns from last 3 runs") instead of its standard watch prompt. This lets the swarm use idle monitoring capacity for useful analysis work.
+
+If no GPU is detected, the REM stage falls back to the standard multi-agent creative exploration (Visionary + Pragmatist + Cross-Pollinator + Synthesizer).
+
 ## Blessed Mode — Infinite Warm Loop
 
 `/full-send-bless` activates an infinite warm loop that keeps model weights loaded in VRAM and the agent ready for instant response. The engine sends periodic keep-alive pings to the inference backend (every 2 minutes) to prevent Ollama's automatic model unloading.
@@ -322,7 +364,7 @@ Inspired by the brain's Default Mode Network (Raichle 2001), the DMN activates d
 
 Each DMN cycle runs a lightweight LLM agent (15 max turns, temperature 0.4) with read-only file access plus full memory tools. The DMN writes insights back to memory, creating a self-reinforcing knowledge loop.
 
-**Task categories**: directive (standing orders), exploration (knowledge gaps), capability (underused tools), maintenance (system health), social (communication)
+**Task categories**: directive (standing orders), exploration (knowledge gaps), capability (underused tools), maintenance (system health), social (communication), autoresearch (autonomous GPU ML experiment loop)
 
 **Backoff**: After 3 consecutive cycles with no actionable task, the DMN enters extended rest. A 30-second cooldown between null cycles prevents spin-looping.
 

package/dist/index.js

@@ -23446,6 +23446,31 @@ var init_edit_history = __esm({
 import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11, readFileSync as readFileSync19, existsSync as existsSync26, cpSync, rmSync, readdirSync as readdirSync10 } from "node:fs";
 import { join as join36, basename as basename12 } from "node:path";
 import { execSync as execSync22 } from "node:child_process";
+function loadAutoresearchMemory(repoRoot) {
+  const memoryPath = join36(repoRoot, ".oa", "memory", "autoresearch.json");
+  if (!existsSync26(memoryPath))
+    return "";
+  try {
+    const raw = readFileSync19(memoryPath, "utf-8");
+    const data = JSON.parse(raw);
+    const sections = [];
+    for (const key of AUTORESEARCH_MEMORY_KEYS) {
+      if (data[key] !== void 0 && data[key] !== null) {
+        const value = typeof data[key] === "string" ? data[key] : JSON.stringify(data[key], null, 2);
+        sections.push(`### ${key}
+${value}`);
+      }
+    }
+    if (sections.length === 0)
+      return "";
+    return `
+## AUTORESEARCH MEMORY (from previous experiments)
+
+${sections.join("\n\n")}`;
+  } catch {
+    return "";
+  }
+}
 function adaptTool(tool) {
   return {
     name: tool.name,
@@ -23584,14 +23609,130 @@ function renderDreamEnd(state) {
 
 `);
 }
-var SLEEP_STAGES, DreamFileWriteTool, DreamFileEditTool, DreamShellTool, DreamEngine;
+function renderSwarmPhase(phase, description) {
+  const phaseLabels = ["Load", "Hypothesis", "Experiment", "Summary"];
+  const label = phaseLabels[phase] ?? `Phase ${phase}`;
+  process.stdout.write(`
+  ${c2.yellow("\u2B21")} ${c2.bold(`Swarm Phase ${phase}: ${label}`)} ${c2.dim(`\u2014 ${description}`)}
+`);
+}
+function renderSwarmExperiment(round, total, hypothesis) {
+  const truncated = hypothesis.length > 80 ? hypothesis.slice(0, 77) + "..." : hypothesis;
+  process.stdout.write(`
+    ${c2.cyan("\u25C8")} ${c2.bold(`Experiment ${round}/${total}`)} ${c2.dim(truncated)}
+`);
+}
+function renderSwarmComplete(workspace) {
+  const kept = workspace.experimentResults.filter((r) => r.verdict === "keep").length;
+  const discarded = workspace.experimentResults.filter((r) => r.verdict === "discard").length;
+  const best = workspace.bestValBpb === Infinity ? "N/A" : workspace.bestValBpb.toFixed(6);
+  process.stdout.write(`
+  ${c2.green("\u2B22")} ${c2.bold("Autoresearch Swarm Complete")}
+`);
+  process.stdout.write(`    Rounds: ${workspace.roundsCompleted} | Kept: ${kept} | Discarded: ${discarded} | Best val_bpb: ${best}
+`);
+  process.stdout.write(`    Report: ${c2.cyan(".oa/dreams/")}
+`);
+}
+var SWARM_ROLE_CONFIG, AutoresearchFileWriteTool, AutoresearchFileEditTool, AUTORESEARCH_MEMORY_KEYS, SLEEP_STAGES, DreamFileWriteTool, DreamFileEditTool, DreamShellTool, DreamEngine;
 var init_dream_engine = __esm({
   "packages/cli/dist/tui/dream-engine.js"() {
     "use strict";
     init_dist5();
     init_dist2();
     init_project_context();
+    init_setup();
     init_render();
+    SWARM_ROLE_CONFIG = {
+      researcher: { maxTurns: 25, temperature: 0.4 },
+      monitor: { maxTurns: 5, temperature: 0.1 },
+      evaluator: { maxTurns: 12, temperature: 0.3 },
+      critic: { maxTurns: 8, temperature: 0.5 },
+      flow_maintainer: { maxTurns: 10, temperature: 0.3 }
+    };
+    AutoresearchFileWriteTool = class {
+      autoresearchDir;
+      name = "file_write";
+      description = "Write a file (autoresearch mode: writes confined to .oa/autoresearch/ directory)";
+      parameters = {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path (relative to .oa/autoresearch/)" },
+          content: { type: "string", description: "File content to write" }
+        },
+        required: ["path", "content"]
+      };
+      constructor(autoresearchDir) {
+        this.autoresearchDir = autoresearchDir;
+      }
+      async execute(args) {
+        const start = Date.now();
+        const rawPath = String(args["path"] ?? "");
+        const content = String(args["content"] ?? "");
+        if (!rawPath)
+          return { success: false, output: "", error: "path is required", durationMs: Date.now() - start };
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join36(this.autoresearchDir, basename12(rawPath)) : join36(this.autoresearchDir, rawPath);
+        if (!targetPath.startsWith(this.autoresearchDir)) {
+          return { success: false, output: "", error: "Autoresearch mode: writes are confined to .oa/autoresearch/", durationMs: Date.now() - start };
+        }
+        try {
+          const dir = join36(targetPath, "..");
+          mkdirSync12(dir, { recursive: true });
+          writeFileSync11(targetPath, content, "utf-8");
+          return { success: true, output: `Wrote ${content.length} bytes to ${rawPath}`, durationMs: Date.now() - start };
+        } catch (err) {
+          return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
+        }
+      }
+    };
+    AutoresearchFileEditTool = class {
+      autoresearchDir;
+      name = "file_edit";
+      description = "Edit a file (autoresearch mode: edits confined to .oa/autoresearch/ directory)";
+      parameters = {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path (relative to .oa/autoresearch/)" },
+          old_string: { type: "string", description: "Text to replace" },
+          new_string: { type: "string", description: "Replacement text" }
+        },
+        required: ["path", "old_string", "new_string"]
+      };
+      constructor(autoresearchDir) {
+        this.autoresearchDir = autoresearchDir;
+      }
+      async execute(args) {
+        const start = Date.now();
+        const rawPath = String(args["path"] ?? "");
+        const oldStr = String(args["old_string"] ?? "");
+        const newStr = String(args["new_string"] ?? "");
+        const targetPath = rawPath.startsWith("/") || rawPath.startsWith(".oa/autoresearch") ? join36(this.autoresearchDir, basename12(rawPath)) : join36(this.autoresearchDir, rawPath);
+        if (!targetPath.startsWith(this.autoresearchDir)) {
+          return { success: false, output: "", error: "Autoresearch mode: edits are confined to .oa/autoresearch/", durationMs: Date.now() - start };
+        }
+        try {
+          if (!existsSync26(targetPath)) {
+            return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: Date.now() - start };
+          }
+          let content = readFileSync19(targetPath, "utf-8");
+          if (!content.includes(oldStr)) {
+            return { success: false, output: "", error: "old_string not found in file", durationMs: Date.now() - start };
+          }
+          content = content.replace(oldStr, newStr);
+          writeFileSync11(targetPath, content, "utf-8");
+          return { success: true, output: `Edited ${rawPath}`, durationMs: Date.now() - start };
+        } catch (err) {
+          return { success: false, output: "", error: String(err), durationMs: Date.now() - start };
+        }
+      }
+    };
+    AUTORESEARCH_MEMORY_KEYS = [
+      "best_config",
+      "experiment_log",
+      "failed_approaches",
+      "hypothesis_queue",
+      "architectural_insights"
+    ];
     SLEEP_STAGES = [
       { name: "NREM-1", label: "Light Scan", description: "Quick codebase overview, surface observations" },
       { name: "NREM-2", label: "Pattern Detection", description: "Identify recurring patterns, technical debt, gaps" },
@@ -23772,7 +23913,11 @@ var init_dream_engine = __esm({
               renderDreamStage(stage.name, stage.label, stage.description);
               const startMs = Date.now();
               let result;
-              if (stage.name === "REM" && modelTier === "large") {
+              if (stage.name === "REM" && modelTier === "large" && detectSystemSpecs().gpuVramGB > 0) {
+                renderInfo("REM: Autoresearch swarm \u2014 5-agent GPU experiment loop (Researcher + Monitor + Evaluator + Critic + Flow Maintainer)");
+                const swarmResult = await this.runAutoresearchSwarm(cycle, previousFindings, onEvent);
+                result = { summary: swarmResult.summary, turns: 0, toolCalls: 0 };
+              } else if (stage.name === "REM" && modelTier === "large") {
                 renderInfo("REM: Multi-agent creative mode \u2014 parallel Visionary + Pragmatist + Cross-Pollinator");
                 const remResult = await this.runMultiAgentREM(cycle, totalCycles, previousFindings, mode === "lucid" ? "full" : "sandboxed", onEvent);
                 result = { summary: remResult.summary, turns: 0, toolCalls: 0 };
@@ -23980,6 +24125,433 @@ INSTRUCTIONS:
 After synthesis, call task_complete with the final prioritized summary.`, toolMode, onEvent);
         return synthesisResult;
       }
+      // ── Autoresearch Swarm ────────────────────────────────────────────────
+      /**
+       * Run a single swarm sub-agent with role-specific tools and config.
+       * Follows the runBrainRegionAgent() pattern from dmn-engine.ts.
+       */
+      async runSwarmAgent(role, prompt, workspace, onEvent) {
+        const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+        const roleConfig = SWARM_ROLE_CONFIG[role];
+        const modelTier = getModelTier(this.config.model);
+        const runner = new AgenticRunner(backend, {
+          maxTurns: roleConfig.maxTurns,
+          maxTokens: 8192,
+          temperature: roleConfig.temperature,
+          requestTimeoutMs: this.config.timeoutMs,
+          taskTimeoutMs: role === "researcher" ? this.config.timeoutMs * 5 : this.config.timeoutMs * 2,
+          compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
+          modelTier
+        });
+        const tools = this.buildSwarmTools(role, workspace);
+        runner.registerTools(tools);
+        if (onEvent) {
+          runner.onEvent((event) => {
+            const taggedEvent = {
+              ...event,
+              content: event.type === "status" ? `[${role}] ${event.content ?? ""}` : event.content
+            };
+            onEvent(taggedEvent);
+          });
+        }
+        const result = await runner.run(prompt, `Swarm role: ${role}. Working directory: ${this.repoRoot}`);
+        return result.summary || "{}";
+      }
+      /** Build role-specific tool sets for swarm agents */
+      buildSwarmTools(role, _workspace) {
+        const autoresearchDir = join36(this.repoRoot, ".oa", "autoresearch");
+        const taskComplete = this.createSwarmTaskCompleteTool(role);
+        switch (role) {
+          case "researcher": {
+            const tools = [
+              new FileReadTool(this.repoRoot),
+              new AutoresearchFileEditTool(autoresearchDir),
+              new AutoresearchFileWriteTool(autoresearchDir),
+              new AutoresearchTool(this.repoRoot),
+              new GrepSearchTool(this.repoRoot),
+              new GlobFindTool(this.repoRoot),
+              new MemoryReadTool(this.repoRoot),
+              new MemorySearchTool(this.repoRoot)
+            ];
+            return [...tools.map(adaptTool), taskComplete];
+          }
+          case "monitor": {
+            const tools = [
+              new FileReadTool(this.repoRoot),
+              new DreamShellTool(this.repoRoot),
+              // read-only shell
+              new AutoresearchTool(this.repoRoot)
+              // status-only in prompt
+            ];
+            return [...tools.map(adaptTool), taskComplete];
+          }
+          case "evaluator": {
+            const tools = [
+              new FileReadTool(this.repoRoot),
+              new AutoresearchTool(this.repoRoot),
+              // results/keep/discard
+              new MemoryReadTool(this.repoRoot),
+              new MemorySearchTool(this.repoRoot),
+              new MemoryWriteTool(this.repoRoot),
+              new GrepSearchTool(this.repoRoot)
+            ];
+            return [...tools.map(adaptTool), taskComplete];
+          }
+          case "critic": {
+            const tools = [
+              new FileReadTool(this.repoRoot),
+              new MemoryReadTool(this.repoRoot),
+              new MemorySearchTool(this.repoRoot),
+              new GrepSearchTool(this.repoRoot)
+            ];
+            return [...tools.map(adaptTool), taskComplete];
+          }
+          case "flow_maintainer": {
+            const tools = [
+              new MemoryReadTool(this.repoRoot),
+              new MemoryWriteTool(this.repoRoot),
+              new MemorySearchTool(this.repoRoot)
+            ];
+            return [...tools.map(adaptTool), taskComplete];
+          }
+        }
+      }
+      createSwarmTaskCompleteTool(role) {
+        return {
+          name: "task_complete",
+          description: `Signal that the ${role} swarm agent is done with its task.`,
+          parameters: {
+            type: "object",
+            properties: {
+              summary: { type: "string", description: "JSON summary of findings/results" }
+            },
+            required: ["summary"]
+          },
+          async execute(args) {
+            return { success: true, output: args["summary"] || "{}" };
+          }
+        };
+      }
+      /**
+       * Run the 5-agent autoresearch swarm — the core orchestrator.
+       *
+       * Phase 0: Load memory + GPU check
+       * Phase 1: Parallel critic + flow maintainer to generate/filter hypothesis queue
+       * Phase 2: Sequential experiment loop (up to 3 rounds)
+       * Phase 3: Consolidated summary to memory + dream report
+       */
+      async runAutoresearchSwarm(cycleNum, previousFindings, onEvent) {
+        renderSwarmPhase(0, "Loading autoresearch memory + GPU check");
+        const memoryContext = loadAutoresearchMemory(this.repoRoot);
+        const specs = detectSystemSpecs();
+        const gpuInfo = specs.gpuVramGB > 0 ? `GPU: ${specs.gpuName} (${specs.gpuVramGB.toFixed(0)}GB VRAM)` : "GPU: not detected";
+        onEvent?.({
+          type: "status",
+          content: `Autoresearch swarm activating \u2014 ${gpuInfo}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const workspace = {
+          hypothesisQueue: [],
+          experimentResults: [],
+          monitor: { status: "idle" },
+          memoryContext,
+          bestValBpb: Infinity,
+          roundsCompleted: 0
+        };
+        const baseContext = `AUTORESEARCH SWARM \u2014 Autonomous ML Experiment Loop
+
+You are part of a 5-agent swarm that iteratively improves a language model
+training script through hypothesis \u2192 experiment \u2192 evaluate cycles.
+
+PREVIOUS DREAM FINDINGS:
+${previousFindings}
+${memoryContext}
+
+GPU: ${gpuInfo}
+Workspace: .oa/autoresearch/`;
+        renderSwarmPhase(1, "Generating hypothesis queue (Critic + Flow Maintainer)");
+        const [criticInit, flowInit] = await Promise.allSettled([
+          this.runSwarmAgent("critic", `${baseContext}
+
+ROLE: CRITIC \u2014 Hypothesis Generator & Filter
+You are the adversarial critic. Your job is to:
+1. Review the current state of experiments (check autoresearch memory above)
+2. Read train.py in .oa/autoresearch/ to understand current architecture
+3. Generate 5-8 hypotheses for improving val_bpb (bits per byte)
+4. For each hypothesis, assess: feasibility, expected impact, risk of regression
+5. Filter out hypotheses that overlap with failed_approaches in memory
+
+Output JSON with: { "hypotheses": [{ "id": number, "description": string, "rationale": string, "risk": "low"|"medium"|"high", "expected_impact": string }] }
+
+Call task_complete with your JSON when done.`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[critic] ${event.content ?? ""}` : event.content })),
+          this.runSwarmAgent("flow_maintainer", `${baseContext}
+
+ROLE: FLOW MAINTAINER \u2014 Experiment Planner
+You are the flow controller. Your job is to:
+1. Review autoresearch memory for past experiments and their outcomes
+2. Identify the current best val_bpb and what changes produced it
+3. Determine if there's a clear direction of improvement (e.g., architecture changes vs hyperparams)
+4. Propose an ordering strategy: which types of experiments should run first?
+5. Set initial experiment budget: how many rounds (1-3) should we attempt?
+
+Output JSON with: { "strategy": string, "recommended_rounds": number, "priority_order": string[], "stop_conditions": string[] }
+
+Call task_complete with your JSON when done.`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[flow_maintainer] ${event.content ?? ""}` : event.content }))
+        ]);
+        const criticOutput = criticInit.status === "fulfilled" ? criticInit.value : "{}";
+        const flowOutput = flowInit.status === "fulfilled" ? flowInit.value : "{}";
+        try {
+          const parsed = JSON.parse(criticOutput.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
+          if (Array.isArray(parsed.hypotheses)) {
+            workspace.hypothesisQueue = parsed.hypotheses.map((h) => h.description ?? `Hypothesis ${h.id ?? 0}`);
+          }
+        } catch {
+        }
+        let maxRounds = 3;
+        try {
+          const parsed = JSON.parse(flowOutput.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
+          if (typeof parsed.recommended_rounds === "number") {
+            maxRounds = Math.min(3, Math.max(1, parsed.recommended_rounds));
+          }
+        } catch {
+        }
+        if (workspace.hypothesisQueue.length === 0) {
+          workspace.hypothesisQueue = [
+            "Increase model depth while reducing width to maintain parameter count",
+            "Adjust learning rate schedule with warmup",
+            "Modify attention mechanism (e.g., grouped query attention)"
+          ];
+        }
+        onEvent?.({
+          type: "status",
+          content: `Phase 1 complete: ${workspace.hypothesisQueue.length} hypotheses queued, ${maxRounds} rounds planned`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        renderSwarmPhase(2, `Running experiments (up to ${maxRounds} rounds)`);
+        for (let round = 0; round < maxRounds; round++) {
+          if (this.abortController?.signal.aborted)
+            break;
+          if (workspace.hypothesisQueue.length === 0)
+            break;
+          const hypothesis = workspace.hypothesisQueue.shift();
+          renderSwarmExperiment(round + 1, maxRounds, hypothesis);
+          const criticScreen = await this.runSwarmAgent("critic", `${baseContext}
+
+ROLE: CRITIC \u2014 Pre-screen Hypothesis
+Quickly evaluate this hypothesis before we spend GPU time on it:
+
+HYPOTHESIS: ${hypothesis}
+
+Previous experiment results:
+${workspace.experimentResults.map((r) => `- ${r.hypothesis}: val_bpb=${r.valBpb}, verdict=${r.verdict}`).join("\n") || "(none yet)"}
+
+Questions to answer:
+1. Is this hypothesis likely to improve val_bpb given what we know?
+2. Does it overlap with any failed approaches?
+3. Is it safe to implement (won't corrupt the training script)?
+
+Output JSON: { "approved": boolean, "reason": string, "modifications": string }
+If not approved, briefly explain why and we'll skip to the next hypothesis.
+
+Call task_complete with your JSON.`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[critic] ${event.content ?? ""}` : event.content }));
+          let approved = true;
+          try {
+            const parsed = JSON.parse(criticScreen.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
+            if (parsed.approved === false) {
+              approved = false;
+              onEvent?.({
+                type: "status",
+                content: `[critic] Rejected hypothesis: ${parsed.reason ?? "no reason given"}`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          } catch {
+          }
+          if (!approved)
+            continue;
+          workspace.monitor.status = "watching";
+          const [researcherResult, monitorResult] = await Promise.allSettled([
+            this.runSwarmAgent("researcher", `${baseContext}
+
+ROLE: RESEARCHER \u2014 Implement & Run Experiment
+You are the researcher. Your hypothesis for this round:
+
+HYPOTHESIS: ${hypothesis}
+
+INSTRUCTIONS:
+1. Read the current train.py in .oa/autoresearch/ using file_read
+2. Modify train.py using file_edit to implement the hypothesis
+3. Run the experiment using autoresearch(action="run")
+4. Report the results
+
+Previous experiments:
+${workspace.experimentResults.map((r) => `- ${r.hypothesis}: val_bpb=${r.valBpb}, verdict=${r.verdict}`).join("\n") || "(none yet)"}
+
+Best val_bpb so far: ${workspace.bestValBpb === Infinity ? "N/A (first experiment)" : workspace.bestValBpb.toFixed(6)}
+
+Be precise with file_edit \u2014 match exact strings from the file. Small, targeted changes are better than large rewrites.
+
+Call task_complete with JSON: { "val_bpb": number, "changes_made": string, "observations": string }`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[researcher] ${event.content ?? ""}` : event.content })),
+            this.runSwarmAgent("monitor", `${baseContext}
+
+ROLE: MONITOR \u2014 Watch Experiment Status
+${workspace.monitor.detachedTask ? `DETACHED TASK: ${workspace.monitor.detachedTask}
+Complete the detached task, then check experiment status.` : "Watch the experiment status."}
+
+INSTRUCTIONS:
+1. Check autoresearch status: autoresearch(action="status")
+2. Report GPU utilization and any concerning patterns
+3. If the experiment seems hung, report that
+
+Call task_complete with JSON: { "status": string, "gpu_usage": string, "concerns": string[] }`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[monitor] ${event.content ?? ""}` : event.content }))
+          ]);
+          workspace.monitor.status = "idle";
+          const researcherOutput = researcherResult.status === "fulfilled" ? researcherResult.value : "{}";
+          let experimentValBpb = Infinity;
+          let changesMade = hypothesis;
+          try {
+            const parsed = JSON.parse(researcherOutput.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
+            if (typeof parsed.val_bpb === "number")
+              experimentValBpb = parsed.val_bpb;
+            if (typeof parsed.changes_made === "string")
+              changesMade = parsed.changes_made;
+          } catch {
+          }
+          const evaluatorResult = await this.runSwarmAgent("evaluator", `${baseContext}
+
+ROLE: EVALUATOR \u2014 Assess Experiment Results
+Evaluate the experiment that just completed:
+
+HYPOTHESIS: ${hypothesis}
+RESULT: val_bpb = ${experimentValBpb === Infinity ? "unknown/failed" : experimentValBpb.toFixed(6)}
+CHANGES: ${changesMade}
+BEST SO FAR: ${workspace.bestValBpb === Infinity ? "N/A" : workspace.bestValBpb.toFixed(6)}
+MONITOR REPORT: ${monitorResult.status === "fulfilled" ? monitorResult.value : "unavailable"}
+
+INSTRUCTIONS:
+1. Check experiment results using autoresearch(action="results")
+2. Compare to previous best val_bpb
+3. If improved: call autoresearch(action="keep", description="...") and write insights to memory
+4. If worse: call autoresearch(action="discard", description="...") and record failed approach
+5. Extract architectural insights regardless of outcome
+
+Use memory_write to save insights to "autoresearch" topic.
+
+Call task_complete with JSON: { "verdict": "keep"|"discard", "val_bpb": number, "insights": string, "architectural_lesson": string }`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[evaluator] ${event.content ?? ""}` : event.content }));
+          let verdict = "discard";
+          let insights = "";
+          try {
+            const parsed = JSON.parse(evaluatorResult.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
+            if (parsed.verdict === "keep")
+              verdict = "keep";
+            if (typeof parsed.val_bpb === "number" && parsed.val_bpb < experimentValBpb) {
+              experimentValBpb = parsed.val_bpb;
+            }
+            if (typeof parsed.insights === "string")
+              insights = parsed.insights;
+          } catch {
+          }
+          if (verdict === "keep" && experimentValBpb < workspace.bestValBpb) {
+            workspace.bestValBpb = experimentValBpb;
+          }
+          workspace.experimentResults.push({
+            hypothesis,
+            valBpb: experimentValBpb,
+            verdict,
+            insights
+          });
+          workspace.roundsCompleted = round + 1;
+          const flowDecision = await this.runSwarmAgent("flow_maintainer", `${baseContext}
+
+ROLE: FLOW MAINTAINER \u2014 Continue/Stop Decision
+Round ${round + 1}/${maxRounds} just completed.
+
+EXPERIMENT HISTORY:
+${workspace.experimentResults.map((r, i) => `Round ${i + 1}: ${r.hypothesis} \u2192 val_bpb=${r.valBpb === Infinity ? "failed" : r.valBpb.toFixed(6)} (${r.verdict})`).join("\n")}
+
+REMAINING HYPOTHESES: ${workspace.hypothesisQueue.length}
+${workspace.hypothesisQueue.map((h, i) => `  ${i + 1}. ${h}`).join("\n") || "  (none)"}
+
+DECISIONS:
+1. Should we continue to the next round? (consider: are we improving? are hypotheses promising?)
+2. Should the monitor be given a detached task between rounds? (e.g., "analyze GPU memory patterns")
+3. Any hypotheses to add or remove from the queue?
+
+Call task_complete with JSON: { "continue": boolean, "reason": string, "monitor_task": string|null, "add_hypotheses": string[], "remove_indices": number[] }`, workspace, (event) => onEvent?.({ ...event, content: event.type === "status" ? `[flow_maintainer] ${event.content ?? ""}` : event.content }));
+          try {
+            const parsed = JSON.parse(flowDecision.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
+            if (typeof parsed.monitor_task === "string" && parsed.monitor_task) {
+              workspace.monitor.status = "detached";
+              workspace.monitor.detachedTask = parsed.monitor_task;
+            }
+            if (Array.isArray(parsed.add_hypotheses)) {
+              workspace.hypothesisQueue.push(...parsed.add_hypotheses.map(String));
+            }
+            if (Array.isArray(parsed.remove_indices)) {
+              const toRemove = new Set(parsed.remove_indices.map(Number));
+              workspace.hypothesisQueue = workspace.hypothesisQueue.filter((_, i) => !toRemove.has(i));
+            }
+            if (parsed.continue === false) {
+              onEvent?.({
+                type: "status",
+                content: `[flow_maintainer] Stopping early: ${parsed.reason ?? "no reason"}`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              break;
+            }
+          } catch {
+          }
+        }
+        renderSwarmPhase(3, "Writing consolidated summary");
+        const summaryResult = await this.runSwarmAgent("flow_maintainer", `${baseContext}
+
+ROLE: FLOW MAINTAINER \u2014 Final Summary
+All experiment rounds are complete. Write a consolidated summary.
+
+EXPERIMENT RESULTS:
+${workspace.experimentResults.map((r, i) => `Round ${i + 1}: ${r.hypothesis}
+  val_bpb: ${r.valBpb === Infinity ? "failed" : r.valBpb.toFixed(6)}
+  verdict: ${r.verdict}
+  insights: ${r.insights}`).join("\n\n")}
+
+BEST val_bpb: ${workspace.bestValBpb === Infinity ? "no successful experiments" : workspace.bestValBpb.toFixed(6)}
+
+INSTRUCTIONS:
+1. Write a consolidated summary of all experiments to memory using memory_write:
+   - Topic: "autoresearch"
+   - Include: best_config, experiment_log, architectural_insights, failed_approaches, hypothesis_queue
+2. Summarize the key learnings and next steps
+
+Call task_complete with a human-readable summary of the autoresearch session.`, workspace, onEvent);
+        const reportPath = join36(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
+        const report = `# Autoresearch Swarm Report \u2014 Cycle ${cycleNum}
+
+**Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+**Rounds completed**: ${workspace.roundsCompleted}
+**Best val_bpb**: ${workspace.bestValBpb === Infinity ? "N/A" : workspace.bestValBpb.toFixed(6)}
+
+## Experiments
+
+${workspace.experimentResults.map((r, i) => `### Round ${i + 1}: ${r.hypothesis}
+- **val_bpb**: ${r.valBpb === Infinity ? "failed" : r.valBpb.toFixed(6)}
+- **Verdict**: ${r.verdict}
+- **Insights**: ${r.insights || "none"}`).join("\n\n")}
+
+## Summary
+
+${summaryResult}
+
+---
+*Generated by open-agents autoresearch swarm*
+`;
+        try {
+          mkdirSync12(this.dreamsDir, { recursive: true });
+          writeFileSync11(reportPath, report, "utf-8");
+        } catch {
+        }
+        renderSwarmComplete(workspace);
+        return { summary: summaryResult };
+      }
       /** Build tools appropriate for the dream mode */
       buildDreamTools(toolMode) {
         if (toolMode === "full") {
@@ -24596,7 +25168,8 @@ var init_dmn_engine = __esm({
           "browser_action \u2014 headless Chrome automation",
           "scheduler, reminder, agenda \u2014 temporal agency",
           "codebase_map, diagnostic, git_info \u2014 project analysis",
-          "sub_agent \u2014 delegate subtasks to independent agents"
+          "sub_agent \u2014 delegate subtasks to independent agents",
+          "autoresearch \u2014 autonomous GPU ML experiment loop (modify architecture/hyperparams, train 5min, keep/discard)"
         ];
         const prompt = buildDMNGatherPrompt(this.recentTaskSummaries, reminders, attention, memoryTopics, capabilities, this.state.competence, this.state.reflectionBuffer);
         const modelTier = getModelTier(this.config.model);
@@ -25019,7 +25592,7 @@ OUTPUT: Call task_complete with JSON:
             task: String(p.task ?? ""),
             rationale: String(p.rationale ?? ""),
             provenance: Array.isArray(p.provenance) ? p.provenance.map(String) : [],
-            category: ["directive", "exploration", "capability", "maintenance", "social"].includes(String(p.category)) ? String(p.category) : "exploration",
+            category: ["directive", "exploration", "capability", "maintenance", "social", "autoresearch"].includes(String(p.category)) ? String(p.category) : "exploration",
             confidence: typeof p.confidence === "number" ? p.confidence : 0.5,
             challengeResult: p.challengeResult ? String(p.challengeResult) : void 0
           }));
@@ -25070,7 +25643,7 @@ OUTPUT: Call task_complete with JSON:
             task: String(t.task ?? ""),
             rationale: String(t.rationale ?? ""),
             provenance: Array.isArray(t.provenance) ? t.provenance.map(String) : [],
-            category: ["directive", "exploration", "capability", "maintenance", "social"].includes(t.category) ? t.category : "exploration",
+            category: ["directive", "exploration", "capability", "maintenance", "social", "autoresearch"].includes(t.category) ? t.category : "exploration",
             confidence: typeof t.confidence === "number" ? Math.min(1, Math.max(0, t.confidence)) : 0.5,
             challengeResult: t.challengeResult ? String(t.challengeResult) : void 0
           };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",