Hoe kun je openClaw (Moltbot/ Clawdbot ) uitvoeren op lokale LLM's zonder API

CometAPI
AnnaFeb 1, 2026
Hoe kun je openClaw (Moltbot/ Clawdbot ) uitvoeren op lokale LLM's zonder API

OpenClaw (voorheen Clawdbot, kortstondig Moltbot) is sneller geëxplodeerd dan bijna elk agentproject dat ik heb gezien.

Binnen minder dan drie weken bereikte het 100.000 GitHub-sterren. Mensen noemen het een “24/7 AI-stagiair”, en eerlijk gezegd zit die beschrijving er niet ver naast. Het kan berichten lezen, shell-opdrachten uitvoeren, bestanden beheren en stil op de achtergrond leven terwijl jij je dag doorloopt.

Maar na de eerste opwinding dook overal een heel praktische vraag op:

“Dit is cool… maar hoe draai ik het zonder geld te verbranden aan API’s?”

Die vraag is precies waarom ik de gids heb geschreven.

Wat is de buzz rond OpenClaw (voorheen Clawdbot)?

Om de technische verschuiving richting lokale uitvoering te begrijpen, moet je eerst waarderen wat OpenClaw eigenlijk is. In de kern is openClaw ( Moltbot / Clawdbot) een “conversation-first” autonome agent. In tegenstelling tot traditionele chatbots die in een browsertab leven en wachten op prompts, draait OpenClaw als een achtergrond-daemon op je machine. Het integreert direct met messagingplatforms zoals WhatsApp, Telegram, Discord en Signal, waardoor je chatapp effectief verandert in een command line voor je leven.

De evolutie van Clawdbot naar OpenClaw

De geschiedenis van het project is even volatiel als fascinerend.

Clawdbot (late 2025): Gemaakt door Peter Steinberger, gelanceerd als een wrapper voor Anthropic’s Claude, ontworpen om taken uit te voeren in plaats van alleen tekst uit te spugen. Het werd “Claude met handen” genoemd.

Moltbot (jan 2026): Na een merkrechtelijk geschil met Anthropic over de naam “Clawd” rebrandde het project naar “Moltbot”, met een kreeftmascotte genaamd “Molty” (verwijzend naar het vervellen van een schild).

OpenClaw (30 jan 2026): Om de open-source aard te benadrukken en zich verder te distantiëren van specifieke bedrijfsidentiteiten, terwijl de “Claw”-erfenis behouden bleef, koos de community voor OpenClaw.

Wat OpenClaw onderscheidt, is het toestemmingssysteem. Het kan je e-mails lezen, je agenda checken, shell-opdrachten uitvoeren en zelfs zijn eigen geheugen beheren in lokaal opgeslagen Markdown-bestanden. De standaardconfiguratie vertrouwt er echter op dat al deze context naar cloud-API’s wordt gestuurd (voornamelijk Anthropic of OpenAI), wat twee cruciale problemen oproept: kosten en privacy.

Waarom zou je overstappen op lokale LLM’s?

De “out-of-the-box” ervaring van openClaw ( Moltbot / Clawdbot) wordt aangedreven door Claude 3.5 Sonnet of Opus. Hoewel deze modellen zeer intelligent zijn, worden ze per token geprijsd. Een autonome agent die 24/7 draait—e-mails checkt, serverlogs monitort en chats samenvat—kan miljoenen tokens per dag genereren.

De kosten van autonomie

Autonome agents gedragen zich niet zoals chatsessies. Ze lopen in lussen. Ze lezen context opnieuw. Ze vatten logs samen. Ze controleren herhaaldelijk postvakken.

Ik heb gebruikers dingen zien melden als:

“Ik liet Clawdbot ’s nachts draaien om mijn Obsidian-vault te reorganiseren en werd wakker met een rekening van $40.”

Dat is geen misbruik — zo werkt autonomie nu eenmaal.

Met een lokaal model dalen de marginale kosten naar nul (afgezien van elektriciteit). Je stopt met denken “moet ik dit laten draaien?” en begint te denken “wat kan ik nog meer automatiseren?”

Privacy is geen nevenvoordeel — het is het belangrijkste

openClaw ( Moltbot / Clawdbot) kan het volgende lezen:

  • E-mails
  • Chatgeschiedenis
  • Broncode
  • Persoonlijke documenten

OpenClaw is ontworpen om diepe toegang tot je systeem te hebben. Het leest je persoonlijke berichten en bestandssystemen. Bij gebruik van een API wordt elk bestand dat de bot leest geüpload naar een server van een derde partij voor verwerking. Door een lokaal LLM te gebruiken, verlaat geen enkele data ooit je lokale netwerk. Je financiële documenten, privéchats en codebases blijven volledig gescheiden van Big Tech.

OpenClaw draaien met Ollama (mijn standaardaanbeveling)

Als je vertrouwd bent met de terminal, is Ollama vandaag de gemakkelijkste manier om lokale LLM’s te draaien.

openClaw ( Moltbot / Clawdbot) spreekt OpenAI-compatibele API’s. Ollama stelt er standaard een beschikbaar. Dat is de hele truc.

Minimale systeem- en softwarechecklist

  • Een machine met een recent OS (Linux/macOS/Windows + WSL2). Lokale GPU-acceleratie aanbevolen voor grotere modellen; alleen CPU werkt voor kleine modellen of lichte taken.
  • Node.js ≥ 22 (OpenClaw’s CLI en Gateway verwachten Node).
  • Ollama (of een andere lokale LLM-runtime) lokaal geïnstalleerd als je van plan bent lokale modellen te draaien. Ollama stelt standaard een OpenAI-compatibele lokale API bloot (meestal op http://localhost:11434).
  • Als je een proxy zoals Lynkr gebruikt, installeer die (npm of repo clonen). Lynkr kan een Anthropic/OpenAI-achtig endpoint aanbieden aan OpenClaw terwijl het naar lokale modellen routeert.

Stap 1: OpenClaw installeren (snelle commando’s)

OpenClaw beveelt installatie via npm/pnpm aan. Voer uit:

# install OpenClaw CLI globally (Node >= 22)
npm install -g openclaw@latest
# or using pnpm
pnpm add -g openclaw@latest

# run first-time onboarding (installs Gateway daemon)
openclaw onboard --install-daemon

De onboardingwizard installeert een gebruikersservice-daemon (systemd/launchd) zodat de Gateway op de achtergrond blijft draaien. Na onboarding kun je de Gateway handmatig uitvoeren voor debugging:

openclaw gateway --port 18789 --verbose

Stap 2: Ollama installeren en een model ophalen

Ollama is eenvoudig te installeren en te draaien. Op macOS/Linux:

# install Ollama (one-line installer)
curl -fsSL https://ollama.com/install.sh | sh

# pull a recommended assistant model (example)
ollama pull kimi-k2.5

# verify Ollama is running (default API on port 11434)
ollama list
# or check HTTP
curl http://localhost:11434/v1/models

Ollama biedt een API die compatibel is met veel OpenAI-stijl clients; de providerintegratie van OpenClaw ondersteunt Ollama en detecteert vaak automatisch een lokale Ollama-instantie, tenzij je de configuratie overschrijft.

Stap 3: Minimale OpenClaw-modelconfiguratie

een compatibiliteitslaag (Lynkr) inzetten of OpenClaw configureren zodat het naar het lokale endpoint wijst

Omdat openClaw ( Moltbot / Clawdbot) historisch tegen bepaalde API-vormen sprak (bijv. Anthropic-stijl endpoints), is de makkelijkste weg het draaien van een kleine proxy die OpenClaw-aanroepen naar de API van je lokale server vertaalt.

  • Lynkr: installeer en configureer Lynkr om te luisteren op de poort die OpenClaw verwacht; configureer het om door te sturen naar je Ollama/text-generation-webui-instantie. Community-tutorials tonen stappen en voorbeeld config.json-entries. Nadat Lynkr draait, kan OpenClaw geconfigureerd blijven voor de oorspronkelijke provider maar in werkelijkheid met je lokale model praten.

Als je liever de OpenClaw-config direct wijzigt, wijs de backend-URL voor het model in de .openclaw-configuratie naar het endpoint van je lokale server:

openClaw ( Moltbot / Clawdbot) slaat configuratie op in ~/.openclaw/openclaw.json. Een minimaal bestand om een lokaal model te prefereren ziet er zo uit:

{
  "agent": {
    "model": "ollama/kimi-k2.5"
  },
  "models": {
    "providers": {
      "ollama": {
        "name": "Ollama (local)",
        "options": {
          "baseURL": "http://127.0.0.1:11434/v1"
        }
      }
    }
  }
}

Als je een models.providers.ollama-blok weglaat, zal openClaw ( Moltbot / Clawdbot) vaak automatisch een lokale Ollama-instantie detecteren indien beschikbaar. Gebruik openclaw models list en openclaw models set om modelinstellingen interactief te beheren zonder het bestand direct te bewerken.

Stap 4: OpenClaw starten en een bericht testen

Met Ollama actief en de Gateway draaiend:

# start the gateway (if not running as a daemon)
openclaw gateway --port 18789 --verbose

# send a test message to the agent
openclaw agent --message "Hello from local OpenClaw" --thinking low

Als de Gateway en modellen correct zijn geconfigureerd, zie je de assistant reageren en wordt het bericht via het lokale Ollama-model gerouteerd.

Kan ik wijzigingen aan OpenClaw vermijden door een proxy te gebruiken?

Ja — dat is precies wat proxietools zoals Lynkr doen: ze bieden een Anthropic/OpenAI-stijl endpoint aan openClaw ( Moltbot / Clawdbot) terwijl ze luisteren op de poort die OpenClaw verwacht en de content doorsturen naar een lokale Ollama- of text-generation-webui-instantie. Dit is waardevol omdat het geen API-sleutel, geen cloudkosten en lokale modeluitvoering betekent; het voorkomt aanpassingen aan OpenClaw intern terwijl je lokale controle krijgt.

Architectuuroverzicht (welke componenten met welke communiceren)

  • OpenClaw (agent/app) — de hoofd-assistent, die modelaanroepen doet en tools en berichtintegratie orkestreert.
  • LLM-proxy (bijv. Lynkr) — ontvangt de API-stijlverzoeken van OpenClaw en stuurt ze door naar lokale modelservers (of cloud fallback). De proxy kan ook caching, token-trimming en geheugencompressie implementeren om kosten te verlagen.
  • Lokale LLM-server (bijv. Ollama, standalone ggml-runtime, Llama.cpp, lokale gecontaineriseerde modellen) — verzorgt inferentie op de machine. Ollama wordt veel gebruikt omdat het een eenvoudige lokale server en model-packagingworkflow biedt; andere runtimes zijn mogelijk.
  • Optionele cloudfallback — de proxy kan complexe verzoeken naar cloudmodellen routeren indien nodig (hybride modus).

Waarom een proxy gebruiken in plaats van openClaw direct te patchen?

Privacy & TCO: Lokale inferentie houdt data op je machine en voorkomt API-rekeningen.

Compatibiliteit: openClaw ( Moltbot / Clawdbot) verwacht een bepaald API-oppervlak (Anthropic/“Copilot”-stijl). Een proxy behoudt dat oppervlak zodat OpenClaw minimale veranderingen nodig heeft.

Veiligheid & flexibiliteit: De proxy kan routeringsregels implementeren (eerst lokaal, cloudfallback), rate limiting, verzoektruncatie en andere waarborgen.

Voorbeeld: Lynkr configureren om naar lokale Ollama te routeren

  1. Lynkr installeren:
npm install -g lynkr
# or: git clone https://github.com/Fast-Editor/Lynkr.git && npm install
  1. Een .env aanmaken (voorbeeld):
cp .env.example .env

Bewerk .env met:

# primary provider: local Ollama
MODEL_PROVIDER=ollama
OLLAMA_MODEL=kimi-k2.5
OLLAMA_ENDPOINT=http://localhost:11434

# optional hybrid fallback
PREFER_OLLAMA=true
FALLBACK_ENABLED=true
FALLBACK_PROVIDER=openrouter
OPENROUTER_API_KEY=sk-...
  1. Lynkr starten:
# if installed globally
lynkr

# if cloned
npm start

Lynkr zal standaard een lokale proxy aankondigen (bijvoorbeeld: http://localhost:8081) en een OpenAI/Anthropic-compatibel /v1-endpoint waar OpenClaw naartoe kan wijzen. Configureer vervolgens de modelprovider van OpenClaw om de Lynkr-base-URL te gebruiken (zie volgende snippet).

OpenClaw naar het Lynkr-endpoint wijzen

Bewerk ~/.openclaw/openclaw.json of gebruik de CLI om je provider-base-URL in te stellen:

{
  "models": {
    "providers": {
      "copilot": {
        "options": {
          "baseURL": "http://localhost:8081/v1"
        }
      }
    }
  },
  "agent": {
    "model": "kimi-k2.5"
  }
}

Nu zal openClaw ( Moltbot / Clawdbot) http://localhost:8081/v1 (Lynkr) aanroepen, wat lokaal naar ollama://kimi-k2.5 routeert. Je krijgt de naadloze ervaring van een externe provider zonder je machine te verlaten.

Voor gebruikers die een Graphical User Interface (GUI) prefereren om hun modellen te beheren, of die specifieke gequantiseerde modellen (GGUF-formaat) van Hugging Face willen gebruiken, is LM Studio de voorkeurskeuze.

Is het veilig om autonome agents lokaal uit te voeren?

Dit is wellicht de meest kritische vraag. Wanneer je openClaw ( Moltbot / Clawdbot) draait, geef je in essentie een AI shell-toegang tot je computer.

Het “sudo”-probleem

Als je een cloudgebaseerde Claude vraagt om “alle bestanden in mijn documenten te verwijderen”, kan die weigeren vanwege veiligheidsfilters. Een lokaal, ongecensureerd Llama 3-model heeft dergelijke remmingen niet. Als openClaw ( Moltbot / Clawdbot) een opdracht verkeerd interpreteert, kan het theoretisch destructieve commando’s uitvoeren.

Beveiligingsbest practices

Draai in Docker: voer openClaw ( Moltbot / Clawdbot) niet rechtstreeks uit op de “bare metal” van je hostmachine tenzij je absoluut zeker bent van de risico’s. Gebruik de officiële Docker-image die de omgeving sandboxt.

Onderstaand voorbeeld is een minimale docker-compose.yml die drie services demonstreert: Ollama (lokale modelruntime), Lynkr (proxy) en OpenClaw Gateway (CLI die in een container draait). Let op: pas volumes en device-passthrough aan voor GPU-toegang.

version: "3.8"
services:
  ollama:
    image: ollama/ollama:latest
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ./ollama-data:/var/lib/ollama

  lynkr:
    build: ./lynkr
    restart: unless-stopped
    ports:
      - "8081:8081"
    environment:
      - MODEL_PROVIDER=ollama
      - OLLAMA_ENDPOINT=http://ollama:11434

  openclaw:
    image: node:22
    working_dir: /workspace
    volumes:
      - ~/.openclaw:/root/.openclaw
      - ./workspace:/workspace
    command: sh -c "npm install -g openclaw && openclaw gateway --host 0.0.0.0 --port 18789"
    depends_on:
      - lynkr

Dit is een illustratieve stack; productie-deployments moeten netwerkisolatie, resource-limieten en GPU-device-mapping toevoegen waar passend.

Veelvoorkomende probleemoplossingsstappen en beperkingen

Als openClaw ( Moltbot / Clawdbot) Ollama niet ziet

  • Zorg dat Ollama draait en dat de base-URL bereikbaar is (http://127.0.0.1:11434/v1).
  • Gebruik openclaw models list en openclaw doctor om configuratieproblemen zichtbaar te maken.

Als Lynkr-routing faalt

  • Bevestig dat Lynkr luistert (meestal http://localhost:8081).
  • Controleer .env op correctheid van OLLAMA_ENDPOINT en MODEL_PROVIDER.
  • Valideer dat Lynkr de /v1-paden die openClaw ( Moltbot / Clawdbot) aanroept, mappt — sommige providerimplementaties verwachten licht verschillende paden; pas base-paden indien nodig aan.

Beperkingen in modelcapaciteiten

Lokale modellen variëren: sommige excelleren in coderen, andere in chat. Hybride strategieën (eerst lokaal, cloudfallback) kunnen helpen: routeer routinetaken lokaal en schaal complexe redenering op naar een cloudmodel met caching om kosten te verlagen. Lynkr en vergelijkbare proxies implementeren precies deze logica.

Conclusie

Het ontwerp van OpenClaw en het actieve ecosysteem eromheen maken een lokale, API-vrije deployment vandaag praktisch. Met tools zoals Ollama voor lokale hosting, Lynkr voor API-vertaling en robuuste communitydocumentatie kun je capabele agents draaien op machines die jij beheert — van een desktop-GPU tot een handheld apparaat — zonder je data naar een externe LLM-provider te sturen.

Als je echter de voor- en nadelen afweegt, bijvoorbeeld als je openClaw ( Moltbot / Clawdbot) toch via de API wilt gebruiken zonder de benodigde uitrusting, dan raad ik CometAPI aan. Het biedt Anthropic- en OpenAI-endpoints en geeft vaak kortingen — doorgaans 20% onder de officiële prijs.

Developers kunnen toegang krijgen tot en Claude Sonnet/ Opus 4.5 en GPT-5.2 via CometAPI; de laatst vermelde modellen zijn actueel op de publicatiedatum van het artikel. Om te beginnen, verken de mogelijkheden van het model in de Playground en raadpleeg de API-gids voor gedetailleerde instructies. Zorg vóór toegang dat je bent ingelogd bij CometAPI en de API-sleutel hebt verkregen. CometAPI biedt een prijs die veel lager is dan de officiële om je integratie te ondersteunen.

Klaar om te starten?→ Meld je vandaag aan voor Gemini 3!

Als je meer tips, gidsen en nieuws over AI wilt, volg ons op VK, X en Discord!

Lees Meer

500+ modellen in één API

Tot 20% korting