¿Qué es Ollaya? El Ollama de los modelos de decisión
DominicodeEl 15 de septiembre TypeSafe presentó Jev en Hacker News: un modelo que no escribe ni una palabra. Le pasas un estado y unas preguntas tipadas, y te devuelve probabilidades. Cerrado y de pago.
Diez días después, otro hilo llegó a 618 puntos: Ollaya, un runtime open source que prometía lo mismo en tu máquina. En el hilo, alguien que ya lo había instalado escribió: "I installed it, I tried the examples, it works…. But forgive my lack of imagination… what is this useful for?" (comentario).
Esa pregunta vale más que cualquier benchmark. Explicar qué es Ollaya cuesta un párrafo. Lo difícil es saber si te sirve, y cuánta calidad pierdes.
En corto: Ollaya es un runtime open source (Apache-2.0, escrito en Rust) que descarga y sirve en local modelos de decisión abiertos al estilo de Jev, con la misma API HTTP que TypeSafe. Cambias tres variables de entorno y tu código de Jev apunta a tu máquina. A cambio, los modelos abiertos rinden por debajo de Jev en preguntas difíciles y tienes que recalibrar tus umbrales.
¿Qué es Ollaya?
Ollaya es un binario que descarga, sirve y ejecuta en local modelos de decisión abiertos —modelos que leen un estado y devuelven probabilidades calibradas para preguntas tipadas, sin generar texto— detrás de una API idéntica a la de TypeSafe.
Lo creó y lo mantiene Mert Cobanov. El repositorio se abrió el 23 de septiembre de 2026, va por la v0.13.0 (13 de octubre) y la web lo marca como beta. Es un proyecto independiente: sin relación con Ollama ni con TypeSafe.
Si vienes de Ollama, la mecánica es la misma: pull, run, list, ps, create con Modelfile y serve para el daemon. Lo que cambia es la salida: no hay /api/generate ni /api/chat; esas rutas devuelven 404 y te mandan a /api/decide.
Las preguntas son las tres primitivas de Jev: choice (elige una opción), score (puntúa en una escala) y noul (¿es verdad esta afirmación?). Si es la primera vez que las ves, en el post sobre si Jev es open source explico por qué TypeSafe no publica pesos y qué alternativas locales había antes de que apareciera Ollaya.
Cómo funciona Ollaya con la API de Jev
El daemon escucha en 127.0.0.1:11435 y expone /v1/systemone, /v1/decisions y /v1/models con el mismo formato que TypeSafe. El SDK oficial funciona sin tocar código.
Instalación y primera prueba (el README usa winnow:e4b; aquí uso laya porque corre en cualquier CPU):
curl -fsSL https://ollaya.dev/install.sh | sh # Windows: irm https://ollaya.dev/install.ps1 | iex
ollaya run laya --preset triage "Me cobraron dos veces este mes. Quiero la devolución."
run descarga y carga el modelo si hace falta. --preset triage es uno de los seis juegos de preguntas que trae de serie (triage, email, guard, moderation, router y agent); también puedes pasar los tuyos con --questions.
Para apuntar una integración de Jev existente a local, la referencia de la API pide tres variables:
export TYPESAFE_BASE_URL=http://localhost:11435
export TYPESAFE_API_KEY=local # el SDK exige una clave no vacía
export TYPESAFE_DEFAULT_MODEL=laya # si no, pide "jev-latest" y recibe 404
La tercera es la que se olvida: los nombres de modelo son los de Ollaya.
La respuesta tiene exactamente la forma de TypeSafe. Este es el ejemplo de la documentación:
{
"model": "laya:en",
"answers": {
"intent": {
"type": "choice",
"choice": "invoice",
"confidence": 0.8995,
"probabilities": {"invoice": 0.933, "refund": 0.021, "other": 0.046}
},
"billing": {"type": "noul", "noul": 0.9641}
},
"usage": {"input_tokens": 71, "output_tokens": 0}
}
Fíjate en billing: un noul devuelve un objeto, no un número suelto. Si tu código hace answers.billing > 0.5, falla en la primera llamada. Como la forma es fija, valídala en la frontera con un schema; es justo el tipo de contrato que trabajamos en el curso de Zod.
Sobre modelos: la web lista 21 familias. El README recomienda winnow:e4b, un modelo de clase 4B que pide GPU NVIDIA. Sin GPU, empieza por laya, que es un router: detecta el idioma y responde con laya:en o laya:multilingual (más de 100 idiomas). Para un texto en español eso importa, porque la propia doc de TypeSafe reconoce que el inglés es el idioma donde Jev rinde mejor.
Ollaya vs Ollama vs la API de TypeSafe
Las tres opciones hablan ya el mismo formato /v1/systemone, así que entender qué es Ollaya frente a Ollama y frente a la API de TypeSafe es decidir entre calidad, calibración y dónde viven tus datos. Si necesitas la mejor precisión en preguntas difíciles, Jev. Si los datos no pueden salir de tu red, Ollaya. Si ya usas Ollama para LLMs y te bastan Nimble o Tev1, Ollama.
| Criterio | Ollaya | Ollama 0.35+ | API de TypeSafe (Jev) |
|---|---|---|---|
| Qué ejecuta | Solo modelos de decisión abiertos (21 familias) | LLMs y, además, dos modelos de decisión: Nimble y Tev1 | Jev, cerrado (jev-latest = 1.13; la 1.14 está en preview desde el 14 de octubre) |
| Dónde corre | Tu máquina, CPU o GPU | Tu máquina | Nube de TypeSafe |
| Coste | Tu hardware | Tu hardware | 0,042 USD por millón de tokens de entrada; salida gratis |
| Calibración | Temperaturas ajustadas por modelo; error de calibración 0,022 con pesos Nimble* | Error de calibración 0,122 con los mismos pesos Nimble* | Sin cifra comparable publicada |
| Precisión (benchmark typed-decisions) | winnow:e4b: 0,722* |
Nimble, su mejor modelo de decisión, saca 0,665 en Ollaya; Ollama no publica cifra propia* | Jev: 0,738* |
| Latencia publicada | laya:en: 8-10 ms para cinco preguntas en una RTX 4090; winnow:e4b: 89 ms* |
Nimble: 210 ms frente a 310 ms en Ollaya, en una RTX 5090 (Ollama usa GGUF Q8_0; Ollaya, fp32)* | "About 100 ms" de inferencia, según su doc |
| Limitación o riesgo | Beta; modelos pequeños claramente por debajo de Jev en preguntas difíciles | Solo dos modelos de decisión; Tev1 sin licencia publicada para sus pesos | Datos fuera de tu red; idioma principal el inglés |
*Cifras medidas por el propio proyecto Ollaya en su README y su FAQ, consultados el 16 de octubre de 2026. Ollaya compite con Ollama, así que tómalas como lo que son: autorreportadas. Con los mismos pesos Nimble, Ollaya y Ollama empatan en precisión (0,748 y 0,749) en otro benchmark, el público de Bespoke Labs; esas cifras no se pueden comparar con las de typed-decisions. Precio de Jev: modelos de TypeSafe. Latencia: su guía de System One, una cifra de inferencia, no el tiempo de extremo a extremo que verás desde tu red.
Ollaya como servidor MCP en Claude Code
ollaya mcp expone los modelos locales a clientes MCP: Claude Code, Claude Desktop o Cursor. Registrarlo en Claude Code es una línea, y el proyecto trae una skill, ollaya-decisions, que enseña al agente cuándo usar estos modelos:
claude mcp add ollaya -- ollaya mcp
npx skills add ollaya-dev/ollaya --skill ollaya-decisions
La idea: que el agente consulte un modelo barato antes de actuar, en vez de gastar tokens de un LLM grande en clasificar. En HN, un usuario cuenta que su harness usa Jev o un modelo compatible para aprobar comandos de shell, y que ha usado Ollaya para pruebas locales. Si estás diseñando ese tipo de arquitectura de agente con herramientas y guardarraíles, el ebook gratuito El Developer Agéntico la recorre capítulo a capítulo.
Lo que se dijo en Hacker News sobre Ollaya
El hilo de lanzamiento tiene 145 comentarios y la crítica más útil la hizo el propio autor. Cuando un usuario preguntó si Laya daba resultados comparables a Jev, Cobanov respondió: "Developer here. You're right, Laya is a lot weaker than Jev, especially on harder queries."
Otro comentario fue más duro con la categoría entera: ""Decision model" is just marketing jargon" (enlace), y lo reducía a un clasificador con otro nombre.
Y un uso real: un usuario cuenta que montó Laya sin Ollaya en una GTX 970 de 4 GB y lo usa en lugar de la API de Jev en tareas pequeñas, con una ventana de contexto muy corta.
Mi lectura: Ollaya no compite con Jev en calidad. Compite en dónde corre y en cuánto cuesta equivocarse de proveedor.
Cuándo NO usar Ollaya
Si la decisión es difícil y no tienes GPU, no lo uses. Los modelos que corren bien en CPU son los encoders pequeños, y su autor admite que quedan lejos de Jev en preguntas complejas. Los que se acercan, como winnow:e4b o kev:9b, necesitan GPU para ir rápido (el README recomienda NVIDIA); kev:9b, 24 GB.
Si ya calibraste umbrales contra Jev, no cambies de proveedor sin rehacerlos. La propia doc de Ollaya lo dice: la fórmula de confidence es la misma en todos los modelos, pero un umbral no se transfiere de un modelo a otro. Calibra sobre probabilities y con tus datos, modelo a modelo.
Si tu state es largo, prepárate para errores. Cuando el estado no cabe en el contexto del modelo, /v1/systemone devuelve 422 STATE_TRUNCATED en vez de decidir con información incompleta. Es la conducta correcta, pero con modelos pequeños de 512 tokens llega antes de lo que esperas.
Si vas a exponerlo en red, para. El daemon no trae autenticación por defecto: con OLLAYA_HOST=0.0.0.0 y sin OLLAYA_API_KEY, cualquiera que alcance el puerto puede descargar o borrar modelos. Y no termina TLS.
Si tu empresa factura mucho, lee la licencia de cada modelo. Ollaya es Apache-2.0, pero cada modelo conserva la suya. d1, de Liquid AI, no cubre el uso comercial de organizaciones con 10 millones de dólares o más de facturación anual.
Y si necesitas estabilidad, recuerda que es beta: 22 releases en tres semanas, de la v0.1.0 a la v0.13.0, y bugs como el issue #69, ya cerrado, en el que kev fallaba en CUDA cuando pasaban unos 15 segundos entre peticiones.
Cómo probar Ollaya hoy sin cambiar de proveedor
No migres: compara. Ese es el valor real de que la API sea idéntica.
Toma entre 30 y 50 casos reales que ya pasen por Jev y lánzalos también contra Ollaya, con el mismo payload. Compara la etiqueta elegida y la distribución de probabilities, no solo confidence. En una tarde sabes si un modelo abierto aguanta tu caso.
Para que eso funcione sin reescribir nada, la llamada al modelo tiene que vivir detrás de tu propia interfaz. Es la misma conclusión que en el post de las cuatro capas de IA local: el proveedor es un detalle de implementación. Si quieres ver cómo se diseña esa frontera en un producto real con Claude Code, de la especificación al despliegue, lo hacemos en Construye con IA.
Preguntas frecuentes
¿Ollaya es open source?
Sí. El runtime está publicado en GitHub bajo licencia Apache-2.0 y está escrito principalmente en Rust. Ojo: cada modelo que descargas conserva su propia licencia, y algunas, como la de d1 o la de Gemma en arbiter, tienen condiciones distintas.
¿Ollaya es lo mismo que Ollama?
No. Copia la experiencia de uso de Ollama (CLI, daemon, Modelfiles), pero solo sirve modelos de decisión y no genera texto. Es un proyecto independiente, sin relación con Ollama. Desde la versión 0.35 (28 de septiembre de 2026), Ollama también sirve dos modelos de decisión, Nimble y Tev1, con el mismo formato de API.
¿Necesito GPU para usar Ollaya?
No. Los encoders como laya corren en CPU y responden en fracciones de segundo, según el README. La GPU importa para los decoders, como winnow:e4b, que son los que se acercan a la calidad de Jev. En Mac con Apple silicon, laya usa la GPU vía MLX.
¿Ollaya funciona con textos en español?
Sí, con matices. El router laya detecta el idioma del texto y elige entre laya:en y laya:multilingual, que cubre más de 100 idiomas. Mide la calidad con tus propios casos en español antes de confiar en él, igual que harías con Jev.
Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.
¿Te resultó útil este artículo?
Compártelo con tu comunidad y ayuda a otros desarrolladores.