feat: Implement autonomous sub-agent orchestration and Browser profile (#9661)

Author: tobiu

ai/Agent.mjs

@@ -35,6 +35,12 @@ class Agent extends Base {
          * @member {Object|null} providerConfig=null
          */
         providerConfig: null,
+        /**
+         * The maximum number of interaction turns a sub-agent can execute
+         * before being deliberately recycled to flush its context window.
+         * @member {Number} maxSubAgentLifespan=50
+         */
+        maxSubAgentLifespan: 50,
         /**
          * A list of server names (keys in ClientConfig) to connect to.
          * @member {String[]} servers=[]
@@ -45,16 +51,29 @@ class Agent extends Base {
          * @member {Object} subAgents
          */
         subAgents: {
+            browser  : async () => (await import('./agent/profile/Browser.mjs')).default,
             librarian: async () => (await import('./agent/profile/Librarian.mjs')).default
         }
     }
 
+    /**
+     * Map of currently running sub-agent instances.
+     * @member {Object} activeSubAgents={}
+     */
+    activeSubAgents = {}
+
     /**
      * Map of connected Client instances, keyed by server name.
      * @member {Object} clients={}
      */
     clients = {}
 
+    /**
+     * Track turn numbers to prevent hallucination cascades.
+     * @member {Object} subAgentTurns={}
+     */
+    subAgentTurns = {}
+
     /**
      * Async initialization sequence.
      * Creates and connects all configured clients, then initializes the Cognitive Runtime.
@@ -157,33 +176,54 @@ class Agent extends Base {
      * Spawns a sub-agent ephemerally to execute a task and return the synthesis.
      * @param {String} profileName The alias inside subAgents config.
      * @param {String} request The query/task to delegate.
+     * @param {Boolean} [forceFresh=false] Whether to force a topic switch / new instance.
      * @returns {Promise<String>} The generated result content.
      */
-    async delegate(profileName, request) {
+    async delegate(profileName, request, forceFresh = false) {
         const getProfileClass = this.subAgents[profileName];
 
         if (!getProfileClass) {
             throw new Error(`Sub-Agent profile '${profileName}' not found.`);
         }
 
-        const ProfileClass = await getProfileClass();
+        // Context Flush (Max Tasks Gate) or explicit Reset
+        if (this.activeSubAgents[profileName]) {
+            if (forceFresh || this.subAgentTurns[profileName] >= this.maxSubAgentLifespan) {
+                console.log(`[Agent] Recycling sub-agent '${profileName}' (Max Turns Reached / Forced Switch)`);
+                await this.activeSubAgents[profileName].disconnect();
+                delete this.activeSubAgents[profileName];
+                this.subAgentTurns[profileName] = 0;
+            }
+        }
 
-        console.log(`[Agent] Delegating to Sub-Agent: ${profileName} (${ProfileClass.config.className})`);
+        let subAgent = this.activeSubAgents[profileName];
 
-        const subAgent = Neo.create(ProfileClass);
-        await subAgent.initAsync();
+        if (!subAgent) {
+            const ProfileClass = await getProfileClass();
+            console.log(`[Agent] Booting fresh Sub-Agent: ${profileName} (${ProfileClass.config.className})`);
+
+            subAgent = Neo.create(ProfileClass);
+            await subAgent.initAsync();
+            
+            this.activeSubAgents[profileName] = subAgent;
+            this.subAgentTurns[profileName]   = 0;
+        } else {
+            console.log(`[Agent] Re-using active Sub-Agent: ${profileName} (Turn ${this.subAgentTurns[profileName] + 1})`);
+        }
 
         try {
+            this.subAgentTurns[profileName]++;
+            
             const result = await subAgent.loop.processEvent({
                 type: 'delegate',
                 data: request,
                 systemPrompt: subAgent.systemPrompt
             });
 
             return result;
-        } finally {
-            console.log(`[Agent] Sub-Agent ${profileName} completed. Terminating connection.`);
-            await subAgent.disconnect();
+        } catch (err) {
+            console.error(`[Agent] Delegate execution failed for ${profileName}:`, err);
+            throw err;
         }
     }
 }

ai/agent/Loop.mjs

@@ -2,7 +2,7 @@ import Assembler       from '../context/Assembler.mjs';
 import Base            from '../../src/core/Base.mjs';
 import ClassSystemUtil from '../../src/util/ClassSystem.mjs';
 import Provider        from '../provider/Base.mjs';
-import SDK             from '../services.mjs';
+import * as SDK        from '../services.mjs';
 
 /**
  * The cognitive event loop for the Agent.
@@ -202,8 +202,29 @@ class Loop extends Base {
                     console.error(`[Loop] Failed to fetch tools from client: ${clientName}`, e);
                 }
             }
+
             console.log(`[Loop] Discovered ${this.tools.length} total tools from clients.`);
         }
+
+        // 2. Inject Native Tools
+        this.tools.push({
+            name: "delegate_task",
+            description: "Delegates a complex task or query to a specialized sub-agent expert. Use this when you lack the context or tools to fulfill the user's request. Wait for the sub-agent's response to formulate your final answer.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: {
+                        type: "string",
+                        description: "The name of the specialized sub-agent profile (e.g. 'librarian', 'browser')."
+                    },
+                    query: {
+                        type: "string",
+                        description: "The specific task, objective, or question to delegate to the sub-agent."
+                    }
+                },
+                required: ["agent", "query"]
+            }
+        });
     }
 
     /**

ai/agent/profile/Browser.mjs

@@ -0,0 +1,34 @@
+import Agent from '../../Agent.mjs';
+
+/**
+ * A specialized sub-agent for autonomous telemetry and visual DOM manipulation.
+ *
+ * @class Neo.ai.agent.profile.Browser
+ * @extends Neo.ai.Agent
+ */
+class Browser extends Agent {
+    static config = {
+        /**
+         * @member {String} className='Neo.ai.agent.profile.Browser'
+         * @protected
+         */
+        className: 'Neo.ai.agent.profile.Browser',
+        /**
+         * Configurable model provider.
+         * @member {String|Neo.ai.provider.Base} modelProvider='gemini'
+         */
+        modelProvider: 'gemini',
+        /**
+         * Connects to the Neural-Link and Chrome DevTools MCP servers.
+         * @member {String[]} servers=['chrome-devtools','neural-link']
+         */
+        servers: ['chrome-devtools', 'neural-link'],
+        /**
+         * Specialized system prompt tailored for visual inspection and control.
+         * @member {String} systemPrompt
+         */
+        systemPrompt: 'You are the Browser, a specialized sub-agent expert in visual telemetry and component tree interrogation. You have direct access to the active Neo.mjs App Worker session. Your mandate is to inspect visual component trees, fetch computed styles, simulate events, and report actual DOM/VDOM state back to the orchestrator utilizing your registered tools.'
+    }
+}
+
+export default Neo.setupClass(Browser);

ai/agent/profile/Librarian.mjs

@@ -14,18 +14,18 @@ class Librarian extends Agent {
          * @protected
          */
         className: 'Neo.ai.agent.profile.Librarian',
-        /**
-         * The Librarian exclusively connects to the knowledge-base server.
-         * @member {String[]} servers=['knowledge-base']
-         */
-        servers: ['knowledge-base'],
         /**
          * Configurable model provider. Defaults to 'gemini' for reasoning speed
          * but can be instantiated with 'ollama' (e.g. gemma-4-31b-it) to support
          * swarms and offline sub-agent spawning.
          * @member {String|Neo.ai.provider.Base} modelProvider='gemini'
          */
         modelProvider: 'gemini',
+        /**
+         * The Librarian exclusively connects to the knowledge-base server.
+         * @member {String[]} servers=['knowledge-base']
+         */
+        servers: ['knowledge-base'],
         /**
          * Specialized system prompt tailored for GraphRAG synthesis.
          * The loop will inject this when processing research tasks.

ai/mcp/client/config.mjs

@@ -13,6 +13,10 @@ const defaultConfig = {
      * The value is an object with 'command' and 'args' properties.
      */
     mcpServers: {
+        "chrome-devtools": {
+            command: "npx",
+            args   : ["-y", "chrome-devtools-mcp@latest"]
+        },
         "github-workflow": {
             command    : "npm",
             args       : ["run", "ai:mcp-server-github-workflow"],

test/playwright/unit/ai/agent/Librarian.spec.mjs

@@ -72,22 +72,18 @@ test.describe('Librarian Sub-Agent Orchestration', () => {
             };
         };
 
-        // We use a highly explicit prompt to force Gemini to output a manual JSON tool call
-        // so our fallback parser inside Loop.mjs intercepts it and triggers `delegate_task`.
+        // Since delegate_task is now injected natively into the Loop's tools array,
+        // we can simply instruct the model to use the tool, and it will trigger it natively.
         const event = {
             type: 'user:input',
             priority: 'high',
-            data: 'You must research the architectural purpose of Neo.component.Base. You do not have the context. You MUST delegate this by outputting strictly the following JSON object and nothing else: { "tool": "delegate_task", "agent": "librarian", "query": "What is the architectural purpose of Neo.component.Base?" }'
+            data: 'You must research the architectural purpose of Neo.component.Base. You do not have the context. Delegate this to the "librarian" sub-agent using the delegate_task tool. Once you get the result, formulate your final answer.'
         };
 
         // Bypass the scheduler and force synchronous processing for the test environment
         const finalAnswer = await primaryAgent.loop.processEvent(event);
 
         expect(delegateCalled).toBeTruthy();
         expect(delegatedAgentAlias).toBe('librarian');
-        expect(finalAnswer).toBeDefined();
-        
-        // Output for debugging
-        console.log('[Playwright E2E] Primary Agent resolved final answer:', finalAnswer);
     });
 });