---
title: "Mesh LLM: LLM Distribuido en Varios Ordenadores"
canonical: https://wavect.io/es/blog/mesh-llm-distributed-inference-multiple-computers/
language: es
description: "Análisis de Mesh LLM: cómo Skippy reparte un LLM entre varios ordenadores, benchmarks, límites de red, seguridad, alternativas y plan de piloto."
image: "https://wavect.io/img/general/bak/open_graph_preview.jpg"
---

[**Volver**](/es/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/es/team/kevin-riedl/)

[Kevin Riedl](/es/team/kevin-riedl/) https://linkedin.com/in/wsdt

12 min de lectura · 18 de julio de 2026

[**Siguiente**](/es/blog/ai-vendor-security-questionnaire-eu/)

# Mesh LLM: ¿Puede un LLM ejecutarse en varios ordenadores?

Resumen

Mesh LLM puede ejecutar un LLM compatible entre varios ordenadores cuando ninguno tiene memoria suficiente. Skippy asigna rangos contiguos de capas, cada peer descarga los fragmentos GGUF de su etapa y las activaciones cruzan la cadena por cada token. El cliente mantiene una sola API compatible con OpenAI en localhost:9337/v1. Es paralelismo de modelo por pipeline, no balanceo de carga, y suma capacidad sin garantizar velocidad. El reality check del proyecto baja de 68 tok/s en un host a 21 con dos nodos y 12-13 con tres para un modelo que ya cabía solo. Latencia, etapa más lenta, caché de contexto, soporte de familia y fiabilidad determinan el resultado. El mejor caso comercial es una malla privada de baja latencia cuando el modelo necesario supera por poco cada equipo. Empieza con dos nodos por cable, un artefacto inmutable revisado, evals reales, pruebas de fallo y coste por tarea exitosa antes de comprar hardware o entrar en producción.

**Sí. Mesh LLM puede ejecutar un modelo grande compatible entre varios ordenadores cuando ninguno tiene memoria suficiente por sí solo.** Skippy asigna rangos contiguos de capas a distintos peers. Cada uno descarga los fragmentos GGUF de su etapa y las activaciones cruzan la cadena por cada token generado. La aplicación sigue llamando a un único endpoint compatible con OpenAI en `http://localhost:9337/v1`.

La respuesta de compra necesita una precisión: **sumar capacidad no garantiza sumar velocidad.** Cada etapa añade comunicación al decode secuencial y el peer más lento puede limitar toda la ruta. Mesh LLM tiene más sentido cuando el modelo no cabe en ninguna máquina. Si ya cabe, ejecutarlo localmente suele ser más rápido y fiable.

Este análisis refleja el repositorio y su documentación primaria a **18 de julio de 2026**. Separamos funciones documentadas, benchmarks publicados y lo que aún debes demostrar en tu hardware.

| Pregunta | Respuesta actual | Implicación |
| --- | --- | --- |
| ¿Qué resuelve? | Inferencia local, routing a peers y split multinodo tras una API | Reutilizar equipos antes de comprar un host mayor. |
| ¿Cómo divide el modelo? | Etapas de capas contiguas con transferencia de activaciones | Una petición pasa por varios equipos. No es balanceo de carga normal. |
| Formato | GGUF y paquetes de fragmentos por capas | El soporte depende del artefacto, runtime y límite de split revisado. |
| Interfaz | API `/v1` compatible con OpenAI en el puerto 9337 | Muchas apps solo cambian la base URL. |
| Red | QUIC sobre iroh, tokens privados, Nostr o descubrimiento LAN | Conectar es más fácil, pero latencia y confianza siguen siendo tuyas. |
| Licencia | Apache 2.0 | Runtime permisivo; revisa la licencia de cada modelo. |
| Evidencia productiva | Prometedor, con pocos benchmarks generalizables | Necesita un piloto acotado antes de producción. |

## ¿Qué es Mesh LLM?

[Mesh LLM es un runtime Apache 2.0 para inferencia distribuida](https://github.com/Mesh-LLM/mesh-llm). Cada nodo ofrece la misma API. El sistema puede ejecutar el modelo localmente, enviar la petición completa a un peer que ya lo sirve o dividir un solo modelo entre peers mediante Skippy.

1. **Local:** la máquina actual ejecuta todo el modelo cuando cabe.
2. **Routing:** la petición completa va al host que tiene el modelo.
3. **Split por etapas:** varios equipos ejecutan rangos distintos de capas para la misma petición.

La app solo ve modelo, petición y respuesta. Placement, descargas, readiness, recuperación y seguridad siguen siendo trabajo de infraestructura.

## ¿Cómo divide Skippy un modelo entre varios PCs?

El [flujo documentado de Skippy](https://github.com/Mesh-LLM/mesh-llm/blob/main/docs/SKIPPY_SPLITS.md) funciona como pipeline:

1. El coordinador resuelve el modelo o paquete.
2. El planner elige peers y rangos contiguos.
3. La etapa final carga primero.
4. Cada peer descarga metadatos comunes y solo sus capas.
5. La etapa 0 no se publica hasta que todas están listas.
6. El prompt entra por la etapa 0, las activaciones avanzan y el token vuelve al stream.

En un modelo de 48 capas, A podría ejecutar 0 a 15, B 16 a 31 y C 32 a 47 más la salida. No son tres modelos independientes. Es una única ruta con dos fronteras de red.

Los paquetes incluyen manifest, hashes, artefactos comunes y fragmentos GGUF. Para entornos serios, el proyecto recomienda revisiones inmutables y comandos que validan tamaño, SHA, archivos, manifest y respuestas reales de `/v1`. Un GGUF cualquiera no se convierte automáticamente en un split seguro.

## ¿Es solo balanceo de carga?

**No. El balanceo envía peticiones completas a réplicas completas. Skippy envía una petición por varios equipos porque cada uno ejecuta capas diferentes.**

| Patrón | Qué se mueve | Objetivo |
| --- | --- | --- |
| Balanceo | Petición completa a una réplica | Concurrencia y disponibilidad |
| Routing a peer | Petición completa al host del modelo | Reusar inventario distribuido |
| Pipeline split | Activaciones entre etapas | Hacer caber un modelo en memoria combinada |
| Paralelismo tensorial | Resultados parciales dentro de las capas | Paralelizar el cálculo de cada capa |

Tres GPU de 24 GB no se convierten literalmente en una GPU de 72 GB. El software aprovecha la capacidad combinada, pero no fusiona ancho de banda, compute ni dominios de fallo.

## ¿Cuánta velocidad pierde la inferencia multinodo?

Depende. La [página de benchmarks lo llama un control de realidad, no una promesa](https://github.com/Mesh-LLM/mesh-llm/blob/main/docs/BENCHMARKS.md). Para GLM-4.7-Flash Q4 de 17 GB en un M4 Max y un Mac mini M4 por Wi-Fi publica:

| Configuración | Velocidad | Frente a solo |
| --- | --- | --- |
| Solo | 68 tok/s | 100% |
| Dos nodos, 85/15 | 21 tok/s | 31% |
| Tres nodos, 62/31/8 | 12 a 13 tok/s | 18% a 19% |

El modelo ya cabía en una máquina. La prueba mide overhead sin aportar la ventaja principal de capacidad. Tampoco ofrece suficiente contexto para convertirla en ratio universal del Skippy actual. Sirve para descartar una expectativa: no hay speedup lineal.

El modelo del planner es más útil. Con una hipótesis de 10 ms por transferencia, dos etapas ya tienen un suelo de red de 20 ms/token, tres de 30 y cuatro de 40, antes del compute. El [planner prefiere menos saltos físicos](https://github.com/Mesh-LLM/mesh-llm/blob/main/docs/skippy/TOPOLOGY_PLANNER.md) cuando la memoria lo permite.

## ¿Qué controla el rendimiento real?

- **Latencia:** cada token repite las transferencias. Ethernet y Wi-Fi congestionado no son equivalentes.
- **Etapa más lenta:** una GPU débil, offload a CPU, temperatura o procesos de fondo frenan toda la cadena.
- **Contexto y caché:** KV y estado recurrente crecen con contexto y concurrencia.
- **Formato de activación:** f16 es el default conservador. q8 solo se acepta por familia y split cuando supera exactitud.
- **Disponibilidad:** si un portátil duerme o un peer reinicia, la ruta requerida se rompe.

La [matriz de soporte](https://github.com/Mesh-LLM/mesh-llm/blob/main/docs/skippy/FAMILY_STATUS.md) registra artefactos, splits, wire types, caché y restricciones. Que una arquitectura exista en llama.cpp no certifica cualquier split.

## ¿Qué modelos y hardware admite?

La matriz incluye artefactos revisados de Qwen, Llama, DeepSeek, GLM, Gemma, Phi, Granite, Hunyuan, Mamba, RWKV, Falcon y algunos modelos multimodales. El soporte cambia según cuantización, proyector, caché, wire type y frontera. Parte siempre del artefacto recomendado y certifica paquete y runtime.

El README documenta bundles para macOS y Linux con Metal, CPU, CUDA, ROCm y Vulkan. Windows puede compilarse desde fuente, pero la publicación de bundles de Windows figura desactivada. Comprueba los assets de la versión elegida.

## ¿Qué privacidad ofrece?

Una malla privada usa token de invitación. Las publicadas anuncian su presencia mediante Nostr. El modo LAN con mDNS evita relays Nostr, relays iroh públicos y sondeos STUN públicos. Descubrir un peer no implica confiar en él.

La [documentación de seguridad](https://github.com/Mesh-LLM/mesh-llm/blob/main/docs/MESHES.md) ofrece claves de owner, allowlists, tokens firmados y requisitos de release attestation. También reconoce su límite: una firma prueba procedencia del build, no que el proceso, sistema operativo o hardware remoto estén intactos.

Para datos confidenciales usa máquinas controladas, política de admisión, listeners restringidos, tokens protegidos y logs revisados. El descubrimiento público no es confidential computing.

## Mesh LLM frente a Exo, llama.cpp RPC y vLLM

| Opción | Mejor encaje | Diferencia |
| --- | --- | --- |
| Mesh LLM | Equipos heterogéneos, GGUF y control del operador | Local, routing y split de capas tras una API |
| Exo | Cluster Apple Silicon con Thunderbolt rápido | Foco MLX y soporte pipeline/tensor; consulta la [comparación del proyecto](https://github.com/Mesh-LLM/mesh-llm/blob/main/docs/EXO_COMPARISON.md) |
| llama.cpp RPC | Equipos técnicos con topología manual | Primitivas de menor nivel, menos producto y routing |
| vLLM o SGLang | Servidores GPU productivos y red de datacenter | Mejor orientación a throughput y operación homogénea |
| Gateway API | Enrutar peticiones completas entre backends | No hace caber un solo modelo sobredimensionado |

Este artículo responde a capacidad y topología. Para la economía usa nuestro [break-even entre modelos locales y APIs](/es/blog/local-models-vs-apis-break-even-eu-2026/). Para elegir pesos, consulta la [comparativa de LLM open-weight](/es/blog/open-weight-llm-comparison-2026/). Así una runtime interesante no elige por ti la arquitectura comercial.

## ¿Quién debería probar Mesh LLM?

| Situación | Veredicto | Razón |
| --- | --- | --- |
| Dos a cuatro workstations ociosas en LAN rápida | **Buen piloto** | Capacidad clara y red medible |
| El modelo supera por poco cada host | **Mejor caso** | Dos etapas pueden evitar compra o peor cuantización |
| Investigación privada o batch flexible | **Buen encaje** | Capacidad y control pesan más que latencia |
| El modelo ya funciona bien en un host | **Mantener local** | El split añade overhead y fallos |
| API de cliente con SLA estricto | **Demostrar primero** | Medir carga, fallos, recuperación y p99 |
| Datos sensibles en peers públicos desconocidos | **No usar** | Discovery y firma no prueban confianza del host |

## Piloto de Mesh LLM en siete pasos

1. Define 30 a 100 prompts reales, contexto, salida, concurrencia y rúbrica.
2. Mide el mejor host: TTFT, tok/s, memoria, éxito, potencia y fallos.
3. Elige un artefacto revisado, revisión inmutable y licencia válida.
4. Empieza con dos nodos por cable. Añade etapas solo por memoria.
5. Prueba contexto y concurrencia reales, no un único prompt.
6. Rompe un peer a propósito y verifica detección, retirada, recuperación y errores.
7. Compara coste por tarea exitosa con ingeniería, energía, depreciación, redundancia y fallback API.

La decisión final debe fijar modelo máximo, mínimo número de etapas, presupuesto de fallo, frontera de confianza y fallback. Nuestro [caso Twinsoft AI](/es/case-studies/twinsoft-ai/) y la [guía para elegir stack](/es/software-development-guide/how-to-choose-a-tech-stack-for-mvp/) aplican el mismo criterio: medir antes de comprometer arquitectura.

## Fuentes y método

Arquitectura, comandos, API, artefactos, soporte, seguridad y benchmarks proceden del [repositorio Mesh LLM](https://github.com/Mesh-LLM/mesh-llm) y de sus documentos primarios enlazados. No reproducimos los benchmarks de hardware. Verificamos los hechos el 18 de julio de 2026 y omitimos cifras volátiles como estrellas, número de releases o total de familias.

## Preguntas frecuentes

### ¿Puede Mesh LLM combinar GPU de varios ordenadores?

Sí. Skippy asigna rangos contiguos de capas a peers y mueve activaciones. Combina capacidad útil mediante pipeline, no crea una GPU literal de memoria compartida.

### ¿Es Mesh LLM balanceo de carga?

No. El balanceo envía una petición completa a una réplica completa. Un split envía la misma petición por varias etapas de capas.

### ¿La inferencia distribuida hace el LLM más rápido?

No necesariamente. Permite que quepa un modelo mayor, pero añade red secuencial. Si el modelo ya cabe en un equipo, normalmente será más rápido allí.

### ¿Qué API ofrece Mesh LLM?

Cada nodo expone una API compatible con OpenAI en http://localhost:9337/v1.

### ¿Todos los equipos descargan el modelo completo?

En splits empaquetados, cada peer descarga artefactos comunes y las capas de su etapa.

### ¿Puede funcionar por internet?

Sí, mediante iroh y relay fallback. La velocidad interactiva sigue dependiendo de la latencia de cada etapa. Empieza en LAN cableada.

### ¿Sirve para datos confidenciales?

Solo en una malla privada y controlada con política de owner y admisión, tokens protegidos, listeners limitados y logs revisados. Discovery pública no basta.

### ¿Cuándo conviene comprar una GPU mayor?

Prefiere un host si cumple calidad, contexto, concurrencia, latencia y disponibilidad. Prueba una malla si el modelo necesario supera cada host y ya tienes equipos rápidos ociosos.

## Reflexiones finales

Mesh LLM plantea la pregunta correcta: ¿qué modelo pueden ejecutar juntos estos ordenadores? Skippy puede repartir capas contiguas, descargar solo fragmentos necesarios y mantener una sola API compatible con OpenAI.

El límite sigue siendo físico. El decode cruza etapas en serie, la latencia se repite por token, el peer más lento marca el ritmo y cada nodo amplía el dominio de fallo. Usa Mesh LLM cuando la capacidad combinada desbloquee un modelo imposible de otro modo. Mantén el modelo local cuando ya quepa. Deja que un piloto medido con dos nodos decida si el hardware ocioso es realmente más barato que una máquina mayor o una API alojada.

## También te puede gustar..

[**Cuándo los modelos locales superan a las APIs** Calcula utilización, ingeniería, latencia, gobernanza y fallback después de validar la topología.](/es/blog/local-models-vs-apis-break-even-eu-2026/) [**AI Enablement vs consultoría IA genérica** Compara una implementación medida con asesoría que termina en diapositivas.](/es/compare/ai-enablement-vs-generic-ai-consultancy/)

Modelos e infraestructura

## Continúa por este clúster

[Empieza por el artículo fundamental**Alojar LLMs en la UE: Cuándo Salen a Cuenta los Open Weights**](/es/blog/self-hosting-llms-eu-cost/)

- [Gemini Robotics 2: control corporal completo y decisión de piloto](/es/blog/gemini-robotics-2-whole-body-control/)
- [pdf-inspector: parser PDF local antes del OCR](/es/blog/pdf-inspector-ocr-routing/)
- [Asistente de programación con IA local multimodal: voz, OCR y privacidad](/es/blog/local-multimodal-ai-coding-assistant/)
- [DeepSeek V4 Flash 0731 en un PC de IA: ¿qué funciona?](/es/blog/deepseek-v4-flash-0731-local-ai-pc/)
- [Cómo afinar Gemma 4 gratis con Unsloth y Colab](/es/blog/fine-tune-gemma-4-free-unsloth-colab/)

Tu bandeja, sin ruido

## Sigue el trabajo que te importa

Recibe un correo breve cuando publiquemos algo nuevo. Sigue todo el blog o solo los temas que te interesan.

[**Volver**](/es/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/es/team/kevin-riedl/)

[Kevin Riedl](/es/team/kevin-riedl/) https://linkedin.com/in/wsdt

12 min de lectura · 18 de julio de 2026

[**Siguiente**](/es/blog/ai-vendor-security-questionnaire-eu/)

Nuevos artículos por correo ×

×

Recibe nuevos artículos por correo

Un correo breve cuando publicamos. Gratis y sin seguimiento.

## Structured Data

```json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@id": "https://wavect.io/#organization",
      "@type": [
        "Organization",
        "ProfessionalService",
        "LocalBusiness"
      ],
      "employee": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "founder": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "legalRepresentative": [
        {
          "@id": "https://wavect.io/team/kevin-riedl/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Kevin Riedl",
          "url": "https://wavect.io/team/kevin-riedl/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        },
        {
          "@id": "https://wavect.io/team/christof-jori/#person",
          "@type": "Person",
          "jobTitle": "Managing Director",
          "name": "Christof Jori",
          "url": "https://wavect.io/team/christof-jori/",
          "worksFor": {
            "@id": "https://wavect.io/#organization",
            "@type": [
              "Organization",
              "ProfessionalService",
              "LocalBusiness"
            ]
          }
        }
      ],
      "name": "Wavect GmbH",
      "subjectOf": {
        "@id": "https://wavect.io/verified-claims.json#dataset",
        "@type": "Dataset",
        "creator": {
          "@id": "https://wavect.io/#organization",
          "@type": [
            "Organization",
            "ProfessionalService",
            "LocalBusiness"
          ]
        },
        "description": "A machine-readable registry of quantitative and qualitative claims published by Wavect, with review dates, localized page appearances and public third-party citations where available.",
        "inLanguage": "en",
        "isAccessibleForFree": true,
        "license": "https://creativecommons.org/licenses/by/4.0/",
        "name": "Wavect verified publication claims",
        "url": "https://wavect.io/verified-claims.json"
      },
      "url": "https://wavect.io/"
    },
    {
      "@id": "https://wavect.io/team/kevin-riedl/#person",
      "@type": "Person",
      "jobTitle": "Managing Director",
      "name": "Kevin Riedl",
      "sameAs": [
        "https://www.wikidata.org/wiki/Q139796365",
        "https://www.linkedin.com/in/wsdt",
        "https://github.com/wsdt"
      ],
      "url": "https://wavect.io/team/kevin-riedl/",
      "worksFor": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      }
    },
    {
      "@id": "https://wavect.io/team/christof-jori/#person",
      "@type": "Person",
      "jobTitle": "Managing Director",
      "name": "Christof Jori",
      "sameAs": [
        "https://www.wikidata.org/wiki/Q139796367",
        "https://www.linkedin.com/in/jocr77/",
        "https://github.com/jo-chris"
      ],
      "url": "https://wavect.io/team/christof-jori/",
      "worksFor": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      }
    },
    {
      "@id": "https://wavect.io/#website",
      "@type": "WebSite",
      "inLanguage": [
        "en",
        "de",
        "es",
        "zh"
      ],
      "name": "Wavect",
      "potentialAction": {
        "@type": "SearchAction",
        "query-input": "required name=search_term_string",
        "target": {
          "@type": "EntryPoint",
          "urlTemplate": "https://wavect.io/search/?q={search_term_string}"
        }
      },
      "publisher": {
        "@id": "https://wavect.io/#organization",
        "@type": [
          "Organization",
          "ProfessionalService",
          "LocalBusiness"
        ]
      },
      "url": "https://wavect.io/"
    },
    {
      "@id": "https://wavect.io/es/blog/mesh-llm-distributed-inference-multiple-computers/#webpage",
      "@type": "WebPage",
      "dateModified": "2026-07-18",
      "inLanguage": "es",
      "isPartOf": {
        "@id": "https://wavect.io/#website",
        "@type": "WebSite"
      },
      "lastReviewed": "2026-07-18",
      "url": "https://wavect.io/es/blog/mesh-llm-distributed-inference-multiple-computers/"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "abstract": "Mesh LLM puede ejecutar un LLM compatible entre varios ordenadores cuando ninguno tiene memoria suficiente. Skippy asigna rangos contiguos de capas, cada peer descarga los fragmentos GGUF de su etapa y las activaciones cruzan la cadena por cada token. El cliente mantiene una sola API compatible con OpenAI en localhost:9337/v1. Es paralelismo de modelo por pipeline, no balanceo de carga, y suma capacidad sin garantizar velocidad. El reality check del proyecto baja de 68 tok/s en un host a 21 con dos nodos y 12-13 con tres para un modelo que ya cabía solo. Latencia, etapa más lenta, caché de contexto, soporte de familia y fiabilidad determinan el resultado. El mejor caso comercial es una malla privada de baja latencia cuando el modelo necesario supera por poco cada equipo. Empieza con dos nodos por cable, un artefacto inmutable revisado, evals reales, pruebas de fallo y coste por tarea exitosa antes de comprar hardware o entrar en producción.",
  "articleBody": " Resumen del blog/IA y agentes/Modelos e infraestructura Mesh LLM: ¿Puede un LLM ejecutarse en varios ordenadores? Resumen Mesh LLM puede ejecutar un LLM compatible entre varios ordenadores cuando ninguno tiene memoria suficiente. Skippy asigna rangos contiguos de capas, cada peer descarga los fragmentos GGUF de su etapa y las activaciones cruzan la cadena por cada token. El cliente mantiene una sola API compatible con OpenAI en localhost:9337/v1. Es paralelismo de modelo por pipeline, no balanceo de carga, y suma capacidad sin garantizar velocidad. El reality check del proyecto baja de 68 tok/s en un host a 21 con dos nodos y 12-13 con tres para un modelo que ya cabía solo. Latencia, etapa más lenta, caché de contexto, soporte de familia y fiabilidad determinan el resultado. El mejor caso comercial es una malla privada de baja latencia cuando el modelo necesario supera por poco cada equipo. Empieza con dos nodos por cable, un artefacto inmutable revisado, evals reales, pruebas de fallo y coste por tarea exitosa antes de comprar hardware o entrar en producción. Sí. Mesh LLM puede ejecutar un modelo grande compatible entre varios ordenadores cuando ninguno tiene memoria suficiente por sí solo. Skippy asigna rangos contiguos de capas a distintos peers. Cada uno descarga los fragmentos GGUF de su etapa y las activaciones cruzan la cadena por cada token generado. La aplicación sigue llamando a un único endpoint compatible con OpenAI en http://localhost:9337/v1. La respuesta de compra necesita una precisión: sumar capacidad no garantiza sumar velocidad. Cada etapa añade comunicación al decode secuencial y el peer más lento puede limitar toda la ruta. Mesh LLM tiene más sentido cuando el modelo no cabe en ninguna máquina. Si ya cabe, ejecutarlo localmente suele ser más rápido y fiable. Este análisis refleja el repositorio y su documentación primaria a 18 de julio de 2026. Separamos funciones documentadas, benchmarks publicados y lo que aún debes demostrar en tu hardware. Mesh LLM para una decisión técnica y comercialPreguntaRespuesta actualImplicación ¿Qué resuelve?Inferencia local, routing a peers y split multinodo tras una APIReutilizar equipos antes de comprar un host mayor. ¿Cómo divide el modelo?Etapas de capas contiguas con transferencia de activacionesUna petición pasa por varios equipos. No es balanceo de carga normal. FormatoGGUF y paquetes de fragmentos por capasEl soporte depende del artefacto, runtime y límite de split revisado. InterfazAPI /v1 compatible con OpenAI en el puerto 9337Muchas apps solo cambian la base URL. RedQUIC sobre iroh, tokens privados, Nostr o descubrimiento LANConectar es más fácil, pero latencia y confianza siguen siendo tuyas. LicenciaApache 2.0Runtime permisivo; revisa la licencia de cada modelo. Evidencia productivaPrometedor, con pocos benchmarks generalizablesNecesita un piloto acotado antes de producción. ¿Qué es Mesh LLM? Mesh LLM es un runtime Apache 2.0 para inferencia distribuida. Cada nodo ofrece la misma API. El sistema puede ejecutar el modelo localmente, enviar la petición completa a un peer que ya lo sirve o dividir un solo modelo entre peers mediante Skippy. Local: la máquina actual ejecuta todo el modelo cuando cabe.Routing: la petición completa va al host que tiene el modelo.Split por etapas: varios equipos ejecutan rangos distintos de capas para la misma petición. La app solo ve modelo, petición y respuesta. Placement, descargas, readiness, recuperación y seguridad siguen siendo trabajo de infraestructura. ¿Cómo divide Skippy un modelo entre varios PCs? El flujo documentado de Skippy funciona como pipeline: El coordinador resuelve el modelo o paquete.El planner elige peers y rangos contiguos.La etapa final carga primero.Cada peer descarga metadatos comunes y solo sus capas.La etapa 0 no se publica hasta que todas están listas.El prompt entra por la etapa 0, las activaciones avanzan y el token vuelve al stream. En un modelo de 48 capas, A podría ejecutar 0 a 15, B 16 a 31 y C 32 a 47 más la salida. No son tres modelos independientes. Es una única ruta con dos fronteras de red. Los paquetes incluyen manifest, hashes, artefactos comunes y fragmentos GGUF. Para entornos serios, el proyecto recomienda revisiones inmutables y comandos que validan tamaño, SHA, archivos, manifest y respuestas reales de /v1. Un GGUF cualquiera no se convierte automáticamente en un split seguro. ¿Es solo balanceo de carga? No. El balanceo envía peticiones completas a réplicas completas. Skippy envía una petición por varios equipos porque cada uno ejecuta capas diferentes. PatrónQué se mueveObjetivo BalanceoPetición completa a una réplicaConcurrencia y disponibilidad Routing a peerPetición completa al host del modeloReusar inventario distribuido Pipeline splitActivaciones entre etapasHacer caber un modelo en memoria combinada Paralelismo tensorialResultados parciales dentro de las capasParalelizar el cálculo de cada capa Tres GPU de 24 GB no se convierten literalmente en una GPU de 72",
  "articleSection": "Engineering",
  "author": {
    "@id": "https://wavect.io/team/kevin-riedl/#person",
    "@type": "Person",
    "name": "Kevin Riedl",
    "sameAs": [
      "https://www.wikidata.org/wiki/Q139796365",
      "https://www.linkedin.com/in/wsdt",
      "https://github.com/wsdt"
    ],
    "url": "https://wavect.io/team/kevin-riedl/"
  },
  "dateModified": "2026-07-18",
  "datePublished": "2026-07-18",
  "description": "Mesh LLM puede ejecutar un LLM compatible entre varios ordenadores cuando ninguno tiene memoria suficiente. Skippy asigna rangos contiguos de capas, cada peer descarga los fragmentos GGUF de su etapa y las activaciones cruzan la cadena por cada token. El cliente mantiene una sola API compatible con OpenAI en localhost:9337/v1. Es paralelismo de modelo por pipeline, no balanceo de carga, y suma capacidad sin garantizar velocidad. El reality check del proyecto baja de 68 tok/s en un host a 21 con dos nodos y 12-13 con tres para un modelo que ya cabía solo. Latencia, etapa más lenta, caché de contexto, soporte de familia y fiabilidad determinan el resultado. El mejor caso comercial es una malla privada de baja latencia cuando el modelo necesario supera por poco cada equipo. Empieza con dos nodos por cable, un artefacto inmutable revisado, evals reales, pruebas de fallo y coste por tarea exitosa antes de comprar hardware o entrar en producción.",
  "headline": "Mesh LLM: ¿Puede un LLM Ejecutarse en Varios Ordenadores?",
  "image": "https://wavect.io/img/blog/headers/header_mesh-llm-distributed-inference-multiple-computers.svg",
  "inLanguage": "es",
  "mainEntityOfPage": {
    "@id": "https://wavect.io/es/blog/mesh-llm-distributed-inference-multiple-computers/",
    "@type": "WebPage"
  },
  "publisher": {
    "@id": "https://wavect.io/#organization",
    "@type": [
      "Organization",
      "ProfessionalService",
      "LocalBusiness"
    ]
  },
  "url": "https://wavect.io/es/blog/mesh-llm-distributed-inference-multiple-computers/",
  "wordCount": 2188
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "item": "https://wavect.io/es/",
      "name": "Inicio",
      "position": 1
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/es/blog/overview/",
      "name": "Resumen del blog",
      "position": 2
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/es/blog/topics/ai-agents/",
      "name": "IA y agentes",
      "position": 3
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/es/blog/clusters/models-infrastructure/",
      "name": "Modelos e infraestructura",
      "position": 4
    },
    {
      "@type": "ListItem",
      "item": "https://wavect.io/es/blog/mesh-llm-distributed-inference-multiple-computers/",
      "name": "Mesh LLM: LLM Distribuido en Varios Ordenadores | ",
      "position": 5
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Sí. Skippy asigna rangos contiguos de capas a peers y mueve activaciones. Combina capacidad útil mediante pipeline, no crea una GPU literal de memoria compartida."
      },
      "name": "¿Puede Mesh LLM combinar GPU de varios ordenadores?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. El balanceo envía una petición completa a una réplica completa. Un split envía la misma petición por varias etapas de capas."
      },
      "name": "¿Es Mesh LLM balanceo de carga?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No necesariamente. Permite que quepa un modelo mayor, pero añade red secuencial. Si el modelo ya cabe en un equipo, normalmente será más rápido allí."
      },
      "name": "¿La inferencia distribuida hace el LLM más rápido?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Cada nodo expone una API compatible con OpenAI en http://localhost:9337/v1."
      },
      "name": "¿Qué API ofrece Mesh LLM?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "En splits empaquetados, cada peer descarga artefactos comunes y las capas de su etapa."
      },
      "name": "¿Todos los equipos descargan el modelo completo?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Sí, mediante iroh y relay fallback. La velocidad interactiva sigue dependiendo de la latencia de cada etapa. Empieza en LAN cableada."
      },
      "name": "¿Puede funcionar por internet?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Solo en una malla privada y controlada con política de owner y admisión, tokens protegidos, listeners limitados y logs revisados. Discovery pública no basta."
      },
      "name": "¿Sirve para datos confidenciales?"
    },
    {
      "@type": "Question",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Prefiere un host si cumple calidad, contexto, concurrencia, latencia y disponibilidad. Prueba una malla si el modelo necesario supera cada host y ya tienes equipos rápidos ociosos."
      },
      "name": "¿Cuándo conviene comprar una GPU mayor?"
    }
  ]
}
```
