Sakana Fugu en de opkomst van orchestration-first AI

Sakana Fugu is geen gewoon AI-model. Het is een signaal.

De centrale innovatie ligt niet in een nieuw monolithisch foundation model, maar in een orchestration layer die meerdere modellen dynamisch selecteert, aanstuurt, laat samenwerken, laat controleren en vervolgens één synthetisch antwoord produceert. Fugu presenteert zich naar buiten als één model-API, maar functioneert conceptueel als een multi-agent control plane.

Deze verschuiving is wezenlijk. De dominante AI-ontwikkeling van de afgelopen jaren was schaalvergroting: grotere modellen, grotere datasets, grotere contextvensters. Fugu laat een alternatief pad zien: performanceverbetering door runtime-compositie. Niet één model moet alles kunnen, maar een coördinator moet kunnen bepalen welke combinatie van modellen, rollen, prompts, tools en verificatiestappen nodig is voor een bepaalde taak.

De kernvraag: intelligentie van één model of van een systeem?

De meeste AI-discussies vertrekken vanuit een impliciete aanname: intelligentie zit in het model. Wie meer parameters, meer data en betere benchmarks heeft, wint.

Fugu betwist die aanname niet volledig, maar verschuift het zwaartepunt. De relevante vraag wordt: hoeveel intelligentie ontstaat uit het individuele model, en hoeveel uit de organisatie van meerdere modellen?

In menselijke organisaties wordt complexe probleemoplossing zelden bereikt door één universele expert. We gebruiken teams, rollen, specialisaties, reviewmechanismen en taakverdeling. Een ziekenhuis functioneert niet doordat één arts alles weet. Een SOC functioneert niet doordat één analist alle signalen verwerkt.

Fugu past dit principe toe op AI. Het systeem probeert niet één model alle rollen te laten vervullen, maar organiseert een runtime-samenwerking tussen modellen. De orchestrator wordt de nieuwe intelligentielaag.

Wat Fugu werkelijk is

Aan de buitenkant ziet de gebruiker één endpoint, OpenAI-compatible, waardoor bestaande tooling eenvoudig kan overschakelen. Aan de binnenkant bevindt zich geen enkelvoudig model, maar een orchestrator die een pool van modellen kan inzetten.

De productmatige elegantie zit in de abstractie. Gebruikers hoeven geen agent-framework te bouwen, geen modelrouter te configureren en geen planner-verifier-loop te ontwerpen. De complexiteit wordt verborgen achter één API.

Maar precies daar ontstaat ook de kernspanning. Wat voor ontwikkelaars een gemak is, kan voor governance een probleem zijn. Wanneer de runtime verborgen is, wordt het moeilijker om te weten welke modellen zijn gebruikt, welke data naar welke provider is gegaan en hoe het eindantwoord tot stand kwam.

Fugu is dus tegelijk een productinnovatie en een governance-provocatie.

TRINITY: rolgebaseerde modelcoördinatie

TRINITY is een van de belangrijkste conceptuele bouwstenen onder Fugu. Het gebruikt een lichte coördinator die meerdere LLM's over meerdere beurten aanstuurt via drie rollen:

Rol	Functie	Epistemische functie
Thinker	Analyseert de taak, maakt strategie, identificeert onzekerheden	Abductie: vormen van plausibele hypothesen
Worker	Voert concrete stappen uit: code, berekening, analyse	Constructie: produceren van artefacten
Verifier	Beoordeelt output op correctheid, volledigheid, consistentie	Falsificatie: zoeken naar fouten en aannames

De kracht van TRINITY zit niet in de complexiteit van de rollen, maar in de scheiding ervan. Veel LLM-systemen laten hetzelfde model plannen, uitvoeren én controleren. Dat vergroot het risico op correlated failure: dezelfde redeneerfout die tot een verkeerd antwoord leidt, besmet ook de zelfcontrole.

Dit principe is bekend uit high-assurance domeinen. In software scheiden we implementatie en code review. In security scheiden we detectie en validatie. In wetenschap scheiden we hypothese, experiment en peer review. TRINITY operationaliseert een vergelijkbare epistemische discipline binnen multi-model AI.

Conductor: orchestration leren in natuurlijke taal

Conductor gaat verder dan TRINITY. Waar TRINITY laat zien dat een lichte coördinator modellen kan aansturen, onderzoekt Conductor hoe een model via reinforcement learning kan leren om agenten in natuurlijke taal te orkestreren.

Traditionele multi-agent systemen zijn handmatig ontworpen: een engineer maakt een workflow met vaste rollen en prompts. Dat werkt in gecontroleerde situaties, maar is fragiel. Taken verschillen, modellen veranderen, contexten variëren.

Conductor doorbreekt deze rigiditeit. Het model leert niet alleen welk model moet worden ingeschakeld, maar ook hoe instructies moeten worden geformuleerd, hoe communicatie tussen agenten wordt georganiseerd en wanneer recursie nuttig is. Dit is een verschuiving van human-designed workflows naar learned workflows.

Een bijzonder interessant concept is recursive test-time scaling: de conductor kan zichzelf opnieuw inzetten als worker, waardoor geneste structuren ontstaan. Het systeem kan een taak decomponeren, een tussenresultaat beoordelen, een nieuwe subworkflow starten en iteratief verbeteren, vergelijkbaar met hoe menselijke experts complex werk aanpakken.

Maar recursie is gevaarlijk zonder begrenzing. Het kan leiden tot kostenexplosie, loopgedrag en moeilijk te reconstrueren besluitvorming. Wat in benchmarks werkt, moet in enterprisecontext worden omgezet naar gecontroleerde runtime-governance.

Fugu versus klassieke benaderingen

Fugu moet niet worden verward met bestaande patronen:

• Een klassieke router kiest één model op basis van taakclassificatie. Fugu organiseert een workflow van meerdere modellen, rollen en verificatiestappen.
• Mixture-of-Experts is een interne modelarchitectuur, de experts zijn onderdeel van hetzelfde netwerk. Fugu orkestreert externe, onafhankelijke modellen.
• Mixture-of-Agents stuurt dezelfde taak naar meerdere modellen en combineert antwoorden. Fugu past taakafhankelijke samenwerking toe: niet altijd een menigte, maar een gerichte workflow.

Fugu vertegenwoordigt een beweging van model selection naar task governance.

De governance-paradox

Fugu introduceert een fundamentele spanning: hoe autonomer de orchestration, hoe groter de functionele waarde, maar hoe moeilijker controleerbaarheid wordt.

Voor organisaties met accountability-verplichtingen zijn deze vragen essentieel:

• Welke onderliggende modellen zijn gebruikt?
• Welke data is naar welke provider gegaan?
• Welke verificatiestappen zijn uitgevoerd?
• Waarom is deze route gekozen?
• Hoe kan een fout worden gereconstrueerd?

Als deze vragen niet beantwoord kunnen worden, ontstaat een audit gap. Dat hoeft niet problematisch te zijn voor informele taken, maar wel voor sectoren waarin accountability verplicht is, denk aan overheidsbesluitvorming, medische diagnostiek, juridische analyse en financiële rapportage.

Een systeem dat uitstekende antwoorden produceert maar geen traceability biedt, is vergelijkbaar met een high-performing medewerker die geen dossiers, bronnen of besluitmotivering vastlegt. Nuttig, maar niet verantwoord inzetbaar in kritieke processen.

Zero Trust AI: geen agent impliciet vertrouwen

Fugu-achtige systemen vragen om een Zero Trust-benadering voor AI. Niet alleen netwerksegmentatie, maar een fundamenteel principe: geen enkel model, geen enkele agent, geen enkele tool en geen enkele contextbron wordt impliciet vertrouwd.

Een Zero Trust AI-architectuur bevat minimaal:

• Sterke identiteit per agentrol, elke rol heeft een eigen security context
• Least privilege voor contexttoegang, een worker ziet alleen wat hij nodig heeft
• Policy enforcement per taaktype, dataclassificatie vóór modelrouting
• Scheiding tussen planner, executor en verifier, geen enkele agent combineert deze rollen
• Logging van alle model- en toolcalls, volledige audit trail
• Bounded recursion, harde limieten op diepte, tokens en tijd
• Human approval voor high-risk acties, geen autonome beslissingen in kritieke domeinen

Dit is essentieel omdat agentische systemen anders te veel autonomie krijgen zonder equivalent controlemechanisme. Een agent die kan plannen, tools gebruiken, context ophalen én zijn eigen output goedkeuren, combineert te veel macht in één runtime. Dat is het AI-equivalent van een privileged service account zonder monitoring.

Orchestration-soevereiniteit: de nieuwe geopolitieke laag

Fugu wordt ook interessant tegen de achtergrond van geopolitieke AI-afhankelijkheid. Veel organisaties en landen zijn afhankelijk van een beperkt aantal Amerikaanse frontier providers. Exportcontrole, beschikbaarheidsrestricties en geopolitieke spanningen kunnen toegang beïnvloeden.

Een multi-model orchestrator kan deze afhankelijkheid verminderen, omdat het systeem kan werken met een swappable pool van modellen. Maar dit creëert een nieuwe afhankelijkheid: afhankelijkheid van de orchestrator zelf.

Daarom is modelsoevereiniteit niet genoeg. Organisaties moeten drie lagen begrijpen:

Soevereiniteitslaag	Vraag	Controlepunt
Modelsoevereiniteit	Welke modellen worden gebruikt?	Model allowlists/denylists, providerdiversiteit
Datasoevereiniteit	Waar staat data en hoe wordt die verwerkt?	EU data residency, verwerkersovereenkomsten
Orchestration-soevereiniteit	Hoe worden modellen, data en tools runtime gecombineerd?	Routinglogica, policy engine, audit trail

Fugu versterkt het besef dat de echte machtspositie niet alleen ligt bij wie het beste model bezit, maar bij wie de coördinatielaag beheerst.

De vijf lagen van volwassen AI-orchestration

Een volwassen Fugu-achtig systeem kan worden geanalyseerd in vijf lagen:

1. Interface abstraction, één uniforme API, verlaagt integratiecomplexiteit
2. Capability routing, taakclassificatie en modelselectie
3. Role-based collaboration, planner, executor, verifier, criticus, synthesizer
4. Adaptive learning, het systeem leert welke workflows werken voor welke taken
5. Governed orchestration, routing, policy, dataflows en risico's zijn zichtbaar, toetsbaar en auditable

Fugu is sterk in de eerste vier lagen. Laag vijf, governed orchestration, is waar de volgende volwassenheidsfase van de markt ligt. Voor enterprise-adoptie is transparantie geen nice-to-have, maar een vereiste.

Waarom orchestration de nieuwe moat wordt

De belangrijkste strategische les van Fugu is dat orchestration de nieuwe competitieve laag wordt.

Modellen blijven belangrijk, maar worden relatief meer uitwisselbaar. Er komen steeds meer sterke open en gesloten modellen. Organisaties zullen niet één model gebruiken, maar een portfolio. Het verschil ontstaat in de laag die bepaalt hoe deze modellen worden ingezet.

De moat verschuift naar: taakclassificatie, contextselectie, modelrouting, agentrolontwerp, toolintegratie, verification loops, policy enforcement, observability en continue evaluatie.

Dit verklaart waarom Fugu strategisch belangrijk is. Het product laat zien dat de markt niet alleen "betere modellen" wil, maar "betere georganiseerde intelligentie".

Conclusie: geen eindpunt, maar een richtingaanwijzer

Sakana Fugu is belangrijk omdat het laat zien dat AI-performance niet alleen voortkomt uit grotere modellen, maar uit betere organisatie van modellen. Het producteert een verschuiving van monolithische intelligentie naar orchestration-first intelligentie.

De onderliggende ideeën zijn krachtig. TRINITY toont dat rolgebaseerde coördinatie substantiële waarde heeft. Conductor laat zien dat orchestrationstrategieën zelf geleerd kunnen worden. Fugu brengt deze ideeën naar een productinterface.

Maar de enterprisevraag blijft scherp. Een systeem dat meerdere modellen dynamisch orkestreert, moet niet alleen goede antwoorden geven, het moet kunnen aantonen hoe die antwoorden tot stand kwamen. Zonder route-inzicht, policy evidence, datagovernance en auditability blijft de inzet beperkt tot lagere-risico contexten.

De toekomst ligt niet simpelweg in Fugu of in één ander model. De toekomst ligt in governed AI orchestration: model-agnostisch, policy-driven, traceable, verifier-first en ontworpen voor gecontroleerde autonomie.

Fugu is daarmee geen eindantwoord. Het is een duidelijke aanwijzing dat de volgende fase van AI niet draait om de vraag welk model wint, maar om wie de orchestration layer bestuurt.