Cómo usar el modelo Jev AI: guía paso a paso para desarrolladores

Si buscas cómo usar el modelo Jev AI, empieza por una idea práctica: Jev está diseñado para tomar decisiones que el software pueda consumir, no para sustituir una interfaz de chat. Proporcionas un State, haces una o varias preguntas tipadas y recibes respuestas estructuradas con señales de probabilidad.

Esto hace que Jev resulte útil para clasificar tickets de soporte, enrutar solicitudes, puntuar riesgos, decidir si una acción requiere revisión o elegir el siguiente modelo de un flujo de agente. La página de inicio de Jev AI lo presenta como una capa de decisión para equipos de software.

Esta guía recorre el proceso completo, desde el primer experimento hasta la integración de la API en el servidor.

Qué hace el modelo Jev AI

Normalmente se pide a los modelos de lenguaje tradicionales que generen texto. Jev se centra en una pregunta más acotada y operativa: dado este State, ¿qué decisión estructurada debería utilizar a continuación la aplicación?

La interacción básica tiene tres partes:

1. State — el texto, objeto JSON o array de textos que aporta el contexto.
2. Questions — las decisiones que necesita resolver tu aplicación.
3. Answers — resultados tipados que tu código puede utilizar para ramificar, ordenar, enrutar o enviar a revisión.

Por ejemplo, un flujo de soporte puede enviar un ticket como State y pedir a Jev que determine el departamento, la urgencia y si debe revisarlo una persona. Es posible evaluar todas esas preguntas a la vez sobre el mismo State.

Jev resulta más útil cuando el espacio de respuestas está claro. Si necesitas una explicación abierta, un borrador creativo o una respuesta conversacional larga, suele encajar mejor un LLM generativo. Aun así, Jev puede situarse antes o después de un LLM para controlar el enrutamiento y la ejecución.

Paso 1: Elige una decisión con un resultado claro

El primer paso para aprender a usar Jev AI no consiste en escribir un prompt, sino en definir qué decisión necesita tomar tu producto.

Algunas buenas decisiones iniciales son:

• ¿Qué equipo debe recibir esta solicitud de soporte?
• ¿Es lo bastante urgente para entrar en una cola prioritaria?
• ¿Esta llamada propuesta a una herramienta necesita aprobación humana?
• ¿Qué gravedad tiene el problema en una escala definida?
• ¿Qué modelo debería encargarse del siguiente paso?

Evita empezar con una petición vaga como «entiende a este cliente». Conviértela en una pregunta acotada, por ejemplo: «¿Qué equipo de soporte autorizado debe gestionar este ticket?». Una pregunta concreta es más fácil de evaluar, probar con ejemplos históricos y conectar de forma segura con la lógica de la aplicación.

Paso 2: Prepara el State

El State es el contexto que comparten todas las preguntas. Jev acepta actualmente tres formatos de entrada útiles:

State de texto

Usa una cadena para un mensaje, ticket, correo electrónico o documento breve.

{
  "state": "My payout has failed three times and I need help before payroll runs tomorrow."
}

State como objeto JSON

Usa un objeto cuando la decisión dependa de varios campos con nombre. Así mantienes explícito el contexto importante, en vez de ocultarlo en un prompt largo.

{
  "state": {
    "message": "My payout has failed three times.",
    "account_age_days": 420,
    "recent_failures": 3,
    "requested_action": "retry payout"
  }
}

State como array

Usa un array cuando el contexto esté formado naturalmente por varios textos, como mensajes o notas. Limita el array a las pruebas necesarias para tomar la decisión.

No envíes más datos de los que necesita la pregunta. Un State pequeño y pertinente facilita la comprensión del flujo y ayuda a identificar qué pruebas influyeron en la respuesta.

Paso 3: Selecciona el tipo de pregunta adecuado

Jev ofrece tres tipos principales de pregunta. Elige el que corresponda a la decisión, en lugar de intentar convertir cualquier tarea en una pregunta de sí o no.

Tipo de pregunta	Ideal para	Resultado habitual
Choice	Clasificación o enrutamiento	Una opción de una lista predefinida, con probabilidades y confianza
Score	Gravedad, calidad o intensidad	Una posición en una escala ordenada, con probabilidades y confianza
Noul	Una pregunta concreta de sí o no	Una probabilidad de 0 a 1 de que la respuesta sea sí

Usa Choice para clasificar

Choice es adecuado cuando la aplicación dispone de un conjunto finito de destinos. Por ejemplo, los equipos autorizados para un ticket podrían ser facturación, soporte técnico y ventas.

Usa Score para evaluar una escala

Score resulta útil cuando hay niveles ordenados, como una gravedad baja, media o alta. Define los niveles de menor a mayor. La puntuación devuelta se pondera por probabilidad, por lo que puede situarse entre los niveles con nombre.

Usa Noul para una afirmación concreta

Noul encaja con preguntas como «¿Esta solicitud incluye un plazo urgente?» o «¿Debe una persona revisar esta acción?». El resultado es una probabilidad de 0 a 1 de que la afirmación sea verdadera.

Puedes combinar Choice, Score y Noul en una misma solicitud. Asigna una clave estable a cada pregunta, ya que esa misma clave identifica su respuesta en el resultado.

Paso 4: Valida la decisión en el entorno de pruebas

Antes de añadir credenciales o código de producción, prueba la pregunta con ejemplos reales en el entorno de pruebas de Jev AI.

Sigue este breve ciclo de validación:

1. Pega un State representativo.
2. Añade una pregunta bien delimitada.
3. Ejecuta la decisión e inspecciona la respuesta y la probabilidad.
4. Repite con casos claros, extremos y ambiguos.
5. Reescribe las instrucciones o los criterios si cuesta interpretar el resultado.

El objetivo no es hacer que un único ejemplo parezca correcto. Crea un pequeño conjunto de evaluación que represente el tráfico real de tu aplicación. Incluye casos en los que lo correcto sea detenerse, pedir más información o enviar el elemento a revisión humana.

Paso 5: Llama a la API de Jev desde tu servidor

Cuando la pregunta ya resulte útil, crea una clave API y llama al endpoint de producción desde un servicio del servidor. El endpoint actual es:

POST https://thejevai.com/v1/systemone

Envía la clave API como token Bearer e incluye state, model y questions en el cuerpo JSON. El nombre actual del modelo insignia en la referencia de la API es jev-latest.

curl -X POST https://thejevai.com/v1/systemone \
  -H "Authorization: Bearer $JEV_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": {
      "message": "My payout has failed three times.",
      "days_waiting": 3
    },
    "questions": {
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this request?",
        "criteria": {
          "billing": "Payments, invoices, refunds, or payouts",
          "technical": "Bugs, outages, or integration failures",
          "sales": "Pricing, upgrades, or new accounts"
        }
      },
      "needs_human": {
        "type": "noul",
        "instructions": "Does this request require human review?"
      }
    }
  }'

Guarda JEV_API_KEY en una variable de entorno del servidor. No la incluyas en código del navegador, artículos públicos, bundles de cliente ni repositorios.

Paso 6: Usa la respuesta estructurada en el código de la aplicación

La respuesta contiene un resultado para cada clave de pregunta. Una versión simplificada podría tener este aspecto:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": {
        "billing": 0.94,
        "technical": 0.05,
        "sales": 0.01
      },
      "confidence": 0.92
    },
    "needs_human": {
      "type": "noul",
      "noul": 0.87
    }
  },
  "usage": {
    "input_tokens": 180,
    "output_tokens": 24
  }
}

Tu aplicación decide qué ocurre a continuación. Por ejemplo:

const department = result.answers.department.choice;
const humanProbability = result.answers.needs_human.noul;

if (humanProbability >= 0.8) {
  await queueForReview(ticket.id);
} else {
  await routeToTeam(ticket.id, department);
}

La frontera importante es que Jev proporciona una señal, mientras que tu código controla la acción. Jev no debería borrar datos, enviar pagos, publicar contenido ni llamar a herramientas sensibles sin una comprobación de permisos en la aplicación.

Cómo usar la probabilidad y la confianza de forma segura

La probabilidad y la confianza ayudan a enrutar, priorizar y escalar casos, pero no garantizan que una decisión de negocio sea correcta. Trátalas como señales que ayudan al sistema a escoger un flujo.

Una política práctica podría ser:

• probabilidad alta y riesgo bajo → continuar automáticamente;
• probabilidad media o caso desconocido → recopilar más contexto;
• acción de alto riesgo o confianza baja → exigir aprobación humana;
• entrada no compatible o mal formada → devolver un error o usar una alternativa segura.

Elige umbrales con ejemplos históricos y, después del lanzamiento, supervisa los falsos positivos y los falsos negativos. Un umbral adecuado para enrutar solicitudes de soporte puede no servir para pagos, acceso a cuentas o herramientas destructivas.

Lista de comprobación para producción

Antes de publicar un flujo de Jev, verifica lo siguiente:

• El espacio de respuestas de la decisión está definido.
• El State contiene las pruebas necesarias para la pregunta y pocos datos irrelevantes.
• Cada pregunta tiene un único propósito claro.
• Los criterios de Choice son comprensibles y completos.
• Los niveles de Score están ordenados de menor a mayor.
• Las instrucciones de Noul describen una sola afirmación verificable.
• La clave API se almacena en el servidor.
• Los tiempos de espera, reintentos y errores de API tienen una alternativa segura.
• Los umbrales de probabilidad y confianza se han probado con casos históricos.
• Las acciones de gran impacto siguen requiriendo permisos de la aplicación o revisión humana.
• Los registros guardan las versiones de entrada y pregunta, el resultado y la acción final, sin revelar secretos.

Para consultar los campos actuales de la solicitud, los formatos de respuesta, los límites de entrada y el comportamiento ante errores, usa la documentación de la API de Jev AI como referencia principal.

Preguntas frecuentes sobre el uso de Jev AI

¿Jev AI es un chatbot?

No. Jev está pensado para tomar decisiones tipadas que el software pueda consumir. Puede formar parte de un producto de IA más amplio, pero su función principal no es generar transcripciones de chat.

¿Puedo hacer varias preguntas en una solicitud?

Sí. Varias preguntas pueden compartir el mismo State y evaluarse en paralelo. Resulta útil si un flujo necesita clasificar, puntuar y comprobar la seguridad al mismo tiempo.

¿Debería Jev sustituir a mi LLM?

No necesariamente. Usa Jev para decisiones acotadas y un modelo generativo para escribir, resumir o razonar de forma abierta. En muchos sistemas, Jev decide qué modelo o herramienta debe ejecutarse después.

¿Puedo enviar imágenes, audio o vídeo como State?

La documentación actual de la API incluye texto, objetos JSON y arrays de texto entre las entradas State compatibles. No enumera imágenes, audio ni vídeo como entradas directas; transforma o resume esas fuentes en tu aplicación antes de plantear la pregunta de decisión.

Conclusión

La forma más sencilla de empezar con el modelo Jev AI es elegir una decisión de bajo riesgo: preparar el State mínimo necesario, definir una pregunta tipada, probarla con ejemplos representativos y conectar el resultado estructurado al código. Cuando ese ciclo sea fiable, añade preguntas en paralelo, revisiones basadas en probabilidades, enrutamiento de modelos y controles de permisos.

Jev aporta más valor cuando la aplicación necesita una decisión repetible con una siguiente acción clara. Mantén la acción final en tu código, conserva las credenciales en el servidor y utiliza datos de evaluación para decidir dónde debe detenerse la automatización y empezar el criterio humano.