When Microsoft announced that the Copilot Studio extension for Visual Studio Code is now generally available, it immediately resonated with the kind of work I’ve been doing lately: complex, multi‑agent Copilot Studio solutions that have outgrown the browser‑only authoring experience.
In this post, I want to share a very concrete scenario where the VS Code extension saved a significant amount of time: refactoring website knowledge sources from a parent agent into a dedicated child agent as part of a multi‑agent orchestration pattern.
The starting point: a parent agent doing too much
Originally, my parent agent contained roughly 100 website‑based knowledge sources. While this worked initially, it became clear that this architecture didn’t scale well:
- The parent agent should focus on orchestration and intent routing
- Domain‑specific knowledge belongs in child agents
- Knowledge isolation improves maintainability and clarity
Moving that many knowledge sources via the Copilot Studio web UI would have been slow and repetitive. The VS Code extension made it practical.
The refactoring workflow (step by step)
1. Create the child agent
First, I created a new child agent in Copilot Studio. This agent would ultimately own the website knowledge sources that were previously attached to the parent agent.
At this stage, the agent was mostly empty by design.
2. Publish the child agent
Publishing the child agent early is important. It ensures the agent exists as a fully realized artifact in Copilot Studio and can safely receive changes when syncing from VS Code later. Also publishing is needed so that you can set child agent to parent agent source.
3. Import the parent agent into VS Code
Next, I used the Copilot Studio VS Code extension to clone the parent agent into my local workspace.
This step exposes the full agent definition—topics, settings, and most importantly, knowledge source references—as editable files. Searching, navigating, and copying content is dramatically faster in VS Code than in the browser UI.
4. Import the child agent into VS Code
After that, I imported the child agent into VS Code as well, so both the parent and child agent definitions were available locally.
Having both agents side‑by‑side in the editor made it easy to reason about ownership boundaries and move content safely without losing context.
5. Copy the knowledge sources to the child agent in VS Code
With both agent definitions available locally, I copied the website knowledge source definitions from the parent agent files into the corresponding files of the child agent.
This is where the VS Code extension really shines:
bulk copy‑paste operations that would be painful in the UI are trivial when everything is plain text and fully searchable.
6. Rename the files in the child agent
Knowledge sources in Copilot Studio are stored in Dataverse, which enforces unique naming constraints. Because the child agent cannot reuse the same knowledge source names that already exist in the parent agent, renaming was required.
Rather than doing this manually, I used GitHub Copilot inside VS Code to:
- Systematically rename the knowledge source files
- Apply a consistent naming convention
- Avoid Dataverse name collisions
This was fast, repeatable, and far less error‑prone than manual edits.
7. Upload changes to the child agent from VS Code
Once everything looked correct locally, I used the VS Code extension to apply the changes back to Copilot Studio, syncing the updated knowledge sources into the child agent.
At this point:
- The child agent owned the website knowledge
- The parent agent was lighter and focused on orchestration
- The multi‑agent structure was much cleaner
All without having to recreate or reconfigure dozens of sources by hand.
Why this matters
This workflow highlights why the Copilot Studio VS Code extension is such a big step forward. It allows you to:
- Treat agents as versionable, editable artifacts
- Perform large‑scale refactoring safely
- Combine Copilot Studio with GitHub Copilot for AI‑assisted changes
- Evolve multi‑agent architectures without UI friction
As Microsoft puts it, the extension enables teams to apply software development hygiene—source control, structured edits, and confident iteration—to Copilot Studio agents.
Final thoughts
If you’re building multi‑agent Copilot Studio solutions and dealing with large knowledge bases, the VS Code extension isn’t just a convenience—it’s an architectural enabler.
For me, it turned what would have been a tedious migration into a fast, controlled refactor, and made it much easier to keep the parent agent focused on what it should do best: orchestrate.