Tus GPUs.
Tus modelos.
Un plano de control.
Loadcore es un sistema distribuido que pone en marcha, ejecuta y gobierna LLMs abiertos en tus propios servidores GPU. Instala un agente en cada máquina, despliega modelos desde una sola consola y ofrécelos a todo tu equipo mediante una API compatible con OpenAI.
Tres componentes. Un sistema distribuido.
El plano de control decide qué debe ejecutarse y dónde. Los agentes lo hacen realidad en tu hardware. Tus herramientas hablan directamente con los agentes.
Tu equipo gestiona la flota. La API guarda el estado y valida las claves.
Envía latidos y estado. Ejecuta instancias de llama.cpp en local.
Las peticiones van directas al endpoint /v1 del agente, nunca a través de Loadcore.
Loadcore Console
Una app web para ver cada servidor, descargar modelos, iniciar instancias, gestionar personas y seguir el uso.
- +servidores, modelos, instancias
- +miembros, departamentos, invitaciones
- +claves de API personales
- +estadísticas de uso personales
Loadcore API
SaaS multiinquilino que guarda el estado de la flota, las reglas de acceso y las claves. Orquesta, pero nunca hace de proxy de la inferencia.
- +organizaciones y roles
- +registro de servidores por latidos
- +estado de instancias y descargas
- +validación de claves por modelo
Loadcore Agent
Un único binario en Go. Instala llama.cpp, descarga los pesos, supervisa los procesos y sirve /v1 directamente.
- +instala llama.cpp automáticamente
- +descargas GGUF con progreso
- +comprobaciones de salud cada 15 s
- +compatible con OpenAI en :9090/v1
Del servidor GPU vacío a servir tokens.
Todo lo que antes hacías entrando por SSH en cada servidor, uno a uno, ahora desde un solo lugar y sincronizado en toda la flota.
- 01
Registrar
Añade un servidor en la consola y obtén una clave de servidor de un solo uso.
servers / new - 02
Conectar
Inicia el agente. Instala llama.cpp y empieza a enviar latidos.
./loadcore-agent - 03
Descargar
Busca en HuggingFace, elige una cuantización y descárgala en el servidor destino.
Q4_K_M 18.6 GB - 04
Servir
Inicia una instancia con tu puerto, tamaño de contexto y capas en GPU.
:8081 ctx 32k ngl 99 - 05
Escalar
Ejecuta el mismo modelo en más servidores para ganar rendimiento, o combina modelos libremente.
3 réplicas
Más grande que una GPU.
Una instancia distribuida reparte un modelo entre varios servidores GPU usando llama.cpp RPC. Ejecuta un modelo de 70B+ en varias tarjetas de 24 GB que ya tienes.
Guarda llama-70b-Q8_0.gguf (75 GB) y 24 GB de VRAM.
24 GB de VRAM cada uno, sin archivo de modelo.
Una instancia, un endpoint, en tu red local.
Inicia una instancia en un servidor principal y elige "Distribuir entre servidores" para añadir servidores rpc. La consola muestra la memoria GPU combinada frente al tamaño del modelo.
Solo el servidor principal necesita el archivo del modelo. Los servidores rpc aportan su memoria GPU.
Un servidor principal y hasta 7 servidores rpc por instancia distribuida.
Los servidores deben compartir una red local rápida. Cada servidor rpc solo acepta conexiones del servidor principal.
Sirve para que quepan modelos más grandes, no para ganar velocidad. Para repartir la carga, ejecuta instancias separadas y elige entre ellas. Los tamaños del diagrama son un ejemplo.
Decide quién usa cada modelo.
Agrupa a los miembros en departamentos y concede acceso a modelos por departamento. Cada miembro recibe claves de API personales y el agente aplica las reglas en cada petición.
| Departamento | qwen3-coder-next | gpt-oss-120b | gemma-4-31b | gemma-4-26b-a4b |
|---|---|---|---|---|
| Ingeniería | ||||
| Investigación | ||||
| Soporte | ||||
| Admins de la org |
Ingeniería, Investigación, Soporte o lo que encaje con tu organización. Una persona puede estar en varios.
El acceso se concede por modelo, así un gran modelo de razonamiento puede quedarse con el equipo que lo necesita.
Se muestran una vez y se pueden revocar en cualquier momento. Una clave tiene los permisos de su propietario, nada más.
Invita a tus compañeros por correo o deja que cualquiera cree su propia cuenta.
Tus prompts nunca tocan nuestros servidores.
Loadcore separa el tráfico de control del tráfico de inferencia. El plano de control sabe qué servidores y modelos existen y quién puede usarlos. Nunca ve un prompt, una respuesta ni los pesos de un modelo.
- Prompts y respuestas
- Respuestas en streaming
- Se queda dentro de tu red
- Latidos e información del sistema
- Progreso de descargas y estado de instancias
- Comprobación de claves de API, en caché 5 minutos
Los pesos de los modelos se descargan de HuggingFace directamente a tu servidor.
Un comando por servidor.
Inicia el agente con la clave que obtuviste al registrar el servidor. Después apunta cualquier cliente de OpenAI hacia él con tu clave personal.
# en tu servidor GPU
$ ./loadcore-agent \
--api-key="lc_your-server-key" \
--backend-url="https://api.loadcore.io"
Loadcore Agent starting on port 9090
llama.cpp not found, installing latest version...
llama.cpp installed
Agent listening on :9090
OpenAI-compatible API at http://localhost:9090/v1curl http://gpu-ams-01:9090/v1/chat/completions \
-H "Authorization: Bearer $LOADCORE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3-coder-next.gguf",
"messages": [{"role": "user", "content": "Hello"}]
}'El rendimiento es tuyo.
Una H200 alquilada con Llama 4 Maverick bajo Loadcore, comparada con pagar por token en modelos alojados. Precio combinado por 1M de tokens.
Precios de abril de 2026. El precio combinado supone un reparto 50/50 entre entrada y salida. El rendimiento autoalojado depende de la cuantización y la longitud de contexto, y las API alojadas ofrecen capacidades de modelo distintas.
¿Qué ejecuta Loadcore en mis servidores?
Un binario en Go, el Loadcore Agent. Instala llama.cpp, descarga modelos GGUF en ~/.loadcore/models y arranca y supervisa procesos de llama.cpp en los puertos que elijas.
¿Pasan mis prompts por Loadcore?
No. Tus herramientas llaman directamente al agente en tu servidor. El plano de control solo recibe latidos, progreso de descargas, estado de instancias y comprobaciones de claves de API.
¿Qué hardware necesito?
Un servidor Linux con una GPU compatible con llama.cpp. Tus propios racks, un servidor en colocation o una GPU alquilada en la nube funcionan igual.
¿Qué modelos puedo ejecutar?
Cualquier modelo GGUF de HuggingFace, en cualquier cuantización que quepa en tu VRAM. Ejecuta modelos distintos en servidores distintos o el mismo modelo en varios para ganar rendimiento.
¿Cómo se controla el acceso?
Los miembros pertenecen a departamentos y a los departamentos se les conceden modelos concretos. Los admins de la organización pueden usar todos los modelos. Cada petición lleva una clave sk-lc- personal que el agente comprueba.
¿Existe un plano de control autoalojado?
No. La Loadcore API es un servicio gestionado y multiinquilino. Solo el agente se ejecuta en tu infraestructura, y ahí es donde ocurre toda la inferencia.
Pon tus GPUs a trabajar.
Registra tu primer servidor y ofrece hoy mismo un modelo a tu equipo.