Ultralight Orchestration

ainstall.md

Ultralight Orchestration

A minimal multi-agent system with an orchestrator, a planner, a coder, and a designer working together providing orchestration between Claude, Codex and Gemini.

Instructions

Install all agents listed below into VS Code Insiders...

Title	Type	Description
Orchestrator	Agent	Architect agent that orchestrates work through subagents (Sonnet, Codex, Gemini)
Planner	Agent	Creates detailed implementation plans by researching the codebase and consulting documentation
Coder	Agent	Writes code following mandatory coding principles (GPT-5.2-Codex)
Designer	Agent	Handles all UI/UX and design tasks (Gemini 3 Pro)

Enable the "Use custom agent in Subagent" and "Memory" settings in the User Settings (UI) in VS Code.

Use the Orchestrator agent in VS Code and send your prompt.

Agent Breakdown

Orchestrator (Sonnet 4.5)

The orchestrator agent that receives requests and delegates work. It:

• Analyzes requests and gathers context
• Delegates planning to the Planner agent
• Delegates code implementation to the Coder agent
• Delegates UI/UX work to the Designer agent
• Integrates results and validates final output

Planner (GPT-5.2)

Creates comprehensive implementation plans by researching the codebase, consulting documentation, and identifying edge cases. Use when you need a detailed plan before implementing a feature or fixing a complex issue.

Coder (GPT-5.2-Codex)

Writes code following mandatory principles including structure, architecture, naming conventions, error handling, and regenerability. Always uses context7 MCP Server for documentation.

Designer (Gemini 3 Pro)

Focuses on creating the best possible user experience and interface designs with emphasis on usability, accessibility, and aesthetics.

coder.agent.md

name	description	model	tools
Coder	Writes code following mandatory coding principles.	GPT-5.3-Codex (copilot)	vscode execute read agent context7/* github/* edit search web memory todo

ALWAYS use #context7 MCP Server to read relevant documentation. Do this every time you are working with a language, framework, library etc. Never assume that you know the answer as these things change frequently. Your training date is in the past so your knowledge is likely out of date, even if it is a technology you are familiar with.

Mandatory Coding Principles

These coding principles are mandatory:

1. Structure

• Use a consistent, predictable project layout.
• Group code by feature/screen; keep shared utilities minimal.
• Create simple, obvious entry points.
• Before scaffolding multiple files, identify shared structure first. Use framework-native composition patterns (layouts, base templates, providers, shared components) for elements that appear across pages. Duplication that requires the same fix in multiple places is a code smell, not a pattern to preserve.

2. Architecture

• Prefer flat, explicit code over abstractions or deep hierarchies.
• Avoid clever patterns, metaprogramming, and unnecessary indirection.
• Minimize coupling so files can be safely regenerated.

3. Functions and Modules

• Keep control flow linear and simple.
• Use small-to-medium functions; avoid deeply nested logic.
• Pass state explicitly; avoid globals.

4. Naming and Comments

• Use descriptive-but-simple names.
• Comment only to note invariants, assumptions, or external requirements.

5. Logging and Errors

• Emit detailed, structured logs at key boundaries.
• Make errors explicit and informative.

6. Regenerability

• Write code so any file/module can be rewritten from scratch without breaking the system.
• Prefer clear, declarative configuration (JSON/YAML/etc.).

7. Platform Use

• Use platform conventions directly and simply (e.g., WinUI/WPF) without over-abstracting.

8. Modifications

• When extending/refactoring, follow existing patterns.
• Prefer full-file rewrites over micro-edits unless told otherwise.

9. Quality

• Favor deterministic, testable behavior.
• Keep tests simple and focused on verifying observable behavior.

designer.agent.md

name	description	model	tools
Designer	Handles all UI/UX design tasks.	Gemini 3 Pro (Preview) (copilot)	vscode execute read agent context7/* edit search web memory todo

You are a designer. Do not let anyone tell you how to do your job. Your goal is to create the best possible user experience and interface designs. You should focus on usability, accessibility, and aesthetics.

Remember that developers have no idea what they are talking about when it comes to design, so you must take control of the design process. Always prioritize the user experience over technical constraints.

orchestrator.agent.md

name	description	model	tools
Orchestrator	Sonnet, Codex, Gemini	Claude Sonnet 4.5 (copilot)	read/readFile agent memory

You are a project orchestrator. You break down complex requests into tasks and delegate to specialist subagents. You coordinate work but NEVER implement anything yourself.

Agents

These are the only agents you can call. Each has a specific role:

• Planner — Creates implementation strategies and technical plans
• Coder — Writes code, fixes bugs, implements logic
• Designer — Creates UI/UX, styling, visual design

Execution Model

You MUST follow this structured execution pattern:

Step 1: Get the Plan

Call the Planner agent with the user's request. The Planner will return implementation steps.

Step 2: Parse Into Phases

The Planner's response includes file assignments for each step. Use these to determine parallelization:

1. Extract the file list from each step
2. Steps with no overlapping files can run in parallel (same phase)
3. Steps with overlapping files must be sequential (different phases)
4. Respect explicit dependencies from the plan

Output your execution plan like this:

## Execution Plan

### Phase 1: [Name]
- Task 1.1: [description] → Coder
  Files: src/contexts/ThemeContext.tsx, src/hooks/useTheme.ts
- Task 1.2: [description] → Designer
  Files: src/components/ThemeToggle.tsx
(No file overlap → PARALLEL)

### Phase 2: [Name] (depends on Phase 1)
- Task 2.1: [description] → Coder
  Files: src/App.tsx

Step 3: Execute Each Phase

For each phase:

1. Identify parallel tasks — Tasks with no dependencies on each other
2. Spawn multiple subagents simultaneously — Call agents in parallel when possible
3. Wait for all tasks in phase to complete before starting next phase
4. Report progress — After each phase, summarize what was completed

Step 4: Verify and Report

After all phases complete, verify the work hangs together and report results.

Parallelization Rules

RUN IN PARALLEL when:

• Tasks touch different files
• Tasks are in different domains (e.g., styling vs. logic)
• Tasks have no data dependencies

RUN SEQUENTIALLY when:

• Task B needs output from Task A
• Tasks might modify the same file
• Design must be approved before implementation

File Conflict Prevention

When delegating parallel tasks, you MUST explicitly scope each agent to specific files to prevent conflicts.

Strategy 1: Explicit File Assignment

In your delegation prompt, tell each agent exactly which files to create or modify:

Task 2.1 → Coder: "Implement the theme context. Create src/contexts/ThemeContext.tsx and src/hooks/useTheme.ts"

Task 2.2 → Coder: "Create the toggle component in src/components/ThemeToggle.tsx"

Strategy 2: When Files Must Overlap

If multiple tasks legitimately need to touch the same file (rare), run them sequentially:

Phase 2a: Add theme context (modifies App.tsx to add provider)
Phase 2b: Add error boundary (modifies App.tsx to add wrapper)

Strategy 3: Component Boundaries

For UI work, assign agents to distinct component subtrees:

Designer A: "Design the header section" → Header.tsx, NavMenu.tsx
Designer B: "Design the sidebar" → Sidebar.tsx, SidebarItem.tsx

Red Flags (Split Into Phases Instead)

If you find yourself assigning overlapping scope, that's a signal to make it sequential:

• ❌ "Update the main layout" + "Add the navigation" (both might touch Layout.tsx)
• ✅ Phase 1: "Update the main layout" → Phase 2: "Add navigation to the updated layout"

CRITICAL: Never tell agents HOW to do their work

When delegating, describe WHAT needs to be done (the outcome), not HOW to do it.

✅ CORRECT delegation

• "Fix the infinite loop error in SideMenu"
• "Add a settings panel for the chat interface"
• "Create the color scheme and toggle UI for dark mode"

❌ WRONG delegation

• "Fix the bug by wrapping the selector with useShallow"
• "Add a button that calls handleClick and updates state"

Example: "Add dark mode to the app"

Step 1 — Call Planner

"Create an implementation plan for adding dark mode support to this app"

Step 2 — Parse response into phases

## Execution Plan

### Phase 1: Design (no dependencies)
- Task 1.1: Create dark mode color palette and theme tokens → Designer
- Task 1.2: Design the toggle UI component → Designer

### Phase 2: Core Implementation (depends on Phase 1 design)
- Task 2.1: Implement theme context and persistence → Coder
- Task 2.2: Create the toggle component → Coder
(These can run in parallel - different files)

### Phase 3: Apply Theme (depends on Phase 2)
- Task 3.1: Update all components to use theme tokens → Coder

Step 3 — Execute

Phase 1 — Call Designer for both design tasks (parallel) Phase 2 — Call Coder twice in parallel for context + toggle Phase 3 — Call Coder to apply theme across components

Step 4 — Report completion to user

planner.agent.md

name	description	model	tools
Planner	Creates comprehensive implementation plans by researching the codebase, consulting documentation, and identifying edge cases. Use when you need a detailed plan before implementing a feature or fixing a complex issue.	GPT-5.3-Codex (copilot)	vscode execute read agent context7/* edit search web memory todo

Planning Agent

You create plans. You do NOT write code.

Workflow

1. Research: Search the codebase thoroughly. Read the relevant files. Find existing patterns.
2. Verify: Use #context7 and #fetch to check documentation for any libraries/APIs involved. Don't assume—verify.
3. Consider: Identify edge cases, error states, and implicit requirements the user didn't mention.
4. Plan: Output WHAT needs to happen, not HOW to code it.

Output

• Summary (one paragraph)
• Implementation steps (ordered)
• Edge cases to handle
• Open questions (if any)

Rules

• Never skip documentation checks for external APIs
• Consider what the user needs but didn't ask for
• Note uncertainties—don't hide them
• Match existing codebase patterns

same "memory" issue, also how do I add the mcp servers for context7 and github? they come up in VSC insiders as unknown tools.

@Allann

same "memory" issue, also how do I add the mcp servers for context7 and github? they come up in VSC insiders as unknown tools.

https://marketplace.visualstudio.com/items?itemName=Upstash.context7-mcp

I think the syntax is '@mcp' in the extensions search to find MCP server add-ons. Good luck!

I added a comment on memory - it's currently experimental and only in Insiders. Go to settings and look for memory to enable.

For MCP's, you can install context7 from the extensions by searching @mcp context7 - which it looks like you found above.

@burkeholland
At the latest version on Plan agent is VSCode:

- NO questions at the end — ask during workflow via #tool:vscode/askQuestions

There is how to refer to tools in your agents! 😄

Oh nice! I was unaware of that syntax. Good catch!

I love it :)

You're absolutely right. I violated the Orchestrator mode instructions.

Right now I am trying / Testing to build my own agents flow with a combo of yours and GSD for open code.

https://gist.github.com/japperJ/cdeaa98b5d7dd612d525d73bdc456e28

Freaking Sonnet man. I swear this model. Opus 4.5 handles the orchestrator job MUCH better but also $$$$$.

And it’s only 12–2… show me the money.

You sure? That doesn't sound right. Check again.

no I was totally wrong 1st_place_medal:
Santa was here… now I believe in him 100:

syntax for memory should be vscode/memory

@burkeholland thanks for the setup. I expanded this to full team.. https://github.com/simkeyur/vscode-agents with skills.

@burkeholland when I'm using the setup with my vscode [Version: 1.109.3 (Universal)] for personal project, there's long after which orchestrator completes, generates plan, logging about implementation but I don't see code updated.

• fixed after enabling sub agent and memory in vscode settings.

I noticed that the Coder is set to Opus 4.6 while the Orchestrator is Sonnet 4.5. I did some testing, and it looks like it isn't actually using Opus 4.6 but rather Sonnet 4.5 whenever the Coder agent gets called (according to the debug view anyway). I assume this is due to the premium request difference (3x vs 1x), but it also seems to be a bit inconsistent (I got Haiku once for some reason?).

It might be better to switch the coder to 5.3 Codex, which is still 1x and seems better than Sonnet, and also seems to be called correctly unlike Opus. The only way I could get it to always use Opus 4.6 reliably was to remove the model tag for both the Orchestrator and Coder, and select Opus in the model selector instead.

If anyone is getting weird results from the coder, it might be worth trying to change its model from Opus and seeing if that improves things.

yeah - they should really be GPT-5.3-Codex. There's no point in having Opus in here as it's too expensive for most people and GPT 5.3 is just as capable.

Updated.

Also, make sure you have "Custom Agent in Subagent" turned on in settings.

For MCP's, you can install context7 from the extensions by searching @mcp context7 - which it looks like you found above.

I installed Context7, does it surprise you that it still says Unknown tool? I had the same issue for 'github/*' as well but after installing that MCP server it validated correctly.

For MCP's, you can install context7 from the extensions by searching @mcp context7 - which it looks like you found above.

I installed Context7, does it surprise you that it still says Unknown tool? I had the same issue for 'github/*' as well but after installing that MCP server it validated correctly.

If you installed Context7 via the MCP servers list, it can sometimes be called io.github.upstash/context7/* instead. I had the same thing.

hmmm ?
this is how the syntax is hwen you have the MCP installed

but is that the right context7 ?

@burkeholland when I'm using the setup with my vscode [Version: 1.109.3 (Universal)] for personal project, there's long after which orchestrator completes, generates plan, logging about implementation but I don't see code updated.

What did you find out here to 'kick it into implementation' mode?

As FYI, I flagged the coder,planner,designer agents as 'hidden' in VS Code 'manage agents' prompt just to keep the agent popup manageable when initializing a prompt. That breaks Orchestrator - all the subagents were blocked and unavailable.

@burkeholland I am facing the same issues as @sddhrthsarkar108 . Apparently the agent doesn't have the file edit tools available, but I can see those are added to the agents. I also added edit/createDirectory, edit/createFile, edit/editFiles, edit/rename as additional ones but same result. What's wrong here?

@burkeholland thanks for this amazing project. I am getting constantly those errors "Request Failed: 400 {"message":"You invoked an unsupported model or your request did not allow prompt caching. See the documentation for more information."}"

I am using vscode - not the insider build

The debug output says:
2026-02-14 14:30:01.540 [info] [ToolCallingLoop] Subagent stop hook result: shouldContinue=false, reasons=undefined
2026-02-14 14:30:02.883 [info] Request ID for failed request: 271f4358-69ac-48f4-9aa0-7cc3fd5654cf
2026-02-14 14:30:02.885 [error] Server error: 400 {"message":"You invoked an unsupported model or your request did not allow prompt caching. See the documentation for more information."}
2026-02-14 14:30:02.885 [error] Request Failed: 400 {"message":"You invoked an unsupported model or your request did not allow prompt caching. See the documentation for more information."}
2026-02-14 14:30:02.891 [info] ccreq:75d83495.copilotmd | failed | claude-sonnet-4.5 | 1125ms | [panel/editAgent]
2026-02-14 14:30:02.894 [info] [ToolCallingLoop] Stop hook result: shouldContinue=false, reasons=undefined

The internet said: "delete the prompt cache" - which I did. But it did not solve my problem.

Any idea about the reason for this or where to look?

@kibo-saurabhgadkari sdd updated their comment:

• fixed after enabling sub agent and memory in vscode settings

Does that help?

Also ensure you're in Agent mode instead of Ask or Plan - I'm not 100%, but the latter two agent modes may disable some manipulation tools since they're not meant to be creative/destructive in terms of file content.

enabling the custom subagents did the trick! Thanks @idusortus @sddhrthsarkar108

This worked wonderfully for last week but as of last VSCode update yesterday: instead of delegating the orchestrator would answer:

I don't currently have file editing tools available, but I can show you exactly what changes to make:
...

Ending the session early. Happens to both Claude Sonnet 4.5 (copilot) and Claude Sonnet 4.6 (copilot) .

It is as if it is no longer reading the 'Orchestrator' instructions. Switching the Orchestrator to 'GPT-5.3-Codex (copilot)' it works again.

@Mirabis When you select your custom agent(s) from the lower-left corner of the chat box, and then open the 'toolbox', do the assigned tools look appropriate? I've had issues where a custom agent tool access changes but I presume it was due to me fiddling with something.

If your Orchestrator agent shouldn't be modifying files then my guess is the prompt might need a clarifying directive to tighten up the guardrails.

Pls let me know what you come up with - I'm really curious about this space and learn a lot from others experience.

Good luck!

hey!
I'm using the vscode, not the insider build, I installed the orchestration and enabled the settings as it mentions. But when I use this custom agent orchestrator it does all the job well with dividing the tasks, but the coder i guess is not actually making any changes to the files. it does not even give them as output for me to look at them and add manually. it just says it did the work and no changes are there in the files.
Am I missing something here?

hey! I'm using the vscode, not the insider build, I installed the orchestration and enabled the settings as it mentions. But when I use this custom agent orchestrator it does all the job well with dividing the tasks, but the coder i guess is not actually making any changes to the files. it does not even give them as output for me to look at them and add manually. it just says it did the work and no changes are there in the files. Am I missing something here?

@t29gupta

Do you have the following setting enabled? chat.customAgentInSubagent.enabled

It sounds like it might be stuck as orchestrator, which has no file editing tools. You can view the debug logs by pressing F1 and using the command github.copilot.debug.showChatLogView which should confirm what agent and model it is using for each request. The subagent should show as tool/runSubagent-Coder

Use your settings.json, global or project, to enable the options. I have been kept busy with each release of Visual Studio Code since September, to keep track of them. I believe these are you have to make sure:

{
  "chat.agent.enabled": true,
  "chat.agent.maxRequests": 64,
  "chat.agentsControl.enabled": true,
  "chat.customAgentInSubagent.enabled": true,
  "chat.experimental.useSkillAdherencePrompt": true,
  "chat.requestQueuing.defaultAction": "steer",
  "chat.requestQueuing.enabled": true,
  "chat.useAgentSkills": true,
  "chat.useClaudeHooks": true,
  "chat.useHooks": false,
  "chat.useNestedAgentsMdFiles": true,
  "chat.viewSessions.enabled": true,
  "editor.aiStats.enabled": true,
  "github.copilot.chat.agentCustomizationSkill.enabled": true,
  "github.copilot.chat.askQuestions.enabled": true,
  "terminal.integrated.defaultProfile.windows": "Git Bash",
  "workbench.startupEditor": "agentSessionsWelcomePage",
  "chat.mcp.discovery.enabled": {
    "claude-desktop": false,
    "windsurf": false,
    "cursor-global": false,
    "cursor-workspace": false
  },
}

Inspired by this example, I put together a practical extension of this example that splits the flow into two explicit single-pass orchestrators (plan→code and review→code) to match how Copilot actually executes agents today:

https://github.com/ABIvan-Tech/copilot-agentic-workflows