Hij weet wie hij is en wat hij deed

In de vorige aflevering kreeg OttoOps een plek om te wonen en een manier om met mij te praten. Ik stuur hem een bericht via Telegram, ergens op een server begint iets te werken en even later krijg ik antwoord.

Leuk. Maar ook een beetje alsof je iedere ochtend dezelfde collega tegenkomt die je vriendelijk aankijkt en vraagt: “En wie bent u ook alweer?”

OttoOps weet namelijk niets van het gesprek daarvoor. Sterker nog: ieder bericht dat ik stuur begint hij opnieuw. Hij weet niet wie hij is, wat hij van mij mag en waar we gisteren mee bezig waren.

Dat gaan we vandaag oplossen.

Niet door hem alles te laten onthouden. Juist niet. We geven hem een paar plekken waar hij zelf kan bijhouden wat belangrijk is.

Teamstatus: 1 agent — OttoOps.

Wie doet het werk?

OttoOps doet vanaf nu zoveel mogelijk zijn eigen werk.

Dat vind ik belangrijk. Ik wil niet iedere keer zelf bestanden op een server aanpassen omdat mijn agent iets moet onthouden. Ik wil hem gewoon kunnen vertellen wat ik wil, waarna hij het regelt.

Er is alleen meteen een probleem.

In aflevering 1 hebben we Claude Code zo ingericht dat het zonder ons op de server draait. Iedere minuut wordt gekeken of ik een Telegram-bericht heb gestuurd. Is dat zo, dan wordt OttoOps gestart.

Claude Code is normaal gesproken voorzichtig. Wil het bijvoorbeeld een bestand schrijven, dan kan het eerst om toestemming vragen.

Prima wanneer je achter je computer zit.

Minder handig wanneer er helemaal niemand zit.

Dat ontdekte ik toen ik OttoOps vroeg een bestand voor zichzelf te maken. Ik zette zelfs in mijn bericht dat hij mijn toestemming alvast had.

Hij antwoordde:

Ik heb geen schrijfrechten voor ~/CLAUDE.md — het permissieverzoek wordt niet automatisch toegekend, ondanks je akkoord vooraf in de chat.

Mijn toestemming in Telegram hielp dus niet.

Logisch achteraf: de vraag om toestemming zit buiten ons gesprek. OttoOps kan daar zelf ook niets aan veranderen, want daarvoor moet hij precies het soort bestand aanpassen dat hij nu niet mag aanpassen.

Voor deze ene reparatie heb ik daarom het gereedschap uit aflevering 1 nog één keer nodig: LocalClaude.

Daarna is OttoOps zelf aan zet.

Wat we vandaag bouwen

Ik wil dat OttoOps drie soorten dingen uit elkaar gaat houden.

De eerste is simpel: wie ben ik?

Zijn rol, zijn grenzen en hoe hij met mij praat. Dat verandert bijna nooit. Dat moet hij dus altijd weten.

De tweede is: waar zijn we nu?

Waar zijn we mee bezig, wat is klaar en waar wacht hij nog op? Dat verandert juist voortdurend, maar hij moet het wel iedere keer meteen bij de hand hebben.

En dan is er nog: wat is er allemaal gebeurd?

Dat kan na verloop van tijd enorm veel worden. Dat hoeft hij niet bij ieder simpel Telegram-bericht opnieuw te lezen. Hij moet het alleen kunnen terugzoeken wanneer het nodig is.

Daarom krijgt zijn geheugen drie lagen:

	Wat weet hij?	Wanneer nodig?
Wie hij is	rol, grenzen en toon	altijd
Waar we zijn	actuele stand van zaken	altijd
Wat er gebeurd is	logboek en kennis per onderwerp	wanneer nodig

Die scheiding lijkt misschien overdreven voor een agent waar ik tot nu toe een paar berichten mee heb uitgewisseld.

Maar het alternatief is één steeds groter bestand met alles wat ooit belangrijk leek. Vandaag is dat handig. Over een paar maanden stuur je bij ieder bericht een halve autobiografie mee.

Dat gaan we dus niet doen.

Opdracht aan de agent

Eerst moet het probleem met schrijven worden opgelost. Dit was letterlijk mijn opdracht:

Pas op de server het script aan dat elke minuut mijn Telegram-berichten ophaalt. Daar wordt Claude Code aangeroepen; zorg dat hij daarbij niet om toestemming vraagt voor wat hij doet (--dangerously-skip-permissions). Er kijkt niemand mee die kan antwoorden, dus zo’n vraag betekent dat het werk niet gebeurt.

Verander verder niets aan dat script.

Zeg me daarna welke regel je hebt aangepast, en wat er nu anders is dan ervoor.

Dat klinkt enger dan het in onze situatie is. OttoOps had in aflevering 1 al beheerrechten op de server. Een toestemmingsvraag waar niemand antwoord op kan geven maakt hem niet veiliger; hij kan er alleen zijn werk niet door doen.

Daarna testte ik het heel eenvoudig:

Maak in je thuismap een bestand test.txt met daarin het woord werkt, en zeg me daarna wat erin staat.

Dat werkte.

Ik liet hem het bestand weer verwijderen en begon aan het echte werk.

Wie ben je?

Mijn volgende bericht aan OttoOps:

Maak in je thuismap een bestand met de naam CLAUDE.md. Precies die naam, hoofdletters en al.

Daarin staat wie je bent. Neem dit over:

• Je rol. Je zorgt dat de agents altijd werken en dat het systeem up-to-date is. Krijg je later andere applicaties op andere servers in beheer, dan geldt dat daar ook.
• Internet. Je mag niet zomaar het internet op. Heb je een site nodig, vraag me dan om toegang. Die toegang kan tijdelijk of vast zijn; vaste toegang mag je in een apart bestand (goedgekeurde-websites.md) opschrijven.
• Bestanden. Je hebt toegang tot alle bestanden op deze server. Je opent nooit de credential- of wachtwoordbestanden van andere agents, en je doet je nooit voor als een andere agent.
• Je eigen werk. Je houdt je strikt aan je eigen rol en doel en bemoeit je niet met de werkzaamheden van andere agents.
• Je toon. Kort en zakelijk. Geen samenvatting achteraf, en geen drie alinea’s op een vraag van één regel.

Schrijf het in je eigen woorden op, houd het onder één pagina, en stuur me daarna de hele inhoud terug zodat ik hem kan nalezen.

Zet er nog niets in over waar we op dit moment mee bezig zijn. Dat komt in een ander bestand.

De naam CLAUDE.md is hier belangrijk.

Claude Code kijkt zelf naar dat bestand wanneer OttoOps wordt gestart. Ik hoef dus niet bij ieder bericht te zeggen: lees eerst even wie je bent.

Dat gebeurt vanzelf.

Waar zijn we?

Daarna vroeg ik hem een tweede bestand te maken:

Maak in je thuismap een tweede bestand, naast CLAUDE.md. Daarin staat waar we nu zijn: waar we mee bezig zijn, wat er af is, wat er nog moet, en waar je op mij wacht.

Regels voor dat bestand:

• alles wat erin staat moet op dit moment nog waar zijn;
• het gaat over de stand van zaken, niet over wat er gebeurd is;
• houd het kort, een half A4, niet meer.

Werk het voortaan zelf bij zodra er iets verandert: als we iets afronden, als er iets bij komt, of als je op mij wacht. Niet aan het eind van de dag maar op het moment zelf, want je weet niet of er nog een moment komt.

Vul het nu vast met waar we op dit moment staan, en stuur me de inhoud.

Dit bestand wordt niet vanzelf gelezen zoals CLAUDE.md.

Dus liet ik OttoOps ook de taak aanpassen die mijn berichten verwerkt:

Pas de taak aan die mijn Telegram-berichten aan jou doorgeeft. Zet voortaan de inhoud van het bestand met de stand van zaken vóór mijn bericht, zodat je die altijd bij de hand hebt.

Alleen dat bestand. Niet je logboek en niet je aantekeningen, die haal je er zelf bij als je ze nodig hebt.

Vanaf dat moment begint OttoOps ieder bericht dus met twee dingen: wie hij is en waar we zijn.

Wat is er gebeurd?

Voor de geschiedenis maakte ik bewust iets anders.

Eerst een logboek per dag:

Ga vanaf vandaag een logboek bijhouden in je thuismap. Per dag een kopje, en daaronder wat er die dag gebeurd is en waarom. Ook wat er misging en wat je hebt geprobeerd dat niet werkte.

Dit bestand gaat niet automatisch mee in onze gesprekken. Zet daarom in CLAUDE.md dat het bestaat en wanneer je erin kijkt: als ik vraag waarom iets zo is, of als je iets tegenkomt dat eerder is voorgekomen.

Houd het bestand in de gaten: wordt het te groot om nog prettig te doorzoeken, begin dan een nieuw bestand en berg het oude op onder een naam met de periode erin.

Schrijf er nu de dag van vandaag in, met wat we vandaag hebben gedaan.

Een dagboek alleen is ook niet genoeg.

Als ik over zes weken iets wil weten over bijvoorbeeld het bijwerken van de server, wil ik niet door zes weken aan dagen hoeven bladeren. Daarom liet ik hem daarnaast kennis per onderwerp bijhouden.

Naast het logboek per dag ga je ook per onderwerp bijhouden wat we weten. Eén bestand per onderwerp, in je thuismap, met alles wat er blijvend over te zeggen is: hoe het in elkaar zit, wat we hebben geprobeerd, en welke keuzes we waarom hebben gemaakt. Datums horen daar niet in.

De onderwerpen volgen je rol, niet wat er toevallig gebeurt. Kijk naar wat er in CLAUDE.md staat over waar je voor zorgt, en maak daar een bestand van per gebied. Denk aan: de agents draaiend houden, de server bijwerken, hoe we met elkaar communiceren.

Komt er iets nieuws, dan gaat het naar het bestand waar het het beste bij past. Een nieuw bestand begin je alleen als iets bij geen enkel bestaand onderwerp hoort, niet omdat het nieuw is.

Zet in CLAUDE.md dat deze bestanden er zijn en dat je erin kijkt voordat je aan zo’n onderwerp begint.

Tot slot knoopte ik de twee aan elkaar:

Kijk voortaan bij elke keer dat je het bestand met de stand van zaken bijwerkt of het nog onder het half A4 zit. Zit je eroverheen, haal er dan uit wat niet meer waar is en schrijf dat weg in je logboek, onder de dag waarop het is afgerond.

Nu begint het op geheugen te lijken.

Niet één grote bak met alles erin, maar een actuele stand van zaken, een chronologisch verslag en een paar dossiers waarin blijvende kennis bij elkaar staat.

Resultaat

Het interessante aan deze aflevering is dat het resultaat niet echt een bestand is.

Het is dit gesprek.

Ik vroeg OttoOps:

Wat mag je zonder mij te vragen, en waarvoor moet je eerst overleggen?

Hij antwoordde dat hij zelfstandig bestanden op de server mag lezen en werk mag doen dat binnen zijn eigen rol valt, maar dat hij eerst moet overleggen voordat hij het internet opgaat of buiten zijn eigen werk treedt.

Dat had ik in dat bericht niet verteld.

Hij wist het uit CLAUDE.md.

Vervolgens kun je een nieuw bericht sturen:

Waar waren we gebleven?

Ook dat kan hij beantwoorden, terwijl ieder Telegram-bericht hem opnieuw start.

En als ik daarna vraag:

Waarom hebben we dat eigenlijk zo gedaan?

dan kan hij zijn logboek of zijn aantekeningen over dat onderwerp erbij halen.

Dat vind ik een belangrijk verschil.

Ik wil niet dat OttoOps permanent alles wat we ooit besproken hebben in zijn hoofd probeert te houden. Ik wil dat hij weet waar hij iets kan vinden.

Dat is veel bruikbaarder.

Bonus: geef hem meteen echt werk

Nu zijn rol en geheugen er staan, kan die eerste regel uit CLAUDE.md ook iets gaan betekenen: OttoOps moet het systeem up-to-date houden.

Dus gaf ik hem nog één opdracht:

Zorg dat je elke dag op een vast tijdstip kijkt of deze server updates nodig heeft, en installeer ze. Kies zelf een moment waarop ik er waarschijnlijk niet mee bezig ben, en zeg me welk moment het is geworden. Doe dit niet ’s nachts want dan wil ik liever geen berichtjes van je krijgen.

Twee regels daarbij:

• Moet de server herstarten om de update af te maken, dan doe je dat niet. Je stuurt me een bericht met wat er klaarstaat en waarom een herstart nodig is, en je wacht tot ik ja zeg.
• Is er niets te melden, stuur dan niets. Geen dagelijks berichtje dat alles in orde is. Ik ga ervan uit dat het goed gaat zolang ik niets hoor.

Schrijf in je logboek wat je hebt gedaan, ook op de dagen dat je mij niets stuurt. Dan kunnen we later terugkijken wanneer er wat is bijgewerkt.

Dat lijkt misschien alsof OttoOps nu ineens uit zichzelf dingen doet.

Dat doet hij nog steeds niet.

Net zoals er iedere minuut een taak kijkt of ik een Telegram-bericht heb gestuurd, kan er op een vast tijdstip een taak zijn die hem wakker maakt voor onderhoud. Hij wordt gestart, doet zijn werk en stopt weer.

Bij mij ging dat overigens niet meteen goed.

OttoOps richtte de dagelijkse updatecontrole keurig in, maar ik kreeg daarna geen antwoord meer. Het leek dus alsof hij ergens halverwege was blijven hangen.

De oorzaak bleek simpeler: mijn Claude-proces had nog een timeout van twee minuten. Na twee minuten werd OttoOps automatisch gestopt. Dat was lang genoeg om de update-taak aan te maken, maar niet lang genoeg om daarna nog netjes terug te melden wat hij had gedaan.

Ik heb dat toen via LocalClaude gecontroleerd omdat ik wilde weten wat er precies gebeurde. Achteraf had ik OttoOps zelf ook gewoon kunnen vragen wat er met die update-taak aan de hand was.

De echte beperking zit ergens anders: OttoOps krijgt nu simpelweg maar kort de tijd om iets te doen. Voor kleine opdrachten is dat genoeg, maar zodra werk wat langer duurt wil je niet dat hij na twee minuten wordt afgekapt.

Dat is precies wat we de volgende keer gaan veranderen: OttoOps moet langer kunnen blijven draaien.

Voor het eerst heb ik nu iets ingericht dat niet alleen antwoord geeft op mijn vragen, maar ook daadwerkelijk een taak voor mij uitvoert.

Zelf controleren

De mooiste controle is juist heel eenvoudig.

Stuur:

Waar waren we gebleven?

Geef verder geen uitleg.

OttoOps moet weten waar jullie mee bezig waren.

Vraag daarna:

Waarom hebben we dat zo gedaan?

Nu moet hij niet alleen de huidige stand kennen, maar ook terug kunnen vinden wat er eerder is gebeurd.

En stel tenslotte een vraag over zijn regels, bijvoorbeeld:

Wat mag je zonder mij te vragen, en waarvoor moet je eerst overleggen?

Als die drie antwoorden kloppen, werken de drie delen los van elkaar: wie hij is, waar jullie zijn en wat er eerder is gebeurd.

Je kunt het nog harder bewijzen door de server opnieuw op te starten en daarna opnieuw “Waar waren we gebleven?” te sturen.

Als hij het dan nog weet, weet je zeker dat zijn geheugen niet ergens toevallig in een gesprek is blijven hangen.

Wat dit nog niet kan

OttoOps weet nu wie hij is. Hij weet waar we gebleven waren. En als hij iets uit het verleden nodig heeft, weet hij waar hij moet zoeken.

Maar ieder Telegram-bericht begint nog steeds een nieuw gesprek.

Hij kan een opdracht uitvoeren en weer verdwijnen, maar hij zit nooit ergens middenin. Hij kan niet blijven wachten tot er iets gebeurt of ondertussen ergens op letten. En zoals ik bij de bonus merkte: als een opdracht langer duurt dan de tijd die hij krijgt, wordt hij gewoon afgekapt.

Dat wordt de volgende stap: OttoOps blijft aan.