Het draaien van grote AI-modellen betekent meestal dat je de hardware van iemand anders huurt, de prijzen van iemand anders accepteert en erop hoopt dat het model waar je van afhankelijk bent niet stilletjes van de ene op de andere dag verandert. Mesh LLM is gebouwd rond een andere premisse: dat gedistribueerde AI-computing over machines die je al bezit die hele regeling kan vervangen — en dit alles kan blootleggen via één enkele, vertrouwde API.
Summary
Belangrijkste punten
- Mesh LLM bundelt GPU’s en geheugen van meerdere machines in één enkele gedistribueerde AI-computing-mesh, toegankelijk via één OpenAI-compatibele API op localhost:9337/v1.
- Modellen kunnen lokaal draaien, worden doorgestuurd naar een peer of worden opgesplitst over machines met behulp van een pijplijnmodus genaamd “Skippy” — zonder dat de client ooit het verschil merkt.
- Netwerken is gebaseerd op iroh-endpoints, die openbaar-sleutel-geauthenticeerde, NAT-overbruggende QUIC-verbindingen tot stand brengen zonder dat een centrale server nodig is.
- De modelcatalogus wordt geleverd met meer dan 40 modellen, variërend van modellen met minder dan een miljard parameters tot mixture-of-experts-architecturen met 235 miljard parameters.
- Zowel deelname aan een publieke mesh als private implementaties worden ondersteund, met een mobiele app in ontwikkeling die gebruikmaakt van iroh’s Swift SDK.
Mesh LLM maakt gedistribueerde AI-computing mogelijk met gebundelde GPU’s
Het kernidee is bedrieglijk eenvoudig. Mesh LLM bundelt de GPU’s en het geheugen die verspreid staan over zoveel machines als je wilt toevoegen — een workstation in de ene kamer, een server in een andere, een machine aan de andere kant van het kantoor — en presenteert het geheel als één coherent rekenoppervlak. Geen herconfiguratie vereist voor de clientapplicaties die ermee verbinden.
Dat is belangrijk omdat de hardware al bestaat. Teams die AI-workloads draaien, hebben vaak GPU’s verspreid over kantoren, onder bureaus en in kleine serverruimtes. Wat ontbrak, is een laag die die machines zich als één laat gedragen.
OpenAI-compatibele API-abstractie
De interface die Mesh LLM blootlegt, is bewust vertrouwd. Elke OpenAI-compatibele client kan wijzen naar http://localhost:9337/v1 en verzoeken precies zo verzenden als naar een gehoste clouddienst. Vanuit het perspectief van de client verandert er niets. Waar het werk daadwerkelijk draait — lokaal, op een peer-machine of verspreid over meerdere — is volledig onzichtbaar.
Dit is een betekenisvolle ontwerpkeuze. Het betekent dat bestaande tools, workflows en integraties niet hoeven te worden herschreven. De gedistribueerde aard van de mesh is een implementatiedetail waar de client nooit over hoeft na te denken.
Flexibele uitvoeringsmodi, inclusief de “Skippy”-pijplijn
Wanneer een verzoek binnenkomt, heeft Mesh LLM drie manieren om het af te handelen. Het kan het model lokaal draaien op de GPU van de ontvangende machine, het verzoek doorsturen naar een peer die het doelmodel al geladen heeft, of — voor modellen die te groot zijn voor één enkele machine — de workload in volgorde over meerdere nodes verdelen. Dat derde pad heet “Skippy”-modus.
Hoe Skippy grote modellen over machines verdeelt
Skippy partitioneert een model per laagbereik in pijplijnstages: lagen 0 tot en met 15 kunnen op één node draaien, 16 tot en met 31 op de volgende, enzovoort langs de keten. Activaties stromen van stage naar stage door de mesh. Het praktische gevolg is dat een cluster van bescheiden machines gezamenlijk een model kan draaien dat geen van hen alleen in het geheugen zou kunnen houden.
Hier wordt de architecturale ambitie van Mesh LLM duidelijk. Een mixture-of-experts-model met 235 miljard parameters is niet iets wat de meeste teams op een enkele consumenten- of prosumer-GPU kunnen draaien. Skippy maakt het mogelijk om precies dat te proberen — met hardware die al is betaald en nu stilstaat. De latentie- en doorvoereigenschappen van zo’n opzet worden hier niet gekwantificeerd, maar de mogelijkheid zelf vertegenwoordigt een betekenisvolle uitbreiding van wat zelfgehoste AI kan bereiken.
Veilige peer-to-peer-netwerkarchitectuur met iroh-endpoints
Er is geen centrale server die de mesh coördineert. Elke node start een iroh-endpoint — een publieke sleutel die zowel dient als de identiteit van de node als zijn enige netwerkoppervlak. Vanuit die basis verzorgt iroh hole-punching, NAT-traversal en relay-fallback om directe, geauthenticeerde QUIC-verbindingen tussen twee willekeurige nodes tot stand te brengen, waar ze zich ook bevinden.
QUIC ALPN-protocollen voor verkeersscheiding
De protocolstack is bewust gesegmenteerd. Drie verschillende QUIC ALPN-identifiers scheiden verschillende soorten verkeer:
- mesh-llm/1 — het hoofdmesh-kanaal, dat gossip, routing, HTTP-tunnels en plugin-events vervoert
- mesh-llm-control/1 — het eigenaars-controlplane, dat configuratiesynchronisatie en eigendomsattestatie afhandelt
- skippy-stage/2 — een speciaal, latentiegevoelig transport voor activatiedata die tussen pijplijnstages stroomt
Binnen de hoofdverbinding wordt elke stream getagd met een leidende byte die het type identificeert — gossip, inference-proxying, routequeries, peer-lifecycle-events, plugin-RPC-kanalen en meer — allemaal gemultiplexed over één enkele verbinding. Het effect is schone verkeersscheiding zonder de overhead van aparte verbindingen voor elke zorg.
Node-identiteit en NAT-traversal
Om nodes te ondersteunen die elkaar niet direct kunnen bereiken via het open internet, draait Mesh LLM twee iroh-relayservers in verschillende geografische regio’s. Nodes die directe paden kunnen opzetten, doen dat; nodes die dat niet kunnen, hebben altijd een nabijgelegen fallback. De netwerklayer is, met andere woorden, ontworpen om gewoon te werken — in plaats van zorgvuldige firewallconfiguratie of statische adressering te vereisen.
Wat deze architectuur in feite oplevert, is een soort netwerkuniformiteit. Of een verzoek nu naar localhost wordt gerouteerd of activaties via een Skippy-pijplijn naar een machine op een ander continent streamt, de onderliggende primitief is dezelfde: een geauthenticeerde QUIC-verbinding geadresseerd via een publieke sleutel. De complexiteit van de fysieke topologie verdwijnt achter een consistente abstractie.
Een modelcatalogus van laptopschaal tot 235B-parameterreuzen
Mesh LLM wordt standaard geleverd met meer dan 40 modellen. Het bereik loopt van modellen met een half miljard parameters die klein genoeg zijn om op een laptop te draaien tot de mixture-of-experts-architecturen met 235 miljard parameters aan de bovenkant. De architectuur is inplugbaar: plugins declareren hun mogelijkheden in een manifest, en de runtime routeert aanroepen en stelt mogelijkheden bloot via MCP, HTTP, inference en mesh-events.
De praktische implicatie is dat gebruikers niet afzonderlijk modellen hoeven te zoeken en te configureren om aan de slag te gaan. De catalogus beslaat het volledige spectrum aan use-cases — van lichte, snelle inference op bescheiden hardware tot grootschalige workloads die over een mesh worden verdeeld.
Gedistribueerde compute als tegenbeweging
Het ontwerp van Mesh LLM staat tegen een zichtbaar decor: gecentraliseerde AI-infrastructuur ondervindt echte wrijving. Een enquête uit mei wees uit dat meer dan 70 procent van de Amerikanen tegen de bouw van nieuwe datacenters in de buurt van hun gemeenschappen is, onder verwijzing naar zorgen over vervuiling, geluid en energie en waterverbruik. Zonne- en thuisenergiebedrijf Sunrun lanceerde onlangs een pilotprogramma om kleine computenodes in de huizen van klanten te plaatsen, met de bedoeling die gedistribueerde rekenkracht te verkopen aan enterprise AI-afnemers — een teken dat de sector zelf zoekt naar alternatieven voor grote, geconsolideerde datacenters.
Mesh LLM benadert dezelfde druk vanuit een andere hoek. In plaats van nieuwe gedistribueerde infrastructuur vanaf nul op te bouwen, activeert het compute die al bestaat — GPU’s die teams bezitten maar niet volledig kunnen benutten omdat er geen coherente laag is die ze verbindt. De nadruk op het wegnemen van lock-in bij centrale aanbieders, het verlagen van kosten en het behouden van gebruikerscontrole over waar modellen draaien en waar data naartoe gaat, weerspiegelt een echte leemte in wat bestaande cloud-API’s kunnen bieden.
Er is een mobiele app in ontwikkeling die is gebouwd op iroh’s Swift SDK, met plannen om de opkomende ACP-agentstandaard te ondersteunen. Dat zou andere clients in staat stellen om direct tot de mesh toe te treden, waardoor de netwerkeffecten van elke node die online komt worden vergroot. De langetermijnrichting is duidelijk: meer peer-to-peer-uitvoering, minder tussenpersonen en een open standaard voor agentinteroperabiliteit die niet via de centrale server van iemand anders loopt.
FAQ
Hoe maakt Mesh LLM gedistribueerde AI-computing mogelijk?
Mesh LLM bundelt GPU’s en geheugen van meerdere machines in een mesh-netwerk en stelt de volledige gedistribueerde opzet vervolgens bloot als één enkele OpenAI-compatibele API. Clients verbinden met localhost:9337/v1 en interacteren normaal, terwijl de mesh beslist of verzoeken lokaal worden uitgevoerd, naar een peer worden gerouteerd of over machines worden opgesplitst.
Welke uitvoeringsmodi ondersteunt Mesh LLM voor AI-modellen?
Modellen kunnen lokaal draaien op de GPU van een machine, worden doorgestuurd naar een peer die het model al geladen heeft, of worden opgesplitst over meerdere machines met behulp van de “Skippy”-pijplijnmodus, waarbij een model per laagbereik wordt gepartitioneerd en activaties van stage naar stage door de mesh stromen.
Hoe wordt veilige netwerking afgehandeld in Mesh LLM?
Elke node draait een iroh-endpoint dat openbaar-sleutel-geauthenticeerde QUIC-verbindingen tot stand brengt met NAT-traversal en relay-fallback, zonder afhankelijk te zijn van een centrale server. Twee regionale iroh-relays bieden fallbackpaden voor nodes die niet direct kunnen verbinden.
Welke modellen zijn beschikbaar via Mesh LLM?
Mesh LLM wordt geleverd met meer dan 40 modellen, variërend van kleine modellen met een half miljard parameters die geschikt zijn voor laptops tot zeer grote mixture-of-experts-modellen met 235 miljard parameters, bedoeld voor Skippy-implementaties over meerdere machines.
{“@context”:”https://schema.org”,”@type”:”FAQPage”,”mainEntity”:[{“@type”:”Question”,”name”:”Hoe maakt Mesh LLM gedistribueerde AI-computing mogelijk?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Mesh LLM bundelt GPU’s en geheugen van meerdere machines in een mesh-netwerk en stelt de volledige gedistribueerde opzet vervolgens bloot als één enkele OpenAI-compatibele API. Clients verbinden met localhost:9337/v1 en interacteren normaal, terwijl de mesh beslist of verzoeken lokaal worden uitgevoerd, naar een peer worden gerouteerd of over machines worden opgesplitst.”}},{“@type”:”Question”,”name”:”Welke uitvoeringsmodi ondersteunt Mesh LLM voor AI-modellen?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Modellen kunnen lokaal draaien op de GPU van een machine, worden doorgestuurd naar een peer die het model al geladen heeft, of worden opgesplitst over meerdere machines met behulp van de “Skippy”-pijplijnmodus, waarbij een model per laagbereik wordt gepartitioneerd en activaties van stage naar stage door de mesh stromen.”}},{“@type”:”Question”,”name”:”Hoe wordt veilige netwerking afgehandeld in Mesh LLM?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Elke node draait een iroh-endpoint dat openbaar-sleutel-geauthenticeerde QUIC-verbindingen tot stand brengt met NAT-traversal en relay-fallback, zonder afhankelijk te zijn van een centrale server. Twee regionale iroh-relays bieden fallbackpaden voor nodes die niet direct kunnen verbinden.”}},{“@type”:”Question”,”name”:”Welke modellen zijn beschikbaar via Mesh LLM?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”Mesh LLM wordt geleverd met meer dan 40 modellen, variërend van kleine modellen met een half miljard parameters die geschikt zijn voor laptops tot zeer grote mixture-of-experts-modellen met 235 miljard parameters, bedoeld voor Skippy-implementaties over meerdere machines.”}}]}
Artikel geproduceerd met behulp van kunstmatige intelligentie en beoordeeld door de redactie.
