Ik stond op het punt om de eerste repo níét te clonen.
Het was zondagochtend, ik had drie koppen koffie klaarstaan en een half-afgeschreven agent die steeds willekeurige tool-argumenten verzon, en mijn GitHub "Trending"-tab deed weer dat ding waarbij elk project op dezelfde screenshot lijkt — donkere terminal, paarse gradient, "autonomous" in de tagline. Ik was klaar om de browser te sluiten en mijn kapotte agent met Claude Code en brute kracht te fixen. Toen zag ik Hermes Agent, keek naar het geheugenarchitectuurdiagram, en dacht, wacht eens, dit zou zomaar het probleem kunnen oplossen waar ik nu met brute force tegenaan loop.
Zo begon deze post.
In de week daarna kloneerde ik zes open-source AI-projecten die in maart en begin april 2026 flink stegen in de GitHub trendinglijsten. Niet om ze te reviewen als een toerist die persberichten leest. Maar om ze echt op mijn eigen machine te draaien, kapot te maken, de stukken te testen die de README overslaat, en te zien welke het waard zijn om je weekend aan te besteden. Sommige veranderden mijn kijk op waar AI thuishoort (hint: niet altijd in een datacenter). Eén doet agent-geheugen op een manier die ik nu schaamteloos in mijn eigen stack aan het kopiëren ben. En één is een piepklein CLAUDE.md-bestand dat misschien wel het meest bruikbare is wat ik deze maand heb geïnstalleerd.
Voor we in de zes projecten duiken, eerst een kader dat me tijdens het testen steeds weer opviel: de interessante grens in open-source AI is op dit moment niet grotere modellen. Het is kleiner, meer gespecialiseerd, meer lokaal, en eerlijker over wat LLMs eigenlijk zijn. Elk project in deze lijst beweegt die kant op — weg van "één gigantisch cloudmodel doet alles" en richting "kleine stukjes, losjes gekoppeld, draaiend waar je daadwerkelijk werkt."
Laten we beginnen.
Waarom Deze Roundup Anders Is Dan De Velen Die Je Al Gelezen Hebt
Ik weet het. Weer zo’n “trending GitHub repos”-artikel. Ik scroll er zelf ook langs.
Het probleem met de meeste van deze roundups is dat ze rechtstreeks uit de README zijn geschreven. Iemand opent de repo, leest de vastgepinde beschrijving, pakt de screenshot, en parafraseert de featurelijst tot vijftien alinea’s AI-achtig proza. Je eindigt het artikel met nul idee hoe het daadwerkelijk is om het ding te gebruiken.
Ik heb het anders aangepakt. Voor elk van deze zes projecten heb ik drie dingen gedaan:
- De repo gekloond en lokaal aan de praat gekregen — of geïnstalleerd zoals een normale gebruiker dat zou doen (de edge gallery kwam op mijn iPhone, de Karpathy-skill ging als echte plugin in Claude Code).
- Eén concrete taak uitgevoerd die aansluit bij hoe ik het in echt werk zou gebruiken — niet de zorgvuldig gekozen demo uit de readme.
- Het eerste genoteerd dat kapot ging, verwarrend was, of niet overeenkwam met de marketing.
Dat derde punt is waar dit artikel zijn woorden waard is. De eerste twee dingen vind je op elk blog. Het derde punt is precies wat je een verspilde zaterdag bespaart.
Even een huishoudelijke mededeling: ik schrijf al een tijd over het open-source agent-ecosysteem, en een paar van deze projecten overlappen met onderwerpen die ik eerder heb behandeld — dingen als het agent skills-systeem van Claude Code, open-source Claude-alternatieven zoals OpenClaw, en multi-agent workflows beheren met Kanban-tools. Waar er een directe link is, verwijs ik je liever door naar het diepgaandere artikel dan alles opnieuw uit te kauwen.
Goed. Zes projecten. Laten we beginnen met degene die stilletjes het meest ontwrichtend is.
1. Google AI Edge Gallery — De App Store Voor Kleine LLM’s In Je Zak
De eerste keer dat je Google AI Edge Gallery installeert en je wifi uitzet, voelt het als een klein goocheltrucje.
Je opent de app. Je laadt een model — bijvoorbeeld een van de Gemma 4-varianten met een kleine voetafdruk uit de ingebouwde catalogus. Je tikt op "chat." Je typt een vraag. Het antwoord verschijnt. Geen spinner die wacht op een server. Geen "Verbinding controleren..."-banner. Geen tokenmeter ergens in de cloud die oploopt. Alleen een model, de chip van je telefoon, en een reactie.
Dat is de pitch, en het werkt echt.
Wat het eigenlijk is
AI Edge Gallery is een open-source referentie-app van Google — geschreven in Kotlin voor Android, Swift voor iOS — gebouwd bovenop LiteRT-LM, Google’s nieuwe high-performance inference engine voor het draaien van LLM’s aan de edge. Zie de gallery als een etalage en ontwikkeltool in één: een gepolijste eindgebruikersapp die je op je eigen telefoon kunt draaien, én een open-source codebase die je kunt forken, strippen en hergebruiken in je eigen mobiele AI-project.
De repo staat op google-ai-edge/gallery op GitHub. De iOS-versie is te vinden in de App Store als "Google AI Edge Gallery." En het belangrijkste om te weten: de volledige referentie-implementatie — modelselectie-UI, lokale inference, gestructureerde output, zelfs agentic tool-calls — staat gewoon in de codebase om te lezen.
Wat ik heb getest
Ik heb het in drie specifieke richtingen gepusht:
Test 1: Vliegtuigmodus, long-form generatie. Ik laadde een kleine Gemma-variant, zette mijn iPhone in vliegtuigmodus en vroeg om een release note van drie alinea’s te genereren op basis van een bulletlist. De respons was misschien 40% trager dan een cloud-call vanaf dezelfde plek, maar — en daar gaat het om — het gebeurde überhaupt, op een apparaat dat voor het netwerk een baksteen was. Voor onderweg schrijven waar privacy telt (medische notities, klantbriefings, alles wat je niet via een externe API wilt laten lopen), is dit nu al bruikbaar.
Test 2: Agentvaardigheden met tool-calls. Volgens de Google developers blog ondersteunt Gemma 4 aan de edge nu wat ze "agentic skills" noemen — grounding via Wikipedia, interactieve kaarten, samenvattingskaarten. Ik probeerde de Wikipedia-grounded flow en die werkte ongeveer zoals beloofd, al was de betrouwbaarheid van de tool-calls duidelijk minder dan ik gewend ben van grotere cloudmodellen. Prima voor een demo. Nog niet geschikt voor productie.
Test 3: De code forken naar mijn eigen mobiele project. Hier betaalt de gallery zich uit. Omdat het een echte, uitgebrachte referentie-app is, kun je precies zien hoe Google vindt dat on-device LLM-inference opgebouwd moet zijn — modelbeheer, geheugenafhandeling, promptconstructie, de hele stack. Ik heb een uur besteed aan het lezen van de inference pipeline en heb meer geleerd over praktische edge-AI-architectuur dan drie weken aan blogposts me hadden kunnen leren.
Wat er misgaat (of in elk geval, wat nog ruw is)
Twee eerlijke kanttekeningen. Ten eerste: de modellen die je vandaag realistisch op een telefoon kunt draaien zijn echt klein, en hun faalmodi zijn zichtbaar. Reken op zelfverzekerde onzin bij alles wat brede wereldkennis of meerstapsredenering vereist. Ten tweede: het agent-tool-calling pad is nieuw en nog wat fragiel — als het misgaat, gebeurt dat stilletjes, wat een slechtere faalmodus is dan een harde foutmelding.
De echte conclusie
On-device AI is niet langer "een leuke demo in een onderzoeksartikel." Het wordt nu geleverd, als open source, met een productieklare referentie-app die je direct kunt draaien. Elke mobiele ontwikkelaar die ik ken zou één avond moeten besteden aan het clonen van deze repo en het lezen van de inference code. De toekomst waarin elke app een klein lokaal model heeft dat 80% van het werk doet voordat er ooit een cloud-API wordt aangeroepen, is ineens een stuk dichterbij gekomen.
En dat was project één. Als de edge gallery draait om waar AI draait, gaat het volgende project over hoe we ervan leren.
2. DeepTutor — Open-Source, Agent-Native Leerassistent
Ik ga iets zeggen dat misschien oneerlijk klinkt tegenover ChatGPT: voor echt leren uit een document is het gewone chatvenster de verkeerde interface.
Je hebt dit vast zelf ervaren. Je uploadt een PDF, stelt vragen, krijgt antwoorden, maar je leert het document nooit echt. Er is geen structuur. Geen voortgang. Geen “dit heb je begrepen, dit is nog onzeker, hier is een oefenvraag om te testen.” Het document en de chat bestaan in twee verschillende universums, terwijl jij hectisch heen en weer kopieert.
DeepTutor, van het data science-lab van de Universiteit van Hong Kong, is de meest serieuze open-source poging die ik heb gezien om dit probleem op te lossen.
Wat het is
DeepTutor noemt zichzelf een “agent-native gepersonaliseerde leerassistent.” In gewoon Nederlands: het is een open-source multi-agent systeem, gebouwd rond het idee dat leren een workflow is, geen chat. Je uploadt PDF’s, TXT of Markdown. Het bouwt een doorzoekbare kennisbank. Vervolgens draaien er agents bovenop — één voor document Q&A met correcte bronvermeldingen, één voor het genereren van oefenvragen, één voor begeleide meerstaps leerpaden, één voor het bouwen van een kennisgrafiek die entiteit-relatie-mappingen over je materiaal heen legt.
Wat ik interessant vind: het onderhoudt een persistent “profiel” van jou — je doelen, je voorkeuren, je voortgang — en een doorlopende “samenvatting” van wat je geleerd hebt. Dit is de feedbackloop die chatinterfaces missen.
Volgens de beheerders haalde het project binnen de eerste week al meer dan 1.400 GitHub-sterren en blijft het groeien. Ik heb het huidige aantal sterren niet onafhankelijk geverifieerd, maar de activiteit op de repo is duidelijk zichtbaar.
Wat ik getest heb
Ik heb het getest op een stapel die ik zelf moest begrijpen: de Anthropic Agent SDK-documentatie plus twee lange technische PDF’s over geheugenarchitectuur voor agents. Ongeveer 180 pagina’s verdeeld over drie bestanden. Dit gebeurde er:
Ik uploadde de bestanden, wachtte op het indexeren (verrassend snel — minder dan twee minuten op een gemiddelde machine), en stelde een vraag waar ik al mee worstelde: “Wanneer treedt de memory compaction van de SDK in werking, en wat zijn de afwegingen tussen eager en lazy compaction?” Het antwoord kwam terug met specifieke verwijzingen naar de exacte passages in de PDF’s, geen vage parafrases. Dat alleen al was beter dan de standaard chat-met-PDF-ervaring die ik al tientallen keren had geprobeerd.
Daarna probeerde ik de oefenvragengenerator. Die produceerde vijf vragen op ongeveer het juiste niveau, waarvan er drie echt nuttig waren (de andere twee waren trivia). Het begeleide leerpad was waar DeepTutor echt uitblonk — het veranderde de drie documenten in een globaal lesplan met checkpoints.
Waar het tekortschiet
De installatie is zwaarder dan “even een app installeren.” Het is een open-source multi-agent systeem, wat betekent dat je modellen, omgevingsvariabelen en een lokale runtime moet configureren. Dit is een project voor ontwikkelaars en power users, niet voor je niet-technische vriend die gewoon een betere PDF-chat wil. Ook varieert de kwaliteit van de oefenvragen en de kennisgrafiek sterk, afhankelijk van het onderliggende LLM dat je gebruikt.
Waarom het ertoe doet
DeepTutor wijst op iets dat groter is dan zichzelf. De toekomst van “leren met AI” is niet een chatvenster dat op een PDF-viewer is geplakt. Het zijn doelgerichte agent-workflows waarbij de AI je doelen, je voortgang en het materiaal kent — en alles op elkaar afstemt. DeepTutor is een vroege, onvolmaakte, maar veelbelovende versie van die toekomst, en volledig open source. Als je lesgeeft, bijles geeft, cursusmateriaal schrijft, of gewoon slimmer wilt worden van je documentstapel, clone het.
Dat zijn twee projecten over waar AI leeft en hoe we ervan leren. Nu komen we bij het project dat stilletjes heeft veranderd hoe ik over agentgeheugen denk.
3. Hermes Agent — Een AI-agent die echt onthoudt
Oké. Dit is degene die mij mijn eigen agentarchitectuur heeft laten herzien.
Dit is het punt waar elke bouwer van open-source AI-agents uiteindelijk tegenaan loopt: geheugen. Je begint met een schone prompt, bouwt context op gedurende een sessie, en alles werkt. Dan probeer je de agent dingen te laten onthouden over meerdere sessies heen. Je eerste zet is om alles in de system prompt te proppen — eerdere gesprekken, gebruikersvoorkeuren, projectfeiten. Dat werkt. Tot het niet meer werkt. Tot de prompt uit zijn voegen barst, de kosten exploderen, de latency keldert, en het model vol vertrouwen dingen verkeerd begint te herinneren die het zou moeten weten.
Ik heb dit patroon een dozijn keer gezien. Ik heb dit patroon een dozijn keer gebouwd. Hermes Agent, van Nous Research, is het eerste open-source framework dat ik heb gevonden dat geheugen als een eersteklas architecturaal probleem behandelt en het oplost zoals het zou moeten: met gespecialiseerde, on-demand opvraagbare geheugenniveaus in plaats van prompt-stuffing.
Wat er daadwerkelijk in het geheugensysteem zit
Volgens de documentatie van het project draait Hermes op een meerlagige geheugenarchitectuur (de marketing noemt het soms drie lagen, soms multi-level — ik houd het bij wat de docs beschrijven). Minimaal maakt het onderscheid tussen:
- Sessiegeheugen — de standaard lopende context van de huidige interactie.
- Persistent geheugen — feiten, voorkeuren en projectdetails die sessies overstijgen.
- Skill-geheugen — wanneer de agent iets niet-triviaals oplost, schrijft hij een herbruikbaar "skill document" waarin staat hoe hij dat heeft gedaan, en dat document wordt een opvraagbaar item waar de agent later naar kan verwijzen.
Onder de motorkap gebruikt de persistente laag FTS5 full-text search plus LLM-gestuurde samenvatting. Dus in plaats van elk vorig gesprek in de prompt te proppen, haalt de agent alleen de relevante stukken op wanneer ze relevant zijn. Ook wordt dialectisch gebruikersmodelleren (geleend van Honcho) toegepast om een levend model van de gebruiker te behouden, in plaats van een statisch "over mij"-blokje.
Nous Research noemt dit "een agent die met je meegroeit." Op basis van wat ik heb getest, verdient die omschrijving het grotendeels.
Wat ik heb getest
Ik heb Hermes getest in een scenario dat ik goed ken: een langdurig codeerproject waarbij de agent architecturale beslissingen moet onthouden over meerdere sessies heen, zonder telkens opnieuw te worden geïnstrueerd. Ik gaf het een fictieve SaaS-codebasebeschrijving, voerde een ontwerpsessie, sloot de sessie af, kwam drie uur later terug en stelde een vervolgvraag die afhankelijk was van een eerdere beslissing.
Het werd onthouden. Niet door het hele vorige gesprek in context te houden — maar door het specifieke beslissingsdocument op te halen, het te tonen, en daar verder te gaan. Dat is het juiste gedrag, en het is de eerste keer dat ik een open-source agentframework dit zo netjes zie doen.
Ik heb ook de skill-generatielus getest: ik liet Hermes een redelijk complexe taak uitvoeren (het opzetten van een TypeScript CLI), en na afloop controleerde ik of het zichzelf een skill had geschreven. Dat had het. Het skill document was niet perfect — het was iets te specifiek voor de exacte taak die ik had opgegeven — maar de lus werkte. De volgende keer dat ik vraag om iets soortgelijks op te zetten, heeft het die skill om op terug te vallen.
Waar ik voorzichtig mee zou zijn
Hermes is jong, beweegt snel en de architectuur is ambitieus. Een paar dingen om op te letten: de kwaliteit van het ophalen hangt sterk af van hoe goed de FTS5-index is opgebouwd, skill-documenten kunnen rommel verzamelen als je ze niet af en toe opschoont, en omdat het systeem zelfmodificerend is (voegt over tijd skills toe), wil je de skill store behandelen als een code-repository — review wat het schrijft, vertrouw het niet blindelings.
Als je bezig bent met het bouwen van een persistente AI-agent, is dit het project om deze maand te lezen. Niet per se om direct volledig over te nemen, maar om van te leren. Het mentale model — geheugen als retrieval over gespecialiseerde lagen, niet als stuffing — is het juiste mentale model, en Hermes is de schoonste open-source implementatie die ik tot nu toe heb gevonden.
En dat leidt vanzelf tot het volgende probleem: als je eenmaal slimme agents hebt, hoe draai je er dan meer dan twee zonder gek te worden?
4. Multica — Projectmanagement voor teams van mensen en agenten
Ik moet iets bekennen. Maandenlang bestond mijn "multi-agent workflow" uit zes Claude Code-terminals in een tiling window manager, genaamd agent-1 tot en met agent-6, en een Notion-document dat ik handmatig bijwerkte als ik eraan dacht. Dat is geen workflow. Dat is een overlevingsstrategie.
Multica probeert precies dat probleem op te lossen.
Wat het is
Multica omschrijft zichzelf als "het open-source platform voor beheerde agents" — een orkestratie- en projectmanagementlaag voor AI-coderingsagents. In tegenstelling tot tools die zelf de agent willen zijn, wikkelt Multica zich om de agenten die je al gebruikt (Claude Code, Codex, OpenClaw, OpenCode — de daemon detecteert automatisch CLI’s op je PATH) en biedt het een Kanban-achtige interface waarmee je werk kunt toewijzen, volgen en coördineren.
De pitch in gewone taal: "behandel je codeeragents als teamgenoten." Je maakt een taak aan. Je wijst deze toe aan een agent. De agent pakt het op, rapporteert de status, markeert blokkades en werkt het bord bij terwijl hij bezig is. Jij krijgt een mission-control dashboard dat in realtime laat zien waar elke agent mee bezig is, en een taaklevenscyclus die weerspiegelt hoe menselijke engineeringteams daadwerkelijk werken.
Multica is zelf te hosten via Docker Compose of Kubernetes, en ze bieden ook een beheerde cloudversie aan als je geen eigen infrastructuur wilt draaien.
Wat ik getest heb
Ik draaide de zelfgehoste Docker Compose-versie op mijn ontwikkelmachine, koppelde het aan mijn lokale Claude Code-installatie, en gaf het drie kleine taken: een rate limiter toevoegen aan een Express API, een GitHub Action schrijven voor een Node-project, en een rommelige React-component refactoren. Standaardtaken die elke redelijke codeeragent zou moeten aankunnen.
Wat ik goed vond: het in realtime zien updaten van de Kanban-kolommen terwijl de agent tickets verschoof van "queued" → "in progress" → "needs review." Toen de agent vastliep op de React-refactor omdat de component vreemder was dan het ticket beschreef, markeerde hij een blokkade in plaats van stilletjes rommel te genereren. Dat is precies het gedrag dat je wilt van een beheerd systeem.
Wat minder was: de initiële setup duurde langer dan verwacht. De autodetectie van mijn Claude Code CLI werkte vlekkeloos, maar het laten communiceren van de runtime met mijn voorkeursprojectmap vereiste wat configuratie-aanpassingen. Niet moeilijk, maar ook niet "één klik".
Waar het uitblinkt — en waar niet
Multica blinkt uit als je daadwerkelijk meerdere agents parallel op gerelateerd werk inzet. Zodra je drie of meer agents over een project orkestreert, wordt iets als Multica niet alleen een "mooie UI", maar echt noodzakelijk. Als je één agent op één taak draait, is het overkill.
Ook goed om te benoemen: deze categorie raakt snel overvol. Vibe Kanban, Veritas Kanban, Mission Control dashboards, GitHub’s eigen Agent HQ — iedereen wil de "projectmanager voor agents" zijn. Multica’s pitch is open-source, zelf te hosten, multi-CLI. Als dat jouw eisen zijn, is het een sterke keuze. Ben je tevreden in een gesloten ecosysteem, dan heb je het misschien niet nodig.
Nog een interessante observatie: ik heb eerder geschreven over hoe Kanban-interfaces de standaard UI worden voor multi-agent systemen, en Multica is daar een goed voorbeeld van. De agent tooling-wereld heeft duidelijk besloten dat "tickets op een bord" de juiste abstractie is voor samenwerking tussen mens en AI, en ik denk niet dat dat snel zal veranderen.
Vier gehad. Volgende: een project dat helemaal niets met agents, geheugen of orkestratie te maken heeft, en op deze lijst staat omdat het iets veel simpelers doet. Een betaalde SaaS onderbieden.
5. OpenScreen (en vrienden) — Gratis Screen Studio, Geen Abonnementen
Screen Studio is een prachtige Mac-app. Het kost echter $29 per maand of een fors eenmalig bedrag, afhankelijk van welke versie je kiest, en dat is veel geld voor een schermrecorder, zelfs als deze automatisch inzoomt en cursoranimaties echt, echt goed doet.
De open-sourcegemeenschap, zoals je van open-source mag verwachten, keek hiernaar en zei: dat kunnen wij ook bouwen.
En dat deden ze. Meerdere keren zelfs.
Wat er daadwerkelijk beschikbaar is
De briefing voor dit artikel beschreef "Open Source Screen Studio" als één project, maar wat ik in april 2026 aantrof, lijkt meer op een klein ecosysteem van zeer vergelijkbare projecten die allemaal rond hetzelfde idee draaien:
- OpenScreen — het originele open-source alternatief voor Screen Studio. Geen abonnementen, geen watermerken, gratis voor commercieel gebruik.
- Recordly — een Mac/Windows/Linux-schermrecorder met auto-zoom, geanimeerde cursors, automatische ondertiteling. Bouwt substantieel voort op de basis van OpenScreen.
- Open Recorder — een Tauri + Rust-variant op hetzelfde idee, geoptimaliseerd voor klein en snel.
- Open ScreenStudio — weer een fork/variant, gericht op automatische zoom en vloeiende cursoreffecten.
Dat zijn vier open-sourceprojecten die in wezen hetzelfde doen, allemaal ontstaan in de afgelopen zes tot negen maanden. Wil je het nog breder trekken, dan bestaan de bewezen opties (OBS Studio, ShareX) nog steeds, maar die hebben niet de "gepolijste walkthrough-uitstraling" waar deze nieuwere projecten op mikken.
Wat ik getest heb
Ik installeerde OpenScreen en deed wat ik normaal in Screen Studio zou doen: een walkthrough van twee minuten opnemen van een terminalworkflow, met auto-zoom op klikgebeurtenissen en een zachte achtergrond achter het venster. Het resultaat was niet pixel-perfect identiek aan de output van Screen Studio, maar voor 90% van de toepassingen — tutorialvideo’s, Loom-alternatieven, productwalkthroughs — was het goed genoeg dat het verschil niet uitmaakte. En ik betaalde geen $29.
Recordly is degene die ik daadwerkelijk als eerste zou aanraden om te testen als je op een Mac werkt en de meest vergelijkbare ervaring zoekt; het is begin april 2026 de meest actief onderhouden van het stel.
Waarom deze projectcategorie ertoe doet
Dit gaat niet over schermopname. Het gaat over het patroon.
Elke categorie van betaalde creatieve SaaS — schermopname, schrijftools, designhulpmiddelen, notities, taakbeheer — krijgt nu een "gratis open-source alternatief gebouwd met Tauri of Electron in een weekend"-variant. Soms zelfs drie. De economie van gesloten consumentgerichte productiviteitssoftware wordt van onderaf onder druk gezet op een manier die twee jaar geleden nog niet bestond, en dat komt deels door AI: als een solodeveloper met Claude Code in een weekend een echte desktop-app kan bouwen, daalt de kostprijs van het klonen van een $29/maand-product richting nul.
Ik schrijf al langer over hoe AI SaaS-prijsmodellen verstoort en dit is precies dat patroon, maar dan in een specifieke categorie. Verwacht hier nog veel meer van.
Nog eentje te gaan. En dit is de kleinste repo op de lijst. En misschien wel mijn favoriet.
6. Karpathy-geïnspireerde Skills voor Claude Code — Het Kleine Bestand Dat De Slechtste Gewoontes van Mijn Agent Oploste
Andrej Karpathy is publiekelijk en herhaaldelijk uitgesproken over hoe de huidige generatie LLM’s op voorspelbare, specifieke manieren faalt bij het schrijven van code. De citaten die je moet onthouden zijn ongeveer: de modellen nemen verkeerde aannames voor je aan en gaan daar zonder te checken mee door. Ze gaan niet goed om met hun verwarring, zoeken geen verduidelijking, brengen inconsistenties niet naar voren, presenteren geen afwegingen, en bieden geen weerstand wanneer dat wel zou moeten.
Dat is nogal een diagnose. En Forrest Chang nam die diagnose en veranderde het in één enkel CLAUDE.md-bestand dat je in elk Claude Code-project kunt droppen.
Wat het is
andrej-karpathy-skills is in de kern één bestand. Het is een CLAUDE.md-configuratie, gedistilleerd uit Karpathy’s observaties over valkuilen van LLM’s bij coderen, verpakt als een Claude Code-plugin. Je installeert het, het leeft op project- of gebruikersniveau, en het herprogrammeert hoe Claude Code zich gedraagt bij de taken waar het het vaakst de mist in gaat.
De belangrijkste principes die het afdwingt:
- Doelgerichte uitvoering boven imperatieve instructies. In plaats van simpelweg “doe wat de gebruiker zegt”, wordt de agent gestimuleerd om het doel achter de instructie te begrijpen en het succes daaraan te toetsen.
- Chirurgische aanpassingen boven grootschalige herschrijvingen. Als je vraagt om een bug te fixen, fix die bug. Ga niet stiekem drie niet-gerelateerde bestanden refactoren terwijl je toch bezig bent.
- Aannames expliciet maken in plaats van er stilzwijgend naar handelen. Is er onduidelijkheid? Vraag het. Is er een afweging? Benoem die.
- Definieer verifieerbare succescriteria. Zeg niet alleen dat iets werkt. Draai het bewijs dat het werkt.
Geen van deze principes is revolutionair. Maar samen maken ze het verschil tussen een agent die je een uur bespaart en een agent die je drie uur kost.
Wat ik heb getest
Ik heb de plugin geïnstalleerd in mijn dagelijkse Claude Code-setup en mijn normale workflow een week lang gedraaid — bugfixes, kleine features, wat refactorwerk aan de merkensite. Twee dingen vielen direct op.
Ten eerste nam het probleem van overijverige refactors sterk af. Ik vroeg om een specifieke caching-bug in een Laravel-controller te fixen. Voor de plugin zou Claude Code “behulpzaam” ook de methodesignature herschrijven en drie niet-gerelateerde regels verplaatsen. Na installatie fixte het de bug, liet de rest met rust, en legde uit waarom.
Ten tweede — en dit is de belangrijkste — begon het betere vragen te stellen. Wanneer ik opzettelijk vage instructies gaf (als test), stopte het in plaats van te gokken en door te denderen, en vroeg welke interpretatie ik bedoelde. Alleen die gedragsverandering is de installatie al waard.
De eerlijke kanttekening
Dit is één configuratiebestand, geen framework. Het is zo goed als het LLM-model dat het aanstuurt, en het kan fundamentele modelbeperkingen niet oplossen — alleen eerlijker zichtbaar maken. Gebruik je Claude Code met een zwak basismodel, dan maakt deze plugin het minder roekeloos, niet slimmer. Gebruik je Claude Code met een sterk basismodel, dan is deze plugin een echte productiviteitsupgrade.
Ik schrijf al een tijd over Claude Code skills en hoe je je eigen bouwt, en dit is een uitstekend voorbeeld van het patroon in zijn meest minimale vorm. Het bewijst dat een echt goed geschreven skill-bestand waardevoller kan zijn dan een ingewikkelde plugin met custom tools.
Het patroon onder alle zes projecten
Na een week testen ben ik gaan zitten om te achterhalen wat deze zes projecten met elkaar gemeen hebben, behalve dan “open source” en “AI”. Dit is waar ik op uitkwam.
Ze wijzen allemaal het monoliet af. Google Edge Gallery laat zien dat AI niet in een datacenter hoeft te draaien. DeepTutor bewijst dat je leerworkflow niet in een chatvenster hoeft te zitten. Hermes toont aan dat het geheugen van je agent niet in de prompt hoeft te leven. Multica laat zien dat je multi-agent workflow niet in zes terminaltabs hoeft te draaien. OpenScreen maakt duidelijk dat je creatieve tools niet achter een abonnementsmuur hoeven te zitten. En de Karpathy skill bewijst dat het brein van je codeeragent niet één grote gok hoeft te zijn dat het model het goed doet.
Elk van deze projecten pakt een onderdeel van het mentale model “één groot AI-systeem doet alles” en breekt het op in kleinere, meer gespecialiseerde, meer open onderdelen. Dat is de echte trend. Niet een specifieke tool, model of benchmark — maar de ontleding van AI-workflows in onderdelen die je zelf kunt bezitten, wisselen en draaien.
Het andere patroon: geprononceerde specialisatie wint het van algemene veelzijdigheid. Hermes verslaat “prompt-stuffing Claude-klonen” niet omdat het een groter model is, maar omdat het een duidelijke visie heeft op geheugen. DeepTutor wint van “generieke chat-met-PDF” omdat het een uitgesproken visie heeft op leren. De Karpathy skills plugin wint van vanilla Claude Code omdat het een scherp beeld heeft van waar LLM’s tekortschieten. In een wereld waarin elk foundation model probeert zo algemeen mogelijk te zijn, komen de successen juist van agents en tools die zelfverzekerd en compromisloos gespecialiseerd zijn.
Als je in deze sector bouwt — zelfs als solodeveloper — is dat de belangrijkste les die ik op een post-it zou schrijven. Kies een visie. Wees gespecialiseerd. Probeer niet algemener te zijn dan de foundation models. Dat lukt je niet, en het hoeft ook niet.
Wat Ik Met Dit Alles Ga Doen
Hier is mijn eerlijke plan voor de komende twee weken, voor het geval je er iets aan hebt.
Ik neem de geheugenarchitectuur van Hermes als inspiratie en ga de geheugenlaag in mijn eigen agent-stack opnieuw opbouwen — specifiek de splitsing tussen sessiegeheugen, persistent geheugen en skill-geheugen. De Karpathy-skill is al geïnstalleerd in mijn dagelijkse Claude Code, en die ga ik er niet meer uit halen. Ik heb Multica draaien op een ontwikkelmachine voor een experiment waarbij ik vier codeeragents parallel laat werken aan een echt project. En ik ga een avond besteden aan het lezen van de inference-pijplijn van de Edge Gallery, gewoon om ervan te leren.
DeepTutor houd ik achter de hand voor een specifiek gebruiksscenario: wanneer ik de volgende keer diepgaand een lang technisch document moet bestuderen, is dat de tool waar ik naar grijp in plaats van weer een nieuwe ronde cloud chat.
OpenScreen vervangt inmiddels al mijn workflow voor schermopnames, wat — aangezien ik veel tutorials schrijf — stiekem de grootste wekelijkse tijdsbesparing op deze lijst is.
Jouw uitdaging voor het weekend, als je er een wilt: kies het project uit deze lijst dat aansluit bij een probleem dat je al hebt. Clone het. Laat het draaien. Breek het een keer. Kom terug en beslis of je het wilt houden. Dat is alles. Eén project, één weekend, één eerlijke test.
Want wat ik deze week heb geleerd — wat ik elke keer weer leer als ik zo’n deep dive doe — is dat lezen over tools niet hetzelfde is als ze daadwerkelijk gebruiken, en dat iemands workflow nooit verandert door alleen een blogpost te lezen. De projecten op deze lijst zijn interessant. Wat er gebeurt nadat je er één hebt gecloned, dáár draait het om.
Ga iets clonen.
Veelgestelde Vragen
Wat zijn de beste open-source AI-projecten op GitHub in april 2026?
De meest interessante open-source AI-projecten op dit moment zijn verdeeld over on-device inference (Google AI Edge Gallery, LiteRT-LM), agentgeheugen en orkestratie (Hermes Agent, Multica), leerworkflows (DeepTutor), alternatieven voor Screen Studio (OpenScreen, Recordly) en Claude Code skill-plugins (andrej-karpathy-skills). Voor een diepere blik op waarom elk van deze projecten ertoe doet, zie de zes projectbesprekingen hierboven.
Kan ik echt een LLM op mijn telefoon draaien zonder internet?
Ja. Google AI Edge Gallery, gebouwd op LiteRT-LM, draait open-weight kleine LLM’s zoals Gemma 4-varianten volledig on-device op iOS en Android. De prestaties zijn trager dan cloud-inferencing en de modellen zijn kleiner, maar voor privé, offline en latency-gevoelige toepassingen is het nu al productieklaar voor echte workflows.
Is Hermes Agent beter dan Claude Code of OpenClaw voor het bouwen van AI-agents?
Ze lossen verschillende problemen op. Claude Code en OpenClaw zijn codegerichte agentomgevingen; Hermes Agent is een algemeen inzetbaar agentframework met een gespecialiseerd multi-level geheugensysteem. Als je een langlopende persoonlijke agent bouwt die dingen over meerdere sessies moet onthouden, is de geheugenarchitectuur van Hermes het bestuderen waard — zie de Hermes-sectie hierboven voor de volledige uitleg.
Wat is het beste open-source alternatief voor Screen Studio?
Vanaf april 2026 is OpenScreen het originele open-source alternatief voor Screen Studio, terwijl Recordly de meest actief onderhouden fork is met de meeste feature-pariteit. Open Recorder (Tauri + Rust) is de lichtste optie. Alle drie zijn gratis, zonder abonnementen, en prima geschikt voor de meeste tutorial- en walkthrough-workflows.
Is de Karpathy Claude Code-plugin het installeren waard?
Voor dagelijkse Claude Code-gebruikers: ja. Het is één configuratiebestand dat chirurgische codewijzigingen afdwingt, aannames zichtbaar maakt en het probleem van te enthousiaste refactors vermindert — precies de LLM-coding-valkuilen waar Andrej Karpathy herhaaldelijk op heeft gewezen. Het is de installatie met de minste moeite en de meeste impact uit deze lijst.
Laten We Samenwerken
Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag verder.
- Fiverr (maatwerk & integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
