Een agent voor jullie eigen proces?
Kies een afgebakende taak en werk toe naar een agent met heldere bronnen, rechten en controle.
Dennis Claassen
AI-trainer · 35+ teams getraind
Key takeaways
- GitHub Copilot Fusion is sinds 28 oktober 2026 algemeen beschikbaar. In plaats van zelf een model te kiezen, kiest en combineert Copilot zelf welk model (of welke modellen) je taak oppakt.
- Drie patronen onder de motorkap: Single, Cascade en Critique. Een goedkoop model probeert het eerst, een duurder model controleert of grijpt in, of meerdere modellen leveren kritiek op elkaars concept.
- Standard zit in elk plan, High en Max vereisen Pro+ of hoger. Dat is 39 dollar per gebruiker per maand tegenover 10 dollar bij Pro, een verschil van 29 dollar.
- De grootste valkuil: een verworpen concept kan al bestanden hebben aangepast. GitHub's eigen documentatie zegt het met zoveel woorden: die wijzigingen gaan niet automatisch terug.
- Je beheerder kan modellen uitsluiten. Zonder een toegestaan model binnen je organisatiebeleid verdwijnt Fusion gewoon uit de modelkiezer.
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:
- Single. Eén model voert de taak in zijn geheel uit. Dit gebeurt bij taken die Copilot als eenvoudig genoeg inschat.
- Cascade. Een goedkoper, efficiënt model schrijft eerst een concept. Een apart beoordelend model accepteert dat concept, of escaleert naar een sterker model als het concept niet voldoet.
- Critique. Eén model schrijft een concept, meerdere modellen leveren daar parallel kritiek op, en het eerste model herschrijft op basis van die gecombineerde feedback.
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-niveau | Wat het doet | Vereist plan | Waarom de drempel daar ligt |
|---|---|---|---|
| Standard | Balanceert kosten, kwaliteit en snelheid voor dagelijks werk. Kiest meestal één model per taak. | Alle plannen, inclusief Free | Dagelijks werk (kleine fixes, losse functies) heeft geen zwaardere orchestratie nodig; een hoger niveau zou hier alleen meer credits kosten zonder een beter antwoord. |
| High | Gebalanceerde orchestratie voor substantiële, goed afgebakende taken, zoals een complexe bug of een wijziging over meerdere bestanden. | Pro+ of hoger | Multi-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. |
| Max | Frontier-niveau, met aandacht voor tokenefficiëntie, voor de diepste redenering en analyse. | Pro+ of hoger | Voor het zwaarste redeneerwerk zet Copilot de sterkste beschikbare modellen in. Dat is het duurst per aanroep, dus alleen beschikbaar vanaf hetzelfde plan als High. |
| Fast | Niet zelf te kiezen; alleen actief in VS Code inline chat. | Alle plannen | Inline 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 ziet | Wat het betekent | Wat je doet |
|---|---|---|
| Beide lijsten zijn gelijk | Single, of Cascade zonder escalatie. Er is geen verworpen concept dat iets heeft achtergelaten | Normaal reviewen en committen |
| Het diff toont een bestand dat het antwoord niet noemt | Dit is precies het spoor uit de valkuil hierboven: een eerder, verworpen concept heeft dat bestand al aangepast en dat is niet teruggedraaid | Open 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 staat | Het model beschrijft een wijziging die het niet heeft doorgevoerd | Niet 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 geldt | Dan kies je dit | Waarom de drempel daar ligt |
|---|---|---|
| Een losse functie, een kleine bugfix, of je weet nog niet of de taak zwaar is | Standard | Zit 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" bestempelt | High, op Pro+ of hoger | De 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 draaien | Max | Dit 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 loont | Meet eerst een week op Standard: tel hoeveel taken een tweede poging nodig hadden. Zet dat aantal naast de 29 dollar per gebruiker per maand | Reken 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:
- Hoeveel credits verbruikte je team deze week, tegenover een vergelijkbare week met een vast model? Vergelijk de stijging met het escalatiepercentage uit de rekensom hierboven. Ligt de stijging daar duidelijk boven, dan escaleert Fusion vaker dan je dacht.
- Hoe vaak werd er daadwerkelijk geëscaleerd? Dat zie je niet rechtstreeks, maar wel indirect: als dezelfde soort taak op Standard herhaaldelijk een tweede poging nodig heeft, is dat een signaal dat die taakcategorie thuishoort op High.
- Heeft een commit onverwachte, niet-toegelichte wijzigingen in een bestand dat niet in de uiteindelijke uitleg werd genoemd? Dat is precies het signaal van de valkuil hierboven: een spoor van een verworpen concept. Vind je dat, bekijk dan vanaf nu bij elke multi-file sessie het volledige diff voor je commit.
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
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.
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.
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.
Bronnen
- GitHub, GitHub Copilot Fusion. Officiële documentatie. Zelf geopend. Bron voor de drie patronen (Single, Cascade, Critique), de effort levels, lokale modellen in preview, en de beperking over niet-teruggedraaide file-edits bij een verworpen concept.
- GitHub, GitHub Copilot. Officiële productpagina. Zelf geopend. Bron voor de plan-prijzen (Free, Pro 10 dollar, Pro+ 39 dollar, Max 100 dollar) en de featurebeschrijving van Fusion ("Let Copilot choose").
- Microsoft, Visual Studio Code 1.144 release notes. Officiële release notes. Zelf geopend. Bron voor de exacte GA-datum van 28 oktober 2026 en de bevestiging dat Fusion de opvolger is van de eerdere Project HydraFusion-preview.
- Project Impact, AI-agent. Eigen uitleg van het onderliggende begrip dat in deze post wordt gebruikt.
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.




