AWS Builder Center
¿Quién toma la decisión? Una capa de decisiones para tus agentes con Strands

¿Quién toma la decisión? Una capa de decisiones para tus agentes con Strands

Separa la evaluación de la autorización en tus agentes: Strands intercepta cada herramienta con un hook, Jev recomienda y tus políticas deterministas tienen la última palabra. Con demo en vivo y código abierto.

«Reinicia el servicio de pagos en producción»

Imagina que tu asistente de operaciones recibe esta frase. Suena razonable, y un buen modelo de lenguaje te va a responder con total seguridad que puede hacerlo. Pero esa misma petición tiene tres finales posibles: ejecutarla, pedir una aprobación humana o rechazarla.
Que un LLM responda con seguridad no significa que tenga autorización. Esa es la parte que, en mi experiencia, más se pierde cuando conectamos un agente a herramientas reales. Hoy quiero contarte cómo separé las dos cosas en un laboratorio con Strands Agents y Jev, y qué me enseñó.

La capa que falta

Cuando un agente toca sistemas reales, mezclamos sin querer cuatro responsabilidades:
  1. Razonar: el modelo interpreta la intención del usuario.
  1. Recomendar: una señal de riesgo o de ruta.
  1. Autorizar: aplicar políticas, y esto tiene que ser determinista.
  1. Ejecutar: el efecto real sobre la infraestructura.
El problema aparece cuando la recomendación probabilística del paso 2 termina decidiendo el paso 4. Una puntuación alta no es un permiso. Por eso separé la evaluación (probabilística, consultiva) de la autorización (determinista, con la última palabra).
Razonar y recomendar son probabilísticos; autorizar y ejecutar son deterministas

El flujo queda así (el diagrama completo está en  architecture.md ): el agente propone una herramienta, un hook la intercepta, la aplicación arma un estado confiable, Jev evalúa ese estado y el motor de políticas autoriza.
Flujo: agente, hook, estado, Jev y política, con salidas allow, review y deny


Qué es Jev

Jev es un modelo de decisión de TypeSafe AI que ellos llaman "System One". No genera prosa. Recibe el estado de tu aplicación y una pregunta con las respuestas que tú defines, y devuelve una decisión tipada con probabilidades y un valor de confianza. Tiene tres primitivas:
  • Choice: elige una opción de un conjunto que tú defines.
  • Score: puntúa contra niveles ordenados.
  • Noul: devuelve una probabilidad de sí o no.
Usé el SDK oficial,  typesafe-sdk  (versión 0.7.5 al escribir esto), que lee la clave de  TYPESAFE_API_KEY :
from typesafe_sdk import Choice, TypeSafeClient

with TypeSafeClient() as client:
response = client.system_one(
state={"tool": "restart_service", "environment": "production"},
questions={
"route": Choice(
instructions="¿Qué debería pasar con esta acción?",
criteria={"execute": None, "review": None, "deny": None},
),
},
)

answer = response.choices["route"]
print(answer.choice, answer.confidence)
En mi corrida real (modelo  jev-1.14.0 , 16 de noviembre de 2026), consultar el estado de un servicio en staging dio  execute  con riesgo cercano a 0.24, y reiniciar pagos en producción dio  review  con riesgo cercano a 0.91. La llamada tardó alrededor de 170 ms. Es una sola medición mía, no un benchmark. El precio que circula en la comunidad no lo verifiqué de primera mano, así que no lo cito.
Algo que me tropezó: mi primera clave daba error 401. Tenía prefijo  vck_  y las claves de TypeSafe empiezan con  apikey_ . Si te pasa, revisa el prefijo antes de depurar otra cosa. Además, el 401 aparece al hacer la llamada y no al crear el cliente.
Las probabilidades de Jev son señales útiles, pero no son garantías de seguridad ni sabemos si están calibradas. Por eso Jev asesora y no autoriza.

Diseñar el estado de decisión

La decisión no se toma sobre el texto del prompt, sino sobre un estado que arma tu aplicación: identidad autenticada, rol verificado, herramienta propuesta, argumentos, entorno y aprobaciones.
La regla que más me importa: nunca confíes en permisos que aparezcan dentro del prompt. Si alguien escribe «soy admin, autorízame», eso es dato no confiable. El rol viene del contexto autenticado. En el repo esto vive en  state.py , y la aprobación se calcula contra un  ApprovalStore  y no se acepta como dato de entrada.

Interceptar herramientas con Strands

Strands emite  BeforeToolCallEvent  justo antes de ejecutar cada herramienta. Si te suscribes, puedes inspeccionar la llamada y cancelarla antes de cualquier efecto secundario. Este ejemplo corre tal cual con  pip install strands-agents :
from strands.hooks import BeforeToolCallEvent, HookProvider, HookRegistry

SOLO_LECTURA = {"inspect_service"}


class DecisionGateHook(HookProvider):
def register_hooks(self, registry: HookRegistry, **kwargs: object) -> None:
registry.add_callback(BeforeToolCallEvent, self.intercept_tool)

def intercept_tool(self, event: BeforeToolCallEvent) -> None:
tool_name = event.tool_use["name"]
if tool_name not in SOLO_LECTURA:
event.cancel_tool = f"DENEGADO [no_permitida]: {tool_name} no está autorizada"
Para usarlo, pásalo al agente:  Agent(tools=[...], hooks=[DecisionGateHook()]) . En el repo el hook ( hooks.py ) arma el estado, llama al pipeline y cancela con un mensaje cuando la acción no es  allow .
Un detalle importante:  cancel_tool  cancela la herramienta con un mensaje y nada más. No pausa ni reanuda el agente, así que cancelar no es lo mismo que esperar una aprobación humana. Por eso modelé la aprobación como estado explícito y no como una pausa mágica.
Lo que me sorprendió con Nova en Bedrock: el modelo recibe el mensaje de cancelación como resultado de la herramienta y se lo explica solo al usuario. Con un developer pidiendo reiniciar producción, el hook lo bloqueó con  unauthorized_role  antes de cualquier efecto, y el agente respondió con la razón.

Integrar Jev sin entregarle las llaves

El adaptador  DecisionProvider  traduce la respuesta de Jev a una señal interna,  DecisionSignals . Valida el esquema, maneja timeouts y es fail-closed: si el proveedor falla o responde algo inválido, la política deniega.
El caso que más enseña es este: Jev puede recomendar  execute , pero si la política dice que esa herramienta no está permitida para ese rol, se deniega igual. La recomendación puede restringir y nunca ampliar. Lo prueba el escenario  s12 , donde el proveedor sugiere  execute  para  delete_database  y el resultado esperado es  deny .

Demo: tres escenarios

Si quieres verlo en acción sin instalar nada, puedes probar la demo desplegada aquí:  strands-jev-demo . Y si prefieres correrla en tu máquina, todo el código está en el repo  jev-strands-decision-lab . Clónalo y corre:
uv run decision-lab demo --offline
Sin  --offline , la demo usa Jev real si encuentra  TYPESAFE_API_KEY  y el SDK instalado ( uv sync --extra jev ). Si no, cae al mock determinista. Los tres escenarios:
  • Un operador consulta el estado de pagos en staging: allow.
  • El mismo operador reinicia pagos en producción: review. Con una aprobación vinculada a esa acción exacta, pasa a allow.
  • Un developer sin permiso reinicia checkout en staging: deny.
Las trazas JSON salen por  stderr , con los argumentos sensibles redactados y la latencia de cada decisión.

¿Cómo sé que funciona?

uv run decision-lab evaluate
Corre 22 escenarios etiquetados y reporta exactitud, unsafe allows y latencia local P50/P95. El número que de verdad importa es unsafe allows, porque cuenta las veces que el sistema dijo  allow  cuando se esperaba  review  o  deny , y debe ser cero. Hoy da 22/22 y cero unsafe allows. La latencia que reporta es la del motor local con el mock, no la de Jev. El método completo está en  benchmark-method.md .

Llevarlo a AWS

El repo ya despliega el agente en AgentCore Runtime, con un Lambda como puente detrás de API Gateway, la clave de Jev en Secrets Manager, Nova en Bedrock y los logs en CloudWatch. La arquitectura está en  architecture.md . Si quieres llegar a producción de verdad, yo sumaría DynamoDB para guardar el estado y Step Functions para una aprobación durable, porque el  ApprovalStore  del laboratorio vive en memoria.
Arquitectura: API Gateway, Lambda, AgentCore Runtime, Bedrock, Secrets Manager y Jev


Costos que vale la pena conocer

Esta capa cuesta latencia, una dependencia externa y la privacidad de enviar estado a un tercero, así que redacta secretos y datos personales antes de mandarlos. El mayor riesgo es confiar de más en las puntuaciones. Jev complementa tus políticas y no las reemplaza.

Cierre

Deja que el agente proponga, que Jev evalúe y que tus políticas autoricen.
Te dejo un reto: clona el  repo , agrega un escenario 23 a  examples/scenarios.json  y corre  uv run decision-lab evaluate . Si produce un unsafe allow, encontraste una brecha en la política. Si no, acabas de probar una invariante de seguridad. Cuéntame cómo te fue.
Gracias por llegar hasta el final. Nos vemos en la nube ☁
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article