# Laya vs Jev: modelos System One, open weights o API

Comparativa real entre Laya y Jev para clasificar texto en tu pipeline de agentes: cuándo pagar una API externa y cuándo correr pesos abiertos en local.

*agentes · 2026-09-21 · [mauriciosneira.com](https://mauriciosneira.com/blog/laya-vs-jev-system-one-open-vs-cerrado)*

---

Tu pipeline de agentes necesita clasificar o filtrar texto rápido y gastás tokens de un modelo generativo solo para obtener un booleano. Para resolver esto aparecieron los modelos System One: devuelven decisiones tipadas con probabilidades calibradas en un único forward pass.

La discusión central hoy pasa por la comparativa de Laya vs. Jev: pesos abiertos o API para decisiones en tu pipeline. Por un lado tenés a Jev (de TypeSafe AI), una API cerrada y hosteada. Por el otro está Laya (de Convai Innovations), un System One con pesos abiertos bajo licencia Apache 2.0 que bajás de Hugging Face y corrés en tu máquina. En este post te muestro cómo rinde cada uno en una tarea real y vas a ver cuándo te conviene pagar una API remota o correr el cómputo en tu propia infraestructura.

En vez de mirar benchmarks oficiales, corrí los dos sobre mi propia tarea con los mismos inputs y medí los resultados.

```mermaid
flowchart TD
    Input["Titular a evaluar (texto)"] --> JevAPI["Jev (API remota / caja negra)"]
    Input --> LayaLocal["Laya System One (Local / Open-weights)"]
    JevAPI --> ResJev["Decisión zero-shot calibrada (~840 ms)"]
    LayaLocal --> ResLaya["Decisión local en CPU (~30 ms, requiere fine-tuning)"]
```

## Arquitectura y acceso: el dilema de Laya vs. Jev

Laya es un modelo discriminativo pensado para correr en tu servidor o en el borde. Al ser un desarrollo de pesos abiertos bajo Apache 2.0, tenés el control total del artefacto: podés auditar las capas, cambiar el forward pass y ejecutar inferencias sin conexión externa.

Jev funciona como una API en la nube. Como detallé antes sobre [qué es Jev System One](/blog/jev-system-one-modelos-discriminativos-ia), es un servicio propietario donde la arquitectura y el entrenamiento quedan del lado del proveedor, ofreciendo alta precisión zero-shot directo con llamadas HTTP.

Si analizás Laya vs. Jev desde el despliegue, la diferencia es clara: con Jev consumís un endpoint y te olvidás del hardware, mientras que Laya te exige gestionar el entorno de ejecución a cambio de no depender de terceros.

## El setup: la misma tarea para los dos

Uso Jev en el pipeline del agente que escribe borradores de este blog: puntúa titulares candidatos por relevancia para priorizar los mejores artículos técnicos. Armé un set fijo de 10 titulares con temas técnicos fuertes, relleno puro y casos medios.

A los dos modelos les pasé exactamente las mismas dos preguntas tipadas:

- una Noul (`vale`): ¿da para un post técnico serio sobre IA en producción?
- un Score (`rel`): relevancia para ingenieros que llevan IA a producción (escala de 3 niveles).

El score final usa la fórmula `P(vale) * (0.5 + relevancia/2)`. Mismo prompt, mismos titulares y misma fórmula. Para Laya probé dos checkpoints: `laya-typed-decisions` (fine-tuneado para decisiones en inglés) y `laya-multilingual` (el indicado para español).

Integrar Jev por HTTP requiere este código (según la [documentación de TypeSafe AI](https://docs.typesafe.ai/introduction)):

```python
requests.post(
    "https://api.typesafe.ai/v1/systemone",
    json={"state": titular, "model": "jev-latest", "questions": Q},
    headers={"Authorization": f"Bearer {API_KEY}"},
)
```

Para correr Laya en local hacés `pip install laya` y ejecutás:

```python
import laya
agent = laya.load("convaiinnovations/laya-multilingual")  # baja los weights (~322M)
result = agent.predict(titular, Q)  # mismo formato de questions que Jev
```

## Los números reales

| Titular | esperado | Jev | Laya-td | Laya-ml |
|---|:---:|:---:|:---:|:---:|
| Framework de orquestación de agentes con checkpointing | fuerte | 1.11 | 0.60 | 0.23 |
| OpenAI revela incidentes con agentes descontrolados | medio | 0.89 | 0.70 | 0.39 |
| 5 trucos de productividad para trabajar desde casa | relleno | 0.04 | 0.55 | 0.33 |
| Cómo elegir el mejor smartphone gama media | relleno | 0.03 | 0.53 | 0.81 |
| RAG en producción: reranking y evaluación | fuerte | 1.26 | 0.63 | 0.74 |
| Constrained decoding y structured outputs | fuerte | 1.17 | 0.58 | 0.45 |
| Las 10 mejores series de streaming del mes | relleno | 0.01 | 0.45 | 0.14 |
| Calibración de probabilidades en clasificadores | fuerte | 1.22 | 0.58 | 0.14 |
| Una startup de IA levanta una ronda millonaria | medio | 0.12 | 0.66 | 0.34 |
| Sistemas multiagente: coordinación y fallos parciales | fuerte | 1.18 | 0.68 | 0.21 |

Medí la separación calculando el promedio del score en titulares fuertes menos el de relleno. Cuanto más grande el gap, mejor discrimina la señal del ruido:

| Modelo | gap señal/ruido | lectura |
|---|:---:|---|
| Jev | 1.16 | separa perfecto: relleno ~0.03, técnico ~1.19 |
| Laya-td | 0.11 | casi no separa |
| Laya-ml | −0.07 | invertido: le puso 0.81 a smartphone gama media y 0.21 a sistemas multiagente |

Zero-shot sobre estos 10 titulares, Jev juega en otra categoría. Con Laya hay una explicación: `laya-td` es un checkpoint en inglés evaluando español, por eso su respuesta plana (entre 0.45 y 0.70). El problema es que `laya-ml`, pensado para español, tampoco discrimina y se equivoca con confianza (le dio 0.81 al titular de smartphones).

## Por qué esto no es un problema de fondo para Laya

Para ser justos con la comparación, hay tres factores a considerar:

1. Tarea fuera de distribución: evaluó relevancia editorial en español sobre IA. La documentación de Laya aclara que en zero-shot ronda 0.35 de accuracy y que requiere fine-tuning para tu tarea.
2. Primitivo débil: la documentación indica que las preguntas de tipo Score son su punto bajo (0.372 en SST-5), y mi fórmula depende de un Score.
3. Tamaño y despliegue: Jev corre en la nube con más recursos, mientras que `laya-multilingual` son 322M (el modelo base, 421M) ejecutándose en tu notebook.

Laya no busca competir en zero-shot contra modelos grandes. Su objetivo es ser una base abierta y liviana para adaptar con datos propios.

Donde Laya gana es en latencia: en la CPU de una laptop resolvió cada decisión en ~30 ms. Jev promedió ~840 ms por el viaje de ida y vuelta a la API. Esta diferencia es clave si pensás [cómo rutear requests entre LLMs](/blog/ruteo-inferencia-system-one) sin penalizar los tiempos de respuesta de tu frontend.

## El trade-off real entre ambos modelos

La elección depende de los límites de tu infraestructura:

| Dimensión | Jev (System One cerrado) | Laya (System One open) |
|---|---|---|
| Zero-shot en tu tarea | funciona y calibra | flojo, requiere fine-tuning |
| Acceso | API propietaria, pago por llamada | open weights, Apache 2.0 |
| Dónde corre | infraestructura del proveedor | tu máquina (CPU/GPU), privado |
| Latencia | ~800 ms (red) | ~30 ms (local) |
| Privacidad de datos | salen a un tercero | nunca salen de tu red |
| Costo | por llamada | cómputo propio, fijo |
| Esfuerzo de setup | mínimo | requiere etiquetar y entrenar |

Jev te da conveniencia: funciona sin configuración previa y calibrado, pagando por petición y enviando datos afuera. Laya te da control: pesos abiertos, inferencia local, privacidad y respuesta inmediata, asumiendo el trabajo de entrenarlo.

El benchmark de accuracy de Convai Innovations (0.766 vs 0.727 de Jev) usa su propio dataset con el modelo adaptado. Mi prueba muestra que sin entrenamiento previo no rinde igual en zero-shot, aunque su velocidad en local es indiscutible.

## Preguntas frecuentes

### ¿Jev tiene pesos abiertos disponibles para descargar?
No. Jev no es de pesos abiertos. Funciona únicamente como un servicio administrado mediante endpoints HTTP bajo suscripción comercial. No podés descargar sus pesos ni correrlo en servidores propios.

### ¿Dónde se consiguen los pesos abiertos de Laya?
Los pesos abiertos de Laya están disponibles en el repositorio de [Convai Innovations en Hugging Face](https://huggingface.co/convaiinnovations/laya) bajo licencia Apache 2.0. Podés bajar los checkpoints a tu entorno para inferencia en CPU o GPU con su paquete oficial de Python.

### ¿Existe una API oficial en la nube para Laya?
No existe una API administrada por Convai Innovations. El proyecto se distribuye como código y pesos para correr en local. Si querés consumirlo vía HTTP dentro de tu arquitectura, tenés que hostearlo vos.

### ¿Cómo decidir entre una API remota y un clasificador local para tu pipeline?
1. Usá una API remota si no tenés dataset de entrenamiento y necesitás arrancar hoy con salidas calibradas.
2. Usá un modelo de pesos abiertos local si procesás información confidencial o tu pipeline exige latencias menores a 50 ms.

## Qué hacer el lunes

1. Elegí Jev si necesitás decisiones tipadas inmediatas sin armar un dataset propio. Funciona de una y calibrado, asumiendo la latencia de red y el costo por llamada.
2. Elegí Laya si tenés datos de tu dominio y buscás baja latencia, costo fijo y privacidad. Bajás los pesos, entrenás sobre tus ejemplos y tenés un clasificador de ~30 ms en tu infraestructura.
3. Reemplazá cualquier LLM pesado que uses solo para bifurcar flujos con booleanos por alguna de estas dos opciones.

La arquitectura de tus agentes mejora cuando dejás de usar modelos generativos gigantes para resolver bifurcaciones simples de control de flujo.
