Hoe je Console AI-agents omtovert tot een Pixel-kantoor uit The Office

Onlangs stuitte ik op een repository die je moeilijk kunt passeren als je ooit autonome console-hulpprogramma's zoals Claude Code hebt uitgevoerd en jezelf hebt betrapt op de gedachte dat het beheren van tientallen open terminaltabs ongelooflijk onhandig is. Het project heet Munder Difflin.

De auteurs benaderden terminal-agent-orchestratie met onverwachte humor. Ze wikkelden console-processen in een desktop-applicatie gebouwd met Electron en Pixi.js, waar elke draaiende agent rondloopt in een pixelkantoor, virtuele enveloppen draagt en met collega's communiceert via het lokale bestandssysteem. Toezichthoudend over alles zit je kloon genaamd Michael, in een apart kantoor.

Het klinkt als een grapjesspeeltje, maar onder de motorkap zit serieuze infrastructuur voor het parallel uitvoeren van Claude Code, Antigravity, OpenAI Codex, Kimi, Qwen en lokale modellen via Ollama.

Wat is dit eigenlijk

In plaats van een aangepaste API-client voor elk model te ontwikkelen, maakt Munder Difflin gebruik van de kant-en-klare CLI-tools die je al in de terminal uitvoert. De applicatie start een echte pseudo-terminal op voor elke agent via node-pty en rendert deze in de interface met xterm.js.

Hierdoor werkt de agent in zijn native omgeving. Het behoudt toegang tot lokale bestanden, voert tests uit, maakt commits en leest build-output precies alsof je het handmatig in een reguliere iTerm- of Alacritty-tab had gestart.

Het belangrijkste verschil is dat processen worden verenigd in een gedeeld netwerk. Je geeft een high-level taak aan de hoofd-orchestrator-agent (GOD-agent), die subtaken distribueert onder gespecialiseerde agents, hun status monitort en alleen om je toestemming vraagt voordat gevaarlijke operaties worden uitgevoerd.

Hoe agent-interactie werkt

De gehele architectuur is gebouwd op lokale bestanden en het Git-protocol, zonder externe clouddatabases.

Postvakken en gedeeld geheugen

Wanneer agents context of werkresultaten moeten doorgeven, roepen ze geen complexe externe RPC's aan. Het systeem gebruikt een postvakarchitectuur direct op schijf:

1. De agent schrijft een bericht of artifact naar zijn lokale directory outbox/.
2. Een interne router verplaatst het bestand naar de map van de ontvanger inbox/.
3. De ontvanger ontwaakt via een bestandssysteem-event, leest het bericht en pakt de taak op.
4. Langetermijngeheugen wordt opgeslagen als platte Markdown en geïndexeerd door lokale semantische zoekopdrachten voor snelle contextophaling tussen sessies.

Om te voorkomen dat parallelle processen index.lock in de repository blokkeren, gaan schrijfacties naar de commit-historie via een enkel committer-proces.

Bescherming tegen oneindige lussen en budgetoverschrijdingen

Een van de belangrijkste problemen met autonome CLI-agents is het risico op loopen, wanneer een script herhaaldelijk dezelfde test probeert te repareren of de API bestookt met honderden verzoeken.

Munder Difflin heeft een ingebouwd Circuit Breaker-mechanisme:

• Elke agent heeft een harde tokenlimiet en real-time kostenmonitoring van verzoeken uit logs.
• Het systeem volgt cascadeerende fouten en herhaalpogingen van mislukte commando's.
• Bij overschrijding van het budget of afwijkend gedrag ontvangt de agent eerst een waarschuwing en contextbeperking, en als de fouten aanhouden wordt deze geforceerd gestopt.
• Destructieve acties, scope-wijzigingen en geld uitgeven vereisen bevestiging via het Approvals-panel.

Wat zit erin: technische stack

Architecturaal is de applicatie opgedeeld in twee geïsoleerde vlakken die samenkomen in Electron:

┌───────────────────────────────────────────────────────────────┐
│                     Electron Renderer (React)                 │
│   ┌──────────────────┐    ┌──────────────────────────────┐    │
│   │ Office Floor     │    │ Terminal + Command Bar       │    │
│   │ (Pixi.js)        │    │ Files + Git tabs (xterm.js)  │    │
│   └─────────▲────────┘    └────────────▲─────────────────┘    │
│             │ avatar state             │ pty bytes / fs / git │
└─────────────┼──────────────────────────┼──────────────────────┘
              │ IPC (contextBridge: window.cth)
       ┌──────┴──────────┐        ┌──────┴─────────────┐
       │  Event Plane    │        │  Terminal Plane    │
       │  hooks / hive   │        │  node-pty PTYs     │
       │  router + GOD   │        │  + fs + git        │
       └────────▲────────┘        └──────▲─────────────┘
                │ hook payloads          │ stdin / stdout
                └─────────┬──────────────┘
                   ┌──────┴──────────────┐
                   │ claude / agy / codex│
                   └─────────────────────┘

Het hoofd Node.js-proces beheert de terminal-levenscyclus, bestandsroutering en een SQLite-database voor persistentie van sessiegeschiedenis. De renderer op React en Pixi.js ontvangt data via een getypte IPC-bridge window.cth.

Naast de visuele kantooromgeving bevat de desktop-client een ingebouwde Monaco-editor, een taken-kanbanbord met afhankelijkheden, een Git diff-viewer en Slack-webhook-integratie. Je kunt een taak naar een werkchat sturen, Michael zal een tijdelijke agent op de achtergrond aanmaken, het probleem oplossen en het antwoord naar de thread terugsturen.

Hoe te deployen en uit te proberen

Om het te draaien heb je Node.js 18+, een C/C++-compiler voor het bouwen van de native module node-pty (op macOS zijn Xcode Command Line Tools voldoende) en minimaal één geïnstalleerde console-agent nodig.

Clone de repository en draai het project in ontwikkelingsmodus:

git clone https://github.com/chaitanyagiri/munder-difflin.git
cd munder-difflin
npm install
npm run dev

Bij de eerste lancering opent een setup-wizard. Daar kun je paden naar de binaries claude, codex, copilot opgeven of adressen instellen voor lokale LM Studio / Ollama / vLLM-servers.

Als de vereiste binary niet in het systeem staat, kan de applicatie auto-installatie uitvoeren rechtstreeks in het ingebouwde terminalvenster.

Wie heeft baat bij dit project

Munder Difflin is moeilijk een lichtgewicht dagelijks hulpprogramma te noemen—Electron en sprite-rendering via Pixi.js vragen voorspelbaar resources. Maar als je vaak experimenteert met multi-agent-scenario's, complexe refactorings schrijft aangedreven door meerdere modellen, of het beu bent om parallelle Claude Code-lanceringen in tmux handmatig te besturen, valt er hier veel te leren.

Het concept van het beheren van processen via Markdown-bestanden, branch-isolatie via git worktrees en mensvriendelijke visuele controle over wat er gebeurt maken dit project tot een van de meest originele open-source hacks rond lokale AI-agents. De repository wordt actief onderhouden, de code is geschreven in schone TypeScript, dus graven in de interne hooks en PTY-handlers is zeker de moeite waard.