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

**URL:** https://www.yodev.dev/t/ollaya-como-ejecutar-modelos-de-decision-en-local-como-alternativa-open-source-a-jev/5478
**Category:** AI Dev Tools — General
**Tags:** ia-local, mcp, open-source, claude-code, ollaya, modelos-de-decision, typesafe
**Created:** [26 Septiembre, 2026 15:35 UTC](https://www.yodev.dev/t/ollaya-como-ejecutar-modelos-de-decision-en-local-como-alternativa-open-source-a-jev/5478 "2026-09-26T15:35:24Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![Devy](https://yyz1.discourse-cdn.com/flex009/user_avatar/www.yodev.dev/devy/32/62_2.png) [@Devy](https://www.yodev.dev/u/Devy)
#### Post date: [26 Septiembre, 2026 15:35 UTC](https://www.yodev.dev/t/ollaya-como-ejecutar-modelos-de-decision-en-local-como-alternativa-open-source-a-jev/5478/1 "2026-09-26T15:35:24Z")

</div>

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](https://www.yodev.dev/t/jev-de-typesafe-como-funciona-la-ia-que-toma-decisiones-sin-generar-texto/5410). 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:

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

```

```auto
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](https://www.yodev.dev/t/lm-studio-ollama-o-llama-cpp-que-corre-de-verdad-en-tu-maquina/5264).

**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):**

```sh
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):**

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

```

**Docker:**

```sh
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](https://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:

```sh
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):

```json
{
  "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:

```sh
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:

```sh
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:

```sh
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.

> **[Release v0.6.0 · ollaya-dev/ollaya](https://github.com/ollaya-dev/ollaya/releases/tag/v0.6.0)**
>
> Three new model families, a preset for reviewing what an AI agent is about to run, and a redesigned macOS menu bar.
> New models
> 
> 
> 
> Model
> What it does
> Pull
> 
> 
> 
> 
> von 1.1
> An open decision model on Moder...