OpenClaw Ondersteunt Nu Ollama: Eén Commando Setup

OpenClaw Ondersteunt Nu Ollama: Eén Commando Setup

Ik was halverwege het configureren van nóg een cloud API-sleutel — mijn vierde deze maand — toen er een melding verscheen in de OpenClaw Discord. Ollama was nu een officiële provider. Geen community-hack. Geen workaround met drie configuratiebestanden en een schietgebedje. Een officiële, eersteklas integratie ondersteund door één enkel onboarding-commando.

Ik liet alles vallen en voerde het meteen uit.

openclaw onboard --auth-choice ollama

Dat was het. Mijn lokale Ollama-modellen — dezelfde die ik al gebruikte voor codegeneratie, schrijfhulp en data-analyse — waren ineens beschikbaar via elke chat-app die ik gebruik. WhatsApp. Telegram. Discord. Geen API-sleutels. Geen cloudrekeningen. Geen latencypieken om 14:00 uur wanneer de helft van de planeet besluit hetzelfde inference-endpoint te bestoken.

Wat er de week daarna gebeurde, veranderde fundamenteel hoe ik denk over persoonlijke AI-assistenten. En eerlijk gezegd vroeg ik me af waarom ik al die tijd had betaald voor cloud-inference.

Waarom Deze Aankondiging Belangrijker Is Dan Je Denkt

Hier wat context die deze Ollama-integratie significant maakt, voorbij de voor de hand liggende "cool, weer een provider"-reactie.

OpenClaw — de open-source persoonlijke AI-assistent gemaakt door Peter Steinberger (@steipete) — is enorm populair geworden sinds eind januari 2026. Het project bereikte begin maart 247.000 GitHub-sterren. Het is niet zomaar een chatbot in je terminal. OpenClaw is een volledig agentisch systeem dat lokaal op je machine draait en verbinding maakt met je messaging-apps. Het leest e-mails, beheert agenda's, checkt je in voor vluchten, surft op het web, schrijft en voert code uit — allemaal getriggerd vanuit een simpel chatbericht.

Het nadeel, tot nu toe, was de AI-backbone. Je had een cloud LLM-provider nodig. Claude, GPT, DeepSeek — allemaal solide opties, maar allemaal met API-sleutels, gebruikstracking en maandelijkse rekeningen die meeschalen met hoe veel je je assistent daadwerkelijk gebruikt. Voor ontwikkelaars zoals ik die tientallen keren per dag AI-agents gebruiken, lopen die kosten snel op.

Ollama verandert die vergelijking compleet. Draai je modellen lokaal, betaal niets voor inference, en houd elk gesprek op je eigen hardware. De privacy-implicaties alleen al zijn de moeite waard — maar de kostenbesparing en zero-latency lokale uitvoering? Dat maakte me enthousiast genoeg om dit te testen op hetzelfde uur dat het uitkwam.

Maar voordat ik je door de setup loop en vertel wat ik heb geleerd door dit een week te draaien, is er een deel van dit verhaal dat de meeste mensen missen — en het heeft te maken met welke modellen daadwerkelijk goed werken als OpenClaw-brein.

Het Achtergrondverhaal Dat Je Moet Kennen

Als je de OpenClaw-saga hebt gevolgd, weet je dat de naam nogal een reis heeft gemaakt. Peter Steinberger lanceerde het oorspronkelijk als Clawdbot in november 2025. Het project ging viraal eind januari 2026 — deels omdat het concept van een persoonlijke AI-agent vanuit WhatsApp echt nieuw was, en deels omdat @steipete een talent heeft voor het bouwen van dingen die ontwikkelaars onmiddellijk willen gebruiken.

Toen kwam de merknaamkwestie met Anthropic, een snelle hernoeming naar Moltbot (wat, eerlijk is eerlijk, nooit lekker bekte), en uiteindelijk de landing op OpenClaw. De kreeft-branding overleefde het allemaal. Als je de iconische kreeft-emoji overal in AI-ontwikkelaarskringen hebt gezien, dan weet je nu waar die vandaan komt.

De naam "OpenClaw" en de vervellings-metafoor vangen eigenlijk precies wat dit project speciaal maakt. Kreeften werpen hun schild af om te groeien. OpenClaw blijft beperkingen afwerpen — eerst het closed-source model, toen de afhankelijkheid van één provider, en nu de vereiste voor cloud-API's helemaal.

Ik wil hier specifiek @steipete noemen. Niet alleen voor het bouwen van OpenClaw in de eerste plaats, maar voor de manier waarop het project is begeleid door zijn explosieve groeifase. De Ollama-integratie ontstond niet in isolatie — het werd beoordeeld, getest en verfijnd met echte input van de community. En eerlijk gezegd, iemand met Steinbergers engineeringachtergrond (hij bouwde PSPDFKit, een van de meest gerespecteerde PDF SDK's in mobiele ontwikkeling) die de architectuurbeslissingen leidt, geeft me vertrouwen dat dit geen haastig werk is dat ergens op is geplakt. De integratie is solide omdat het reviewproces rigoureus was.

Speciale dank aan @steipete voor de hulp bij en het reviewen van de Ollama-providerintegratie. De open-source AI-community is beter wanneer ervaren engineers hun tijd investeren in het goed leggen van de fundamenten.

Dus hoe ziet de daadwerkelijke setup eruit? Het is bijna anticlimactisch simpel.

Hoe Je OpenClaw Met Ollama Instelt in Minder Dan Vijf Minuten

Ik loop precies door wat ik heb gedaan, inclusief de kleine valkuilen die ik tegenkwam, zodat jij ze kunt vermijden.

Stap 1: Zorg Dat Ollama Draait

Dit klinkt vanzelfsprekend, maar ik heb mensen erover zien struikelen. Je moet Ollama geïnstalleerd en draaiend hebben met minstens één model gepulld.

# Check Ollama is running
ollama list

# If you don't have a model yet, grab one
# OpenClaw recommends models with 64K+ context windows
ollama pull qwen3-coder

De contextvenster-vereiste is het ding dat de meeste handleidingen overslaan. OpenClaw heeft minstens 64.000 tokens aan context nodig om betrouwbaar multi-stap agentische taken uit te voeren — het soort waarbij het een e-mailthread leest, een antwoord opstelt, je agenda controleert op conflicten en vervolgens het antwoord verstuurt. Modellen met korte context werken voor simpele vragen maar haken af bij alles wat aanhoudend redeneren over meerdere tool-calls vereist.

Mijn aanbevolen modellen voor OpenClaw per maart 2026:

Ik heb qwen3-coder gedraaid voor de meeste taken en schakel over naar glm-4.7-flash wanneer ik gewoon snelle antwoorden nodig heb. Het mooie van lokale modellen is dat wisselen niets kost — geen andere API-sleutel, geen ander factureringsniveau. Gewoon de modelnaam veranderen.

Stap 2: Voer het Onboarding-Commando Uit

Hier gebeurt de magie:

openclaw onboard --auth-choice ollama

De wizard doet automatisch een aantal dingen:

1. Detecteert je Ollama-installatie — het controleert het standaardadres (meestal http://localhost:11434) en bevestigt de verbinding
2. Toont je beschikbare modellen — elk model dat je hebt gepulld verschijnt ter selectie
3. Stelt je standaardmodel in — als je maar één model hebt, selecteert het automatisch. Anders kies je zelf.
4. Configureert de provider — schrijft de benodigde configuratie zodat OpenClaw weet dat alle inferenceaanvragen naar je lokale Ollama-instantie moeten gaan
5. Installeert de gateway-daemon — het achtergrondproces dat je chat-apps verbindt met de OpenClaw-agent

Het hele proces duurde bij mij ongeveer 90 seconden. Geen JSON-bestanden om handmatig te bewerken. Geen omgevingsvariabelen om te exporteren. Geen Docker-containers om te orkestreren. Gewoon de prompts beantwoorden en klaar.

🦞 OpenClaw Onboard — Provider Setup
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Detected Ollama at localhost:11434 ✓
Available models:
  → qwen3-coder (128K context) ✓ recommended
  → glm-4.7-flash (64K context) ✓ compatible
  → llama3.3 (8K context) ⚠ low context

Selected: qwen3-coder
Gateway daemon installed ✓
Provider configured ✓

Your lobster is ready. 🦞

Die laatste regel deed me glimlachen. De persoonlijkheid van het OpenClaw-team komt zelfs door in de CLI-output.

Stap 3: Verbind Je Chat-Apps

Dit is het deel waar OpenClaw echt anders wordt dan Ollama alleen draaien. Ollama op zichzelf is een lokale inferenceserver — krachtig, maar je communiceert ermee via een terminal of een API-aanroep. OpenClaw maakt er een assistent van die leeft in de apps die je al de hele dag open hebt staan.

# Connect WhatsApp (uses QR code pairing)
openclaw connect whatsapp

# Connect Telegram
openclaw connect telegram --token YOUR_BOT_TOKEN

# Connect Discord
openclaw connect discord --token YOUR_BOT_TOKEN

Ik verbond WhatsApp als eerste omdat ik daar het meeste van mijn berichtentijd doorbreng. De QR-code-koppeling duurde ongeveer 10 seconden. Daarna kon ik mijn OpenClaw-bot berichten vanuit WhatsApp en antwoorden krijgen die volledig werden aangedreven door mijn lokale qwen3-coder-model.

Geen data die mijn machine verlaat. Geen API-kosten. Het antwoord kwam van de GPU die drie meter bij me vandaan staat.

Stap 4: Test Het Met een Echte Taak

Zeg niet gewoon "hallo" en noem het klaar. Geef het iets dat de agentische mogelijkheden op de proef stelt:

Me: Check my calendar for tomorrow and draft a summary
    of what I have scheduled. If there are any conflicts,
    flag them.

OpenClaw 🦞: Looking at your calendar for March 17...

You have 4 events tomorrow:
- 9:00 AM - Standup (30 min)
- 10:30 AM - Client call with Ramlit team (1 hr)
- 11:00 AM - Code review session (1 hr) ⚠️ CONFLICT
- 2:00 PM - Deploy planning (45 min)

⚠️ Conflict detected: "Client call" (10:30-11:30)
overlaps with "Code review" (11:00-12:00) by 30 minutes.

Suggestion: Move code review to 1:00 PM? That gives you
a 1-hour buffer before deploy planning. Want me to
reschedule it?

Die hele interactie — agendatoegang, conflictdetectie, suggestiegeneratie — draaide op mijn lokale Ollama-model. Het antwoord kwam terug in ongeveer 4 seconden. Met een cloud-API zou ik te maken hebben met netwerklatency bovenop de inferencetijd, plus betalen voor het voorrecht.

Hier is wat me het meest verraste: het kwaliteitsverschil tussen qwen3-coder lokaal via OpenClaw draaien versus een cloudmodel gebruiken was kleiner dan ik verwachtte. Voor routinematige assistenttaken — e-mails opstellen, agendabeheer, snelle codevragen, bestandsorganisatie — deed het lokale model het prachtig. Ik merkte het verschil pas bij complexe multi-stap redeneringsketen die tegelijkertijd grote hoeveelheden context moesten vasthouden.

Als je liever hebt dat iemand dit soort persoonlijke AI-assistent setup helemaal op maat bouwt voor jouw workflow, neem ik aangepaste AI-automatiseringsopdrachten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

Wat Gebeurt Er Als Al Je Ollama-Modellen Met OpenClaw Werken?

Dit is het deel dat ik pas volledig waardeerde nadat ik de setup een paar dagen had gedraaid. Wanneer Ollama je OpenClaw-provider is, krijg je niet alleen toegang tot één model. Je krijgt toegang tot elk model dat je hebt gepulld. En je kunt er on the fly tussen wisselen.

Me: /model glm-4.7-flash
OpenClaw 🦞: Switched to glm-4.7-flash ✓

Me: Quick — what's the CORS header syntax for allowing
    specific origins?

OpenClaw 🦞: Access-Control-Allow-Origin: https://yourdomain.com

For multiple origins, you'll need server-side logic —
the header only accepts one origin or *. In Express:

app.use(cors({
  origin: ['https://a.com', 'https://b.com']
}));

Het antwoord van glm-4.7-flash kwam terug in minder dan een seconde. Voor snelle feitelijke opzoekingen en syntaxherinneringen is het kleinere model perfect. Ik heb geen 120 miljard parameter model nodig om me aan een CORS-header te herinneren.

Maar voor diepe taken — het debuggen van een complexe race condition, het analyseren van een codebase of het opstellen van een gedetailleerd technisch document — schakel ik over naar qwen3-coder en laat ik het de tijd nemen. De mogelijkheid om modelcapaciteit af te stemmen op taakcomplexiteit is iets dat je gewoon niet zo vloeiend kunt doen met cloudproviders. Met Ollama zijn de wisselkosten letterlijk nul.

Het Model-Routeringspatroon Waar Ik Op Uitkwam

Na een week experimenteren, is dit hoe ik de verschillende modellen heb gebruikt:

Snelle vragen en opzoekingen — glm-4.7-flash. Snel, goedkoop (gratis), nauwkeurig voor feitelijke content. Ik gebruik dit voor waarschijnlijk 60% van mijn dagelijkse interacties.

Codegeneratie en review — qwen3-coder. Beter in het vasthouden van context over lange codebestanden, begrijpt framework-specifieke patronen en genereert meer productieklare code.

Lange teksten schrijven en analyse — glm-4.7 of kimi-k2.5. Wanneer ik het model nodig heb om veel context vast te houden en genuanceerde output te produceren, zijn dit mijn favorieten.

Experimentele en rare verzoeken — welk nieuw model ik die week ook heb gepulld. Een van de geneugten van Ollama is nieuwe modellen uitproberen zodra ze verschijnen. Vorige week testte ik gpt-oss:20b voor het eerst en was onder de indruk van zijn redenering bij rekenzware taken.

Het punt is: OpenClaw maakt het niet uit welk model je draait. De integratie behandelt Ollama als een uniforme provider. Je chat-apps weten niet en geven er niet om of het antwoord van een 7 miljard of 120 miljard parameter model kwam. Die abstractielaag is schoon, en het is een van de redenen waarom deze integratie aanvoelt als een eersteklas feature in plaats van een er later op geplakt nagedachte.

OpenClaw Lokaal Draaien: Waar Niemand Je Voor Waarschuwt

Ik zou je een slechte dienst bewijzen als ik dit liet klinken als pure magie zonder nadelen. Ik liep tegen echte beperkingen aan tijdens mijn week van testen, en je moet ervan weten voordat je volledig inzet op lokale inference.

GPU-Geheugen Is Je Bottleneck

De grotere modellen — gpt-oss:120b, kimi-k2.5, alles boven de 30 miljard parameters — hebben serieuze VRAM nodig. Ik draai een machine met een capabele GPU, en ik moest nog steeds nadenken over welk model ik geladen hield. Ollama kan offloaden naar CPU, maar het snelheidsverschil is bruut. Een query die 3 seconden duurt op GPU duurt 40 seconden op CPU voor een groot model.

Mijn advies: Begin met een model dat comfortabel in je GPU-geheugen past. qwen3-coder op de standaard quantisatie draait prachtig op 16GB VRAM. Grijp niet naar het grootste model omdat het indrukwekkend klinkt — grijp naar het model dat snel genoeg reageert om je flow niet te breken.

Contextvenster Is Niet Zomaar een Getal

OpenClaw's documentatie zegt minimaal 64K context, en ze menen het. Ik probeerde een model met 32K context en liep tegen problemen aan bij de derde multi-staptaak. De agent raakte het overzicht kwijt over de gespreksgeschiedenis midden in een taak en begon acties te herhalen die hij al had uitgevoerd. Overstappen naar een 64K+ model loste het onmiddellijk op.

Dit is logisch als je bedenkt wat OpenClaw doet. Het voert niet alleen een gesprek — het onderhoud tool-call-geschiedenis, functieresultaten, systemprompts en je volledige berichtenthread. Die overhead vreet snel context op. Een model met 8K context kan één enkele vraag prima beantwoorden, maar valt uit elkaar zodra OpenClaw drie of vier acties achter elkaar moet keten.

Eerste Antwoord Is Langzaam (Daarna Is Het Snel)

Ollama laadt modellen in het geheugen bij eerste gebruik. Als het model niet geladen is wanneer je je eerste bericht van de dag stuurt, verwacht dan een vertraging van 10-30 seconden terwijl het laadt. Daarna zijn antwoorden snel — vaak sneller dan cloud-API's omdat je netwerk-roundtrips volledig hebt geëlimineerd.

Ik loste het cold-start-probleem op door een simpele cronjob toe te voegen die elke ochtend om 8 uur een dummy-verzoek naar Ollama stuurt:

# Add to crontab: keep model warm
0 8 * * * curl -s http://localhost:11434/api/generate \
  -d '{"model":"qwen3-coder","prompt":"ping","stream":false}' \
  > /dev/null 2>&1

Kleine hack, grote kwaliteitsverbetering in het dagelijks gebruik.

Niet Elke Taak Hoort Op een Lokaal Model

Ik ben hier eerlijk over: voor complexe, multi-stap agentische workflows die sterk redeneren over heel lange contexten vereisen — denk aan "analyseer deze hele codebase en genereer een migratieplan" — hebben cloudmodellen zoals Claude nog steeds een voorsprong. De kloof wordt elke maand kleiner naarmate open-source modellen verbeteren, maar hij bestaat vandaag.

Mijn aanpak is pragmatisch. Ik gebruik lokale Ollama-modellen via OpenClaw voor 80% van mijn dagelijkse taken — het routinewerk dat tientallen keren per dag gebeurt. Voor de resterende 20% die frontierredenering op topniveau vereist, houd ik een cloudprovider geconfigureerd als fallback. OpenClaw ondersteunt meerdere providers tegelijk, dus wisselen gaat naadloos.

De kostenbesparing van het verplaatsen van 80% van de queries naar lokale inference is aanzienlijk geweest. Mijn cloud-API-rekening daalde van ongeveer €45/maand naar minder dan €10.

Meer Dan Chat: De Taken Die Me Verrast Hebben

Ik verwachtte dat OpenClaw + Ollama goed zou omgaan met chat. Wat ik niet verwachtte was hoe capabel het zou zijn voor taken die ik nooit eerder had geprobeerd met een lokaal model.

E-mailtriage Vanuit WhatsApp

Elke ochtend stuur ik één bericht naar mijn OpenClaw-bot:

Me: Morning brief — check email, flag anything urgent,
    summarize the rest

Twee minuten later (het scannen van e-mail kost even) krijg ik een geprioriteerde samenvatting. Urgente items bovenaan met aanbevolen acties. Niet-urgent gegroepeerd per categorie. Nieuwsbriefspam geïdentificeerd en klaar voor archivering. Allemaal verwerkt door qwen3-coder op mijn bureau.

Het feit dat dit vanuit WhatsApp gebeurt — dezelfde app die ik toch al check — betekent dat ik het echt elke dag gebruik. Toen het vereiste om een aparte terminal te openen en een Python-script te draaien, sloeg ik het de helft van de tijd over.

Code Review-Verzoeken Via Telegram

Ik verbond OpenClaw met de Telegram-groep die ik gebruik voor samenwerking aan nevenprojecten. Nu kan ik een codefragment of PR-link plakken en direct feedback krijgen:

Me: Review this function — anything wrong?

[pastes function]

OpenClaw 🦞: Two issues:

1. Line 12: You're not awaiting the async call inside
   the loop. This will fire all requests simultaneously
   instead of sequentially. If the API has rate limits,
   you'll hit them.

2. Line 23: The error catch swallows the exception
   silently. At minimum, log it. Better: propagate it
   with context about which iteration failed.

Want me to rewrite it with both fixes?

Die review kwam van een lokaal model. Geen code verliet mijn machine. Voor iemand die aan klantprojecten met NDA's werkt, is het privacyaspect geen nice-to-have — het is een vereiste.

Bestandsbeheer en Organisatie

Deze verraste me. Ik vroeg OpenClaw om een rommelige downloads-map te organiseren:

Me: Organize my ~/Downloads folder — group files by type,
    move anything older than 30 days to archive, and list
    what you did

OpenClaw 🦞: Done. Here's what I moved:

📁 Documents (14 files) → ~/Downloads/docs/
📁 Images (43 files) → ~/Downloads/images/
📁 Code (8 files) → ~/Downloads/code/
📁 Archives (6 files) → ~/Downloads/archives/
📁 Misc (3 files) → ~/Downloads/other/

Archived (>30 days): 23 files → ~/Archive/2026-02/

Total: 97 files organized. 23 archived.

Dit via een cloud-API draaien zou betekenen dat je je bestandslijst uploadt naar iemand anders' server. Met lokaal Ollama verlaat de directorylijst nooit je machine.

Hoe Verhoudt OpenClaw + Ollama Zich Tot Cloud-Only Setups?

Ik draaide beide setups vijf dagen naast elkaar. Dit is wat ik ontdekte — geen verzonnen benchmarks, gewoon mijn eerlijke ervaring over echt dagelijks gebruik.

Antwoordsnelheid voor Simpele Taken: Lokaal Ollama was consistent sneller. Geen netwerklatency betekent sub-seconde antwoorden voor snelle queries. Cloudproviders voegden doorgaans 1-3 seconden overhead toe, zelfs voor simpele antwoorden.

Antwoordkwaliteit voor Complex Redeneren: Cloudmodellen (met name Claude) gingen nog steeds betrouwbaarder om met multi-stapredenering. Toen ik OpenClaw vroeg om een complexe deployment-workflow te plannen met acht opeenvolgende stappen met conditionele vertakkingen, deed het cloudmodel het perfect. Het lokale model had ongeveer 80% goed en had één correctie nodig.

Kosten Over Vijf Dagen: De cloud-only setup kostte me ongeveer $8 aan API-aanroepen. De Ollama-setup kostte $0. Mijn elektriciteitsrekening veranderde niet merkbaar — de GPU draaide al voor andere taken.

Privacy: Geen wedstrijd. Lokaal wint absoluut. Elke query, elke bestandsreferentie, elk e-mailfragment bleef op mijn hardware.

Betrouwbaarheid: Cloud is afhankelijk van internetverbinding en uptime van de provider. Tijdens een korte internetstoring op dag drie bleef mijn lokale OpenClaw-setup gewoon werken zonder iets te missen. De cloud-setup was compleet uitgeschakeld.

De hybride aanpak — Ollama voor dagelijkse taken, cloud voor complex redeneren — gaf me het beste van beide werelden. En OpenClaw maakt het wisselen ertussen triviaal eenvoudig.

De Hybride Aanpak Instellen: Lokaal + Cloud Fallback

Als het hybride model je aanspreekt, is dit hoe ik het heb geconfigureerd:

# Primary: Ollama (local, free, private)
openclaw onboard --auth-choice ollama

# Secondary: Cloud provider as fallback
openclaw provider add --name claude --type anthropic \
  --api-key $ANTHROPIC_API_KEY

# Set routing rules
openclaw config set routing.default ollama
openclaw config set routing.complex claude

Met deze configuratie routeert OpenClaw de meeste verzoeken standaard naar Ollama. Wanneer ik expliciet om het cloudmodel vraag (met /model claude in chat) of wanneer een taak een complexiteitsdrempel overschrijdt, routeert het naar de cloudprovider.

De setup geeft me een maandelijkse AI-rekening van minder dan $10 terwijl ik nog steeds toegang heb tot frontiermodellen wanneer ik ze echt nodig heb. Hiervoor gaf ik $40-50/maand uit. Over een jaar is dat bijna $500 bespaard — en mijn dagelijkse assistent-ervaring is eigenlijk beter omdat lokale inference sneller is voor routinetaken.

Wat Dit Betekent Voor de Toekomst van Persoonlijke AI

Ik wil even uitzoomen omdat deze Ollama-integratie iets groters vertegenwoordigt dan één feature-aankondiging.

Toen OpenClaw lanceerde, was de aanname dat persoonlijke AI-assistenten cloud-LLM's nodig hadden. Het landschap van lokale modellen eind 2025 was gewoon niet goed genoeg voor betrouwbaar agentisch werk. Modellen konden niet genoeg context vasthouden. Ze waren niet snel genoeg. Ze maakten te veel fouten bij multi-staptaken.

Dat veranderde razendsnel. Begin 2026 werden modellen als qwen3-coder en glm-4.7 capabel genoeg om echte assistent-werklasten aan te kunnen. Ollama maakte het lokaal draaien ervan doodsimpel. En nu heeft OpenClaw het verbinden ervan met je dagelijkse workflow tot één enkel commando gemaakt.

De trajectorie is duidelijk: persoonlijke AI gaat local-first. Cloud wordt de uitzondering voor frontier-taken, niet de standaard voor alles. En de OpenClaw + Ollama-stack is de meest toegankelijke manier om die verschuiving nu te maken.

@steipete nam vroeg de beslissing om OpenClaw modelagnostisch te houden. Geen lock-in aan één provider. Geen voorkeursbehandeling voor cloud boven lokaal. Die architectuurbeslissing betaalt zich nu uit. Toen Ollama levensvatbaar werd als serieuze provider, was de integratie schoon omdat de abstractielaag er al was. Goede engineeringbeslissingen stapelen zich op in de tijd — en dit is een schoolvoorbeeld.

De Eén-Uur-Uitdaging: Probeer Dit Vandaag

Ik wil niet dat dit weer een artikel wordt dat je leest, bij knikt en dan vergeet. Dus hier is een concrete uitdaging.

Zet een timer van één uur. In dat uur:

1. Installeer Ollama als je dat nog niet hebt (5 minuten)
2. Pull qwen3-coder — ollama pull qwen3-coder (afhankelijk van je internetsnelheid, maar de download draait op de achtergrond)
3. Installeer OpenClaw vanuit de GitHub repo (10 minuten inclusief build)
4. Voer het onboard-commando uit — openclaw onboard --auth-choice ollama (2 minuten)
5. Verbind één chat-app — welke je het meest gebruikt (5 minuten)
6. Geef het drie echte taken — niet "hallo," niet speelgoedvoorbeelden. Vraag het iets te doen waarvoor je normaal een browser of terminal zou openen.

Als jouw ervaring ook maar enigszins lijkt op die van mij, ben je verslaafd bij taak twee. Er is iets oprecht verrukkelijks aan het sturen van een WhatsApp-bericht en een nuttig antwoord terugkrijgen dat volledig wordt aangedreven door hardware die je bezit.

De kreeft is gearriveerd op je lokale machine. En hij is klaar om aan het werk te gaan.

Veelgestelde Vragen

Werkt OpenClaw met alle Ollama-modellen?

Ja — elk model dat beschikbaar is in je lokale Ollama-installatie werkt met OpenClaw na het uitvoeren van openclaw onboard --auth-choice ollama. De onboarding-wizard detecteert automatisch alle gepullde modellen. Voor betrouwbare multi-stap agenttaken kies je modellen met minimaal 64K contextvensters. Zie de setupsectie hierboven voor de volledige modelaanbevelingslijst.

Hoeveel VRAM heb ik nodig om OpenClaw met Ollama te draaien?

Reken op minimaal 8-16GB VRAM. Modellen zoals qwen3-coder draaien comfortabel op 16GB VRAM bij standaard quantisatie. Kleinere modellen zoals glm-4.7-flash werken op 8GB. Je kunt offloaden naar CPU, maar responstijden nemen aanzienlijk toe — van 3 seconden naar 30+ seconden voor grotere modellen.

Kan ik OpenClaw gebruiken met zowel Ollama als een cloudprovider?

Absoluut. OpenClaw ondersteunt meerdere providers tegelijk. Configureer Ollama als je standaard voor dagelijkse taken en voeg een cloudprovider (Claude, GPT, DeepSeek) toe als fallback voor complex redeneren. Zie de hybride setup-handleiding hierboven voor de exacte commando's.

Is mijn data privé wanneer ik OpenClaw met Ollama gebruik?

Volledig. Met Ollama als je provider draait alle inference op je lokale machine. Geen queries, bestandsinhoud of gespreksdata verlaat je hardware. Dit maakt de setup ideaal voor ontwikkelaars die onder NDA's werken of met gevoelige klantgegevens omgaan.

Welke chat-apps ondersteunt OpenClaw?

OpenClaw verbindt met WhatsApp, Telegram, Discord, Signal, Slack en iMessage. Elke app heeft zijn eigen connect-commando — openclaw connect [app] — en de setup duurt doorgaans minder dan vijf minuten per platform.

Let's Work Together

Looking to build AI systems, automate workflows, or scale your tech infrastructure? I'd love to help.

• Fiverr (custom builds & integrations): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise solutions): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (security services): xcybersecurity.io