Ollaya: cómo ejecutar modelos de decisión en local como alternativa open source a Jev

AI Dev Tools — General
, , , , , ,
1

Ollaya es una herramienta open source que ejecuta modelos de decisión en local, detrás de una API compatible con Jev de TypeSafe y sin pagar por llamada. A pesar del nombre, no es Ollama: es un proyecto independiente, sin afiliación con Ollama ni con TypeSafe, y el código escrito para Jev puede apuntar a tu propia máquina cambiando tres variables de entorno.

Estado al 26 de septiembre de 2026: la versión actual es v0.6.0, publicada el 25 de septiembre. El sitio del proyecto todavía identifica a Ollaya como Beta, y la lista de modelos cambia con cada release.

El proyecto toma la experiencia de desarrollo de Ollama casi comando por comando: un único binario, modelos que descargas con pull y ejecutas con run por nombre, Modelfiles para personalizarlos y una API REST local. La diferencia está en lo que ejecuta: modelos que responden preguntas tipadas con probabilidades calibradas en lugar de generar texto. En inglés, la categoría se conoce como decision models, y Ollaya se presenta como una open-source Jev alternative para local inference.

Este artículo se basa en el código, las notas de versión y la documentación publicados por Ollaya. No lo hemos ejecutado ni hemos reproducido sus benchmarks de forma independiente.

¿Qué es un modelo de decisión?

Un modelo de decisión lee un estado y devuelve una respuesta tipada con probabilidades calibradas para cada pregunta, en una sola pasada del modelo. El estado puede ser un mensaje, un correo, un ticket o cualquier objeto JSON. Las preguntas son de tres tipos: choice, score y noul. El modelo nunca genera texto.

Ese resultado es fácil de convertir en acción: derivar el ticket, bloquear el mensaje o escalar cuando una probabilidad supera un umbral.

El modelo cerrado Jev de TypeSafe creó esta categoría. Explicamos cómo funciona y cuánto cuesta en Jev de TypeSafe: cómo funciona la IA que toma decisiones sin generar texto. Ese artículo terminaba con una limitación: los pesos de Jev no son públicos, así que no puedes alojarlo tú mismo. La respuesta de Ollaya es servir modelos de decisión abiertos detrás de la misma forma de API.

Este es el primer ejemplo del README:

ollaya run laya --preset triage "I was charged twice for my subscription this month and want a refund."


intent            refund       ████████████████ 1.00
is_urgent         no           ██████████████░░ 0.88
frustration       1.76 / 3     ██████░░░░░░░░░░ 0.36
refund_requested  yes          ██████████████░░ 0.90
churn_risk        no           ██████████░░░░░░ 0.61

¿Qué diferencia hay entre Ollaya, Ollama y Jev?

Ollaya aplica el flujo de trabajo de Ollama a modelos de decisión en lugar de LLM generativos, y expone el formato de API de Jev con modelos abiertos por debajo.

Frente a Ollama:

  • Los comandos te resultarán familiares: serve, run, pull, list, ps, show, rm, cp, stop y create.
  • Si el daemon no está en marcha, la CLI lo inicia.
  • El puerto por defecto es 11435, uno más que el 11434 de Ollama, así que ambos pueden funcionar a la vez.

Si lo que buscas es ejecutar LLM generativos en tu máquina, Ollama sigue siendo la herramienta; la comparamos con sus alternativas en LM Studio, Ollama o llama.cpp: qué corre de verdad en tu máquina.

Frente a Jev:

  • Los endpoints /v1/systemone, /v1/decisions y /v1/models son idénticos a los de TypeSafe a nivel de protocolo.
  • Los modelos son otros, y su calidad también varía según la tarea (lo vemos más abajo).

¿Qué modelos puedes ejecutar con Ollaya?

Al 26 de septiembre de 2026 (v0.6.0), el README lista estos modelos. Cada uno conserva su propia licencia:

Modelo Qué es Licencia
laya Router: envía el inglés a laya:en y otros idiomas a laya:multilingual Apache-2.0
laya:en Modelo de decisión en inglés (ModernBERT-large); el más rápido Apache-2.0
laya:multilingual Más de 100 idiomas (mmBERT-base) Apache-2.0
laya:typed-decisions Ajustado sobre flujos de decisiones tipadas Apache-2.0
decider, decider:0.8b Decodificadores Qwen3.5 de Mapika; los más precisos y los más lentos Apache-2.0
kev LoRA y pointer head de Jared Palmer sobre Qwen3.5-0.8B (nuevo en v0.6.0) Apache-2.0
von Von 1.1 de Victor Hugo Panisa sobre ModernBERT-large, contexto de 8k tokens (nuevo en v0.6.0) Apache-2.0
qwen3guard Guardia de seguridad de Qwen (safe / controversial / unsafe, 119 idiomas; nuevo en v0.6.0) Apache-2.0
nli:modernbert-large Clasificador NLI zero-shot de Moritz Laurer Apache-2.0
nli:deberta-v3-large Clasificador NLI zero-shot de Moritz Laurer MIT
gliclass Clasificador zero-shot de Knowledgator que sigue instrucciones Apache-2.0

Dos detalles importan si trabajas en español:

  • El router cubre el texto que no está en inglés. laya envía cualquier texto en otro idioma a laya:multilingual. Es relevante porque TypeSafe indica que Jev ofrece actualmente su mayor precisión en inglés.
  • Ollaya nunca vuelve a alojar pesos. Solo publica pequeños grafos ONNX (unos 3 MB cada uno) que leen los pesos originales desde el repositorio de Hugging Face de cada autor, fijados a un commit y verificados con sha256.

¿Cómo se instala Ollaya?

Linux y macOS (Apple silicon):

curl -fsSL https://ollaya.dev/install.sh | sh

En Linux necesitas x86-64 o ARM64 con glibc 2.38 o superior: Ubuntu 24.04, Debian 13, Fedora 39, RHEL 10 o posteriores. Si hay una GPU NVIDIA con driver R580 o superior, el instalador añade el runtime de CUDA.

Windows (x64, PowerShell):

irm https://ollaya.dev/install.ps1 | iex

Docker:

docker run -d --gpus=all -p 11435:11435 ghcr.io/ollaya-dev/ollaya:cuda

Usa ghcr.io/ollaya-dev/ollaya si solo tienes CPU. La imagen de Docker también es el camino para distribuciones Linux más antiguas.

App de escritorio: existe para macOS, Windows y Linux en ollaya.dev/download. Inicia y detiene el servidor, descarga modelos y los ejecuta desde una sola ventana. En macOS vive en la barra de menús, que v0.6.0 rediseñó.

¿Ollaya funciona en Windows? ¿Necesitas GPU?

Sí, pero en Windows funciona solo con CPU. Para usar una GPU NVIDIA en Windows necesitas WSL 2 con el instalador de Linux.

La GPU no es obligatoria en ninguna plataforma: Ollaya funciona con CPU en todas, y en Linux x86-64 usa una GPU NVIDIA cuando la encuentra. Las cifras de velocidad que publica el proyecto se midieron en GPU (ver más abajo), así que espera latencias mayores en CPU.

¿Cómo usar Ollaya con Claude Code mediante MCP?

Registras su servidor MCP (MCP server) en Claude Code con un solo comando:

claude mcp add ollaya -- ollaya mcp

ollaya mcp habla MCP por stdio e inicia el servidor local si no está en marcha. Expone cuatro herramientas:

  • decide responde preguntas tipadas sobre un estado. Recibe state, questions o preset, y model (por defecto, laya).
  • list_models muestra lo que tienes instalado.
  • show_model devuelve los detalles de un modelo, incluida su licencia.
  • pull_model descarga un modelo. decide también lo descarga en el primer uso.

¿Y en Claude Desktop, Cursor o VS Code?

En Claude Desktop, añade este bloque a claude_desktop_config.json (Settings → Developer → Edit Config):

{
  "mcpServers": {
    "ollaya": { "command": "ollaya", "args": ["mcp"] }
  }
}

Si Claude Desktop no encuentra ollaya, usa la ruta completa, por ejemplo /usr/local/bin/ollaya o ~/.local/bin/ollaya.

En Cursor y VS Code se usa el mismo comando, ollaya mcp, en .cursor/mcp.json o .vscode/mcp.json. VS Code necesita "type": "stdio".

¿Hay una skill para agentes?

Sí. Ollaya incluye una skill que enseña a Claude Code cuándo una decisión tipada es mejor que razonar en texto y cómo actuar según las probabilidades:

npx skills add ollaya-dev/ollaya --skill ollaya-decisions

Añade -g para instalarla en todos tus proyectos.

¿Puede Ollaya impedir que un agente ejecute un comando peligroso?

Para eso está el nuevo --preset agent de v0.6.0. Recibe la petición del usuario (request) y el comando propuesto (command), y responde cuatro preguntas:

  • action: ejecutar, preguntar o bloquear (run, ask o block)
  • on_task: si la petición realmente necesita ese comando
  • risk: cuánto daño podría causar
  • destructive: si borra o sobrescribe trabajo

Las notas de versión usan este ejemplo:

ollaya run decider --preset agent '{"request": "Fix the typo in README.md", "command": "git push --force origin main"}'

Según las notas de versión, decider:2b bloquea ese comando en unos 180 ms en una RTX 4090:

Pregunta Respuesta Probabilidad
action block 0,53
on_task fuera de la tarea 0,75
destructive sí 0,90

La misma petición con un sed que corrige la errata obtiene run con 0,90. El preset también funciona desde el servidor MCP (preset: "agent") y desde la app de escritorio.

Ten en cuenta que una probabilidad de bloqueo de 0,53 es una señal, no una garantía. Mantén las comprobaciones de permisos estrictas en código determinista.

¿Cómo pasar tu código de Jev a Ollaya?

Apunta el SDK oficial de Python de TypeSafe (0.7.1) a localhost con tres variables de entorno:

export TYPESAFE_BASE_URL=http://localhost:11435
export TYPESAFE_API_KEY=local           # el SDK necesita una clave no vacía; cualquier valor sirve
export TYPESAFE_DEFAULT_MODEL=laya      # si no, el SDK envía "jev-latest"

Tres diferencias a tener en cuenta:

  • Cambian los nombres de modelo. Necesitas laya o laya:en, no jev-latest.
  • Pon nombres descriptivos a tus preguntas. Cuando una pregunta no tiene instructions, el modelo lee su id en su lugar, así que is_urgent funciona mejor que q1.
  • Límites: como máximo 256 preguntas por petición, entre 2 y 255 opciones y entre 2 y 10 niveles de puntuación. Cada modelo tiene además un presupuesto de opciones: unas 125 para laya:en y 250 para laya:multilingual.

¿Ollaya es tan bueno como Jev?

Depende de la tarea, y la propia documentación de Ollaya lo dice con claridad. Todas las cifras siguientes las publica el proyecto; no están verificadas de forma independiente.

Dónde va por delante:

  • laya:typed-decisions obtiene 0,766 en el benchmark typed-decisions, frente al 0,727 que TypeSafe publicó para Jev 1.13.
  • El error de calibración de Laya tras ajustar la temperatura es 0,081, frente a 0,246 de Jev.

Dónde queda claramente por detrás:

  • Los checkpoints base de Laya están cerca del azar en zero-shot sobre typed-decisions (0,362).
  • Las preguntas de elección con muchas opciones (más de unas 20) son débiles. En Banking77, Laya obtiene 0,425 frente a 0,870 de Jev.

Velocidad: medida de extremo a extremo en una RTX 4090, el proyecto informa estas medianas:

Modelo Cinco preguntas
laya:multilingual 8 ms
laya:en 10 ms
von 23 ms
kev 185 ms

Fidelidad: las exportaciones ONNX eligieron la misma respuesta que la referencia de PyTorch en fp32 en el 100 % de 2.383 preguntas por checkpoint de Laya.

Aplica el consejo de la propia documentación: mide con tus datos antes de mover tráfico de producción. Para los umbrales de los que dependas, vuelve a ajustar las temperaturas con tus datos etiquetados e incorpóralas en un Modelfile.

¿Ollaya es gratis? ¿Tus datos salen de tu máquina?

Ollaya es open source bajo licencia Apache-2.0. Ejecutarlo no tiene coste por llamada; el coste es tu propio cómputo.

Los modelos tienen sus propias licencias, como muestra la tabla anterior: todos son Apache-2.0 salvo nli:deberta-v3-large, que es MIT. Si construyes un producto sobre uno de ellos, revisa la licencia de ese modelo en lugar de dar por hecho que la del proyecto lo cubre.

El servidor escucha por defecto en 127.0.0.1:11435. La red solo se usa para descargar modelos, y la documentación indica que los estados y las preguntas nunca se registran. Es una diferencia relevante frente a cualquier API de decisión alojada cuando el estado contiene tickets o correos de clientes.

¿Para quién tiene sentido Ollaya hoy?

Tres perfiles le sacan más partido hoy:

  • Equipos que ya prototipan con Jev y quieren una alternativa local o probar sin llamadas a la API.
  • Quien construye agentes en Claude Code o Cursor y quiere un filtro rápido antes de que se ejecuten comandos destructivos.
  • Equipos cuyo trabajo no está en inglés, gracias al router multilingüe.

Está en Beta, la lista de modelos crece cada semana y en algunos tipos de tarea los modelos abiertos quedan claramente por detrás de Jev. Como forma instalable de poner un paso de decisión de menos de 100 ms delante de un agente, merece una tarde de pruebas.