Nieuws

GitHub Copilot Fusion: wat verandert automatische modelkeuze voor je devteam

GitHub Copilot Fusion kiest en combineert zelf modellen voor je coding-taak, in plaats van dat jij er één aanwijst. Met de drie onderliggende patronen, wat Standard, High en Max echt kosten, en een valkuil die GitHub's eigen documentatie zelf noemt: een verworpen concept kan al iets in je bestanden hebben veranderd.

Dennis ClaassenDennis Claassen17 min lezen
Lichtpunten die samenkomen tot één gerouteerde lichtstraal, als beeld voor automatische modelkeuze in GitHub Copilot Fusion

Een agent voor jullie eigen proces?

Kies een afgebakende taak en werk toe naar een agent met heldere bronnen, rechten en controle.

Dennis Claassen

Dennis Claassen

AI-trainer · 35+ teams getraind

Bekijk de Agent Sprint

Key takeaways

GitHub Copilot Fusion kiest sinds 28 oktober 2026 zelf welk AI-model je coding-taak oppakt, in plaats van dat jij in de modelkiezer een vast model aanwijst. Je ziet de optie "Let Copilot choose" terug op GitHub's eigen Copilot-pagina: Fusion matcht elke taak met één of meer modellen en weegt daarbij kwaliteit, snelheid en kosten af. Voor een team dat net een vaste modelkeuze had uitgezocht, betekent dit een nieuwe knop die zegt: wij kiezen het wel. Hieronder: hoe de drie onderliggende patronen werken, wanneer je zelf Standard, High of Max kiest, en de valkuil die GitHub's eigen documentatie zelf noemt. Wat een AI-agent daarbij wel en niet zelf mag beslissen, staat in onze bredere uitleg.

Wat is GitHub Copilot Fusion precies?

GitHub Copilot Fusion is een runtime-router: je selecteert "Copilot Fusion" in de modelkiezer, en Copilot bepaalt per prompt welk uitvoeringspatroon en welk model (of welke combinatie van modellen) die taak oppakt, rekening houdend met de actuele beschikbaarheid van elk model. Dat werkt per prompt opnieuw, dus een vervolgvraag in dezelfde sessie kan een ander patroon krijgen dan de vraag daarvoor. Fusion is de algemeen beschikbare opvolger van de eerdere onderzoekspreview Project HydraFusion: dezelfde multi-model-orchestratie, nu gecombineerd met automatische modelselectie en als vaste knop in de modelkiezer, niet meer als iets wat je los moest aanzetten. Dat bevestigen de releasenotes van VS Code 1.144, de versie waarin Fusion op 28 oktober 2026 live ging.

Drie patronen zijn mogelijk, volgens GitHub's eigen documentatie over Copilot Fusion:

Dat Cascade-patroon werkt omdat de meeste coding-taken prima door een goedkoop model worden afgehandeld, en alleen de uitschieters een duurder model nodig hebben: je betaalt het dure model alleen in moeilijke gevallen, in plaats van voor elke taak vooraf te raden hoe zwaar hij is. Het werkt niet goed bij een taak die al zwaar lijkt, zoals een major-versie-upgrade of een migratie met veel bestanden, want dan betaal je eerst voor een concept dat toch wordt weggegooid; kies dan direct een hoger effort-niveau (zie hieronder). Je ziet de tussenresultaten overigens nooit: Copilot toont alleen het eindantwoord, nooit het afgewezen concept.

Hoe werken de effort levels van Copilot Fusion: Standard, High en Max?

Naast het patroon kies je, los daarvan, een effort-niveau. Dat niveau stuurt hoe zwaar Copilot Fusion een taak aanpakt, los van welk patroon er wordt gekozen.

Effort-niveauWat het doetVereist planWaarom de drempel daar ligt
StandardBalanceert kosten, kwaliteit en snelheid voor dagelijks werk. Kiest meestal één model per taak.Alle plannen, inclusief FreeDagelijks werk (kleine fixes, losse functies) heeft geen zwaardere orchestratie nodig; een hoger niveau zou hier alleen meer credits kosten zonder een beter antwoord.
HighGebalanceerde orchestratie voor substantiële, goed afgebakende taken, zoals een complexe bug of een wijziging over meerdere bestanden.Pro+ of hogerMulti-file wijzigingen hebben vaker een Cascade- of Critique-stap nodig om een fout in het ene bestand te laten meewegen in een ander bestand. Dat kost meer modelaanroepen, dus GitHub koppelt het aan een duurder plan.
MaxFrontier-niveau, met aandacht voor tokenefficiëntie, voor de diepste redenering en analyse.Pro+ of hogerVoor het zwaarste redeneerwerk zet Copilot de sterkste beschikbare modellen in. Dat is het duurst per aanroep, dus alleen beschikbaar vanaf hetzelfde plan als High.
FastNiet zelf te kiezen; alleen actief in VS Code inline chat.Alle plannenInline chat moet razendsnel reageren terwijl je typt; daar is geen ruimte voor een afweging tussen meerdere modellen.

Pro kost 10 dollar per gebruiker per maand, Pro+ 39 dollar, bevestigd op GitHub's eigen plannenoverzicht: een verschil van 29 dollar om bij High en Max te kunnen. Er is geen apart Fusion-tarief: je betaalt voor elk model dat Fusion aanroept, tegen het standaardtarief daarvan. High en Max kunnen dus meer credits opsouperen dan Standard, simpelweg omdat ze vaker meer dan één model aanroepen. Om dat te beperken houdt Copilot het hoofdgesprek zoveel mogelijk bij hetzelfde model, want een cachetreffer is goedkoper dan een nieuwe aanvraag bij een ander model.

De grootste valkuil: een verworpen concept kan al iets veranderd hebben in je bestanden

Bij Cascade en Critique bestaat er, voor jij het eindantwoord ziet, altijd een concept dat wordt verworpen of overschreven. Dat concept is tekst, en blijft meestal zonder gevolgen. Het wordt een ander verhaal zodra een model, tijdens het opstellen van zijn concept, al een bestand heeft aangepast: GitHub's eigen documentatie noemt dit met zoveel woorden als beperking, letterlijk vertaald: wijzigingen die een verworpen concept al had gemaakt, zoals file-edits, worden niet automatisch teruggedraaid.

Het mechanisme, stap voor stap bij een taak die drie samenhangende bestanden raakt (bijvoorbeeld een validatieregel die in een parser, een validator en een exportfunctie los wordt toegepast): een coding-agent werkt vaak toe naar een antwoord door al tussentijds in bestanden te schrijven, niet alleen door tekst te genereren die je achteraf plakt. Bij Cascade schrijft het efficiënte model zijn concept daarom meteen in alle drie de bestanden. Accepteert het beoordelende model dat concept zonder meer, dan is er niets aan de hand: de aanpassing in alle drie de bestanden is precies wat je eindantwoord ook is. Het wordt wel een probleem zodra het beoordelende model alleen de validator onvoldoende vindt en voor dát ene bestand escaleert naar een sterker model: dat sterkere model levert een nieuw antwoord voor de validator, maar de wijzigingen die het eerste, verworpen concept al in de parser en de exportfunctie had gemaakt, staan er dan nog steeds, los van wat het uiteindelijke antwoord over die twee bestanden zegt. Jij ziet alleen het eindantwoord over de validator, niet dat er in de andere twee bestanden al tussentijds iets anders is neergezet.

Doe dit daarom bij elke Cascade- of Critique-sessie die meer dan één bestand aanraakt: bekijk het volledige diff voordat je commit, niet alleen het laatste antwoord in de chat. Dat kost ruwweg een halve minuut per aangeraakt bestand. Niet nodig bij een Single-patroon op één bestand, want daar is er maar één model en dus geen verworpen concept dat al iets kan hebben gedaan. Verwacht dat dit bij een gewone bugfix op één bestand zelden iets oplevert. Bij een refactor over meerdere bestanden is het de controle die een stille, half uitgevoerde wijziging voorkomt. Zo'n wijziging duikt anders pas op zodra een latere test breekt, en dan zoek je in de verkeerde sessie. Hoeveel tijd dat kost, hangt van je codebase af; wij hebben daar geen gemeten cijfer voor, en Fusion is te nieuw voor eigen meetdata.

Het uitgewerkte voorbeeld: de diff-check die een verworpen concept zichtbaar maakt

Je hebt hiervoor geen testopstelling nodig. Draai dit op een taak die je toch al moest doen, en je ziet binnen tien minuten zelf of er een spoor van een verworpen concept in je werkmap staat. Begin met een schone werkmap (git status moet leeg zijn), zet de modelkiezer op Copilot Fusion met effort-niveau Standard, en geef een instructie die bewust meer dan één bestand raakt:

In deze repo wordt dezelfde validatieregel op drie plekken los
toegepast: in de parser, in de validator en in de exportfunctie.
Breng die drie op één lijn. Noem in je antwoord expliciet welke
bestanden je hebt aangepast en waarom.

Vraag daarna niets meer aan de chat, maar kijk naar je werkmap:

git diff --stat

Nu heb je twee lijsten: de bestanden die het antwoord in de chat noemt, en de bestanden die git diff --stat toont. Leg ze naast elkaar.

Wat je zietWat het betekentWat je doet
Beide lijsten zijn gelijkSingle, of Cascade zonder escalatie. Er is geen verworpen concept dat iets heeft achtergelatenNormaal reviewen en committen
Het diff toont een bestand dat het antwoord niet noemtDit is precies het spoor uit de valkuil hierboven: een eerder, verworpen concept heeft dat bestand al aangepast en dat is niet teruggedraaidOpen dat bestand apart en beoordeel die wijziging los van het eindantwoord. Hoort hij er niet, draai hem terug met git checkout -- <bestand>
Het antwoord noemt een bestand dat niet in het diff staatHet model beschrijft een wijziging die het niet heeft doorgevoerdNiet committen op basis van de uitleg; controleer wat er echt staat

De tweede rij is de hele reden voor deze oefening. Het eindantwoord is dan niet fout, het is alleen niet compleet: het beschrijft de validator en zwijgt over de parser en de exportfunctie, waar het eerste concept al had geschreven. In de chat is dat onzichtbaar, in git diff --stat niet.

Een voorbeeld: wat een Cascade-escalatie in de praktijk kost

Copilot Fusion toont nooit of een taak is geëscaleerd, dus je ziet dit normaal niet terug in een getal. Je kunt het wel zelf narekenen met de mechaniek die GitHub beschrijft: geen apart Fusion-tarief, je betaalt per model dat wordt aangeroepen. Een taak die in één keer slaagt (Single, of Cascade zonder escalatie) kost het efficiënte model één aanroep. Een taak die escaleert, kost twee aanroepen: het eerste, verworpen concept van het efficiënte model, plus het antwoord van het sterkere model dat daarna overneemt. Zonder escalatie is dat bij 50 taken in een week dus 50 aanroepen van het efficiënte model.

Neem aan (een inschatting die je met je eigen cijfers kunt vervangen, geen cijfer van GitHub zelf) dat bij een gemengde backlog van bugfixes en kleine features ongeveer één op de vijf taken op Standard in de praktijk zwaarder uitpakt dan hij vooraf lijkt, en dus escaleert. Bij diezelfde 50 taken in de week zijn dat 10 escalaties: 10 taken met 2 aanroepen (20 aanroepen) plus 40 taken met 1 aanroep (40 aanroepen), 60 aanroepen in totaal tegenover de 50 die je zou verwachten als je alleen het aantal taken telt. Dat is 20 procent meer modelaanroepen dan de kale taaktelling, en dat is precies het eerste meetpunt dat verderop in dit artikel staat: niet "de credits stegen", maar "de credits stegen met meer dan het escalatiepercentage dat je voor je eigen backlog had ingeschat". Stijgt het meer dan die 20 procent in dit voorbeeld, dan is dat het signaal dat Fusion op Standard vaker escaleert dan je dacht, en loont het om die specifieke taaksoort meteen op effort-niveau High te zetten in plaats van Standard te laten gokken.

Beslisregel: wanneer kies je Standard, High of Max?

Als dit geldtDan kies je ditWaarom de drempel daar ligt
Een losse functie, een kleine bugfix, of je weet nog niet of de taak zwaar isStandardZit in elk plan en kiest zelf via Cascade of een duurder model nodig is. Je betaalt dan alleen extra als de taak dat echt vraagt.
Een bug die meerdere bestanden raakt, of een wijziging die je vooraf al als "niet triviaal" bestempeltHigh, op Pro+ of hogerDe meerwaarde van Critique (meerdere modellen die elkaars werk tegen het licht houden) zit vooral in taken waar één model een detail in het andere bestand kan missen.
Een architectuurkeuze, een beveiligingsanalyse, of code waar een fout duur is om later terug te draaienMaxDit is het niveau waar Copilot de sterkste beschikbare modellen inzet, tegen de hoogste kosten per aanroep. Reserveer dit voor werk waar de kosten van een gemiste fout de extra credits ruim overtreffen.
Je team heeft geen Pro+ en twijfelt of de upgrade loontMeet eerst een week op Standard: tel hoeveel taken een tweede poging nodig hadden. Zet dat aantal naast de 29 dollar per gebruiker per maandReken je eigen terugverdienpunt uit in plaats van het te schatten: 29 dollar is ruim 27 euro, en bij een uurtarief van 50 euro is dat 33 minuten werk per maand (27 gedeeld door 50, maal 60). De upgrade loont dus zodra High of Max je per gebruiker meer dan een halfuur per maand bespaart. Hoeveel taken dat zijn, volgt uit je eigen telling, niet uit een vuistregel.

Welke modellen sluit je beheerder uit, en wat merk je daarvan?

Een organisatie kan, via beleid voor databeleid of FedRAMP-restricties, bepaalde modellen uitsluiten. Dat raakt Fusion direct: is geen van de modellen die Fusion zou gebruiken toegestaan, dan verdwijnt Copilot Fusion zelf uit de modelkiezer, zonder duidelijke foutmelding. Fusion is namelijk geen eigen model maar een laag die bestaande, toegestane modellen combineert. Zonder toegestaan model heeft die laag niets om te routeren.

Een voorbeeld: een financiële instelling staat om datalocatie-redenen maar een beperkte lijst modellen toe. Een developer daar ziet alleen "Choose your model" met die lijst, geen "Copilot Fusion". Een collega bij een bedrijf zonder restrictiebeleid ziet Fusion wel, op dezelfde Copilot-versie. Dat is dus geen storing. Zie je Fusion wel en een collega niet, vraag dan eerst je beheerder of het modelbeleid is aangescherpt, voor je een supportticket opent.

Info

Stand van zaken op 13 november 2026. Copilot Fusion is algemeen beschikbaar sinds 28 oktober 2026, in VS Code, de GitHub Copilot-app, Copilot CLI en JetBrains-IDE's. Pro kost 10 dollar, Pro+ 39 dollar per gebruiker per maand; High en Max vereisen Pro+ of hoger. Lokale modellen (zoals Mai Code 1.1 Flash) kunnen op Standard worden gebruikt, maar dat staat nog in public preview. Plannamen, prijzen en welke modellen meedoen wisselen regelmatig: check je eigen modelkiezer en abonnement voor je een upgrade overweegt.

Wat dit oplevert, en hoe je dat na zeven dagen meet

Wat je redelijkerwijs mag verwachten: op Standard verandert er voor dagelijkse taken weinig. De winst zit bij taken die voorheen tussen twee stoelen vielen: te zwaar voor je snelle model, te duur om er standaard je zwaarste model op te zetten. Wat niet beter wordt: een slecht afgebakende taak blijft slecht afgebakend, ook met Max.

Drie meetpunten, zonder extra tooling, een week nadat je Fusion aanzet voor je team:

Wat Copilot Fusion hier niet goed kan

Fusion kiest beter tussen modellen, maar beoordeelt niet of de taakomschrijving zelf goed is. Een vage opdracht ("maak de facturatie beter") krijgt op Max evengoed een vaag antwoord als op Standard: geen patroon controleert of de prompt genoeg context geeft, want elk patroon beoordeelt een antwoord tegen het gevraagde, niet tegen wat je eigenlijk bedoelde maar niet opschreef. Dat blijft jouw werk.

Fusion start ook geen subagents, zegt GitHub's documentatie met zoveel woorden: werk je al met een losse subagent-opzet, bijvoorbeeld via de Claude Agent SDK, dan blijft dat los van Fusion staan. En Fusion verandert niets aan wat je organisatiebeleid al toestaat: een uitgesloten model blijft uitgesloten.

Probeer dit vandaag

Draai de diff-check uit het uitgewerkte voorbeeld hierboven op een taak die je toch al moest doen. Schone werkmap, Copilot Fusion op Standard, een instructie die meer dan één bestand raakt, en daarna git diff --stat naast de bestandenlijst uit het antwoord. Dat kost tien minuten en laat je in één blik zien of Fusion op Single bleef of via Cascade escaleerde, en of er een bestand is aangeraakt dat niemand heeft genoemd.

Doe dit deze week

  1. Zet Fusion aan voor één terugkerende taakcategorie

    Kies de taaksoort die bij je team het vaakst terugkomt, zoals bugfixes in één module. Draai die een week op Standard en noteer per taak welk patroon je vermoedt (Single of Cascade) aan de hand van de reactietijd en of het antwoord er in één keer goed uitzag.

  2. Reken de upgrade naar Pro+ uit met je eigen cijfers

    Tel hoeveel taken deze week tegen hun grenzen aanliepen op Standard, en vergelijk dat aantal met de beslisregel hierboven: 29 dollar per gebruiker per maand tegenover een half uur bespaarde tijd per zware taak.

  3. Leg de diff-controle vast als teamregel bij Cascade en Critique

    Eén regel in je PR-sjabloon of code-reviewrichtlijn: bij elke Fusion-sessie die meer dan één bestand raakt, controleer het volledige diff voordat je commit. Dat vangt het spoor van een verworpen concept voordat het de hoofdbranch bereikt.

Het agent-recept dat je hiermee test: één terugkerende taaksoort, één week op Standard, met een vaste diff-check bij elke sessie die meer dan één bestand aanraakt. Wil je dit met je eigen team en codebase opzetten? In de Agent Sprint bouwen we dat samen op. Werk je liever met Claude Code naast GitHub Copilot, lees dan eerst AI code review: wat de tool mist en jij moet vangen.

AI-training

Wil je AI leren inzetten?

In onze praktische trainingen leer je hoe je ChatGPT, Claude en andere AI-tools effectief inzet voor jouw werk.

Bekijk trainingen

Bronnen

Veelgestelde vragen

  • Wat is GitHub Copilot Fusion?

    GitHub Copilot Fusion is een runtime-router die sinds 28 oktober 2026 algemeen beschikbaar is: in plaats van dat jij een vast model kiest, bepaalt Copilot per taak zelf welk model of welke combinatie van modellen die taak oppakt, via een van drie patronen (Single, Cascade of Critique).

  • Wat doen de Copilot Fusion effort levels Standard, High en Max?

    Standard balanceert kosten, kwaliteit en snelheid voor dagelijks werk en zit in elk plan. High zet gebalanceerde orchestratie in voor substantiële taken zoals een bug over meerdere bestanden. Max gebruikt de sterkste beschikbare modellen voor de diepste redenering. High en Max vereisen een Pro+ abonnement of hoger.

  • Wat kost GitHub Copilot Pro+ ten opzichte van Pro?

    GitHub Copilot Pro kost 10 dollar per gebruiker per maand, Pro+ kost 39 dollar. Dat is een verschil van 29 dollar per gebruiker per maand om bij de effort levels High en Max van Copilot Fusion te kunnen.

  • Is GitHub Copilot Fusion hetzelfde als Project HydraFusion?

    Project HydraFusion was de onderzoekspreview met multi-model orchestratie. Copilot Fusion is de algemeen beschikbare opvolger daarvan: dezelfde orchestratie, nu gecombineerd met automatische modelselectie en als vaste optie in de modelkiezer, niet meer als experimentele preview.

  • Kan GitHub Copilot Fusion ongewenste wijzigingen in mijn code achterlaten?

    Ja, in een specifiek geval. Bij het Cascade- of Critique-patroon kan een model tijdens het opstellen van een concept al bestanden aanpassen. Wordt dat concept daarna verworpen of overschreven door een sterker model, dan gaat die eerste bestandswijziging niet automatisch terug. Controleer daarom bij een sessie die meer dan één bestand raakt altijd het volledige diff voor je commit.

Tags
ai-agentsgithub-copilotsoftwareontwikkelingdevelopersmodelkeuze
Dennis Claassen

Geschreven door

Dennis Claassen

Oprichter en AI-trainer

Dennis is de oprichter van Project Impact en traint Nederlandse bedrijven in het effectief gebruiken van AI. Met jarenlange ervaring in tech en onderwijs helpt hij teams om AI praktisch toe te passen.

Meer over Dennis
Verder lezen

Gerelateerde artikelen.

Meer artikelen over dit onderwerp.

Microsoft Agent 365 spoort schaduw AI-agents zoals Claude Code op in het bedrijfsnetwerk
Nieuws

Schaduw AI-agents: zo ontdekt Microsoft of je team Claude Code gebruikt

Microsoft kondigde op 17 november 2026 aan dat Agent 365 nu 60 soorten lokale AI-agents herkent, waaronder Claude Code, OpenAI Codex en GitHub Copilot, ook als niemand ze ooit heeft aangemeld. Elke gevonden agent krijgt een eigen identiteit in Microsoft Entra. Met de grootste valkuil (verbieden in plaats van reguleren), een beslisregel voor wanneer je ingrijpt, en een geconstrueerd voorbeeld van hoe een te harde regel averechts werkt.

17 min lezen
Kantoormedewerker en een digitale agent die samen aan hetzelfde document werken op een scherm
Nieuws

Copilot Notebooks wordt Copilot Workspaces: wat werkt al, wat nog niet

Op Microsoft Ignite 2026 kondigde Microsoft aan dat Copilot Notebooks wordt opgevolgd door Copilot Workspaces, een gedeelde ruimte waarin mensen en agents samen aan een document werken. Home en Office in Copilot zijn sindsdien algemeen beschikbaar. Workspaces en Autopilot niet: die draaien nog alleen in het Frontier-programma, en Autopilot is bij de start zelfs alleen voor klanten in de Verenigde Staten. Wat dat concreet betekent voor een Nederlands team, en wat je deze week al wel kunt doen.

17 min lezen
Agent 365 Business Analytics: Microsofts nieuwe dashboard om te zien wat AI-agents per taak kosten
Nieuws

Agent 365 Business Analytics: grip op wat je AI-agents echt kosten

Microsoft kondigde op 17 november 2026, tijdens Microsoft Ignite, Agent 365 Business Analytics en Agent 365 Cost Management aan: een nieuwe laag die moet laten zien wat je AI-agents kosten, voor wie, en of dat zijn geld waard is. Met een echt gedraaid voorbeeld van een kostenbeleid dat op het eerste gezicht klopt maar een typische denkfout bevat, en de beslisregel voor wanneer je dit al nodig hebt.

16 min lezen

Een agent voor jullie eigen proces?

Kies een afgebakende taak en werk toe naar een agent met heldere bronnen, rechten en controle.

Bekijk de Agent Sprint