open-agents-ai 0.110.0 → 0.112.0

package/README.md

@@ -38,7 +38,7 @@ The agent uses tools autonomously in a loop — reading errors, fixing code, and
 
 ## Features
 
-- **54 autonomous tools** — file I/O, shell, grep, web search/fetch/crawl, memory (read/write/search), sub-agents, background tasks, image/OCR/PDF, git, diagnostics, vision, desktop automation, browser automation, temporal agency (scheduler/reminders/agenda), structured files, code sandbox, transcription, skills, opencode delegation, cron agents, nexus P2P networking + x402 micropayments
+- **61 autonomous tools** — file I/O, shell, grep, web search/fetch/crawl, memory (read/write/search), sub-agents, background tasks, image/OCR/PDF, git, diagnostics, vision, desktop automation, browser automation, temporal agency (scheduler/reminders/agenda), structured files, code sandbox, transcription, skills, opencode delegation, cron agents, nexus P2P networking + x402 micropayments, **COHERE cognitive stack** (persistent REPL, recursive LLM calls, memory metabolism, identity kernel, reflection, exploration)
 - **Moondream vision** — see and interact with the desktop via Moondream VLM (caption, query, detect, point-and-click)
 - **Desktop automation** — vision-guided clicking: describe a UI element in natural language, the agent finds and clicks it
 - **Auto-install desktop deps** — screenshot, mouse, OCR, and image tools auto-install missing system packages (scrot, xdotool, tesseract, imagemagick) on first use
@@ -51,6 +51,13 @@ The agent uses tools autonomously in a loop — reading errors, fixing code, and
 - **Inference capability proof** — benchmark local models with anti-spoofing SHA-256 hashed proofs, generate capability scorecards for peer verification
 - **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)
+- **COHERE Cognitive Stack** — layered cognitive architecture implementing [Recursive Language Models](https://arxiv.org/abs/2512.24601), [SPRINT parallel reasoning](https://arxiv.org/abs/2506.05745), governed memory metabolism, identity kernel with continuity register, immune-system reflection, and [strategy-space exploration](https://arxiv.org/abs/2603.02045). See [COHERE Framework](#cohere-cognitive-framework) below
+- **Persistent Python REPL** — `repl_exec` tool maintains variables, imports, and functions across calls. Write Python code that processes data iteratively, with `llm_query()` available for recursive LLM sub-calls from within code
+- **Recursive LLM calls** — `llm_query(prompt, context)` invokes the model from inside REPL code, enabling loop-based semantic analysis of large inputs ([RLM paper](https://arxiv.org/abs/2512.24601)). `parallel_llm_query()` runs multiple calls concurrently ([SPRINT](https://arxiv.org/abs/2506.05745))
+- **Memory metabolism** — governed memory lifecycle: classify (episodic/semantic/procedural/normative), score (novelty/utility/confidence), consolidate lessons from trajectories. Inspired by [TIMG](https://arxiv.org/abs/2603.10600) and [MemMA](https://arxiv.org/abs/2603.18718)
+- **Identity kernel** — persistent self-state with continuity register, homeostasis estimation, relationship models, and version lineage. Persists across sessions in `.oa/identity/`
+- **Reflection & integrity** — immune-system audit: diagnostic ("what's wrong?"), epistemic ("what evidence is missing?"), constitutional ("should this change become part of self?"). Inspired by [LEAFE](https://arxiv.org/abs/2603.16843) and [RewardHackingAgents](https://arxiv.org/abs/2603.11337)
+- **Exploration & culture** — ARCHE strategy-space exploration: generate competing hypotheses, archive successful variants, retrieve past strategies. Inspired by [SGE](https://arxiv.org/abs/2603.02045) and [Darwin Gödel Machine](https://arxiv.org/abs/2505.22954)
 - **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
 - **Live Voice Session** — `/listen` with `/voice` enabled spawns a cloudflared tunnel with a real-time WebSocket audio endpoint. A floating presence UI shows live transcription, connected users, and audio visualization. Echo cancellation prevents TTS feedback loops
@@ -208,7 +215,7 @@ On startup and `/model` switch, Open Agents detects your RAM/VRAM and creates an
 | 8GB+ | 8K tokens |
 | < 8GB | 4K tokens |
 
-## Tools (54)
+## Tools (61)
 
 | Tool | Description |
 |------|-------------|
@@ -284,6 +291,12 @@ On startup and `/model` switch, Open Agents detects your RAM/VRAM and creates an
 | `nexus:remote_infer` | Route inference to a remote peer's model — auto-discovers peers, budget-checks, invokes, returns result |
 | `nexus:ledger_status` | Transaction history (earned/spent/pending USDC) |
 | `nexus:budget_set` | Configure spending limits — daily cap, per-invoke max, auto-approve threshold |
+| **COHERE Cognitive Stack** | |
+| `repl_exec` | Persistent Python REPL — variables/imports persist between calls, `llm_query()` and `parallel_llm_query()` available for recursive LLM invocation, `retrieve()` for handle access |
+| `memory_metabolize` | Governed memory lifecycle — classify (episodic/semantic/procedural/normative), score (novelty/utility/confidence/identity_relevance), consolidate lessons from trajectories |
+| `identity_kernel` | Persistent identity state — hydrate, observe events, propose updates with justification, publish snapshot, reconcile contradictions. Persists in `.oa/identity/` |
+| `reflect` | Immune-system reflection — diagnostic (find flaws), epistemic (identify missing evidence), constitutional (review self-updates). Returns pass/revise/block verdict |
+| `explore` | ARCHE strategy-space exploration — generate diverse strategies, archive successful variants with tags/confidence, compare competing approaches, retrieve past strategies |
 
 Read-only tools execute concurrently when called in the same turn. Mutating tools run sequentially.
 
@@ -371,6 +384,54 @@ When you launch `oa` in a workspace that has saved session context from a previo
 
 Type `y` to restore — the previous session context will be prepended to your next task, giving the agent full continuity. Type `n` (or anything else) to start fresh. The prompt only appears on fresh starts, not on `/update` resumes (which auto-restore context).
 
+## COHERE Cognitive Framework
+
+Open Agents implements the **COHERE layered cognitive stack** — a provenance-grounded architecture for persistent, reflective agentic systems. Each layer adds a distinct cognitive capability, grounded in specific research papers:
+
+```
+Layer 8: Exploration & Culture (ARCHE) — strategy diversity + variant archiving
+Layer 7: Reflection & Integrity      — immune-system audit (diagnostic/epistemic/constitutional)
+Layer 6: Identity Kernel (COHERE)    — persistent self-state + homeostasis
+Layer 5: Memory Metabolism           — governed write/manage/read lifecycle
+Layer 4: Shared Workspace            — handle registry + Memex archive
+Layer 3: SPRINT Reasoning            — parallel sub-calls via ThreadPoolExecutor
+Layer 2: RLM Context OS              — persistent REPL + llm_query + externalization
+Layer 1: Inference Mesh              — Nexus P2P + expose gateway
+Layer 0: Voice & Embodiment          — Whisper ASR + neural TTS
+```
+
+### How It Works
+
+The agent can process inputs **100x beyond its context window** by externalizing large content to a persistent Python REPL and using `llm_query()` to recursively analyze chunks:
+
+```python
+# Inside repl_exec — variables persist between calls
+chunks = context.split('\n\n')
+summaries = parallel_llm_query([
+    ("Summarize this section", chunk) for chunk in chunks
+])
+result = '\n'.join(summaries)
+```
+
+The identity kernel maintains a persistent self-model across sessions, the reflection layer audits plans for unsupported claims, and the exploration layer archives successful strategies for future reuse.
+
+### Research Provenance
+
+| Layer | Primary Paper | Link |
+|---|---|---|
+| L2 | Recursive Language Models (Zhang, Kraska, Khattab — MIT CSAIL, 2026) | [arxiv:2512.24601](https://arxiv.org/abs/2512.24601) |
+| L3 | SPRINT: Interleaved Planning and Parallelized Execution (2025) | [arxiv:2506.05745](https://arxiv.org/abs/2506.05745) |
+| L4 | BIGMAS: Brain-Inspired Graph Multi-Agent Systems (2026) | [arxiv:2603.15371](https://arxiv.org/abs/2603.15371) |
+| L5 | TIMG: Trajectory-Informed Memory Generation (2026) | [arxiv:2603.10600](https://arxiv.org/abs/2603.10600) |
+| L5 | MemMA: Multi-Agent Memory Cycle Coordination (2026) | [arxiv:2603.18718](https://arxiv.org/abs/2603.18718) |
+| L5 | Memory in the Age of AI Agents (2025) | [arxiv:2512.13564](https://arxiv.org/abs/2512.13564) |
+| L5 | Memory for Autonomous LLM Agents (2026) | [arxiv:2603.07670](https://arxiv.org/abs/2603.07670) |
+| L7 | LEAFE: Reflective Experience for Agency (2026) | [arxiv:2603.16843](https://arxiv.org/abs/2603.16843) |
+| L7 | RewardHackingAgents: Evaluation Integrity (2026) | [arxiv:2603.11337](https://arxiv.org/abs/2603.11337) |
+| L8 | Strategy-Guided Exploration (SGE, 2026) | [arxiv:2603.02045](https://arxiv.org/abs/2603.02045) |
+| L8 | Darwin Gödel Machine: Open-Ended Self-Improvement (2025) | [arxiv:2505.22954](https://arxiv.org/abs/2505.22954) |
+| L8 | i-MENTOR: Intrinsic Motivation Exploration (2025) | [arxiv:2505.17621](https://arxiv.org/abs/2505.17621) |
+
 ## Context Compaction — Research-Backed Memory Management
 
 Long conversations consume context window tokens. Open Agents uses progressive context compaction to compress older messages while preserving critical information — decisions, errors, file states, and task progress.

package/dist/index.js

@@ -8010,6 +8010,11 @@ var init_memory_metabolism = __esm({
             type: "string",
             description: "What generated this memory (tool name, event, etc.)"
           },
+          scope: {
+            type: "string",
+            enum: ["private", "public", "guild"],
+            description: "Visibility scope: private (local only), public (share with network), guild (curated group). Default: private"
+          },
           id: {
             type: "string",
             description: "Memory ID (for promote/forget operations)"
@@ -8018,9 +8023,15 @@ var init_memory_metabolism = __esm({
         required: ["op"]
       };
       cwd;
+      /** Callback for publishing memory deltas to the network (COHERE Plane 4) */
+      deltaPublisher = null;
       constructor(cwd4) {
         this.cwd = cwd4;
       }
+      /** Set a callback that publishes memory deltas to the P2P network */
+      setDeltaPublisher(publisher) {
+        this.deltaPublisher = publisher;
+      }
       async execute(args) {
         const op = String(args.op ?? "");
         const start = performance.now();
@@ -8048,6 +8059,7 @@ var init_memory_metabolism = __esm({
         const content = String(args.content ?? "");
         const memType = args.memory_type ?? "episodic";
         const source = String(args.source ?? "user");
+        const scope = String(args.scope ?? "private");
         if (!content.trim()) {
           return { success: false, output: "No content provided", error: "Empty content", durationMs: performance.now() - start };
         }
@@ -8074,6 +8086,22 @@ var init_memory_metabolism = __esm({
         const store = await this.loadStore(metaDir);
         store.push(item);
         await this.saveStore(metaDir, store);
+        if (admitted && scope !== "private" && this.deltaPublisher) {
+          try {
+            this.deltaPublisher({
+              delta_id: item.id,
+              scope,
+              type: memType,
+              content: content.slice(0, 2e3),
+              // truncate for network
+              confidence: avgScore,
+              provenance_refs: [source],
+              ttl_days: 90,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } catch {
+          }
+        }
         return {
           success: true,
           output: `Memory ${item.decision.action}: [${item.id}] type=${memType} scores={novelty:${scores.novelty.toFixed(2)} utility:${scores.utility.toFixed(2)} confidence:${scores.confidence.toFixed(2)} identity:${scores.identityRelevance.toFixed(2)}} avg=${avgScore.toFixed(2)} \u2014 ${item.decision.reason}`,
@@ -30758,40 +30786,58 @@ var init_expose = __esm({
                 const promptEval = responseTail.match(/"prompt_eval_count"\s*:\s*(\d+)/);
                 const evalCount = responseTail.match(/"eval_count"\s*:\s*(\d+)/);
                 if (promptEval || evalCount) {
-                  const tIn = parseInt(promptEval?.[1] ?? "0", 10);
-                  const tOut = parseInt(evalCount?.[1] ?? "0", 10);
-                  this._stats.totalTokensIn += tIn;
-                  this._stats.totalTokensOut += tOut;
-                  user.tokensIn += tIn;
-                  user.tokensOut += tOut;
+                  const tIn2 = parseInt(promptEval?.[1] ?? "0", 10);
+                  const tOut2 = parseInt(evalCount?.[1] ?? "0", 10);
+                  this._stats.totalTokensIn += tIn2;
+                  this._stats.totalTokensOut += tOut2;
+                  user.tokensIn += tIn2;
+                  user.tokensOut += tOut2;
                   if (requestModel) {
                     const mm = user.models.get(requestModel);
                     if (mm) {
-                      mm.tokensIn += tIn;
-                      mm.tokensOut += tOut;
+                      mm.tokensIn += tIn2;
+                      mm.tokensOut += tOut2;
                     }
                   }
                 } else {
                   const promptTokens = responseTail.match(/"prompt_tokens"\s*:\s*(\d+)/);
                   const completionTokens = responseTail.match(/"completion_tokens"\s*:\s*(\d+)/);
                   if (promptTokens || completionTokens) {
-                    const tIn = parseInt(promptTokens?.[1] ?? "0", 10);
-                    const tOut = parseInt(completionTokens?.[1] ?? "0", 10);
-                    this._stats.totalTokensIn += tIn;
-                    this._stats.totalTokensOut += tOut;
-                    user.tokensIn += tIn;
-                    user.tokensOut += tOut;
+                    const tIn2 = parseInt(promptTokens?.[1] ?? "0", 10);
+                    const tOut2 = parseInt(completionTokens?.[1] ?? "0", 10);
+                    this._stats.totalTokensIn += tIn2;
+                    this._stats.totalTokensOut += tOut2;
+                    user.tokensIn += tIn2;
+                    user.tokensOut += tOut2;
                     if (requestModel) {
                       const mm = user.models.get(requestModel);
                       if (mm) {
-                        mm.tokensIn += tIn;
-                        mm.tokensOut += tOut;
+                        mm.tokensIn += tIn2;
+                        mm.tokensOut += tOut2;
                       }
                     }
                   }
                 }
               } catch {
               }
+              const tIn = user.tokensIn;
+              const tOut = user.tokensOut;
+              if (tIn > 0 || tOut > 0) {
+                const receipt = {
+                  job_id: `job-${Date.now().toString(36)}`,
+                  provider_peer_id: "local",
+                  consumer_ip: userIp,
+                  model: requestModel,
+                  usage_final: { input_tokens: tIn, output_tokens: tOut },
+                  latency_ms: Date.now() - (user.lastSeen || Date.now()),
+                  quality_flags: [],
+                  // COHERE revenue split: 70% provider, 10% commons, 8% memory, 7% relay, 5% reserve
+                  provider_reward: (tIn + tOut) * 1e-7 * 0.7,
+                  commons_contribution: (tIn + tOut) * 1e-7 * 0.1,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                };
+                this.emit("settlement_receipt", receipt);
+              }
               this.emitStats();
             };
             const proxyReq = httpRequest({
@@ -51301,8 +51347,35 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   if (flowEnabled) {
     dynamicContext += "\n\n" + FLOWSTATE_PROMPT;
   }
-  let backend;
+  let localFirstOverride = false;
   if (config.backendType === "nexus") {
+    try {
+      const localCheckResp = (() => {
+        try {
+          return __require("node:child_process").execSync("curl -s http://localhost:11434/api/tags 2>/dev/null", { encoding: "utf8", timeout: 3e3 });
+        } catch {
+          return "";
+        }
+      })();
+      if (localCheckResp) {
+        try {
+          const tags = JSON.parse(localCheckResp);
+          const localModels = (tags.models ?? []).map((m) => m.name);
+          const modelBase = config.model.split(":")[0] ?? config.model;
+          const hasLocal = localModels.some((m) => m === config.model || m.startsWith(modelBase));
+          if (hasLocal) {
+            localFirstOverride = true;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  let backend;
+  if (localFirstOverride) {
+    backend = new OllamaAgenticBackend("http://localhost:11434", config.model, void 0, thinkingEnabled);
+  } else if (config.backendType === "nexus") {
     const nexusTool = new NexusTool(repoRoot);
     const connectPromise = nexusTool.execute({ action: "connect" }).catch(() => {
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.110.0",
+  "version": "0.112.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",