Exploring multi-model orchestration and the next step in AI-assisted development.

It started with a simple curiosity

Whenever I use GitHub Copilot, I often find myself thinking about which model to choose. A quick code change needs one kind of model, while complex debugging or multi-file changes might need something more powerful. Sometimes, I even switch models or ask another model to review the generated code.

It works, but I started wondering: What if I could focus on the problem and let Copilot decide which models should work on it?

That’s when I came across GitHub Copilot Fusion, and I wanted to explore it hands-on.

So, what is Copilot Fusion?

Initially, I thought Fusion was just another model in the Copilot model picker. But it’s more than that.

Copilot Fusion is a model orchestration system that intelligently selects models and execution strategies depending on the task.

It supports three execution patterns:

• Single: One model handles the task.
• Cascade: A model generates a solution, and a quality check decides whether to accept it or escalate to a stronger model.
• Critique: One model generates a solution, another reviews it, and the original model refines it using the feedback.

Fusion also provides different effort levels: Standard, High, and Max.

The interesting idea is that not every task needs multiple models. Fusion attempts to choose an appropriate approach based on the complexity of the work.

Official documentation: https://docs.github.com/en/copilot/concepts/models/copilot-fusion

Let’s get our hands dirty: Exploring Fusion in VS Code

I wanted to understand how this works beyond the documentation, so I decided to try it in VS Code.

For my experiment, I chose a small TaskFlow REST API using Python and FastAPI. I asked Copilot to build CRUD endpoints, implement pagination, add validation and error handling, organize the code, and write automated tests.

I selected Copilot Fusion with Standard effort and provided the requirements in a single prompt.

I was interested in more than just the generated code. I wanted to observe how Fusion approached the task, whether it made coordinated changes across files, executed tests, and exposed information about its model selection.

Next, I tried a higher effort level and asked Fusion to review the existing implementation, identify potential issues, and improve the code without rewriting everything.

What’s happening behind the scenes?

This is where Fusion becomes interesting.

Think about how developers work: we write code, ask someone to review it, incorporate feedback, and sometimes involve another engineer when a problem gets complicated.

Fusion brings a similar approach to AI-assisted development. Instead of manually switching between models, it can decide whether a task needs a direct response, escalation, or independent review.

The bigger idea is that improving AI-assisted development isn’t just about building more powerful individual models. It’s also about making models work together effectively.

Another interesting direction: Local models

GitHub has also announced experimental support for selecting local models with Copilot Fusion.

This opens up another interesting area: how Fusion can route work between supported local and cloud models.

I’m particularly interested in exploring how local models fit into the orchestration process and how their performance compares with cloud-based models.

One thing to remember: local-model support doesn’t mean the entire Fusion workflow runs offline. The orchestration still involves cloud services.

Official announcement: https://github.blog/changelog/2026-10-28-github-copilot-fusion-now-supports-selection-of-local-models/

What’s next? Some questions worth exploring

There are still a few things I want to understand better:

• How does Fusion decide when to switch from one model to another?
• When switching models, how is the conversation context, code context, and previous model’s reasoning or intermediate output transferred?
• Does the next model receive the complete context or a summarized version?
• How do local models participate in this process?

I think context management is particularly interesting. Switching models is one thing, but ensuring that the next model understands everything the previous model worked on is a different challenge.

That’s something I’d like to investigate further through hands-on experiments.

My takeaway: The future of AI-assisted coding may not just be about having smarter models. It may be about getting the right models to work together, with the right context, at the right time.