After This Video, You'll Actually Understand Agent Orchestration

Agent Orchestration, otherwise known as what? Yes, the latest hot trend for Vibe Coders or Agentic Engineers is here. In this video, we're going to take a look at what it is, how it works, and whether or not you should use it today. And as always, please remember, all we have right now are new features and ideas, and we're kind of figuring out how things work in real time. So don't feel compelled to understand and use all of this stuff. In the end, Use what's right for you. Whatever works, whatever makes you productive, that's the right thing. You ready? Let's go. Now, the best way to understand agent orchestration is just to look at it from what you're doing today. So in your editor of choice, maybe you send a chat command. What does this project do? And then you can send another chat command. And maybe this one is research design for iOS apps. And on this one, you're going to send it to a background agent. And so now you have two agents going at the same time, a local agent and a background agent, and maybe you even have a Cloud agent. Now, in this scenario, you are the orchestrator. You are running all of these different agents, and maybe you're using Opus for some and Cloud for others and GPT-5 for others. But in an agent orchestration scenario, you actually have one agent that calls others. And this is possible because of the recent tooling that has arrived for both the Copilot CLI and Visual Studio Code. So if we were to go to the Copilot CLI here, so let's just fire that up. So the most naive way that we could orchestrate agents here is to just have them call each other. And we can do that just by saying it like this. Review the code in this project for accuracy and improvements and security flaws. When you're done with your findings, run them by both GPT-5.2 Codex and Gemini 3 Pro. Iterate with these two models to see what their ideas are, what their findings are, and then come back with a complete plan on what we can do to improve this project. Now, I'm going to send this prompt, and in this case, believe it or not, this is all we have to do in the Copilot CLI. It will actually pick up the different models we want to use. And it doesn't even matter that it got it wrong here and it said GPT-52 codex with a K, whatever that is. It should actually figure this out on its own and then delegate to these different agents. Let's see if it does that. So you see here it says now I have the full code base. Let me launch three parallel reviews. It's running GPT-52 Codex and Gemini 3 Pro, and it's doing this all at the same time. So most people don't know this is possible, but yes, you can in Copilot have one model call other models. You don't have to use just one in a chat session. You can use all of them, and that's exactly what's happening here. All right, so I sped that up, but you can see what happened here. It called the general purpose GPT-52 codex agent here and the general purpose Gemini 3 Pro preview. agent here. Now what these are is something called sub-agents and these are available in both the CLI and in Visual Studio Code and they are super powerful because sub-agents can be called by the main agent but sub-agents can have whatever model you want them to have. And then as you can see it went through it created a plan here for us and it's quite a long plan we're not going to look at it because this is a real project that I'm working on that I want to show you. Now, you can probably see that this opens up a lot of possibilities. First and foremost, if you have an agent that can call other agents, then essentially you could just build your own dev team, right? Like you could have a team lead and architects and coders and designers and planners and PMs. I mean, why not? You can have as many sub-agents as you want. And so that is the general idea behind agent orchestration, is that you have agents orchestrating other agents. So let's actually see how this works in practice in a real project. So here's a real project that I'm working on. It is a replacement for the Gemini app on iOS because there are features that the Gemini app doesn't have. I'm tired of waiting for them and it's 2026, so you can just build your own. And so we can make a picture of cats playing volleyball just like this, send it, and this will interact with the Gemini API. It's just a chat app, but it's done the way that I like. Specifically in this app, I can edit history, edit my prompts and resend them. For whatever reason, you can't do that today in the Gemini app. So I just made it so that you could. So we can edit this. Dogs playing volleyball. Now, what we want to do here is create the web experience for this app. Because sometimes you use AI on your phone. And then you go back to the web and you use it there. And so we want to create the web experience. We're going to use agent orchestration to do that. Now, we talked about how Visual Studio Code has custom agents, and those custom agents are here. And you can define these custom agents just by clicking Configure Custom Agent. So what we're going to do is we're going to create an orchestration framework that has an orchestrator with a planner, a designer, and a coder. And we're going to use all three of the big models to do this. Sonnet. GPT-52, GPT-52 Codex, and Gemini 3 Pro. So let's jump in and take a look at this first orchestrator custom agent. The orchestrator's entire job is just to orchestrate work between different agents. It doesn't actually do any work itself other than that. It's like a... PM or a logistics coordinator. So you can see here the first thing that we do in our custom agent is configure the tools and it only has two. It has the ability to call sub-agents with the agent tool and it has a memory and memory is new in Copilot. You can use that today and you can see here if we just scroll down the prompt is fairly simple. You're a project orchestrator. You break down complex requests into tasks. and delegate them to specialist sub-agents. You coordinate work, but you never implement anything yourself. Then this is important. For Visual Studio Code, we need to tell the orchestrator exactly what the name of the different sub-agents it can use are. They are Planner, Coder, and Designer. We'll take a look at these. Then we have a workflow. It's fairly simple. Understand, plan, break it down into steps, delegate it to the sub-agents. coordinate between the agents depending on the work that was done and then report the results back. Now we have some rules down here lower that tell this orchestrator agent, don't tell sub-agents how to do work because these agents really, really, really want to do the work. And so what I noticed is that the main orchestrator agent really wants to tell the sub-agents exactly what to do. wants to give them the line to change, exactly what to change. These models think they know everything. And so you have to really go out of your way to make sure that they don't do that. So that's essentially what the rest of this prompt does. But you can see it's not terribly long. That's the orchestrator. So let's look at the planner. The planner custom agent, as you can see right here, let's jump into that, has all of the tools. It can do pretty much anything. You create plans, you do not write code. And you can see, and this is key here, this model line 5-2. So this is how the agent knows which model to use. So when the orchestrator calls this sub-agent, this sub-agent is just going to use GPT-5-2. So we're using 5-2 for planning. You can see these prompts are not very long. Prompts don't need to be long and complicated to get the job done. They just need to do the job. So now let's take a look at our coder. The coder agent uses GPT-5-2 codecs. That's what that model's good at, is writing code. It's really good at writing code. That's all this agent does. And you can see here, it's got a lot of tools and it has an MCP server called Context 7. And Context 7 is very simple. It has one tool, just allows the agent to go and read the docs. And so here in the prompt, this is... pretty simple except for this block right here. And this block is meant to counter the fact that the orchestrator is probably going to try to tell this agent what to do. And we're basically telling it, don't do that. Question everything you're told. make your own decisions. And then here are just some mandatory coding principles that I use for the coding agent. You don't have to have these, but I like to include these. And these are very generic terms like prefer flat explicit code over abstractions or deep hierarchies, right? We're just trying to keep the code clean and simple. And so you're more than welcome to use these, but you don't have to. Now let's take a look at the designer. The designer handles all of the UI, UX, and styling because as it turns out, not all of these models are the same when it comes to design. And in fact, Theo has a great video on this that you should check out where he looks at which model is best for design. Spoiler alert, he doesn't think that it's Gemini 3 Pro. I tend to disagree. I tend to get better results with Gemini 3, so that's what we're going to use. The designer prompt, probably the most simple of all. The model we're specifying. Gemini 3 Pro. I get way better results with design with Gemini 3 Pro. I don't use Gemini for hardly anything else, but for design, it's unbeatable. And then here, look, I'm doing it again. You are the designer. Don't let the orchestrator tell you how to do your job because the orchestrator is going to try to do that. Instead, your goal is to create the best possible user experience and interface designs, focusing on usability, accessibility, and aesthetics. Conceptually speaking, the design agent needs to have full creative autonomy here. So we don't want to give it a lot of guardrails. We really want to let it do what it does, which is design. So that is essentially the whole orchestration framework. It's ultralight. It's very small, but I want to show it to you in action. And what we're going to do is we're going to use this orchestration framework to build a web experience for the mobile app that we have. Now. Before we actually use this orchestrator agent, it's important to point out that what model should you use for the orchestrator? I use Claude Sonnet 4.5. And the reason that I do this is that Claude Sonnet 4.5 is very agentic, right? It's almost like a Labrador, right? It's like, it's just super eager, always trying to do things. And so we want to harness that. We want that energy. We want the agency that Sonnet 4.5 has, but we don't want it writing any code. It's not good at writing code. I would not recommend that you have Sonnet 4.5 write code. GPT-5.2 codex is just way better at that. So we want the agency of Sonnet and we want the coding chops. of codecs and that's what we're going to do here. To get that, we're going to have Sonnet be the orchestrator. Now, what we're going to do here is we're going to create the web experience for the mobile app and we're going to send it in and try to one-shot it. Probably won't be able to do that because it's quite complex, but let's see what our little orchestration framework can do. We want to create a web experience for this mobile app. We want it to look exactly like the mobile app or rather borrow the same design aesthetics from the mobile app. It should use Firebase. The mobile app is already using Firebase. Feel free to use the Firebase CLI to get the resources that you need or to stand up any resources that you need. Now I'm going to send this prompt and let this thing go. This is going to take some time and then we'll come back when it's done, examine the chat history and then take a look at what it's actually produced and see if orchestration works. All right, it finished and that did take some time, but let's scroll back up through the chat here and I just want to show you a few things because this is pretty fascinating. So from our prompt here, you can see the first thing that it's doing is it's calling the planner agent. just like it's supposed to. And that's going to use GPT-5 too. And if we look at the planner agent, you can see the prompt that actually gets sent. The user wants to create a web experience for their iOS Gemini chat app. Here are the requirements. It's basically taking what I asked and boosting that prompt, and then it asks for a plan and it gets the plan back. Now, after the planning agent is finished, it reviews the plan, reads it, and then Delegates it to the designer to create a web design system. And again, we can dig in here and see the prompt. It's telling the designer a little bit of information about the application and then telling it to create, if we scroll down here, create a design system for this web application. And it puts it here in a markdown document right there. There it is. There's a design system complete with CSS styles and everything. That's Gemini 3 Pro doing its job. After the designer, it starts to coordinate with the coder, and then it calls the coder. Then in the coder, it says, build a complete web application for the better Gemini Chat app, and it passes in the plan here. Then down here, you can see it uses the web design system that was created by the designer. Now, if we scroll back up. Go through here. You can see that now that we're inside the coder agent, it's using the context 7 MCP tool to query documentation, and it just keeps going and going and then eventually finishes. Let's go ahead and collapse this, compiles a list, and then tells you what it has actually created here. Now, here's the most fascinating thing about all of this. Do you see the context window indicator down here? Look at this. Do you see how much context window we have not used? It created 2,707 lines of code and we've only used 10.8K of the context window. How is that possible? That's the magic of sub-agents. They have an isolated context window. They only use what's theirs and then once the sub-agent is done because it has its own context window, that's gone. It doesn't pollute the main context window. It just gets the result of what the sub-agent does. Let's see if this actually worked and see if we have a working web app. All right, here's the app. Let's go ahead. Can we sign in with Google? We can. Brilliant. Let's go ahead and click that. Let's start a new conversation. All right, so already we have some issues. But again, we can probably open up our DevTools here and copy those errors out here and then take them back in and work with our orchestration framework to actually make this functional. But let's talk about this for a second and some improvements that we could probably make here. So one of the things that I noticed is that when it created the plan, It didn't really pass much of the plan to the coder. It sort of just passed a high-level overview of the plan. So we might want to update the planner to say save your plan in a document and always pass that document to the coder. Another thing that I noticed is that it ran one coder agent to do all of the work. Would have been better if it had sliced up the work into discrete chunks and then given that to five coder agents running at the same time, because some agents can run in parallel. You can do that. So we have some tweaks to make to our orchestrator prompt here. If you would like to try this ultralight orchestration framework today, you can do that. It's here. and the link below the video. And then you just need to install each one of these. Just click on the button that will open Visual Studio Code and install the agent for you. And these agents are exactly the same ones that we saw in this video. But remember, what I've created here isn't the end-all be-all. It's just an example of how you can use a single agent to orchestrate multiple sub-agents. But how you put it together is however it works best for you. Choose the models that work for you that make you the most productive. There's also other agent orchestration frameworks out there. So really, really complex ones. You may have heard of them, Gastown, GSD and some others. You probably want to take a look at those as well. And that is basically. Agent orchestration. You can use this today at a very simple level. You don't have to have 100 agents all out there doing various things all at the same time, checking each other's code, reviewing each other's pull requests. That'd be nice. But where we are today is that if you could get one agent to delegate work out to a bunch of sub-agents who are very good at different things, that's a great start when it comes to agent orchestration. Good luck, and as always, happy coding.

In this video, I break down agent orchestration in a way that actually makes sense. No "Gas towns" or "Ralphs" or other terminology that makes no sense out of context. Just a clear, practical explanation of what Agent Orchestration is, why it matters, and how it's changing the way we build with AI.

Whether you're just getting into AI agents or you've been building but want to level up, this is the foundation you need.

🔗 Resources:
Ultralight Orchestration Framework: https://gist.github.com/burkeholland/0e68481f96e94bbb98134fa6efd00436

⏱️ Chapters:
0:00 - Introduction
0:36 - What is orchestration?
3:38 - Orchestration with custom agents
5:38 - Orchestrator Agent
7:23 - Planning Agent
7:57 - Coder Agent
8:58 - Designer
10:10 - Orchestration in action
15:09 - Improving the orchestration

💬 Drop a comment if agent orchestration finally clicked for you—or if you have questions!

#ai #copilotcli #vscode