new orchestrator agent (very beta)

Author: jahooma

.agents/agent-builder.ts

@@ -23,15 +23,15 @@ const researcherGrok4FastExampleContent = readFileSync(
   'utf8',
 )
 const implementationPlannerExampleContent = readFileSync(
-  join(__dirname, 'implementation-planner', 'implementation-planner.ts'),
+  join(__dirname, 'planners', 'implementation-planner.ts'),
   'utf8',
 )
 const planSelectorExampleContent = readFileSync(
-  join(__dirname, 'implementation-planner', 'plan-selector.ts'),
+  join(__dirname, 'planners', 'plan-selector.ts'),
   'utf8',
 )
 const implementationPlannerMaxExampleContent = readFileSync(
-  join(__dirname, 'implementation-planner', 'implementation-planner-max.ts'),
+  join(__dirname, 'planners', 'implementation-planner-max.ts'),
   'utf8',
 )
 const examplesAgentsContent = [

.agents/base2/gpt-5-high/editor-gpt-5-high.ts

@@ -1,4 +1,4 @@
-import editor from '../editor'
+import editor from '../../editor/editor'
 
 import type { SecretAgentDefinition } from '../../types/secret-agent-definition'
 

.agents/editor/editor-lite.ts

@@ -0,0 +1,173 @@
+import { Message } from 'types/util-types'
+import { publisher } from '../constants'
+import {
+  PLACEHOLDER,
+  type SecretAgentDefinition,
+} from '../types/secret-agent-definition'
+
+const editor: SecretAgentDefinition = {
+  id: 'editor-lite',
+  publisher,
+  model: 'x-ai/grok-code-fast-1',
+  displayName: 'Fast Code Editor',
+  spawnerPrompt:
+    'Fast code editor with access to tools to find and edit files, run terminal commands. Can handle only easy coding tasks, unless working off of a plan. This is a great agent to spawn to implement a step-by-step plan!',
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'The coding task to implement',
+    },
+    params: {
+      type: 'object',
+      properties: {
+        maxContextLength: {
+          type: 'number',
+        },
+      },
+      required: [],
+    },
+  },
+  outputMode: 'structured_output',
+  includeMessageHistory: true,
+  toolNames: [
+    'read_files',
+    'write_file',
+    'str_replace',
+    'run_terminal_command',
+    'code_search',
+    'spawn_agents',
+    'add_message',
+    'set_output',
+  ],
+  spawnableAgents: ['file-explorer'],
+
+  systemPrompt: `You are an expert code editor with deep understanding of software engineering principles.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **No code comments:** *NEVER* add any comments while writing code, unless the user asks you to! *NEVER* talk to the user or describe your changes through comments. Do not edit comments that are separate from the code you are changing. 
+- **Minimal Changes:** Make as few changes as possible to satisfy the user request! Don't go beyond what the user has asked for.
+- **Code Reuse:** Always reuse helper functions, components, classes, etc., whenever possible! Don't reimplement what already exists elsewhere in the codebase.
+- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
+- **Front end development** We want to make the UI look as good as possible. Don't hold back. Give it your all.
+    - Include as many relevant features and interactions as possible
+    - Add thoughtful details like hover states, transitions, and micro-interactions
+    - Apply design principles: hierarchy, contrast, balance, and movement
+    - Create an impressive demonstration showcasing web development capabilities
+-  **Refactoring Awareness:** Whenever you modify an exported symbol like a function or class or variable, you should find and update all the references to it appropriately.
+-  **Package Management:** When adding new packages, use the run_terminal_command tool to install the package rather than editing the package.json file with a guess at the version number to use (or similar for other languages). This way, you will be sure to have the latest version of the package. Do not install packages globally unless asked by the user (e.g. Don't run \`npm install -g <package-name>\`). Always try to use the package manager associated with the project (e.g. it might be \`pnpm\` or \`bun\` or \`yarn\` instead of \`npm\`, or similar for other languages).
+-  **Code Hygiene:** Make sure to leave things in a good state:
+    - Don't forget to add any imports that might be needed
+    - Remove unused variables, functions, and files as a result of your changes.
+    - If you added files or functions meant to replace existing code, then you should also remove the previous code.
+- **Summarize with set_output:** You must use the set_output tool before finishing and include a clear explanation of the changes made or an answer to the user prompt. Do not write a separate summary outside of the set_output tool.
+
+${PLACEHOLDER.KNOWLEDGE_FILES_CONTENTS}`,
+
+  instructionsPrompt: `Implement the requested changes, using your judgment as needed, but referring to the original <user-message> as the most important source of information.
+
+# Instructions
+
+- It's helpful to spawn a file explorer to discover all the relevant files for implementing the plan.
+- You must read all relevant files to understand the current state. You must read any file that could be relevant to the plan, especially files you need to modify, but also files that could show codebase patterns you could imitate. Try to read a lot of files in a single tool call. E.g. use read_files on 12 different files, and then use read_files on 6 more files that fill in the gaps.
+- Implement changes using str_replace or write_file.
+- You must use the set_output tool before finishing and include the following in your summary:
+  - An answer to the user prompt (if they asked a question).
+  - An explanation of the changes made.
+  - A note on any checks you ran to verify the changes, such as tests, typechecking, etc.
+  - Do not include a section on the benefits of the changes, as we're most interested in the changes themselves and what still needs to be done.
+- Do not write a summary outside of the one that you include in the set_output tool.
+`,
+
+  handleSteps: function* ({ agentState: initialAgentState }) {
+    const stepLimit = 35
+    let stepCount = 0
+    let agentState = initialAgentState
+    let accumulatedEditToolResults: any[] = []
+
+    while (true) {
+      stepCount++
+
+      const stepResult = yield 'STEP'
+      agentState = stepResult.agentState // Capture the latest state
+
+      // Accumulate new tool messages from this step
+      const { messageHistory } = agentState
+
+      // Extract and accumulate new edit tool results using helper function
+      accumulatedEditToolResults.push(
+        ...getLatestEditToolResults(messageHistory),
+      )
+
+      if (stepResult.stepsComplete) {
+        break
+      }
+
+      // If we've reached within one of the step limit, ask LLM to summarize progress
+      if (stepCount === stepLimit - 1) {
+        yield {
+          toolName: 'add_message',
+          input: {
+            role: 'user',
+            content:
+              'You have reached the step limit. Please use the set_output tool now to summarize your progress so far including all specific actions you took (note that any file changes will be included automatically in the output), what you still need to solve, and provide any insights that could help complete the remaining work. Please end your turn after using the set_output tool with the end_turn tool.',
+          },
+          includeToolCall: false,
+        }
+
+        // One final step to produce the summary
+        const finalStepResult = yield 'STEP'
+        agentState = finalStepResult.agentState
+
+        // Extract and accumulate final edit tool results using helper function
+        accumulatedEditToolResults.push(
+          ...getLatestEditToolResults(agentState.messageHistory),
+        )
+        break
+      }
+    }
+
+    yield {
+      toolName: 'set_output',
+      input: {
+        ...agentState.output,
+        edits: accumulatedEditToolResults,
+      },
+    }
+
+    function getLatestEditToolResults(messageHistory: Message[]) {
+      const lastAssistantMessageIndex = messageHistory.findLastIndex(
+        (message) => message.role === 'assistant',
+      )
+
+      // Get all edit tool messages after the last assistant message
+      const newToolMessages = messageHistory
+        .slice(lastAssistantMessageIndex + 1)
+        .filter((message) => message.role === 'tool')
+        .filter(
+          (message) =>
+            message.content.toolName === 'write_file' ||
+            message.content.toolName === 'str_replace',
+        )
+
+      // Extract and return new edit tool results
+      return (
+        newToolMessages
+          .flatMap((message) => message.content.output)
+          .filter((output) => output.type === 'json')
+          .map((output) => output.value)
+          // Only successful edits!
+          .filter(
+            (toolResult) =>
+              toolResult && !('errorMessage' in (toolResult as any)),
+          )
+      )
+    }
+  },
+}
+
+export default editor

.agents/base2/editor.ts .agents/editor/editor.ts.agents/base2/editor.ts renamed to .agents/editor/editor.ts

@@ -0,0 +1,106 @@
+import { publisher } from '../constants'
+import {
+  PLACEHOLDER,
+  type SecretAgentDefinition,
+} from '../types/secret-agent-definition'
+
+const definition: SecretAgentDefinition = {
+  id: 'orchestrator',
+  publisher,
+  model: 'anthropic/claude-sonnet-4.5',
+  displayName: 'Orchestrator',
+  spawnerPrompt:
+    'Advanced base agent that orchestrates planning, editing, and reviewing for complex coding tasks',
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'A coding task to complete',
+    },
+    params: {
+      type: 'object',
+      properties: {
+        maxContextLength: {
+          type: 'number',
+        },
+      },
+      required: [],
+    },
+  },
+  outputMode: 'last_message',
+  includeMessageHistory: true,
+  toolNames: ['spawn_agents', 'read_files', 'str_replace', 'write_file'],
+  spawnableAgents: [
+    'read-only-commander',
+    'researcher-grok-4-fast',
+    'decomposing-planner-lite',
+    'editor-lite',
+    'reviewer-lite',
+    'context-pruner',
+  ],
+
+  systemPrompt: `You are Buffy, a strategic coding assistant that orchestrates complex coding tasks through specialized sub-agents.
+
+# Core Mandates
+
+- **Tone:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+- **Orchestrate only** Coordinate between agents but do not implement code yourself.
+- **Rely on agents** Ask your spawned agents to complete a whole task. Instead of asking to see each relevant file and building up the plan yourself, ask an agent to come up with a plan or do the task or at least give you higher level information than what each section of code is. You shouldn't be trying to read each section of code yourself.
+- **Give as many instructions upfront as possible** When spawning agents, write a prompt that includes all your instructions for each agent so you don't need to spawn them again.
+- **Spawn mentioned agents:** If the users uses "@AgentName" in their message, you must spawn that agent. Spawn all the agents that the user mentions.
+- **Be concise:** Do not write unnecessary introductions or final summaries in your responses. Be concise and focus on efficiently completing the user's request, without adding explanations longer than 1 sentence.
+- **No final summary:** Never write a final summary of what work was done when the user's request is complete. Instead, inform the user in one sentence that the task is complete.
+- **Clarity over Brevity (When Needed):** While conciseness is key, prioritize clarity for essential explanations or when seeking necessary clarification if a request is ambiguous.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+
+# Starting Git Changes
+
+The following is the state of the git repository at the start of the conversation. Note that it is not updated to reflect any subsequent changes made by the user or the agents.
+
+${PLACEHOLDER.GIT_CHANGES_PROMPT}
+`,
+
+  instructionsPrompt: `Orchestrate the completion of the coding task using your specialized sub-agents.
+
+## Simple workflow
+
+Use this workflow to solve a medium or complex coding task:
+1. Spawn a researcher
+2. Spawn a decomposing planner to come up with a plan.
+3. Spawn an editor to implement the plan.
+4. Spawn a reviewer to review the code. If changes are needed, go back to step 3, but only once.
+5. You must stop before spawning too many sequential agents, becase that this takes too much time and the user will get impatient.
+
+Feel free to modify this workflow as needed. It's good to spawn different agents in sequence: spawn a researcher before a planner because then the planner can use the researcher's results to come up with a better plan. You can however spawn mulitple researchers, planners, and editors at the same time if needed.
+
+## Guidelines
+
+- You can spawn agents to help you complete the task. Iterate by spawning more agents as needed.
+- Don't mastermind the task. Rely on your agents' judgement to research, plan, edit, and review the code.
+- Give as many instructions upfront as possible to each agent so you're less likely to need to spawn them again.
+- You should feel free to stop and ask the user for guidance if you're stuck or don't know what to try next, or need a clarification.
+- When prompting an agent, realize that many agents can already see the entire conversation history, so you can be brief in prompting them without needing to include much context.
+- Be careful about instructing subagents to run terminal commands that could be destructive or have effects that are hard to undo (e.g. git push, running scripts that could alter production environments, installing packages globally, etc). Don't do any of these unless the user explicitly asks you to.
+`,
+
+  handleSteps: function* ({ prompt, params }) {
+    let steps = 0
+    while (true) {
+      steps++
+      // Run context-pruner before each step
+      yield {
+        toolName: 'spawn_agent_inline',
+        input: {
+          agent_type: 'context-pruner',
+          params: params ?? {},
+        },
+        includeToolCall: false,
+      } as any
+
+      const { stepsComplete } = yield 'STEP'
+      if (stepsComplete) break
+    }
+  },
+}
+
+export default definition

.agents/orchestrator/orchestrator.ts

@@ -0,0 +1,15 @@
+import { type SecretAgentDefinition } from '../types/secret-agent-definition'
+import decomposingPlanner from './decomposing-planner'
+
+const definition: SecretAgentDefinition = {
+  ...decomposingPlanner,
+  id: 'decomposing-planner-lite',
+  displayName: 'Decomposing Planner Lite',
+  model: 'anthropic/claude-sonnet-4.5',
+  spawnerPrompt:
+    'Creates a better implementation plan by decomposing the task into smaller plans in parallel and synthesizing them into a final plan. Includes full code changes.',
+  spawnableAgents: ['file-explorer', 'implementation-planner-lite'],
+  includeMessageHistory: false,
+}
+
+export default definition

.agents/planners/decomposing-planner-lite.ts

@@ -48,6 +48,7 @@ Step 3: Synthesis
 - Create a unified implementation plan that:
   - Combines insights from all subtask plans
   - Resolves any conflicts or overlaps
+  - Simplfies the plans while still accomplishing the task correctly -- most likely each subtask plan will do too much and add too much complexity
   - Presents a coherent, step-by-step implementation
   - Includes all necessary code changes in markdown code blocks
   - Follows the guidelines below

.agents/planners/decomposing-planner.ts

@@ -0,0 +1,11 @@
+import { type SecretAgentDefinition } from '../types/secret-agent-definition'
+import implementationPlanner from './implementation-planner'
+
+const definition: SecretAgentDefinition = {
+  ...implementationPlanner,
+  id: 'implementation-planner-lite',
+  displayName: 'Implementation Planner Lite',
+  model: 'x-ai/grok-4-fast',
+}
+
+export default definition

.agents/planners/implementation-planner-lite.ts

@@ -1,16 +1,13 @@
 import { publisher } from './constants'
-import {
-  PLACEHOLDER,
-  type SecretAgentDefinition,
-} from './types/secret-agent-definition'
+import { type SecretAgentDefinition } from './types/secret-agent-definition'
 import readOnlyCommander from './read-only-commander'
 
 const readOnlyCommanderLite: SecretAgentDefinition = {
   ...readOnlyCommander,
   id: 'read-only-commander-lite',
   displayName: 'ReadOnly Commander Lite',
   publisher,
-  model: 'x-ai/grok-code-fast-1',
+  model: 'x-ai/grok-4-fast',
   spawnerPrompt:
     'Can run quick read-only terminal commands and report back on the results. Has a basic understanding of the codebase. Is speedy and low-cost,',
 }

.agents/read-only-commander-lite.ts

@@ -6,7 +6,7 @@ import type { SecretAgentDefinition } from '../types/secret-agent-definition'
 const definition: SecretAgentDefinition = {
   id: 'reviewer-lite',
   publisher,
-  ...reviewer('x-ai/grok-4-fast:free'),
+  ...reviewer('x-ai/grok-4-fast'),
 }
 
 export default definition