Lumabri: Grote MoE-modellen draaien via een swarm van peers met de Colibri engine

Een machine deelt een model, terwijl elke andere machine ermee kan chatten. Er wordt vooraf niets gedownload: de bytes die een inferentie daadwerkelijk nodig heeft, komen bij het eerste gebruik van een peer en blijven opgeslagen in een lokale mirror. Hierdoor wordt een tweede vraag met volledige snelheid vanaf de lokale schijf beantwoord. Het binary-bestand van de engine wordt nooit gewijzigd.

Elke machine kan deelnemen, ongeacht of deze over een GPU beschikt. De engine is primair gebouwd voor CPU en SSD; een GPU maakt het proces enkel sneller, niet anders. De output is in beide gevallen byte-voor-byte identiek. Terwijl netwerken die GPU's poolen afhankelijk zijn van een kleine groep machines, rekruteert Lumabri iedereen.

Snelstart

Start met: make

Op de machine die het model bezit (een willekeurige Colibri model-directory): ./lumabri serve --model /pad/naar/model

Op een machine die wil chatten (hiervoor is een Colibri build voor de engine nodig): ./lumabri chat --tracker <server-ip>:7300 --engines-dir /pad/naar/colibri/c

Het eerste antwoord is trager omdat de benodigde data over het netwerk moet worden verplaatst. Daarna blijft de mirror in ~/.lumabri dienen, zelfs als de server offline gaat.

Opmerking: Heeft u geen model bij de hand? Gebruik make fixture om een klein synthetisch model te bouwen, zodat alle bovenstaande stappen getest kunnen worden.

Alleen de Terminal UI

Start simpelweg met het commando: lumabri

Zonder argumenten vraagt het programma om het swarm-adres en (eenmalig) om de publieke sleutel van de operator. De engines worden automatisch gevonden en alle instellingen worden onthouden in ~/.lumabri/config. Bij een tweede keer opstarten volstaat twee keer op 'Enter' drukken. Vlaggen (flags) hebben altijd prioriteit, zodat scripts nooit per ongeluk opgeslagen antwoorden overnemen.

Binnen de chat tonen de volgende commando's informatie:

• /swarm: Toont het netwerk live en anoniem (peers zijn genummerd, niet benoemd).
• /model: Lijst de modellen in de swarm op en schakelt er on the fly tussen.

Hoe het werkt

Het delen van bytes

Het commando serve draait twee kleine programma's:

1. Een tracker, die fungeert als index van wie welke bestanden bezit.
2. Een maintainer, die antwoordt op byte-range leesverzoeken in de modeldirectory.

Een maintainer kan een deel van een model vasthouden, en meerdere maintainers kunnen samen één model delen.

Het lezen van bytes

De chat-functie monteert het model via liblumabri.so, een LD_PRELOAD-shim die de weinige libc-aanroepen onderschept die een engine maakt op een modeldirectory (open, fopen, opendir, pread). Bestanden verschijnen als sparse lokale mirrors van de werkelijke grootte, waardoor fstat, readdir en de page cache natief werken.

Een ontbrekend blok wordt opgehaald bij een peer, naar de mirror geschreven, waarna de eigen pread van de engine verdergaat. Een 'warm' leesproces bestaat uit een tabelopzoeking plus een normale lokale leesactie: er is geen FUSE of daemon nodig in het leespad. Elk geverifieerd MiB wordt ook via sha256 opgeslagen in een lokale content-addressed store (CAS). Het standaard CLI-pad, ~/.lumabri/cas, wordt gedeeld door elk checkpoint; identieke chunks worden dus slechts één keer gedownload en kunnen een andere sparse mirror herbouwen zonder byteserver.

Er geldt één strikte regel, overgenomen van Colibri: het netwerk mag veranderen waar bytes vandaan komen, maar nooit welke bytes dat zijn. Het schrijven naar een modelbestand resulteert in EROFS. Een blok dat geen enkele peer kan leveren, veroorzaakt een duidelijke EIO en nooit stille nullen. De identiteit van de bytes wordt geverifieerd bij koude starts, warme reads en zelfs wanneer elke peer offline is.

Experts draaien op peers

Voor een Mixture-of-Experts model houdt de chatter alleen de dense gewichten, de router en de KV-cache vast. De 4 KB activatie wordt verzonden naar de peer die de betreffende gerouteerde expert bezit. Expert-gewichten bereiken nooit de chatter.

Beide zijden zijn gebouwd vanuit de broncode van de engine, waardoor de lokale run en de gedistribueerde run één codepad volgen en identieke tokens produceren. Een peer adverteert ook zijn exacte build (engine, source hash, ISA, compiler, kwantisatie, model root). Een chatter weigert een peer wiens build afwijkt voordat er een enkele activatie wordt verzonden; een -march=native rebuild kan namelijk het laatste bit veranderen, wat nooit onopgemerkt mag gebeuren.

Vertrouwen en Beveiliging

Peers worden niet blindelings vertrouwd. Elke maintainer berekent een sha256 per MiB van de inhoud en verzendt dit bij registratie. De oorsprong kan deze waarheid ondertekenen met een ed25519-sleutel die offline wordt bewaard; de tracker draagt enkel de handtekening en kan er zelf geen maken. Een chatter verifieert elk blok tegen een sleutel die hij zelf bezit. Bytes van een leugenaar worden afgewezen en elders opnieuw opgehaald.

Remote compute wordt gecontroleerd via LUMABRI_VERIFY=N, wat N procent van de expert-aanroepen herhaalt op een tweede replica en identieke output eist. Een meningsverschil tussen twee eerlijke peers is onmogelijk, dus is een verschil het bewijs van een leugen, waarna de run stopt.

Prefill en target-verificatie komen bij de MoE al aan als meerdere rijen. Lumabri houdt deze unie intact en verzendt één multi-row EXEC per geselecteerde expert, inclusief speculatieve draft-verificatie; batches worden nooit geserialiseerd in requests ter grootte van één rij. LUMABRIHEDGEMS=N kan optioneel een duplicaat verzenden naar de volgende replica als de dichtstbijzijnde peer niet binnen N milliseconden reageert, waarbij het eerste geldige deterministische resultaat wordt gebruikt.

Engines

Colibri levert verschillende engines die geen gedeelde vorm hebben. De expert-zijde is daarom per engine geregeld via een kleine patch die de MoE-functie koppelt en een expert_node binary die uit de broncode van die specifieke engine is gebouwd. De originele engine wordt nooit aangeraakt; de patch wordt toegepast op een kopie.

Engine	Model	Experts on Peers	Bewijs / Test
olmoe	OLMoE	Ja	expertnode, bewezen door phase2test.sh
colibri	GLM	Ja	expertnodeglm, bewezen door phase2glmtest.sh
inkling	Inkling	Ja	expertnodeinkling, bewezen door phase2inklingtest.sh
kimi_k3	Kimi K3	Ja	expertnodekimi, bewezen door phase2kimitest.sh
deepseek	DeepSeek V4	Ja	expertnodedeepseek, bewezen door phase2deepseektest.sh

"Bewezen" betekent hier dat het experiment is uitgevoerd: dezelfde engine en prompt zijn tweemaal gegenereerd, één keer met lokale experts en één keer met experts op een peer, waarna de tokens bit-voor-bit zijn vergeleken.

Build de peers met make engines, de gepatchte chat-engines met make chatters, of beide met make phase2-all ENGINE=/pad/naar/colibri/c.

Een swarm draaien

Een volledige handleiding voor servers (systemd, firewall, operator key, clients) is te vinden in DEPLOY.md. De verkorte versie:

make && make phase2-all ENGINE=/path/to/colibri/c   # phase2-all optioneel
sudo make install                                    # of PREFIX=$HOME/.local

Op de server opent lumabri serve --model /srv/model TCP-poorten 7300 tot 7302 (tracker, maintainer, executor). Voeg --advertise <public-ip> toe voor het snelste directe pad en --key swarm.key om het model te ondertekenen.

Rollen voor andere machines:

Doel	Commando
Chatten	lumabri chat --tracker SERVER:7300 --engines-dir /path/to/colibri/c
Chatten op machine met model	lumabri chat --local DIR
Disk doneren (bytes hosten)	lumabri serve --model ./slice --join SERVER:7300 --model-name NAME --donate GB
Compute doneren (experts draaien)	expert_node<engine> --model DIR --tracker SERVER:7300 --cache N

Een disk-donor krijgt van de tracker te horen welke bestanden hij moet hosten, beginnend met de zeldzaamste. Een compute-donor geeft aan hoeveel experts hij kan dragen (--hold N) en de tracker wijst het deel toe dat niemand anders dekt. Tijdens het genereren van een antwoord kan een donor worden beëindigd; u krijgt één failover-melding te zien, maar de tokens blijven identiek doorgaan.

Sleutelrotatie

Voor handmatige rotatie van ondertekeningssleutels wordt een keyring gedistribueerd met één publieke sleutel per regel. --pubkey keyring en LUMABRI_PUBKEY=keyring accepteren elke sleutel in de lijst (tot 16). Deploy eerst oud+nieuw, start daarna de origin-signing met het nieuwe geheim, en verwijder pas de oude regel nadat clients en donors zijn overgestapt. Zet de nieuwste sleutel onderaan: de tracker bewaart de geldige handtekening gemaakt door de hoogste prioriteit (laatste) sleutel.

Versleuteld transport en peer-identiteit

Stel LUMABRI_ENCRYPT=1 in op elke tracker, maintainer, expert node en chatter om tokens, modelblokken en activaties te versleutelen met een geauthenticeerde X25519/Ed25519 handshake en ChaCha20-Poly1305 frames. Als een peer-sleutel niet geladen of gemaakt kan worden, faalt de netwerkverbinding direct in plaats van terug te vallen op plaintext.

Elke machine bewaart zijn private endpoint-identiteit in ~/.lumabri/peer.key. De publieke helft wordt getoond met lumabri peer-key. Outbound endpoints worden geregistreerd in ~/.lumabri/known_hosts; een gewijzigde sleutel wordt bij latere verbindingen geweigerd.

Voor bescherming tegen MITM bij het eerste contact kan een door de operator beheerd bestand worden gedistribueerd: SERVER:7300 64HEXPEERKEY SERVER:7301 64HEXPEERKEY SERVER:7302 64HEXPEER_KEY

Stel vervolgens LUMABRIPEERPINS=/pad/naar/peer-pins in. De endpoint-sleutel is niet dezelfde als de model-ondertekeningssleutel: LUMABRI_PUBKEY authenticeert de inhoud van het model, terwijl peer pins de netwerkeindpunten authentificeren.

Testen

Gebruik make test voor de kernsuites: byte-identiteit, donor-integriteit, rol-parsing, security (path escape, hostile frame lengths, etc.), protocol-validatie, cryptografische vectoren en versleuteld transport.

Per-engine expert identiteit draait met fixtures (make test-engines) en DeepSeek V4 wordt getest tegen een echt model (make test-phase2-deepseek MODEL=<dir>). Andere mechanismen hebben eigen scripts zoals assigntest.sh, concurrencytest.sh en sign_test.sh.

Vergelijking

Peer-to-peer LLM-inferentie bestaat al, maar deze specifieke combinatie niet. Projecten zoals Petals en llama.cpp RPC splitsen opeenvolgende transformer-lagen over verschillende apparaten, wat in de praktijk vereist dat elk segment snel draait (meestal via een GPU).

Lumabri splitst echter op expert-granulariteit, wat aansluit bij de MoE-sparsity: er reist slechts 4 KB per expert. Hierdoor is zelfs een peer zonder GPU nuttig en vormt een swarm zonder GPU's nog steeds een werkend geheel. De output is constructief byte-identiek, omdat remote en lokale uitvoering dezelfde code gebruiken; dit maakt ook spot-check verificatie van onbetrouwbare peers mogelijk.

Vereisten

• Linux
• gcc
• GNU make
• Python 3 met numpy (alleen voor de test fixtures)
• Een Colibri build voor de engine binaries

Status

Het project is een werkend prototype en kan worden uitgerold. Open swarms verifiëren bytes (sha256 per MiB en een ondertekende complete-model root) en resultaten (spot-check op een tweede replica). Private swarms kunnen een invite-token toevoegen via LUMABRI_TOKEN.

Implementaties zijn aanwezig voor:

• Multi-row speculatieve verificatie.
• Fixed-delay hedging.
• Lokale cross-checkpoint CAS.
• Handmatige oud+nieuw sleutelrotatie.
• NAT relay voor zowel READ als EXEC.

Automatische SLA-tuning, gedistribueerde/S3 CAS, KMS/HSM integratie en automatische intrekking zijn bewust geen onderdeel van deze dependency-vrije basis. Expert-executie wordt gecontroleerd door replica-overeenstemming, niet door de handtekening van de operator.

Licentie

Apache 2.0