Source: https://ailoot.ai/docs/es/api/systemone/
Canonical: https://ailoot.ai/docs/es/api/systemone/
Language: es

[API](https://ailoot.ai/docs/es/) 

# Jev — modelo de decisiones

[Markdown](https://ailoot.ai/docs/es/api/systemone/index.md)

El modelo de decisiones Jev de TypeSafe responde a preguntas tipadas sobre texto o JSON: elección de una opción, puntuación en una escala o «sí/no» con probabilidades. No es un chat ni genera texto.

POST`https://api.ailoot.ai/v1/systemone`

Jev — modelo de decisiones

```bash
curl https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "¡Ayuda! Mis desembolsos llevan fallando 3 días.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "¿Expresa urgencia?"
      }
    }
  }' 
```

```python
import json, os, urllib.request

body = {
    "model": "jev-latest",
    "state": "¡Ayuda! Mis desembolsos llevan fallando 3 días.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "¿Expresa urgencia?"},
    },
}
req = urllib.request.Request(
    "https://api.ailoot.ai/v1/systemone",
    data=json.dumps(body).encode(),
    headers={"Authorization": "Bearer " + os.environ["AILOOT_API_KEY"],
             "Content-Type": "application/json"},
)
with urllib.request.urlopen(req, timeout=60) as resp:
    result = json.load(resp)
print(result["answers"]["is_urgent"]["noul"])  # 0.95
```

```js
const resp = await fetch("https://api.ailoot.ai/v1/systemone", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AILOOT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "jev-latest",
    state: "¡Ayuda! Mis desembolsos llevan fallando 3 días.",
    questions: {
      is_urgent: { type: "noul", instructions: "¿Expresa urgencia?" },
    },
  }),
});
const result = await resp.json();
if (!resp.ok) throw new Error(`${resp.status} ${JSON.stringify(result)}`);
console.log(result.answers.is_urgent.noul); // 0.95
```

200 OK

```json
{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": {
      "type": "noul",
      "noul": 0.95
    }
  },
  "usage": { "input_tokens": 296, "output_tokens": 20 }
}
```

Jev es un modelo de decisiones de la clase System One de TypeSafe. No escribe texto ni mantiene conversaciones: le envías el **estado** (`state`), en texto o JSON, y un conjunto de **preguntas** y recibes valores tipados con probabilidades. El código puede usarlos directamente para ramificar, ordenar y enrutar, sin analizar texto libre.

Todas las preguntas de una solicitud se evalúan en paralelo e independientemente, sobre el mismo `state`. Según TypeSafe, añadir preguntas apenas cambia el tiempo de respuesta y las preguntas no interfieren entre sí.

| Aspecto | Resumen |
| --- | --- |
| Modelo | `jev-latest` : alias de la última versión estable de Jev; [ficha en el catálogo](https://ailoot.ai/models/es/#m=jev-latest) |
| Método | `POST /v1/systemone`. No es un chat: los formatos OpenAI, Anthropic y Gemini no sirven para Jev. La respuesta llega completa en un único JSON |
| Entradas admitidas | Solo texto: una cadena, un objeto JSON o un array de textos. Convierte antes las imágenes, el audio y el vídeo en texto |
| Contexto | 64K tokens por solicitud, entre state y todas las preguntas; state junto con la pregunta más larga, hasta 32K |
| Idioma | Según TypeSafe, el modelo es más preciso en inglés; admite otros idiomas, pero con menor precisión. Compruébalo con tus propios datos |
| Precio | Entrada a $0.084 por 1 millón de tokens; salida gratuita |

## [](https://ailoot.ai/docs/es/api/systemone/#request)Solicitud

### Autenticación

| Parámetro | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `Authorization` | header | obligatorio | Clave de Ailoot en formato `Bearer sk-…`. |

### Cuerpo de la solicitud

| Parámetro | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `model` | string | obligatorio | `jev-latest`. |
| `state` | string \| object \| array | obligatorio | Qué evaluar: una cadena de texto o JSON, como una consulta de un cliente, un registro de base de datos, una conversación o el estado actual de tu aplicación. Un objeto con nombres de campo claros suele resultar más práctico que una sola cadena. |
| `questions` | object | obligatorio | Preguntas. Tú eliges las claves y las respuestas llegan con esas mismas claves; la clave no influye en la respuesta, ya que la pregunta se define en `instructions`. |
| `questions.*.type` | string | obligatorio | `noul`, `choice` o `score` : consulta los detalles más abajo. |
| `questions.*.instructions` | string \| object \| array | obligatorio | La pregunta en sí. Una pregunta larga con datos se puede enviar como objeto: la pregunta en un campo y los datos en otros; haz referencia a los campos por su nombre entre acentos graves. |
| `questions.*.criteria` | object \| array |  | Opciones de respuesta, distintas para cada tipo: descripciones de «sí» y «no» en noul (opcionales), un diccionario de opciones en choice y una lista ordenada de niveles en score. |

## [](https://ailoot.ai/docs/es/api/systemone/#question-types)Tipos de preguntas

| Tipo | Qué pregunta | Qué devuelve |
| --- | --- | --- |
| `noul` | Si una afirmación es verdadera: sí o no | `noul` : probabilidad de «sí», de 0 a 1 |
| `choice` | Qué opción de las indicadas encaja | `choice`, `probabilities`, `confidence` |
| `score` | En qué punto de tu escala de niveles se sitúa state | `score`, `legend`, `probabilities`, `confidence` |

Se pueden combinar distintos tipos en una misma solicitud.

### noul — sí o no

El campo `criteria` es opcional: permite describir qué significa «sí» (`true`) y «no» (`false`). La respuesta `noul` es un número de 0 (no) a 1 (sí).

```json
"is_urgent": {
  "type": "noul",
  "instructions": "¿Expresa urgencia?",
  "criteria": {
    "true": "Se indica expresamente que el tiempo es determinante",
    "false": "No se expresa urgencia"
  }
}
```

```json
"is_urgent": {
  "type": "noul",
  "noul": 0.95
}
```

### choice — elección de una opción

`criteria` es un diccionario de «opción → descripción»; si no necesitas una descripción, indica `null`. Hasta 255 opciones. En la respuesta, `choice` es la opción más probable, `probabilities` indica la probabilidad de cada opción (la suma es 1) y `confidence` indica la confianza, de 0 a 1.

```json
"department": {
  "type": "choice",
  "instructions": "¿Qué equipo debería encargarse de esto?",
  "criteria": {
    "billing": "Pagos, facturación, reembolsos",
    "technical": "Errores, interrupciones del servicio, integraciones",
    "sales": "Precios, mejoras, nuevos clientes"
  }
}
```

```json
"department": {
  "type": "choice",
  "choice": "billing",
  "probabilities": { "billing": 0.88, "technical": 0.12, "sales": 0.0 },
  "confidence": 0.81
}
```

### score — puntuación en una escala

`criteria` son los niveles, de menor a mayor, hasta un máximo de 10 (TypeSafe recomienda al menos dos). En la respuesta, `score` es el valor ponderado por las probabilidades de los niveles (puede quedar entre dos niveles), `legend` indica el número de nivel y su descripción, `probabilities` y `confidence`. Según TypeSafe, `score` sirve para comparar con un umbral, pero no para obtener un número exacto entre niveles.

```json
"frustration": {
  "type": "score",
  "instructions": "¿Cómo de frustrado está el cliente?",
  "criteria": ["Tranquilo", "Frustrado", "Muy enfadado"]
}
```

```json
"frustration": {
  "type": "score",
  "score": 1.05,
  "legend": { "0": "Tranquilo", "1": "Frustrado", "2": "Muy enfadado" },
  "probabilities": { "0": 0.0, "1": 0.95, "2": 0.05 },
  "confidence": 0.92
}
```

## [](https://ailoot.ai/docs/es/api/systemone/#response)Respuesta

| Parámetro | Tipo | Obligatorio | Descripción |
| --- | --- | --- | --- |
| `model` | string |  | La versión del modelo que ha respondido. El alias jev-latest pasa a versiones nuevas con el tiempo: si has ajustado los umbrales de `confidence` para una versión concreta, vigila este campo. |
| `answers` | object |  | Una respuesta por pregunta, con las mismas claves. Todas las respuestas incluyen `type`, y las de choice y score también incluyen `confidence`. |
| `usage` | object |  | `input_tokens` y `output_tokens`. Solo se facturan los tokens de entrada. |

`confidence` resulta práctico como umbral: ante una respuesta con alta confianza, actúa automáticamente; si la confianza es baja, envíala a una persona o a un modelo grande para revisarla. La respuesta indica qué elegir, y `confidence` indica si conviene actuar.

## [](https://ailoot.ai/docs/es/api/systemone/#many-questions)Varias preguntas en una solicitud

Envía todas las preguntas sobre un mismo state en una sola solicitud: se evalúan en paralelo y state se envía una única vez. Según TypeSafe, en su ejemplo con 13 preguntas, una solicitud conjunta resultó 12,2 veces más barata y 10 veces más rápida que 13 solicitudes independientes enviadas una tras otra, con las mismas respuestas.

Es mejor dividir un juicio complejo en preguntas sencillas y combinar las respuestas en el código: por ejemplo, en vez de «evalúa la propuesta», puntúa por separado el mercado, la viabilidad y la diferenciación respecto a la competencia. Así puedes cambiar los pesos en el código, no en el texto de la pregunta.

```json
{
  "model": "jev-latest",
  "state": "¡Ayuda! Mis desembolsos llevan fallando 3 días.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "¿Qué equipo debería encargarse de esto?",
      "criteria": {
        "billing": "Pagos, facturación, reembolsos",
        "technical": "Errores, interrupciones del servicio, integraciones",
        "sales": "Precios, mejoras, nuevos clientes"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "¿Cómo de frustrado está el cliente?",
      "criteria": ["Tranquilo", "Frustrado", "Muy enfadado"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "¿Expresa urgencia?"
    }
  }
}
```

## [](https://ailoot.ai/docs/es/api/systemone/#use-cases)Cuándo utilizarlo

- **Enrutamiento.** Enviar una consulta al departamento adecuado y una solicitud al procesador correspondiente: código sencillo, un modelo grande o una persona.
- **Orden y prioridad.** Urgencia, tono y riesgo en una escala, con umbrales en el código.
- **Moderación y comprobaciones.** Comprobar si un mensaje infringe las reglas, si una fuente respalda una cita o si un documento contiene la respuesta a una pregunta, antes de que el texto siga adelante.
- **Puntuación y clasificación.** Evaluar documentos, candidatos o fragmentos encontrados con tus propios criterios y decidir en el código cuáles pasan a la siguiente fase.
- **Una alternativa al frágil «devuelve JSON».** Una llamada que devuelve valores tipados por diseño, en lugar de texto que haya que analizar.

## [](https://ailoot.ai/docs/es/api/systemone/#not-for)Cuándo no utilizarlo

- **Chats, respuestas al usuario y generación de texto o código.** Jev no escribe texto; para eso están los [modelos de texto](https://ailoot.ai/models/es/?kind=text).
- **Modelo para Claude Code, Cursor y otros agentes.** No puedes sustituir el modelo de un agente por jev-latest: el agente necesita un modelo que escriba texto y llame a herramientas. Puedes llamar a Jev desde el código que el agente escriba para ti.
- **Aritmética, recuentos y comparación de fechas.** Según TypeSafe, estas operaciones son más fiables en el código; pregunta al modelo solo por la parte semántica, como extraer componentes de una fecha mediante choice.
- **Imágenes, audio y vídeo.** El modelo solo admite texto: convierte esos datos en texto previamente.

El modelo funciona mejor cuando cada pregunta plantea un juicio concreto y acotado. Escribe la condición de forma explícita: según TypeSafe, el modelo interpreta la pregunta literalmente y un state grande con datos innecesarios reduce la precisión. Filtra esos datos en el código.

## [](https://ailoot.ai/docs/es/api/systemone/#price)Precio

Solo se facturan los tokens de entrada, indicados en el campo `usage.input_tokens` de la respuesta: **$0.084 por 1 millón**. Los tokens de salida son gratuitos.

La solicitud del ejemplo de esta página (296 tokens de entrada) cuesta menos de $0.0001.

Antes de la solicitud, Ailoot reserva una cantidad del saldo y, tras la respuesta, cobra una sola vez según el consumo real. Consulta [cómo funciona](https://ailoot.ai/docs/es/billing/reserve/).

## [](https://ailoot.ai/docs/es/api/systemone/#limits)Límites

| Aspecto | Límite |
| --- | --- |
| Solicitud completa: state y todas las preguntas | 64K tokens |
| state junto con la pregunta más larga | 32K tokens |
| Opciones en un choice | hasta 255 |
| Niveles en un score | de 2 a 10 |
| Entrada | solo texto: una cadena, un objeto JSON o un array de textos |

Límites del modelo según TypeSafe. Las restricciones de tu clave y saldo se aplican igual que en cualquier modelo de Ailoot: [Errores y límites](https://ailoot.ai/docs/es/errors/).

## [](https://ailoot.ai/docs/es/api/systemone/#errors)Errores

Los errores llegan en el formato común de Ailoot API: código, mensaje claro y Request ID. Los más habituales en este método son:

| Código | Cuándo ocurre | Qué hacer |
| --- | --- | --- |
| **400** `invalid_request` | El cuerpo no ha superado la validación: falta state, model o questions, type es desconocido, choice tiene más de 255 opciones o score tiene más de 10 niveles | Corrige la solicitud según el mensaje de error; sin cambios, volverá a fallar |
| **400** `context_length_exceeded` | state y las preguntas juntos superan el límite del modelo | Filtra state en el código y conserva los datos necesarios para las preguntas |
| **401** `invalid_api_key` | La clave falta o no es válida | Envía la clave en la cabecera Authorization |
| **402** `insufficient_balance` | No hay suficiente saldo disponible para la reserva | Recarga el saldo |
| **404** `model_not_found`, `unsupported_endpoint` | El ID contiene un error o se ha llamado al modelo mediante un método incorrecto, por ejemplo, /v1/chat/completions | Llama a jev-latest únicamente mediante POST /v1/systemone |
| **429** `rate_limit_exceeded` | Demasiadas solicitudes | Espera los segundos indicados en la cabecera Retry-After y vuelve a intentarlo |
| **503** `model_overloaded`, `model_unavailable` | El modelo está temporalmente sobrecargado o no disponible | Si X-Should-Retry: true, vuelve a intentarlo tras los segundos indicados en Retry-After; si es false, consulta primero el Request ID en el historial |
| **504** `model_timeout` | El modelo no ha respondido a tiempo | No vuelvas a enviar la solicitud hasta consultar el Request ID en el historial |

La lista completa de códigos está en la página [Errores y límites](https://ailoot.ai/docs/es/errors/).

¿Tienes alguna pregunta? Envíanos el Request ID y una descripción; te ayudaremos a resolverla.[Contactar con soporte](mailto:support@ailoot.ai)

## Ailoot · La empresa y su cartera de proyectos





Ailoot se apoya en la experiencia operativa acumulada, una amplia base de clientes, un servicio estable y el seguimiento continuo de KPI.





La empresa y su cartera de proyectos: millones de clientes; ventas por miles de millones al mes.





Ailoot aplica esa experiencia operativa al acceso por API a funciones de IA en productos de clientes, agentes, aplicaciones y automatizaciones.