Ik draai Claude Code op gratis cloudmodellen — zo doe ik dat
Mijn GPU draaide op 94 graden Celsius, de ventilatoren klonken als een straaljager die zich klaarmaakte voor vertrek, en het 70B-parametermodel dat ik lokaal draaide was al negentien seconden bezig met het genereren van een enkel antwoord.
Negentien seconden. Voor één API-aanroep. In een agentische workflow die nog dertig tot veertig aanroepen nodig zou hebben om de taak af te ronden.
Ik had het grootste deel van een weekend besteed aan het werkend krijgen van lokale open-source modelinferentie met Claude Code. Het idee was aantrekkelijk — download krachtige open-source modellen, draai ze op je eigen hardware via Ollama, richt Claude Code op een lokaal endpoint, en geniet voor altijd van gratis onbeperkte AI. Geen API-kosten. Geen snelheidslimieten. Volledige privacy. De droomopstelling voor elke ontwikkelaar die zijn Anthropic-rekening heeft zien stijgen.
De werkelijkheid? Mijn M2 MacBook Pro met 32GB unified memory kon amper bijbenen met een gequantiseerd 70B-model. De antwoorden waren traag. De kwaliteit ging merkbaar achteruit door quantisatie. En de modellen die daadwerkelijk concurreren met cloudaanbiedingen — de 120B-parameterarchitecturen, de enorme mixture-of-experts-systemen — pasten niet eens in het geheugen zonder ze te reduceren tot een schim van hun volledige capaciteit.
Ik stond op het punt het hele concept van open-source modellen draaien met Claude Code op te geven, toen een collega een link in onze teamchat dropte. "Sla de lokale setup over," schreef hij. "Richt Claude Code op OpenRouter. Negenentwintig gratis modellen. Cloud-inferentie. Dezelfde agentische workflow."
Acht minuten later had ik Claude Code draaien op NVIDIA's Nemotron 3 Super — een 120B-parametermodel dat ik niet eens lokaal kon laden — en genereerde een complete SaaS-landingspagina op cloudsnelheid. Gratis.
Dat was drie weken geleden. Sindsdien heb ik lokale inferentie niet meer aangeraakt.
Waarom lokale inferentie voor mij mislukte (en waarschijnlijk ook voor jou)
Ik moet uitleggen waarom ik lokale modellen heb opgegeven, want als je dit leest, heb je waarschijnlijk dezelfde route overwogen. Of je bent er nu mee bezig en kijkt hoe je laptop in een ruimteverwarming verandert.
De rekensom klopt gewoon niet voor de meeste consumenten-hardware.
Kleine modellen — 7B en 13B parameters — draaien prima lokaal. Ze zijn snel, passen in het geheugen en belasten je machine niet. Maar hun outputkwaliteit voor echt ontwikkelwerk is matig. Vraag een 7B-model om een 200-regelige Express.js-handler te refactoren naar nette modules, en je krijgt iets dat technisch werkt maar structureel leest als huiswerk van een eerstejaars informatica-student. De variabelenamen zijn generiek. De foutafhandeling ontbreekt of is klakkeloos gekopieerd. De architecturale beslissingen zijn oppervlakkig.
De modellen die echt bruikbare code produceren beginnen bij 70B parameters. En 70B is waar consumenten-hardware begint te zwoegen. Op mijn M2 met 32GB unified memory gaf een 4-bit gequantiseerd Llama 3.3 70B-model via Ollama me responstijden van 12-20 seconden per generatie. Dat is per enkel antwoord. Claude Code's agentische workflows schakelen tientallen van deze aanroepen achter elkaar — planning, codegeneratie, bestandsschrijfacties, testuitvoering, foutcorrectie. Bij 15 seconden per aanroep over 30 aanroepen duurt een taak die 4 minuten kost op cloud-inferentie lokaal 7-8 minuten. Dat verschil stapelt zich over een werkdag op tot uren verloren productiviteit.
En dat is het beste scenario. De 120B+-modellen die echt concurreren met betaalde cloudaanbiedingen? Mijn machine kan ze helemaal niet draaien. Niet op volledige precisie. Zelfs niet met agressieve quantisatie. Je hebt minimaal 64GB+ RAM nodig, en zelfs dan ruil je substantiële kwaliteit in voor het privilege om het lokaal te draaien.
Ik heb ooit een vier uur durende codeersessie op lokale inferentie gedraaid, gewoon om te zien hoe langdurig gebruik voelde. Mijn batterij ging van 100% naar 12%. Het laptopbehuizing was te warm om op mijn benen te leggen. De energiekosten overtroffen waarschijnlijk wat de equivalente cloud-API-aanroepen me gekost zouden hebben.
Lokale inferentie is een fascinerende technische oefening. Voor dagelijks ontwikkelwerk met modellen die krachtig genoeg zijn om nuttig te zijn? Cloud-inferentie via een dienst als OpenRouter is het praktische antwoord.
Wat OpenRouter doet (en waarom er 29 gratis modellen bestaan)
OpenRouter is een API-routeringslaag die zich bevindt tussen je ontwikkeltool en tientallen modelproviders. Eén API-sleutel, één endpoint, toegang tot 400+ modellen van OpenAI, Google, Meta, Mistral, NVIDIA, Anthropic en meer.
Het deel dat ertoe doet voor dit artikel: OpenRouter onderhoudt een gecureerde collectie van volledig gratis modellen. Per maart 2026 zijn 29 modellen beschikbaar tegen nul kosten — geen creditcard nodig, geen proefperiode, geen addertje behalve snelheidslimieten.
Waarom zou iemand 120B-parametermodellen gratis aanbieden? Twee redenen.
Ten eerste brengen bedrijven als NVIDIA en Meta open-source modellen uit als strategische investering. NVIDIA's Nemotron 3 Super is niet gratis omdat NVIDIA zich vrijgevig voelt — het is gratis omdat brede adoptie de vraag naar NVIDIA's trainingsinfrastructuur en cloudcomputingdiensten stimuleert. Meta's Llama-modellen dienen hetzelfde doel voor hun AI-ecosysteem. Het model is het verliesproduct. De infrastructuur is het bedrijf.
Ten tweede subsidieert OpenRouter gratis modeltoegang als groeistrategie. Gratis gebruikers worden betalende gebruikers wanneer hun behoeften opschalen. Het is hetzelfde draaiboek dat GitHub, Vercel en elk succesvol ontwikkelaarstool hebben gevolgd — geef genoeg waarde weg om gewoonte te creëren en vang dan inkomsten wanneer het gebruik groeit.
Het resultaat voor ons: legitieme, cloud-gehoste, volledig-precisie modellen draaiend op echte GPU-infrastructuur, toegankelijk via een simpele API — zonder een cent te betalen.
Hier is het cruciale inzicht dat dit relevant maakt voor Claude Code specifiek: de kracht van Claude Code zit in het agentframework, niet in het model. De planningsengine, de bestandssysteemtoegang, de shellcommando-uitvoering, de sub-agentcoördinatie, het webzoeken, de codeverkenning — dat is allemaal infrastructuur op frameworkniveau. Het werkt ongeacht welk model de redenering levert. Vervang Anthropic's Opus door NVIDIA's Nemotron 3 Super, en Claude Code leest nog steeds bestanden, schrijft code, draait tests en voert terminalcommando's op precies dezelfde manier uit.
De intelligentie verandert. De mogelijkheden niet.
Die scheiding is de complete basis van wat ik je nu ga uitleggen.
De complete setup: minder dan tien minuten, van begin tot eind
Ik geef je de exacte stappen die ik heb gevolgd, inclusief de debugfout die me tien extra minuten kostte. Als je mijn fout overslaat, draai je binnen acht minuten.
Stap 1: Controleer of Claude Code is geïnstalleerd
Als je Claude Code al hebt, ga naar Stap 2. Zo niet:
npm install -g @anthropic-ai/claude-code
Of op macOS via Homebrew:
brew install claude-code
Verifieer met claude --version. Als je Claude Code nog nooit hebt gebruikt, behandelt mijn beginnersgids alles van installatie tot je eerste build.
Stap 2: Maak een gratis OpenRouter-account aan
Ga naar openrouter.ai en meld je aan. E-mail en wachtwoord — geen creditcard nodig voor de gratis laag.
Navigeer naar het gedeelte API Keys in je dashboard. Klik op Create Key. Kopieer de sleutel meteen — hij begint met sk-or-v1- en OpenRouter toont hem niet meer nadat je de pagina verlaat.
Stap 3: Stel drie omgevingsvariabelen in
Open je shellconfiguratiebestand. Op macOS (de standaard zsh-shell) is dat ~/.zshrc. Op Linux met bash, ~/.bashrc. Voeg deze drie regels toe:
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="sk-or-v1-your-actual-key-here"
export ANTHROPIC_API_KEY=""
Die derde regel — de lege ANTHROPIC_API_KEY — lijkt zinloos. De eerste keer sloeg ik hem over. Slechte beslissing.
Dit is wat er gebeurt zonder: als je Claude Code eerder hebt geauthenticeerd met een Anthropic-account (wat de meeste gebruikers hebben gedaan), cachet Claude Code die inloggegevens. Wanneer zowel een Anthropic-sleutel als een OpenRouter-token tegelijk bestaan, weet Claude Code niet welke voorrang heeft. Verzoeken falen met cryptische authenticatiefouten of — de sluipende foutmodus — slagen maar worden via Anthropic's betaalde API gerouteerd, waardoor je stilletjes je tegoed verbrandt terwijl je denkt dat je op de gratis laag zit.
Het instellen van ANTHROPIC_API_KEY op een lege string vertelt Claude Code expliciet om gecachte Anthropic-inloggegevens te negeren en alles via de opgegeven basis-URL te routeren.
Nog één stap als je eerder was ingelogd: Start Claude Code en voer /logout uit binnen de sessie. Dit wist het OAuth-token van de browsergebaseerde authenticatiestroom. Zonder dit kan het gecachte OAuth-token je omgevingsvariabelen overschrijven.
Stap 4: Kies je gratis model
Blader door OpenRouter's pagina met gratis modellen en kies een model. Ik vertel je welke je moet kiezen in het volgende gedeelte, maar technisch gezien stel je het zo in:
Voeg deze regel toe aan je shellprofiel:
export ANTHROPIC_DEFAULT_SONNET_MODEL="nvidia/nemotron-3-super:free"
Dit vertelt Claude Code welk model te gebruiken voor zijn primaire redeneertaken. Vervang de modelidentificatie door elk gratis model-ID uit OpenRouter's catalogus — elke modelpagina heeft een kopieerknop voor de exacte string.
Stap 5: Herlaad en verifieer
Source je bijgewerkte profiel:
source ~/.zshrc
Of open gewoon een nieuw terminalvenster. Start dan Claude Code in een willekeurige projectdirectory:
claude
Voer /status uit binnen de sessie. Je zou je gekozen model als actief moeten zien en het API-endpoint naar OpenRouter moeten wijzen. Als je nog steeds een Anthropic-model of -endpoint ziet, controleer dan de lege API-sleutel en de /logout-stap.
Dat is de complete setup. Elke prompt, elke agentactie, elke sub-agentaanroep wordt nu via OpenRouter naar je geselecteerde gratis model gerouteerd.
Welk gratis model moet je eigenlijk gebruiken? Ik heb er vijf getest.
Dit is waar de meeste OpenRouter-gidsen stoppen — "zo maak je verbinding, succes met het kiezen van een model." Dat is niet behulpzaam. Het verschil tussen het juiste gratis model kiezen en het verkeerde is het verschil tussen een productieve middag en een frustrerende.
Ik heb een week lang vijf gratis modellen door dezelfde reeks echte ontwikkeltaken gehaald. Geen synthetische benchmarks. Echt werk dat ik normaal met Opus of Sonnet zou doen.
De testbatterij:
- SaaS-landingspagina genereren — volledige pagina met hero, features-raster, prijzentabel, footer. Tailwind CSS. Responsive.
- Code refactoren — neem een rommelige 200-regelige Express.js-routehandler en refactor naar schone, gescheiden modules.
- Bugdiagnose — geef foutlogs en een codefragment met een subtiele async/await-timingbug. Vind en repareer hem.
- Meerstaps agentische taak — onderzoek actuele cloudopslagprijzen, maak een vergelijkingstabel, sla op als markdownbestand. Dit test tool calling, webzoeken en bestandsoperaties.
NVIDIA Nemotron 3 Super — Mijn dagelijkse gratis model
Dit is hem. Als je maar één gratis model gaat configureren, maak het dit.
Nemotron 3 Super is een 120B-parameter mixture-of-experts-model dat slechts 12B parameters per verzoek activeert. Die architectuurkeuze is waarom het gratis kan worden aangeboden terwijl het toch output levert die echt concurreert met betaalde modellen. Volgens NVIDIA's technisch rapport bereikt het tot 2,2x hogere inferentiedoorvoer dan vergelijkbare 120B-modellen zoals GPT-OSS, dankzij de hybride Mamba-Transformer-architectuur.
Het contextvenster van 262K tokens is enorm voor een gratis model — groot genoeg om substantiële codebases te bevatten zonder afkapping.
Landingspaginatest: Genereerde een complete, responsive pagina met een samenhangend kleurenschema, correcte Tailwind-klassen en tekst die niet las als Lorem Ipsum met grootheidswaanzin. De componentstructuur was schoon genoeg om direct in een echt project te plaatsen met kleine aanpassingen aan de witruimte.
Refactoringtest: Hier verraste Nemotron me. Het identificeerde de voor de hand liggende extractiepunten — aparte validatie, databasequery's eruit halen — maar ontdekte ook een race condition in de originele code die ik er opzettelijk in had gelaten als valkuil. Het vond hem. Niet elk model doet dat.
Bugdiagnose: Identificeerde het async-timingprobleem correct bij de eerste poging, legde het mechanisme helder uit en leverde een oplossing met goede foutafhandeling. Solide.
Agentische taak: Functioneel maar wat ruw aan de randen. Het model maakte correcte toolaanroepen — webzoeken, bestandscreatie — maar de opmaak van de vergelijkingstabel had handmatige opschoning nodig. De onderzoeksinhoud was accuraat.
De responssnelheid was gemiddeld 3-4 seconden per generatie. Vergeleken met de 15-20 seconden die ik kreeg van lokale inferentie op een kleiner model, voelde cloud-gehost Nemotron als overschakelen van inbelinternet naar breedband.
Qwen3 Coder 480B — De codespecialist
Momenteel het sterkste gratis codeermodel op OpenRouter, met een contextvenster van 262K tokens en benchmarks die het bijna bovenaan plaatsen voor codegeneratietaken.
Bij de landingspagina- en refactoringtests presteerde Qwen3 Coder iets beter dan Nemotron — strakkere code, minder onnodige commentaren, betere variabelenamen. De bugdiagnose was vergelijkbaar. Waar het afviel was de algemene agentische taak. Vraag het om informatie buiten pure codegeneratie te onderzoeken en samen te vatten, en de kwaliteit daalt merkbaar.
Als je werk voor 90%+ uit codegeneratie bestaat, is Qwen3 Coder misschien de betere standaard. Voor gemengde workflows die onderzoek, documentatie en algemeen redeneren naast coderen omvatten, wint Nemotron's veelzijdigheid.
Ik houd Qwen3 Coder beschikbaar als secundair model:
export CLAUDE_CODE_ALTERNATE_MODEL="qwen/qwen3-coder-480b:free"
Llama 3.3 70B — De betrouwbare terugvaloptie
Meta's Llama 3.3 70B is de Toyota Corolla onder de gratis modellen. Niets eraan zal je opwinden. Niets eraan zal je frustreren ook.
Het doorstond alle vier de tests adequaat. De landingspagina was functioneel maar visueel eenvoudig. De refactoring was correct maar conservatief — het vond de race condition niet. De bugdiagnose was accuraat maar de uitleg miste diepgang. De agentische taak werd zonder problemen afgerond.
Als Nemotron 3 Super uit de gratis laag wordt geroteerd (modellen wisselen periodiek), is Llama 3.3 70B mijn directe terugvaloptie. Voorspelbare consistentie heeft echte waarde wanneer je afhankelijk bent van een gratis laag.
GPT-OSS 120B — Briljant en onbetrouwbaar
OpenAI's open-source 120B-model produceerde de op zichzelf beste landingspagina-output uit mijn gehele testbatterij. Strakke lay-out. Doordachte micro-interacties. Tekst die echt overtuigend aanvoelde.
Daarna draaide ik dezelfde prompt opnieuw en kreeg een pagina met kapotte flexbox, hardgecodeerde pixelwaarden en een prijzentabel die op mobiel overlapte.
Die inconsistentie is een dealbreaker voor agentische workflows. Een enkel slecht antwoord in een agentketen kan doorwerken — het model schrijft een buggy bestand, de volgende stap probeert op dat buggy bestand voort te bouwen, en opeens zit je drie iteraties diep in opgestapelde fouten. Ik zou GPT-OSS gebruiken voor eenmalige generaties waarbij ik de output direct kan controleren. Voor meerstaps agentwerk is de variatie te hoog.
openrouter/free (de auto-router) — Niet aan beginnen
OpenRouter biedt een meta-optie genaamd openrouter/free die automatisch selecteert uit beschikbare gratis modellen op basis van je verzoek. Ik heb het een dag getest.
Het probleem: je weet nooit welk model elk verzoek afhandelt. Het ene antwoord komt van Nemotron, het volgende van iets totaal anders met andere sterktes, andere eigenaardigheden, andere outputformattering. Voor een losse chatvraag is het prima. Voor een coherente meerstaps agentische workflow waar consistentie tussen aanroepen ertoe doet, creëert het chaos. Sla het over.
Wat echt werkt op gratis modellen (en wat niet)
Claude Code's agentische mogelijkheden zijn features op frameworkniveau — ze werken onafhankelijk van het achterliggende model. Maar de kwaliteit waarmee het model die mogelijkheden aanstuurt, verschilt. Dit is wat ik vond na drie weken dagelijks gebruik.
Werkt perfect:
Bestandssysteemoperaties. Lezen, aanmaken, bewerken, verwijderen van bestanden. Het model bepaalt de inhoud; Claude Code handelt de bestandssysteeminteractie af. Geen verschil met betaalde modellen.
Shellcommando-uitvoering. Paketten installeren, buildscripts draaien, testsuites uitvoeren, Git-status controleren. Het model bepaalt welke commando's worden uitgevoerd; de agent voert ze uit. Gratis modellen presteren hier bij duidelijk gedefinieerde taken net zo betrouwbaar als Opus.
Ingebouwd webzoeken. Claude Code's webzoekfunctie werkt via het agentframework ongeacht het achterliggende model. Ik gebruikte Nemotron om API-documentatie te onderzoeken, npm-pakketversies te controleren en actuele prijsgegevens te verifiëren. Zoekresultaten komen identiek terug — het model hoeft alleen redelijke zoekopdrachten te formuleren en resultaten samen te vatten.
Codeverkenning en bestandsontdekking. Glob-patronen, projectstructuuranalyse, afhankelijkhedenmapping. Mogelijkheden op frameworkniveau die onafhankelijk van modelkwaliteit werken.
Geplande prompts. Het opzetten van Claude Code om terugkerende taken te draaien — dagelijkse rapporten, geautomatiseerde controles, periodieke codebeoordelingen — werkt op gratis modellen. Hier worden de kostenbesparingen het meest dramatisch. Een geplande taak die vier keer per dag draait tegen nul kosten versus $0,30-$0,50 per run op een betaald model bespaart $36-$60 per maand op een enkele terugkerende taak.
Werkt met kanttekeningen:
Complexe meerstaps planning. Gratis modellen handelen 4-5 stapsplannen netjes af. Daarboven worden stappen overgeslagen, valt de volgorde uit elkaar, of vergeet het model wat het al heeft gedaan. De oplossing: wees explicieter. In plaats van "bouw een compleet authenticatiesysteem," splits de taak zelf op — "Maak eerst het gebruikersmodel. Bouw dan het registratie-endpoint. Bouw dan het login-endpoint met JWT." Meer structuur in de prompt compenseert voor minder planningscapaciteit in het model.
Sub-agentcoördinatie. Claude Code kan sub-agenten spawnen voor parallelle taken. Met gratis modellen werkt de uitvoering, maar de synthese wordt rommelig — de primaire agent negeert soms sub-agentoutput of voegt resultaten incoherent samen. Ik vermijd complexe sub-agentworkflows op gratis modellen tenzij de subtaken echt onafhankelijk zijn.
Werkt niet goed:
Architectureel redeneren over grote codebases. Ondanks Nemotron's contextvenster van 262K tokens is de kwaliteit van bestandsoverstijgend redeneren merkbaar zwakker dan Opus. Het model kan de context fysiek bevatten maar redeneert niet met dezelfde diepgang over afhankelijkheden tussen bestanden, ontwerppatronen en architecturale implicaties. Voor werk aan enkele bestanden of kleine projecten is het verschil nauwelijks merkbaar. Voor een monorepo met 50 bestanden en complexe afhankelijkheidsketen voel je het direct.
Git-geschiedenismanipulatie. Basisoperaties — commit, push, branch aanmaken — werken prima. Interactieve rebase, merge-conflictoplossing, multi-commit squash-workflows? Gratis modellen worstelen met de nuance en precisie die hiervoor nodig zijn. Ik leerde dit op de harde manier toen een gratis model een slecht beredeneerde force push probeerde. Houd Git-complexiteit op betaalde modellen.
De snelheidslimieten: echte cijfers en hoe ermee om te gaan
De gratis laag geeft je 200 verzoeken per dag en 20 verzoeken per minuut. Die cijfers klinken ruim tot je een agentische workflow in actie ziet.
Een enkele Claude Code-taak als "maak een React-component met tests" kan intern 5-30 API-aanroepen genereren. Planningsaanroepen. Codegeneratie-aanroepen. Bestandsschrijfaanroepen. Testuitvoeringsaanroepen. Foutcorrectie-aanroepen. Een middag actief ontwikkelen brandt sneller door 200 verzoeken dan je zou verwachten.
Strategie 1: Bundel je werk. In plaats van Claude Code sporadisch door de dag heen te gebruiken, concentreer ik gratis-modelsessies in gerichte blokken. Ochtend: componenten scaffolden en tests schrijven. Middag: onderzoek en documentatie. Zo blijf ik ruim binnen de dagelijkse limiet.
Strategie 2: De $10-stortingstruc. OpenRouter heeft een slim mechanisme — houd minimaal $10 aan tegoed op je account aan, en je dagelijkse verzoeklimiet springt naar 1.000, zelfs voor gratis modellen. Je geeft dat tegoed niet uit aan gratis modelverzoeken. Het blijft als saldo staan. Zie het als een restitueerbare borg die je capaciteit vervijfvoudigt. Bij 1.000 verzoeken per dag ben ik nog nooit in de buurt van de limiet gekomen tijdens een volledige werkdag.
Strategie 3: Hybride routering. Ik bewaar mijn Anthropic-inloggegevens in een apart shellprofiel. Wanneer ik Opus-niveau redenering nodig heb of wanneer ik mijn gratis limiet nader op een drukke dag, source ik het Anthropic-profiel en schakel terug. Ik schreef over dit soort strategische modelallocatie in mijn gids voor AI-agent kostenoptimalisatie. De sleutel is voor je aan een taak begint beslissen of het een betaald model nodig heeft of een gratis — halverwege wisselen verspilt context.
Strategie 4: Monitor in realtime. OpenRouter's dashboard toont je verzoektelling live. Ik controleer het halverwege de middag. Als ik op 150/200 sta, verschuif ik resterende taken naar betaalde modellen in plaats van het risico te lopen tijdens iets belangrijks tegen de muur te lopen.
De build die me overtuigde: een SaaS-landingspagina in zes minuten
Theorie is leuk. Bewijs is beter.
Drie dagen na het begin van mijn OpenRouter-experiment gaf ik Nemotron 3 Super een taak die ik normaal voor Sonnet of Opus zou bewaren:
Build a modern SaaS landing page for a project management tool called "FlowBoard."
Include: hero section with gradient background, feature grid with 4 features and icons,
pricing table with 3 tiers, testimonial section, and footer.
Use Tailwind CSS. Make it responsive. Primary color: indigo. Secondary: slate.
Nemotron plande de aanpak — één HTML-bestand met Tailwind CDN, component-voor-component generatie, mobile-first responsive design. Toen begon het te bouwen.
Zes minuten later stond er een complete landingspagina open in mijn browser.
De hero-sectie had een schoon indigo-naar-paars verloop dat er niet als een standaardtemplate uitzag. Het features-raster gebruikte CSS Grid met Heroicons — het model koos een passende iconbibliotheek zonder dat erom gevraagd werd. De prijzentabel had drie gestructureerde lagen met de middelste gemarkeerd als "aanbevolen." De testimonials-sectie bevatte realistisch uitziende placeholder-inhoud met ronde avatarframes.
De tekortkomingen waren specifiek en klein: uniforme py-16 padding tussen secties in plaats van gevarieerde witruimte voor visueel ritme. Eén prijslaagrand lijnde niet perfect uit op kleine mobiele schermen. Footerlinks hadden echte URL's nodig.
Dat zijn vijf-minutenoplossingen. De 95% van het werk — lay-outarchitectuur, responsief gedrag, componentstructuur, kleurensysteem, typografiehiërarchie — was klaar. Door een gratis model. Draaiend in de cloud. In zes minuten.
Ik heb professioneel landingspagina's gebouwd. Deze output had me handmatig 2-3 uur gekost en zag er ongeveer hetzelfde uit. Opus zou de witruimte-nuances bij de eerste poging goed hebben gehad, maar voor prototyping, klantdemo's en interne tools? Nemotron's output is meer dan voldoende.
Die zes-minutenbuild was het moment waarop ik stopte gratis modellen als een compromis te zien en ze als een volwaardig gereedschap in mijn stack begon te beschouwen.
De eerlijke beoordeling: wanneer gratis modellen je meer kosten dan ze besparen
Ik ga direct zijn over iets dat de meeste "gebruik AI gratis"-artikelen overslaan.
Er was een woensdagmiddag waarop ik probeerde een redelijk complex Next.js-formuliercomponent te bouwen op Nemotron 3 Super. Dynamische veldgeneratie, conditionele zichtbaarheidslogica, realtime validatie, voorbeeldpaneel. Niet triviaal, maar het soort ding dat Opus in een enkele poging afhandelt.
Nemotron had drie pogingen nodig. De eerste had een subtiele state-managementbug. De tweede loste die bug op maar introduceerde een renderingprobleem met de conditionele velden. De derde poging werkte, maar ik moest handmatig twee randgevallen corrigeren die het model had gemist.
Totale tijd: ongeveer 40 minuten. Totale kosten: €0.
De volgende dag draaide ik de identieke taak op Opus. Eén poging. Schone code. Correcte randgevallen. Zes minuten. Kosten: ongeveer $0,30 aan tokens.
Als mijn tijd iets waard is — en die van jou ook — dan is 34 extra minuten besteden om $0,30 te besparen objectief een slechte ruil. Dat is een effectief uurtarief van $0,53. Zelfs tegen minimumloon verloor je geld op het "gratis" model.
Dit is wat ik de schijnbesparingsvalkuil noem. Het model is gratis. Je tijd niet.
Gratis modellen zijn economisch zinvol wanneer:
- De taak eenvoudig genoeg is dat het model het bij de eerste poging goed doet
- Je experimenteert en outputkwaliteit niet uitmaakt
- Je aan het leren bent en het debugproces zelf leerzaam is
- Je geplande of bulktaken draait met strak getemplatte prompts
- Je iets prototypet dat je toch opnieuw gaat bouwen
Betaalde modellen zijn economisch zinvol wanneer:
- De taak complex genoeg is dat fouten meer debugtijd kosten dan de API-aanroep
- Je productiecode schrijft waarbij betrouwbaarheid ertoe doet
- Je een deadline hebt en je geen iteratielussen kunt veroorloven
- Je werkt met beveiligingsgevoelige code
- De codebase groot is en diep bestandsoverstijgend redeneren vereist
De sweet spot die ik heb gevonden: gratis modellen behandelen 60-70% van mijn dagelijkse Claude Code-gebruik — scaffolding, boilerplate, testgeneratie, documentatie, onderzoek, geplande taken. Betaalde modellen behandelen de 30-40% die top-tier redenering vereist. Mijn algehele outputkwaliteit is niet gedaald. Mijn maandelijkse API-kosten zijn met ongeveer 60% gedaald.
Vijf valkuilen die ik tegenkwam zodat jij ze kunt vermijden
Drie weken dagelijks gebruik bracht deze gotcha's aan het licht:
Valkuil 1: De spookrekening van Anthropic. Als je verzoeken slagen maar je Anthropic-dashboard nog steeds stijgende kosten toont, heb je de API-sleutel niet goed leeggemaakt of de OAuth-cache niet gewist. Dit is de meest voorkomende foutmodus en de duurste — je denkt dat je op de gratis laag zit terwijl je stilletjes betaald tegoed verbrandt.
Valkuil 2: Verschuivende model-ID's. Gratis modelidentificaties op OpenRouter kunnen veranderen. Ik had nvidia/nemotron-3-super:free twee weken in mijn configuratie staan, en toen gooide Claude Code op een ochtend fouten. Het model-ID was iets verschoven in OpenRouter's catalogus. Als iets plotseling stopt met werken, controleer de modellenpagina en werk de ID-string in je .zshrc bij.
Valkuil 3: CLAUDE.md-instructies moeten worden aangepast. Als je een CLAUDE.md-projectbestand gebruikt (en dat zou je moeten doen), zijn je instructies waarschijnlijk geoptimaliseerd voor het model waarvoor je ze schreef. Gratis modellen reageren anders op dezelfde aanwijzingen. Ik moest sommige instructies vereenvoudigen — kortere zinnen, meer expliciete stapsgewijze structuur — om consistente resultaten van Nemotron te krijgen.
Valkuil 4: Latentievariantie per dag. De prestaties van gratis modellen fluctueren met serverbelasting. Sommige dagen reageert Nemotron in 2 seconden; andere dagen duurt het 5-6 seconden. De outputkwaliteit blijft consistent, maar latentieschommelingen kunnen tijdgevoelige workflows verstoren. Bouw time-outafhandeling in voor elke automatisering die afhankelijk is van gratis modellen.
Valkuil 5: Te veel vertrouwen op gratis modellen voor Git-operaties. Basis-commits en -pushes werken prima. Complexe Git-workflows — interactieve rebase, conflictoplossing, geschiedenisherschrijving — vereisen het soort precisie dat gratis modellen niet consistent leveren. Een slecht beredeneerde rebase kan je commitgeschiedenis beschadigen. Houd Git-complexiteit op betaalde modellen.
Wat er komt voor de kwaliteit van gratis modellen
Drie trends maken deze setup elk kwartaal krachtiger.
De kwaliteit van open-source modellen versnelt. Zes maanden geleden konden gratis modellen niet betrouwbaar een werkend React-component genereren. Nemotron 3 Super en Qwen3 Coder produceren vandaag output die vergelijkbaar is met wat Sonnet 3.5 een jaar geleden leverde. De kloof tussen gratis en betaalde modellen wordt snel kleiner. NVIDIA, Meta, Alibaba en Mistral pompen allemaal middelen in open-source modellen omdat brede adoptie hun infrastructuurbedrijven aandrijft. Volgens Artificial Analysis leidt Nemotron 3 Super al de open-source efficiëntiebenchmark — en het werd gelanceerd in maart 2026.
De catalogus van gratis modellen blijft groeien. OpenRouter's gratis collectie groeide van ongeveer 20 modellen eind 2025 naar 29 in maart 2026. Elke toevoeging verhoogt de bodem van wat beschikbaar is tegen nul kosten. De economische prikkels die gratis modelbeschikbaarheid stimuleren — adoptiegedreven bedrijfsmodellen, groei van het ontwikkelaarsecosysteem — verdwijnen niet.
Claude Code's agentframework blijft verbeteren. Elke update die Anthropic uitbrengt voor Claude Code's planning, toolgebruik en sub-agentmogelijkheden komt elk model ten goede dat je erdoorheen routeert — inclusief gratis modellen. Betere ondersteuning rondom een zwakker model kan resultaten opleveren die vergelijkbaar zijn met een sterker model met minder ondersteuning. Dat hefboomeffect stapelt zich op over tijd.
De eerlijke voorspelling: binnen een jaar zullen gratis open-source modellen 80-90% van typische ontwikkeltaken aankunnen op een kwaliteitsniveau dat niet te onderscheiden is van wat betaalde middenklassemodellen vandaag leveren. De tools om naadloos tussen gratis en betaald te schakelen — OpenRouter is op dit moment de meest volwassen optie — worden standaard ontwikkelaarsinfrastructuur.
We zijn er nog niet helemaal. Maar acht minuten setup brengt je dichter dan je zou verwachten.
De setup die mijn werkstroomberekening veranderde
Drie weken geleden draaide ik elke Claude Code-taak via Anthropic's API. Elke boilerplate-scaffold. Elke testgeneratie. Elke documentatiepass. Alles gefactureerd tegen premiumtarieven.
Vandaag draaien die routinetaken op NVIDIA's Nemotron 3 Super via OpenRouter tegen nul kosten. Het complexe architectuurwerk, de productiedebugging, de klantprojecten — die draaien nog steeds op Opus, waar de precisie de prijs rechtvaardigt.
Het resultaat is niet alleen kostenbesparing, hoewel dat reëel is — ongeveer 60% reductie in mijn maandelijkse API-uitgaven. De grotere verschuiving is psychologisch. Wanneer elke API-aanroep geld kost, censureer je jezelf onbewust. Je aarzelt voor het uitvoeren van verkennende queries. Je slaat het "laat me drie verschillende benaderingen proberen"-experimenteren over dat de beste oplossingen oplevert. Je optimaliseert voor minder aanroepen in plaats van betere resultaten.
Wanneer 60% van je aanroepen gratis zijn, verdwijnt die wrijving. Je experimenteert meer. Je itereert sneller. Je vraagt Claude Code om de speculatieve aanpak te proberen omdat het neerwaartse risico nul is. En soms blijkt die speculatieve aanpak de juiste te zijn.
De acht-minutensetup die ik je heb laten zien is niet alleen een kostenoptimalisatie. Het is een toestemmingsstructuur. Toestemming om AI-assistentie te gebruiken op de manier waarop het het beste werkt — vaak, experimenteel, zonder tokens te tellen.
Je opdracht voor vanavond: maak het OpenRouter-account aan, stel drie omgevingsvariabelen in, kies Nemotron 3 Super als je standaard, en draai dezelfde taak die je normaal naar een betaald model zou sturen. Vergelijk de output naast elkaar. Het verschil is kleiner dan je denkt — en voor de taken waar het nauwelijks uitmaakt, heb je zojuist de rekening volledig geëlimineerd.
Veelgestelde vragen
Kan ik Claude Code volledig gratis gebruiken met OpenRouter?
Ja. Maak een gratis OpenRouter-account aan, genereer een API-sleutel en stel drie omgevingsvariabelen in om Claude Code naar OpenRouter's endpoint te leiden. Geen creditcard nodig. Je krijgt 200 verzoeken per dag over 29 gratis open-source modellen met volledige toegang tot Claude Code's agentische functies — bestandsbeheer, shellcommando's, webzoeken en geplande prompts.
Wat is het beste gratis model voor coderen met Claude Code in 2026?
NVIDIA Nemotron 3 Super biedt de beste allround prestaties voor gemengde ontwikkelworkflows — codegeneratie, refactoring, onderzoek en documentatie. Voor pure codegeneratie is Qwen3 Coder 480B de sterkste gratis optie op OpenRouter. Beide hebben contextvensters van 262K tokens. Zie het testgedeelte hierboven voor de volledige modelvergelijking.
Hoe verhoog ik OpenRouter's dagelijkse verzoeklimiet voor gratis modellen?
Stort $10 op je OpenRouter-account. Het tegoed wordt niet uitgegeven aan gratis modelverzoeken — het blijft als saldo staan. Maar het aanhouden van dat saldo ontgrendelt 1.000 dagelijkse verzoeken in plaats van de standaard 200. Voor ontwikkelaars die agentische workflows draaien die tientallen API-aanroepen per taak genereren, dekt deze uitgebreide limiet een volledige werkdag.
Verliest Claude Code functies bij het gebruik van niet-Anthropic-modellen?
Het agentframework — bestandsoperaties, shellcommando's, webzoeken, geplande taken, codeverkenning — werkt identiek ongeacht het achterliggende model. Wat verandert is de kwaliteit van het redeneren, de planningsdiepte en de code-output van het model. Gratis modellen handelen eenvoudige taken goed af maar worstelen met complexe meerstapsplanning en redeneren over grote codebases vergeleken met Opus of Sonnet.
Waarom brengt Claude Code nog steeds kosten in rekening op mijn Anthropic-account na het configureren van OpenRouter?
Twee veelvoorkomende oorzaken: je hebt ANTHROPIC_API_KEY="" niet ingesteld in je shellprofiel (waardoor gecachte inloggegevens actief blijven), of je hebt /logout niet uitgevoerd in Claude Code om het OAuth-token te wissen. Beide stappen zijn vereist. Verifieer je configuratie door /status uit te voeren in Claude Code — het zou je OpenRouter-model en -endpoint moeten tonen, niet een Anthropic-model.
Laten we samenwerken
Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.
- Fiverr (custom builds & integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
