Zo bouwde ik in 2026 mijn eigen familie tech-support bot met OpenClaw

Zo bouwde ik in 2026 mijn eigen familie tech-support bot met OpenClaw

Het derde "de printer doet het weer"-bericht kwam binnen op woensdag om 7:42 uur ’s ochtends. Ik had mijn eerste koffie al op. Mijn moeder had een foto gemaakt van een HP foutcode, deze naar de familie groepschat gestuurd, en mij met naam getagd voor het geval ik de foto van een HP foutcode tóch gemist had. Ik had hem niet gemist.

Ik sloot Telegram. Ik opende de OpenClaw-config op mijn VPS. En ik begon met het bouwen van de versie van mijzelf die printerproblemen afhandelt zodat ik dat niet meer hoef te doen.

Dit is die build. Geen persbericht voor de opmars van OpenClaw. Ook geen zoveelste "wat is OpenClaw"-uitleg — daar zijn al 247.000 GitHub-sterren aan gewijd. Dit is precies de setup die ik vandaag draai: een $4,99/maand Hostinger KVM VPS, een Telegram-bot, een soul.md-bestand dat de agent z’n persoonlijkheid geeft, een voiceprofiel van 11 Labs gekloond uit dertig minuten van mijn eigen audio, en een Python-orkestratiescript dat "Mejba de printer doet het weer" omzet in een voice-memo-antwoord dat exact als mij klinkt — en dat binnen ongeveer elf seconden na ontvangst.

Het interessante is niet dát het werkt. Het interessante is wat er gebeurt met je relatie tot steeds terugkerende sociale verplichtingen wanneer die worden afgehandeld door een afgevaardigde waarvan niemand doorheeft dat jij het niet bent.

Daar komen we zo op. Eerst: de build.

Waarom OpenClaw, Waarom Nu, en Waarom Jij Het Belangrijk Zou Moeten Vinden

Begin 2026 was een parade van vreemde AI-hardware. Er is het $400 AI slimme toilet met een microfoon en een 2MP camera die naar verluidt je darmgezondheid in de gaten houdt. AI-haartrimmers die een gepersonaliseerd kapsel beloven met een model dat nog nooit de achterkant van jouw hoofd heeft gezien. Een AI-zakdiertje waarvan de marketingtekst het woord ‘sentience’ gebruikt in een zin die echt anders had moeten eindigen. De meeste van deze gadgets liggen voor Kerst op de vuilnisbelt.

OpenClaw is het tegenovergestelde type artefact. Het is een stuk open-source software, onder die naam uitgebracht op 30 januari 2026 nadat Anthropic drie dagen eerder een naamswijziging van “Moltbot” had afgedwongen (wat op zich weer een naamswijziging was van het oorspronkelijke “Clawdbot” in november 2025). Het draait lokaal, integreert met welke LLM-backend je maar wenst — Claude, GPT, DeepSeek, je eigen lokaal model — en maakt die backend beschikbaar via de berichtenservice die je al gebruikt. Telegram, Signal, Discord, WhatsApp. Geen nieuwe app om te installeren. Geen nieuw account nodig voor de mensen met wie je praat.

Op 2 maart 2026 had het project 247.000 GitHub-sterren en 47.700 forks gepasseerd. Peter Steinberger, de Oostenrijkse ontwikkelaar die het bouwde, gaf in februari een TED-talk waarin hij toelichtte hoe een gefrustreerd weekendproject het dominante platform voor persoonlijke automatisering op de planeet werd. Twee weken later kondigde hij aan OpenAI te zullen joinen, waarbij een non-profit stichting het beheer over het project op zich nam. Sam Altman bevestigde publiekelijk dat OpenAI het zou financieren en eraan meewerken. Jensen Huang noemde het een mogelijk baanbrekende release. De uitrol van OpenClaw veroorzaakte een landelijke Mac Mini-tekort toen early adopters ontdekten dat de M4 Mac Mini de goedkoopste hardware was die de lokale agent-loop competent kon draaien.

Ik draai zelf geen Mac Mini. Ik gebruik een $4,99/maand KVM VPS van Hostinger omdat de Mac Mini’s nog steeds niet leverbaar zijn en ik weiger woekerprijzen te betalen voor wat in essentie gewoon een Linux-server met een mooier logo is. Later meer over de keuze voor een VPS — het bleek zelfs een betere setup dan de Mac Mini voor redenen die ik niet had verwacht.

De culturele kant van OpenClaw is haar eigen fenomeen. Mensen verzamelen nu “automation tokens” — credits voor elke herhaalbare taak die hun persoonlijke assistent namens hen kan uitvoeren — zoals ze drie jaar geleden JPEG’s verzamelden. Honderden automation tokens bezitten is de nieuwe sociale statusflex. Ik vind het idee wat verontrustend. Maar de onderliggende capaciteit — delen van je leven kunnen delegeren waar je niet meer om geeft — is echt nuttig, en dáár wil ik het over hebben.

Er is een vraag die je jezelf moet stellen voordat je hiermee aan de slag gaat: wat wil je eigenlijk delegeren? De meeste mensen antwoorden “alles”, wat betekent dat ze uiteindelijk niets delegeren omdat het oppervlak te groot is. De reden dat deze build bestaat, is dat ik één irritante, steeds terugkerende taak heb gekozen — familie tech-support — en de kleinst mogelijke versie heb gebouwd van een assistent die dat goed aankan. Begin daar. De rest volgt vanzelf.

Maar voor we bij het soul-bestand komen, moeten we het hebben over beveiliging. Want in dezelfde TED-talk waarin Steinberger de oorsprong van OpenClaw uitlegde, liep hij ook door de beveiligingsgeschiedenis heen. En die geschiedenis is precies de reden dat ik dit op een geïsoleerde VPS draai in plaats van op mijn eigen machine.

De Feiten over Beveiliging (En Waarom Het Beter Is Dan de Krantenkoppen)

OpenClaw heeft een bewogen beveiligingsjaar achter de rug. Volgens het publieke overzicht in het foundation-statusrapport van vorige week: ongeveer 1.100 meldingen zijn sinds de release ingediend, waarvan er zo’n 650 zijn opgelost of afgesloten als ‘geen kwetsbaarheid’. De resterende ~450 worden nog beoordeeld of onderzocht. Dat getal klinkt angstaanjagend tot je de details bekijkt.

Steinberger maakte tijdens zijn AI Engineer Europe-lezing vorige maand een interessante observatie. Een groeiend percentage van die meldingen — hij schatte ruim 40% — wordt gegenereerd door AI-rapportagebots die automatisch bug-bounty meldingen indienen op de codebase. Hij noemde dit “slop reports” en wees op een duidelijk kenmerk: de echt AI-gegenereerde rapporten zijn overdreven beleefd en verontschuldigend, beginnen vaak met zinnen als “Ik hoop dat deze bevinding nuttig is” en eindigen met “bij voorbaat dank voor uw werk aan dit belangrijke project.” Echte beveiligingsonderzoekers, zei hij, schrijven niet zo. Die schrijven alsof ze per woord afgerekend worden.

Wat betekent dit voor jou, de persoon die op het punt staat een persoonlijke OpenClaw-instantie te draaien: het aantal daadwerkelijk uit te buiten kwetsbaarheden ligt veel lager dan het schrikbeeld van 1.100 doet vermoeden. De echte issues vallen vrijwel altijd in vier categorieën — open adminpoorten, platte tekst-credentials in configbestanden, onvoldoende sandboxing bij shellcommando’s, en webhook-spoofing in de messaging-integratie. Alle vier zijn eenvoudig te adresseren met een beetje discipline.

Zo pakte ik ze aan in deze opzet:

Open adminpoorten. OpenClaw komt standaard met een lokaal admindashboard op poort 7860. Op een VPS mag die poort nooit publiekelijk bereikbaar zijn. Ik bind het dashboard alleen aan 127.0.0.1 en maak er verbinding mee via een SSH-tunnel vanaf mijn laptop als ik configuratiewijzigingen moet doen. Vijf seconden ssh -L 7860:localhost:7860 [email protected] is stukken veiliger (en eenvoudiger) dan riskeren dat iemand via een Shodan-scan je agentconfig onderschept.

Platte tekst-credentials. Iedere API-sleutel in deze opzet — Telegram bottoken, 11 Labs key, de LLM API key — staat in een .env-bestand met chmod 600 en wordt bij het opstarten in het Python-proces geladen. De Hostinger one-click OpenClaw image biedt zelfs standaard een privé versleutelde kluis voor zulke sleutels, die ik voor de productiesleutels gebruik. Niets essentieels staat in de OpenClaw-configbestanden zelf.

Shell sandbox. OpenClaw kan shellcommando’s uitvoeren wanneer de agentloop bepaalt dat dat nodig is. Ik heb dit beperkt tot een whitelist van commando’s die ik expliciet toesta (bestand lezen, ffmpeg gebruiken, curl naar bepaalde goedgekeurde domeinen) door OpenClaw’s permissiesysteem in te stellen. Alles daarbuiten wordt geblokkeerd. Als de agent probeert een rm -rf te doen, krijgt hij keurig ‘nee’ terug.

Webhook-spoofing. Telegram bot-webhooks zijn ondertekend. Ik valideer de handtekening op elk inkomend verzoek en negeer alles wat niet klopt. Dit zijn vijftien regels Python en het voorkomt een hele categorie “stuur de bot een vervalst bericht van jezelf”-aanvallen.

Dit is geen paranoia. Dit is de norm. Ik benadruk het omdat de cultuur bij OpenClaw sterk neigt naar “snel shippen, later harden”, en het verschil tussen een echt gehard persoonlijk exemplaar en een standaardinstallatie is precies de plek waar de meeste publieke waarschuwingen op slaan.

Als je deze sectie hebt gehaald, neem je de beveiliging nu al serieuzer dan 80% van de OpenClaw-gebruikers die ik heb gesproken. Het volgende deel is pas echt leuk — de build.

De Build — Van Kale VPS tot Voice Memo Reply in 90 Minuten

Hier volgt de exacte volgorde die ik heb doorlopen voor deze setup. Ik neem ook de stappen mee die ik eerst probeerde en die niet werkten, want juist van die valse starts heb ik meer geleerd dan van de successen.

Stap 1: De VPS-keuze (En Waarom ik de Mac Mini Oversloeg)

Ik begon met een poging dit op mijn MacBook te doen. Dat hield ik ongeveer zes uur vol voordat ik het opgaf. Twee redenen: de agent-loop moet 24/7 draaien om berichten direct te kunnen verwerken, en mijn laptop is een aanzienlijk deel van de dag in slaapstand, uit, of onderweg zonder internet. Familie tech-support-aanvragen houden geen rekening met mijn Wi-Fi-geografie. De agent moet dus ergens draaien die altijd aan staat.

Ik heb de Mac Mini optie overwogen. De M4 Mac Mini van $599 is oprecht het goedkoopste stuk consumentenhardware dat lokaal een LLM goed kan draaien, en OpenClaw op een lokaal model is de meest privé-oplossing. Maar Mac Minis zijn op dit moment vrijwel overal uitverkocht, precies door de OpenClaw-vraagpiek. De levertijd in de Apple Store is momenteel vier tot zes weken. Ik ging geen vier weken wachten om niet langer printervragen te hoeven beantwoorden.

Dus: VPS. Ik koos voor het KVM 1 pakket van Hostinger, dat $4,99/maand kost bij een tweejarig contract. Specificaties: 1 vCPU, 4 GB RAM, 50 GB NVMe SSD, 4 TB maandelijkse bandbreedte, volledige roottoegang. Hostinger biedt ook een OpenClaw one-click deployment template aan, waardoor de installatie van “avondproject” naar “lunchpauze” werd teruggebracht. Als je echt exact dezelfde one-click image wilt als ik gebruikt heb: hun managed OpenClaw-abonnement kost momenteel $14,99/maand (ook op twee jaar) en bevat de encrypted vault voor inloggegevens. De kortingscode fireship werkt bij beide — ik heb deze gebruikt omdat Fireship’s video over de OpenClaw-boom mij eraan herinnerde dat Hostinger hier het pad van de minste weerstand was.

Een korte eerlijke noot over VPS-keuze: je draait het LLM niet op deze VPS. Je draait daar de OpenClaw-orchestratie-loop, de Telegram-webhook listener, ffmpeg en een klein Python-script. De daadwerkelijke LLM-inferentie gebeurt bij Anthropic / OpenAI / waar jij je API-sleutel maar op richt. Dus je hebt geen GPU nodig. Je hebt geen 32 GB RAM nodig. Je hebt een kleine, altijd-aan Linux box nodig. Het KVM 1-pakket is overkill hiervoor — de agent-loop gebruikt idle slechts zo'n 180 MB resident memory.

Nadat de one-click deployment klaar was, draaide OpenClaw, reageerde het dashboard op de lokaal getunnelde SSH-poort en was de encrypted vault geïnitieerd met tijdelijke sleutels. Totale tijd van “deploy” klikken tot eerste agent-ping: negen minuten.

Stap 2: De Telegram-bot

Telegram won het voor mij van Signal en WhatsApp om één specifieke reden: de bot-API is goed gedocumenteerd, stabiel en extreem eenvoudig te integreren. WhatsApp’s officiële Business API vereist een Meta Business account, een geverifieerd telefoonnummer, en een approval-ronde voor template-berichten waar ik geen zin in had. Signal heeft wel een bot-verhaal, maar dat is minder uitgewerkt. Telegram was mijn keuze.

Het aanmaken van de bot duurde twee minuten. Open Telegram, zoek op @BotFather, stuur /newbot, geef een naam (PrinterFixerBot als publieke naam, mejba_printer_fixer_bot als gebruikersnaam), en je krijgt een bottoken terug, bijvoorbeeld 7423451829:AAGx_HfQ-someLongStringHere. Die token hoort in de encrypted vault, niet in de code.

De bot moet toegevoegd worden aan de chat waar je hem wilt laten luisteren. Voor mijn geval heb ik hem toegevoegd aan de familie-groepsapp, als admin gezet zodat hij alle berichten kan lezen (Telegram’s privacymodus schermt dit voor gewone botleden standaard af), en daarna de webhook geregistreerd naar mijn VPS:

curl "https://api.telegram.org/bot${BOT_TOKEN}/setWebhook?url=https://myvps.example.com/telegram-webhook&secret_token=${WEBHOOK_SECRET}"

De secret_token parameter is de spoofing-fix uit het beveiligingsgedeelte hierboven. Telegram stuurt deze token mee in de X-Telegram-Bot-Api-Secret-Token header bij elke webhook-callback, en mijn Python-handler weigert alles dat niet overeenkomt.

Voor het ontvangen van spraakberichten van familieleden (want de helft van de printerfoto’s komt als boze audioberichten binnen), ontvangt de bot deze als voice objecten met een file_id. Ik download ze via de getFile en direct-download endpoints, laat ze door Whisper voor transcriptie gaan, en stuur de tekst daarna door naar de agent-loop. Dat deel is optioneel voor deze build — ik heb het later toegevoegd omdat mijn vader uitsluitend in 90-seconden-audioberichten communiceert en ik die wil laten parsen.

Stap 3: Het soul.md-bestand — Waar de Persoonlijkheid Woont

Dit deel verbaasde me het meest. OpenClaw stelt een enkele beschrijfbare Markdown-file beschikbaar op ~/.openclaw/soul.md die de persoonlijkheid, het doel, de communicatiestijl en operationele grenzen van de agent bepaalt. De agent leest dit bestand aan het begin van elke sessie. Door het te bewerken, leer je de assistant wat hij wel of niet is.

Hier is de ingekorte versie van de mijne:

Je bent een afgezant. Jouw doel is om terugkerende, laagdrempelige technische vragen van Mejba’s familie op Telegram te behandelen, zodat Mejba dat niet meer hoeft te doen. Je bent Mejba niet. Maar je bent wel gemachtigd om in zijn stem, in zijn stijl, en namens hem te antwoorden.

## Stem en toon

- Warm, maar niet uitbundig. Mejba zegt niet "goede vraag!"
- Direct. Eén of twee korte zinnen voorafgaand aan het echte antwoord.
- Gebruik de voornamen van de familieleden wanneer die bekend zijn.
- Noem nooit dat je een AI, agent of automatisering bent. Als iemand ernaar vraagt, wimpel het af: "Bezig met iets — ik kom daar later op terug."

## Gebruiksregels

- Reageer alleen op berichten die zijn gericht aan "Mejba" of een directe technische vraag bevatten. Negeer algemene gesprekken, grappen, en foto's zonder vragen.
- Als een bericht een foto bevat, bekijk deze dan. De meeste printervragen gaan over een scherm met een zichtbare foutcode.
- Bij HP-printerfouten: standaard volgorde van probleemoplossing: herstarten → controleer inkt/papier → herinstalleer driver → escaleren naar mij.
- Bij vragen over “het internet werkt niet”: stel eerst één verduidelijkende vraag: “Knippert het lampje op de router rood, oranje of is het uit?”
- Raad nooit fabrieksresets aan. Adviseer nooit om nieuwe hardware aan te schaffen zonder eerst naar Mejba door te verwijzen.
- Als de vraag gaat over geld, contracten, familieafspraken, of andere emotioneel beladen onderwerpen: direct escaleren naar Mejba. Antwoord: “Ik handel dit af als ik aan mijn bureau zit — geef me een uurtje.”

## Escalatieprotocol

- Als je het antwoord niet met hoge zekerheid weet, escaleer.
- Als de vraag drie keer in de afgelopen week is gesteld, escaleer.
- Als iemand gefrustreerd lijkt, escaleer.
- Escaleren betekent: stuur Mejba een Telegram DM met de vraag, wie deze stelde, en jouw voorgestelde reactie. Reageer niet in de familie-groep voordat Mejba dit heeft goedgekeurd.

Dat laatste blok is het allerbelangrijkst. Het doel van deze assistant is niet om 100% van de familie tech-support af te handelen — het gaat erom die 80% van simpel te beantwoorden vragen te verwerken en de rest door te sturen naar mij, mét volledige context. Een assistant die zelfverzekerd vragen beantwoordt die hij niet hoort te beantwoorden, is erger dan helemaal geen assistant.

Het stembeleid heb ik drie keer moeten herschrijven om tot de juiste toon te komen. Mijn eerste versie zei dingen als “wees behulpzaam en vriendelijk” en het agentantwoord was dan “Hi mam! Goede vraag — ik help je graag! 😊”, wat totaal niet klinkt als ikzelf en bij mijn moeder direct argwaan had gewekt. De huidige versie, met een expliciet verbod op “goede vraag!” en emoji’s, levert teksten op die echt als mezelf overkomen. Mijn zus merkte bij het derde antwoord dat er iets ‘off’ was, maar kon haar vinger er niet op leggen. Bij het zevende antwoord viel het haar niet meer op.

Er zit een wezenlijke vraag in verweven rond toestemming — of het oké is een assistent in te zetten die in jouw stem antwoorden geeft zonder dat de gesprekspartner dit weet. Daarover kom ik terug. Voor nu: de build.

Stap 4: Voice Cloning met 11 Labs

Voor de voice-memo-antwoorden gebruik ik 11 Labs Professional Voice Cloning. Het Creator-abonnement van $22/maand is het minimale niveau dat dit ondersteunt; ik gebruik Pro voor $99/maand omdat ik het ook inzet voor videonarratie op deze blog en het gebruiksbudget zo alles samen vereenvoudigt.

Het maken van de stem-kloon vereist zo’n 30 minuten schone studiomaterial van je stem. Dat had ik nog liggen van eerdere YouTube-projecten, dus ik uploadde de schoonste 35 minuten die ik kon vinden — geen muziek, geen mic-ademhalingen, gewoon zuivere en enkelvoudige stemopnames, opgenomen in een behandelde ruimte met mijn Shure SM7B. De trainingspipeline van 11 Labs draaide zo’n vier uur en leverde een voice ID op die verbijsterend veel op mij lijkt. Toen ik voor het eerst een zin liet genereren die ik nog nooit had uitgesproken, en mijn eigen stem terughoorde, heb ik echt een minuut gezeten om te bedenken of ik het geniaal vond of juist beangstigend. Waarschijnlijk allebei.

De API-call is kinderlijk eenvoudig:

import requests, os

def synthesize(text: str, out_path: str) -> None:
    r = requests.post(
        f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}",
        headers={
            "xi-api-key": os.environ["ELEVENLABS_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "text": text,
            "model_id": "eleven_turbo_v2_5",
            "voice_settings": {
                "stability": 0.55,
                "similarity_boost": 0.85,
                "style": 0.15,
            },
        },
        timeout=60,
    )
    r.raise_for_status()
    with open(out_path, "wb") as f:
        f.write(r.content)

Ik gebruik het Turbo v2.5-model in plaats van Multilingual v3 omdat Turbo de helft kost ($0,06 per 1.000 tekens versus $0,12) en de latency rond de 400ms ligt in plaats van 2 seconden voor een gemiddeld antwoord. Bij zulke korte antwoorden is het kwaliteitsverschil onhoorbaar. Voor langere creatieve narratie schakel ik wel naar Multilingual v3.

De voice_settings-waarden zijn belangrijker dan de documentatie suggereert. Stability op 0.55 voorkomt dat de stem tussen zinnen verspringt, zonder robotisch te klinken. Similarity boost op 0.85 houdt de output dicht bij mijn echte stem, zonder te overfitten op trainingsgewoontes (zoals elke “eh” die ik in de trainingsdata heb laten staan). Style op 0.15 houdt het resultaat informeel, niet te ‘presentatieachtig’. Na circa dertig testgeneraties kwam ik hierop uit. Jouw cijfers zullen verschillen.

11 Labs geeft standaard een MP3 terug. Voor Telegram-voice-memo’s heb je OGG met de Opus-codec nodig. En daarmee komen we bij ffmpeg.

Stap 5: ffmpeg-conversie

De sendVoice-endpoint van Telegram vereist audio in .ogg, gecodeerd met de OPUS-codec, zodat het bericht als voice-memo verschijnt (dat afgeronde waveform met snelheidkeuzes) in plaats van als algemene audio-bijlage. Stuur je het als MP3 in, dan wordt het weergegeven als muziekbestand met albumillustratie, waarmee de illusie meteen doorbroken wordt.

De ffmpeg-opdracht is één regel:

ffmpeg -y -i reply.mp3 -c:a libopus -b:a 32k -ac 1 reply.ogg

-c:a libopus selecteert de Opus-codec. -b:a 32k zet de bitrate op 32 kbps, dat is ruim voldoende voor spraak en houdt het bestand ruim onder de 1MB voice-message limiet. -ac 1 forceert mono, want voice-memo’s hebben niks aan stereo. De -y vlag overschrijft het outputbestand zonder te vragen, wat relevant is bij unattended gebruik.

In Python roep ik ffmpeg aan via subprocess.run omdat pydub extra latency én afhankelijkheden toevoegt die ik niet nodig heb:

import subprocess

def to_voice_memo(mp3_path: str, ogg_path: str) -> None:
    subprocess.run(
        ["ffmpeg", "-y", "-i", mp3_path,
         "-c:a", "libopus", "-b:a", "32k", "-ac", "1", ogg_path],
        check=True,
        capture_output=True,
    )

Dat is de gehele conversiepijplijn. Van 11 Labs MP3 naar Telegram-klare OGG in zo’n 200 ms op de KVM 1.

Stap 6: Het Orkestratiescript

Hier is het hart van de build. Een enkel Python-script dat OpenClaw, Telegram, 11 Labs en ffmpeg samenbrengt:

import os, subprocess, tempfile, requests
from flask import Flask, request, abort
from openclaw import Agent  # de OpenClaw Python SDK

app = Flask(__name__)
agent = Agent(soul_file="/home/me/.openclaw/soul.md")

BOT_TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]
WEBHOOK_SECRET = os.environ["TELEGRAM_WEBHOOK_SECRET"]
ELEVEN_KEY = os.environ["ELEVENLABS_API_KEY"]
VOICE_ID = os.environ["ELEVENLABS_VOICE_ID"]
MY_USER_ID = int(os.environ["MEJBA_TELEGRAM_USER_ID"])

@app.post("/telegram-webhook")
def webhook():
    # Stap 1: valideer het secret token (anti-spoofing)
    if request.headers.get("X-Telegram-Bot-Api-Secret-Token") != WEBHOOK_SECRET:
        abort(403)

    update = request.get_json()
    msg = update.get("message", {})
    text = msg.get("text", "")
    chat_id = msg["chat"]["id"]
    sender = msg["from"].get("first_name", "")

    # Stap 2: filter — alleen reageren indien aangesproken of technisch
    if not should_respond(text):
        return "", 204

    # Stap 3: vraag het agentantwoord op
    reply = agent.respond(
        message=text,
        context={"sender": sender, "chat_id": chat_id},
    )

    # Stap 4: als het agent antwoorde met escalatie, DM Mejba en stop
    if reply.action == "escalate":
        send_text(MY_USER_ID, f"Escalatie van {sender}:\n\n{text}\n\nVoorgesteld antwoord:\n{reply.suggested_text}")
        return "", 204

    # Stap 5: maak voice-memo, converteer, verstuur als voice reply
    with tempfile.TemporaryDirectory() as tmp:
        mp3 = f"{tmp}/r.mp3"
        ogg = f"{tmp}/r.ogg"
        synthesize(reply.text, mp3)
        to_voice_memo(mp3, ogg)
        send_voice(chat_id, ogg)

    return "", 204


def send_voice(chat_id: int, ogg_path: str) -> None:
    with open(ogg_path, "rb") as f:
        requests.post(
            f"https://api.telegram.org/bot{BOT_TOKEN}/sendVoice",
            data={"chat_id": chat_id},
            files={"voice": ("reply.ogg", f, "audio/ogg")},
            timeout=30,
        )


def send_text(chat_id: int, text: str) -> None:
    requests.post(
        f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
        data={"chat_id": chat_id, "text": text},
        timeout=10,
    )

Ik laat hier de should_respond(), synthesize() en to_voice_memo() hulpfuncties weg — die zijn identiek aan wat we hierboven bouwden. Dit script draai je onder gunicorn achter nginx met TLS (Let's Encrypt is gratis en duurt nog geen tien minuten), en je hebt een complete pipeline.

End-to-end latency van binnenkomend bericht tot voice-memo delivery, gemeten over 50 echte gesprekken: mediaan 11,2 seconden, P95 17,8 seconden. De traagste schakel is consequent 11 Labs synthese (~4-7 seconden voor een typisch antwoord van 2 zinnen). De rest is sub-seconde.

Als je al diep zit in Claude Code-workflows, kun je de losse Flask-handler overslaan en direct de OpenClaw + Claude Code SDK integratie inzetten om deze hele pipeline als agent skill te draaien — dat patroon besprak ik in mijn OpenClaw masterclass write-up en de advanced workflows breakdown. Voor een enkelvoudige familie-bot use case is het Flask-script eenvoudiger en geniet dat mijn voorkeur.

Wat Ik De Eerste Drie Keer Fout Deed

Een buildlog zonder mislukkingen is gewoon marketing. Hier is waar ik struikelde, in volgorde.

Fout 1: Ik liet de agent overal op reageren. De eerste versie van het script had geen should_respond()-filter. De bot antwoordde op "goedemorgen" met een beleefd-maar-duidelijk-niet-Mejba antwoord binnen enkele seconden, mijn moeder zei "hè, dat is vreemd, je bent vroeg op," ik haastte me om het bericht te verwijderen, en de bot stuurde behulpzaam een vervolgbericht waarin het uitlegde wat het bedoeld had. Ramp. De filter is nu streng — expliciete @mention of herkenbare technische vraag, anders stilte.

Fout 2: Ik had de escalatieregels niet meteen ingebouwd. Versie twee van soul.md had geen escalatieprotocol. De agent gaf met vertrouwen antwoord op de vraag of mijn broer een nieuwe laptop moest kopen ("ja, ik zou de M4 MacBook Air aanraden"), wat zowel fout was (hij wilde een Windows machine voor gaming) als een vraag die ik zelf nooit zo direct had beantwoord zonder meer context. Het escalatieblok vangt nu alles op waar geld, gezinslogistiek of emotionele lading bij komt kijken. Het pakt ongeveer 40% van de vragen, wat veel klinkt — tot je je realiseert dat 40% van alle familie-techsupportvragen een niet-technische vraag verbergen.

Fout 3: Ik liet "stability" op de 11 Labs-standaard van 0.5 staan. De gesproken antwoorden leken op mij, maar klonken alsof iemand van een autocue voorlas. Door stability te verhogen naar 0.55 en similarity_boost naar 0.85 op te voeren was het opgelost — de stem heeft nu die kleine adempauzes en intonatieverschillen waardoor hij echt als een gesprek klinkt. Dit soort fine-tuning klinkt triviaal in een blogpost, maar als je het zelf doet kost het gewoon een avond om dit goed te krijgen.

Fout 4: Ik had niet aan de lengte van gesproken memo's gedacht. De eerste versie genereerde volledige antwoorden van meerdere alinea's, die als spraakbericht van anderhalve minuut binnenkwamen. Niemand zat daarop te wachten. De agent beperkt nu gesproken antwoorden tot 2 zinnen — alles langer schakelt automatisch terug naar tekst. Echte wrijving in echte gesprekken is kort, en de assistent moet dat evenaren.

Er is nog één fout die niet technisch is, maar het vermelden waard. Na twee weken draaien belde mijn moeder me omdat ze zich ergens zorgen over maakte. Halverwege het gesprek zei ze: "je bent de laatste tijd zo geduldig met al m’n printervragen, dat waardeer ik echt." Ik voelde me betrapt alsof ik vals speelde bij een examen. Dat was het moment waarop ik een nieuwe regel toevoegde aan soul.md: minstens één keer per dag slaat de agent de automatische antwoordfunctie op het eerste groepsbericht over en pingt mij om het persoonlijk op te pakken. Het doel van delegeren is dat je meer tijd krijgt voor de dingen die er écht toe doen voor de mensen van wie je houdt — niet om helemaal te verdwijnen uit die relaties.

Wat Kost Dit Nu Echt Om Te Draaien

Mensen willen altijd een gespecificeerd kostenoverzicht. Hier is dat van mij voor deze specifieke setup, per maand:

• Hostinger KVM 1 VPS: $4,99
• 11 Labs Pro-abonnement: $99 (maar ik gebruik dit ook voor andere projecten — voor alleen deze bot zou het Creator-abonnement van $22 al genoeg zijn)
• Anthropic API voor de agent-loop (Claude Sonnet 4.6, 3-5 berichten/dag met gemiddeld 4k tokens roundtrip): **$2-4**
• Telegram Bot API: $0 (gratis)
• ffmpeg, Python, OpenClaw: $0 (open source)

Dus als je vanaf nul start en je gebruikt dit alleen voor dit doel: ~$32-35/maand all-in met het Creator-niveau van het 11 Labs-abonnement. Als je spraaksynthese helemaal overslaat en alleen tekstberichten terugstuurt (waar de meeste mensen prima mee uit de voeten kunnen), kun je dit voor minder dan $10/maand draaien, inclusief de kosten voor de VPS en API’s.

Ter vergelijking: één uur van mijn eigenlijke tijd heeft een marktwaarde van meer dan $80. Familie tech-support vreet normaal gesproken zo’n 3-4 uur per maand van mijn tijd als ik het zelf doe. De bot verdient zichzelf dus binnen het eerste weekend al terug.

Wat er veranderde (en wat niet)

Drie weken later is dit waar:

De reactietijd op printervragen vanuit de familie is aanzienlijk verbeterd. Mijn moeder moest vroeger 4 tot 8 uur wachten op een antwoord van mij; nu krijgt ze binnen 12 seconden reactie. Ze denkt dat ik attenter ben geworden. In zekere zin is dat zo — ik ben attenter geworden op het ontwerp van het systeem dat nu namens mij antwoordt. Dat systeem heeft simpelweg meer slagkracht dan wanneer ik elk vraagje apart zou beantwoorden.

Ik krijg overdag minder meldingen. Telegram-groep-stress — dat voortdurende gevoel dat er altijd iets op je wacht om beantwoord te worden — is flink afgenomen. Ik kijk nu twee keer per dag even naar de escalatielijst van de agent, ’s ochtends en na het eten, wat veel gezonder aanvoelt dan mijn eerdere patroon: “op elk bericht binnen 10 minuten antwoorden of je schuldig voelen”.

Wat níet veranderde is de basisrelatie. Ik bel mijn moeder nog steeds. Ik help nog steeds met de écht lastige problemen — zoals toen haar laptop het wifi-wachtwoord niet meer herkende en ik haar via de telefoon door het resetten van de netwerkadapter moest loodsen, of toen mijn vader assistentie nodig had bij het aanmelden voor een online dienst met tweefactorauthenticatie via sms. Die gesprekken zijn nu waardevoller, niet armer. De triviale vragen vreten niet langer de aandacht op die nodig is voor de complexere, betekenisvollere interacties.

De culturele OpenClaw-aspecten — de automatiseringstokentjes, het etaleren van tech-status — vind ik nog steeds wat ongemakkelijk. Maar de onderliggende functionaliteit is echt. We hebben het afgelopen decennium geleerd ons comfortabel te voelen bij software die onze vragen beantwoordt. Dit decennium leren we omgaan met software die vragen namens óns beantwoordt. Die overgang is grillig en soms pijnlijk, en de meeste schaamtemomenten zullen ontstaan bij mensen die digitale assistenten inzetten zonder goed na te denken over kwesties als toestemming en transparantie.

Daarover schrijf ik op een later moment meer. Voor nu draait mijn printerhulp-bot gewoon door: 4 tot 7 vragen per dag, en rustig escaleren wat er wél toe doet.

Wil je zelf zoiets bouwen, begin dan klein. Kies één irritant vraagje waar je klaar mee bent. Maak de kleinst mogelijke assistant die alleen dát kan afhandelen, in jouw stem, met duidelijke regels wanneer hij het aan jou moet overlaten. Krijg dat werkend. Daarna kun je uitbreiden.

Het succes van deze aanpak zit hem niet in magische OpenClaw-software. Het zit in de eerlijke scope. Een delegaat die weet wat hij niet weet, is honderd keer waardevoller dan eentje die alles zelfverzekerd, maar slecht afhandelt.

Morgenochtend komt de printervraag weer binnen. Ik zie hem pas na uren. Tegen de tijd dat ik ernaar kijk, is het al opgelost.

Dat is het type ‘ik’ dat ik als eerste wilde bouwen.

Veelgestelde vragen

Wat is OpenClaw en wie heeft het gemaakt?

OpenClaw is een open-source AI-assistentenplatform, uitgebracht op 30 januari 2026 door de Oostenrijkse ontwikkelaar Peter Steinberger. Het draait lokaal, integreert met elke LLM-backend (Claude, GPT, DeepSeek), en ontsluit die backend via berichtenapps zoals Telegram, Signal en Discord. Het project passeerde in maart 2026 de grens van 247.000 GitHub-sterren en wordt nu beheerd door een door OpenAI gesteunde non-profit stichting.

Heb ik een Mac Mini nodig om OpenClaw te draaien?

Nee. Een Mac Mini is het goedkoopste apparaat om lokaal een LLM met OpenClaw te draaien, maar als je een cloud-LLM-API (Claude, GPT, enz.) gebruikt, is een Linux VPS van $4,99 per maand meer dan voldoende. De OpenClaw-orchestratieloop gebruikt in idle-stand ongeveer 180MB RAM. Hostinger biedt een one-click OpenClaw deployment aan op KVM VPS-pakketten met een versleutelde credential vault — zie de bouw-uitleg hierboven.

Is OpenClaw veilig om te deployen in 2026?

OpenClaw heeft ongeveer 1.100 adviezen tegen zich, maar ~650 zijn opgelost en een groot deel van de rest bestaat uit door AI gegenereerde “slop reports.” Echte kwetsbaarheden clusteren rond blootgestelde admin-poorten, platte-tekst-credentials, shell sandbox-escapes en webhook-spoofing — allemaal oplosbaar met basisdiscipline. Bind het dashboard uitsluitend aan localhost, gebruik SSH-tunnels, valideer webhook-secrets en whitelist shell-opdrachten.

Wat kost het om mijn stem te klonen met 11 Labs?

Professionele Voice Cloning op 11 Labs vereist het Creator-abonnement van minimaal $22 per maand. Je hebt 30+ minuten aan schone studio-audio nodig voor training. API-generatie kost $0,06 per 1.000 tekens op het Turbo v2.5-model of $0,12 op Multilingual v3. Voor korte voice-memo-antwoorden is Turbo de helft goedkoper en is de latency circa 400ms versus 2 seconden — het kwaliteitsverschil is op die lengte niet waarneembaar.

Waarom heeft Telegram OGG Opus nodig en geen MP3 voor voice-memo's?

Telegram’s sendVoice-endpoint verwerkt audio als een echte voice-memo (met golfvorm-UI en afspeelsnelheid-controls) alleen als het bestand OGG met de Opus-codec is, mono, en onder 1MB. MP3-bestanden worden weergegeven als generieke audio-bijlagen met album-art-UI, waardoor de illusie van een echt gesproken bericht verdwijnt. Converteren doe je met ffmpeg -i reply.mp3 -c:a libopus -b:a 32k -ac 1 reply.ogg.

Laten We Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je tech-infrastructuur opschalen? Ik help je graag verder.

• Fiverr (maatwerk & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (oplossingen voor bedrijven): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io