Preguntas frecuentes

¿Qué es un modelo de decisión?

Un modelo que lee un estado (texto, un correo, un ticket, un objeto JSON) más preguntas tipadas, y devuelve una respuesta tipada con probabilidades calibradas para cada pregunta en una sola pasada hacia adelante. Nunca genera texto. Eso lo hace rápido y su salida fácil de usar para actuar: enruta el ticket, bloquea el mensaje, escala cuando la probabilidad supera un umbral.

¿Cómo se instala?

La aplicación de escritorio para macOS, Windows y Linux; curl -fsSL https://ollaya.dev/install.sh | sh para la línea de comandos en Linux y macOS, irm https://ollaya.dev/install.ps1 | iex en Windows; o la imagen de Docker ghcr.io/ollaya-dev/ollaya. Consulta Descargar.

¿Qué relación tiene Ollaya con Ollama?

Ollaya toma la experiencia de Ollama (un solo binario, pull, run, serve, Modelfiles, una API REST local con las mismas convenciones) y la aplica a modelos de decisión en lugar de modelos de lenguaje generativos. Es un proyecto independiente, no está afiliado a Ollama.

Ollama ya ejecuta modelos de decisión. ¿En qué se diferencia Ollaya?

Ollama 0.35 (septiembre de 2026) añadió /v1/systemone para dos modelos decodificadores, Nimble de Bespoke Labs y Tev1 de Together AI. Ambos proyectos siguen el formato de cable de TypeSafe y, para modelos decodificadores, los dos leen las puntuaciones del siguiente token de las etiquetas de respuesta. Ollaya también ejecuta Nimble, desde la 0.8.0. Esta comparación es con Ollama 0.35:

Medidos en paralelo. En una RTX 5090, sobre el benchmark público de Bespoke Labs (3,880 preguntas etiquetadas por humanos de 13 conjuntos de datos, puntuadas con el propio código de Bespoke): winnow:12b en Ollaya obtiene 0.773 a 60 ms por pregunta, frente a 0.749 a 210 ms de Nimble en Ollama, lo mejor de Ollama. Con los mismos pesos de Nimble la exactitud es la misma (0.748 y 0.749), el error de calibración es 5.5 veces menor en Ollaya (0.022 frente a 0.122, porque Ollaya aplica la temperatura del autor) y Ollama es más rápido (210 frente a 310 ms: ejecuta un GGUF Q8_0 mientras que Ollaya calcula en fp32). La página principal tiene el gráfico.

Las ventajas de Ollama también son reales. Tev1 está allí y aquí todavía no (Together AI no ha publicado una licencia para sus pesos) y, si ya usas Ollama para modelos de lenguaje, un solo daemon cubre ambos. Los dos se ejecutan en paralelo: Ollama en el puerto 11434 y Ollaya en el 11435.

¿Qué relación tiene con TypeSafe?

El modelo cerrado Jev de TypeSafe creó la categoría de los modelos de decisión. Ollaya sirve modelos abiertos detrás de una API compatible con TypeSafe: el SDK oficial de TypeSafe para Python 0.7.1 funciona sin cambios con TYPESAFE_BASE_URL=http://localhost:11435 y cualquier API key. Ollaya no está afiliado a TypeSafe. Consulta Compatibilidad con TypeSafe.

¿Qué modelos puedo ejecutar?

Modelos de decisión abiertos de estas familias. Consulta Models, que compara su exactitud y su velocidad.

• winnow de EldanRing: Winnow-E4B (winnow:e4b, el modelo recomendado) y Winnow-12B (winnow), ajustes finos de Gemma 4 publicados como archivos GGUF. Ollaya ejecuta el archivo del autor en llama.cpp, en una GPU NVIDIA, en la GPU de Apple silicon o en la CPU. winnow:e4b obtiene 0.722 en decisiones tipadas, cerca del 0.738 de Jev, en unos 90 ms en una RTX 4090.
• laya de Convai Innovations: laya (un router), laya:en, laya:multilingual y laya:typed-decisions, cada uno también como -fp16 y -fp32. laya envía el texto en inglés a laya:en y los demás idiomas, el turco por ejemplo, a laya:multilingual. Es el más rápido.
• decider de Mapika: decider:4b, decider:2b y decider:0.8b, construidos sobre Qwen3.5. decider:4b obtiene 0.680 en decisiones tipadas. decider:2b-vision también lee una imagen junto con el estado.
• nli de Moritz Laurer: clasificadores NLI zero-shot sobre DeBERTa-v3-large y ModernBERT-large. Es el codificador más exacto.
• gliclass de Knowledgator: un clasificador zero-shot que sigue instrucciones y puntúa cada opción en una sola pasada.
• kev de Jared Palmer: kev:4b (kev), kev:0.8b y kev:9b, una LoRA y una cabeza de puntero sobre Qwen3.5 que puntúa cada opción en su propio span, calibrada. kev:9b obtiene 0.722 en decisiones tipadas, tanto como winnow:e4b, pero necesita una GPU de 24 GB y tarda unos 500 ms.
• decision de los contribuidores de vLLM Semantic Router: decision:eos, Decision 1.0 Eos, un Qwen3.5-0.8B totalmente ajustado con una cabeza de endpoint que puntúa cada opción en su último token, calibrada, con filas de hasta 16,384 tokens.
• qwen3guard del equipo de Qwen: un guardarraíl de seguridad en 119 idiomas. Responde a sus propias preguntas integradas (seguro, polémico o inseguro, y la categoría de inseguro), así que solo le envías el texto.
• von de Victor Hugo Panisa: Von 1.1 sobre ModernBERT-large, que puntúa cada opción en su propio marcador en una sola pasada y lee estados de hasta 8,192 tokens.
• clm de Contrastive-LM: CLM-v0.1-8B, que embebe el estado y cada opción con Qwen3-8B y elige la opción más cercana al estado mediante dos cabezas entrenadas. Las preguntas y las opciones se cachean, así que las repetidas son casi gratuitas. Obtiene 0.357 en decisiones tipadas; sus autores lo crearon para estados de agentes, juegos y llamadas a herramientas.
• jevk5 de alibiserikbay: JevK5 v0.3, un ajuste fino de Qwen3.5-4B publicado como archivos GGUF. Ollaya ejecuta el archivo Q8_0 de 4B del autor en llama.cpp, con hasta 16 opciones por pregunta.

¿De dónde vienen los pesos?

De los propios repositorios de Hugging Face de los autores de los modelos, fijados a un commit. Cada archivo se verifica con su sha256 cuando se descarga. Ollaya nunca vuelve a alojar pesos: su registry solo sirve manifiestos pequeños y archivos derivados, como los grafos ONNX, que referencian los pesos por URL. Los mismos archivos derivados se publican en Hugging Face bajo ollaya-dev.

¿Las respuestas son iguales a las del modelo original?

Ollaya ejecuta Laya como ONNX. En 2,383 preguntas por checkpoint (en, multilingual y typed-decisions), la exportación ONNX eligió la misma respuesta que la referencia PyTorch fp32 el 100% de las veces, con una diferencia máxima de probabilidad de 1.1 × 10⁻⁴. En una GPU CUDA se ejecuta el grafo fp16 de forma predeterminada; puede diferir de fp32 en casos de casi empate. Fija una etiqueta -fp32 para coincidir con la referencia.

¿Cómo se comparan los modelos con Jev?

Depende del modelo. En decisiones tipadas (2,000 preguntas), winnow:e4b y kev:9b son los más cercanos, con 0.722 frente a 0.738 de Jev, y winnow:e4b responde cinco preguntas en unos 90 ms en una RTX 4090, más rápido que la API alojada de Jev. Los codificadores pequeños, como laya, son los más rápidos, pero quedan muy por debajo de Jev en las preguntas difíciles. La página principal enumera la exactitud y la velocidad de cada modelo. Para una comparación independiente de los modelos de decisión abiertos con Jev, en exactitud y calibración, consulta el Decision Index. Si tienes datos etiquetados para una tarea fija, un modelo ajustado con ellos suele superar a cualquier modelo general.

¿Qué tan rápido es?

Una decisión es una sola pasada hacia adelante. Medida de extremo a extremo a través de la API HTTP en una RTX 4090, la solicitud mediana con cinco preguntas tarda 8 ms con laya:multilingual y 10 ms con laya:en (fp16), 15 ms con gliclass, 20 ms con nli y 89 ms con winnow:e4b. Una sola pregunta tarda 8–11 ms en los codificadores. Los decodificadores más grandes tardan más: kev:4b 354 ms, decider:4b 520 ms.

¿Necesito una GPU?

No. Ollaya se ejecuta en la CPU y, en x86-64 Linux y Windows, usa una GPU NVIDIA con el controlador R525 o más reciente cuando hay una presente (bibliotecas CUDA 13 desde R580 en adelante, CUDA 12 antes). Los scripts de instalación descargan las bibliotecas CUDA solo cuando detectan una GPU. Las aplicaciones de escritorio de Windows y Linux no incluyen bibliotecas CUDA: por sí solas ejecutan los modelos en la CPU y, cuando también está instalada la línea de comandos con sus bibliotecas de GPU (y es tan reciente como la app), la app inicia el servidor desde esa instalación, que usa la GPU. Los modelos GGUF como winnow se ejecutan en llama.cpp, que también usa la GPU de los Mac con Apple silicon (Metal); su paridad se ha comprobado en CUDA y en la CPU x86-64, todavía no en Metal. Son modelos de lenguaje grandes, así que una GPU marca una diferencia mucho mayor para ellos que para los modelos codificadores: consulta la página de cada modelo para ver las velocidades medidas. En una tarjeta de las series RTX 30, 40 o 50, los modelos GGUF no necesitan nada más. En tarjetas más antiguas o de centro de datos (serie GTX 10, V100, T4, A100, H100), las bibliotecas CUDA de llama.cpp incluyen código que el controlador compila en el primer uso, lo que exige un controlador más reciente: R570 o más reciente con las bibliotecas CUDA 12, y un controlador para CUDA 13.4 o más reciente con las bibliotecas CUDA 13. Con un controlador más antiguo, Ollaya ejecuta los modelos GGUF en la CPU y registra el motivo; ollaya llama-devices muestra la capacidad de cómputo de cada GPU y si los kernels se ejecutan en ella.

¿Qué plataformas son compatibles?

• Linux x86-64 y ARM64 con glibc 2.38 o más reciente: Ubuntu 24.04, Debian 13, Fedora 39, RHEL 10 o más reciente.
• macOS 14 o más reciente en Apple silicon. laya y nli:modernbert-large se ejecutan en la GPU de Apple a través de MLX, de 2 a 3 veces más rápido que en la CPU; los demás modelos se ejecutan en la CPU.
• Docker: ghcr.io/ollaya-dev/ollaya para linux/amd64 y linux/arm64, y :cuda para GPU NVIDIA (:cuda12 para controladores del host anteriores a R580). Úsala también en distribuciones de Linux más antiguas.
• Windows 10 y 11 en PC x86 de 64 bits: la aplicación de escritorio, y irm https://ollaya.dev/install.ps1 | iex para la línea de comandos, que también usa una GPU NVIDIA (instala ambas y el servidor de la app también la usará). WSL 2 con el instalador de Linux también funciona.
• La aplicación de escritorio se ejecuta en las tres: consulta Descargar.

¿Mis datos salen de mi equipo?

No. El servidor escucha en 127.0.0.1:11435 de forma predeterminada y ejecuta los modelos localmente. La red se usa solo para descargar modelos. Los estados y las preguntas nunca se registran.

¿Por qué el puerto 11435?

Está justo al lado del puerto predeterminado de Ollama, el 11434, para que ambos puedan ejecutarse en paralelo.

¿Cómo se calibran las probabilidades?

Con escalado de temperatura por tipo de pregunta y número de opciones, incluido con cada modelo. Para los umbrales en los que confías, reajusta las temperaturas con tus propios datos etiquetados e incorpóralas con un Modelfile.

¿Hay un servidor MCP o una skill de agente?

Ambos. ollaya mcp sirve los modelos locales a Claude Code, Claude Desktop, Cursor y otros clientes MCP (claude mcp add ollaya -- ollaya mcp), y la skill ollaya-decisions enseña a los agentes cuándo y cómo usarlos. Consulta Agents.

¿Cómo lo actualizo?

Ejecuta ollaya update. Comprueba la última versión y, cuando hay una más reciente, vuelve a ejecutar el script de instalación en el mismo lugar, lo que conserva tus modelos y la configuración del servicio. ollaya update --check solo te dice si existe una actualización. La aplicación de escritorio se actualiza entera: instala la nueva versión desde Descargar. En Docker, descarga la nueva imagen.

¿Cómo lo desinstalo?

En Linux, después de que el instalador configure el servicio:

sudo systemctl disable --now ollaya && sudo rm /etc/systemd/system/ollaya.service
sudo rm -rf /usr/local/bin/ollaya /usr/local/lib/ollaya /usr/local/share/doc/ollaya /usr/local/share/ollaya
sudo userdel -r ollaya    # also deletes /usr/share/ollaya, including the models

Para una instalación sin root (en ~/.local), elimina ~/.local/bin/ollaya, ~/.local/lib/ollaya, ~/.local/share/doc/ollaya y ~/.local/share/ollaya, y los modelos que hay en ~/.ollaya.

¿Cuál es la licencia?

Ollaya es Apache-2.0. Los modelos llevan sus propias licencias: laya, decider, kev, decision, qwen3guard, gliclass, von, winnow, jevk5, clm y nli:modernbert-large son Apache-2.0, y nli:deberta-v3-large es MIT.