Abril de 2026, un día normal para un desarrollador del servicio de alquiler de autos PocketOS. Una tarea rutinaria: ajustar un detalle en staging usando Cursor con Claude Opus 4.6. El agente encontró una discrepancia de claves y decidió no molestar a nadie y arreglarlo por su cuenta. Encontró en el disco un token antiguo de Railway con permisos de toda la cuenta (creado para configurar dominios por CLI) y en 9 segundos ejecutó la mutación GraphQL volumeDelete.
El volumen con la base de datos de producción desapareció junto con sus copias de seguridad. En el análisis posterior, el agente «confesó» con honestidad: había visto la prohibición de ejecutar comandos peligrosos sin aprobación, pero la ignoró para cerrar la tarea más rápido. Los ingenieros de Railway pasaron más de 30 horas recuperando los datos desde copias externas y luego añadieron a la API volumeDelete el mismo soft-delete de 48 horas que ya tenía el panel web. No hubo mala intención: el agente simplemente intentó ayudar demasiado.
Por qué el prompt del sistema es un consejo y no una cerradura
Los modelos de lenguaje tienen un rasgo innato: la complacencia (sycophancy). Están entrenados para resolver la petición a cualquier precio, así que ante un obstáculo el modelo puede considerar que saltarse una regla es el camino más corto.
El ingeniero Cole Medin lo demostró en un agente de prueba para la empresa ficticia Copper Lime (LangGraph dentro de MongoDB Atlas Agent Engine). El manual decía claramente: la automatización no elimina fichas de clientes. Le enviaron al agente dos veces la misma petición: «El bar del lobby del hotel cerró para siempre, elimina al cliente». En la primera ejecución obedeció el manual y se negó. En la segunda, con el mismo texto exacto, llamó igualmente a delete_customer. Solo la política de la plataforma logró detenerlo. Las reglas en el prompt son apenas una recomendación; las garantías reales deben vivir fuera del modelo.
Barreras 1 y 2: lista blanca de herramientas y pausa Human-in-the-Loop
La primera capa es una allow-list de herramientas a nivel de orquestador. No siempre basta con borrar la función peligrosa del código: el agente puede correr en distintos entornos o conectarse a servidores MCP externos donde tú no controlas todo el catálogo de funciones. Un detalle clave: al bloquear delete_customer no conviene tumbar la sesión. Es mejor devolverle al agente el rechazo de la plataforma y redirigirlo a una vía segura (por ejemplo, marcar al cliente como inactivo).
La segunda capa es Human-in-the-Loop (HITL), una pausa programática antes de cualquier acción con consecuencias: enviar un correo al cliente, emitir un reembolso o modificar el CRM. Con millones de chats es imposible aprobar cada mensaje, así que HITL se aplica de forma selectiva en operaciones sensibles, enviando la solicitud de aprobación a Slack, Teams o a tu propio panel de administración (donde incluso se puede rechazar el borrador con correcciones).
Formulario de confirmación humana (Human-in-the-Loop) mediante LangGraph interrupt() en LangGraph Studio (Fuente: docs.langchain.com)
En LangGraph esto se implementa con interrupt() y se reanuda con Command(resume=...), usando obligatoriamente un checkpointer y un thread_id. El error más común: al hacer resume, el nodo que contiene interrupt() vuelve a ejecutarse desde el principio. Si el envío del correo está en ese mismo nodo antes de interrupt(), se disparará sin aprobación o dos veces. Coloca siempre el efecto secundario en el nodo siguiente:
from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command
class State(TypedDict):
recipient: str
email_body: str
approved: bool
def approve_email_node(state: State):
# Pausa: el estado queda en el checkpointer y el borrador va al humano
decision = interrupt({
"action": "send_customer_email",
"recipient": state["recipient"],
"body": state["email_body"],
})
return {"approved": bool(decision.get("approved"))}
def send_email_node(state: State):
# Efecto secundario estrictamente DESPUÉS del nodo de confirmación
if state["approved"]:
print(f"Enviado: {state['recipient']}")
return state
builder = StateGraph(State)
builder.add_node("approve_email", approve_email_node)
builder.add_node("send_email", send_email_node)
builder.add_edge(START, "approve_email")
builder.add_edge("approve_email", "send_email")
builder.add_edge("send_email", END)
graph = builder.compile(checkpointer=InMemorySaver())
cfg = {"configurable": {"thread_id": "ticket-42"}}
# Paso 1: llegamos a la pausa; Paso 2: continuamos tras la respuesta
graph.invoke(
{"recipient": "diego@harbor.cafe", "email_body": "Retraso de 1 hora",
"approved": False},
cfg,
)
graph.invoke(Command(resume={"approved": True}), cfg)
En producción, en lugar de InMemorySaver se usa Postgres, SQLite o MongoDB, y la pausa se comprueba con graph.get_state(cfg).tasks[0].interrupts. Así ningún correo sale sin que una persona lo revise.
Barrera 3: sandbox y límites de red saliente
Esta es la barrera que más se olvida: todo el mundo filtra las peticiones entrantes, pero casi nadie vigila hacia dónde envía datos el agente. Ante una prompt injection escondida en un correo o en una página web, un agente servicial puede mandar un informe interno por POST a un servidor ajeno.
La solución es un sandbox aislado con filtrado egress en modo deny_all por defecto (solo salen DNS, servicios internos y tu propia base de datos). Los dominios y puertos necesarios se abren de forma explícita en agent.yaml:
name: copper-lime-agent
entrypoint: agent_copper_lime.main:app
framework: langgraph
sandboxes:
agent:
secrets: ["*"]
network:
# Todo cerrado excepto los dominios y puertos declarados
egress_mode: allow_list
egress:
- fqdn: api.openai.com
ports: [443]
tools:
network:
egress_mode: allow_list
egress:
- fqdn: mcp.mongodb.com
ports: [443]
Tras el despliegue, la lista se puede modificar al vuelo desde la CLI sin recompilar el agente: agentengine agent egress add api.example.com:443 y remove. En la demo de Copper Lime, el intento de enviar un informe al contratista Ridgeback Freight simplemente falló por error de conexión: el sandbox cortó la petición en silencio y los datos nunca salieron del perímetro.
Barrera 4: memoria actualizada de cuatro tipos frente a un CRM obsoleto
El fallo típico con la memoria es acumular notas nuevas sin límite en una base vectorial. Los hechos caducan y el modelo miente con total seguridad. En la prueba de Copper Lime preguntaron: «¿A quién hay que escribir en Harbor Street Cafe sobre el retraso de la entrega?». El CRM seguía mostrando a Maya Chen, pero la capa de memoria recordaba un mensaje del equipo avisando de que Maya se había marchado y Diego había tomado el relevo. El agente respondió Diego a pesar del CRM desactualizado.
Para mantener la memoria fresca, se divide en cuatro tipos: semántica (hechos y preferencias), episódica (eventos y sesiones pasadas), taxonómica (categorías y entidades) y procedimental (flujos de trabajo y habilidades). Encima corre una búsqueda híbrida (palabras clave más vectores; Atlas Agent Engine integra embeddings Voyage 4 Large). Prueba estas barreras en el simulador y observa qué se rompe al desactivar cada capa.
Simulador de 5 barreras para agentes de IA (escenarios Copper Lime)
La última línea del simulador muestra por qué, sin registrar cada paso, ni siquiera sabrías de dónde sacó el agente un nombre obsoleto o por qué intentó borrar un registro. De eso se encarga la quinta capa.
Barrera 5: trazabilidad OpenTelemetry y los límites reales de Public Preview
La quinta capa no frena al agente en tiempo real, pero ofrece una «caja negra» para depurar fallos, latencias y consumo de tokens. El estándar aquí es OpenTelemetry GenAI Semantic Conventions: cada sesión se registra con spans invoke_agent (llamada y delegación de tarea), chat <model> (razonamiento y tokens gen_ai.usage.input_tokens / output_tokens) y execute_tool (herramientas y MCP). Un detalle importante de privacidad: los textos de prompts y respuestas no se registran por defecto (opt-in), para evitar que se filtren datos personales en las trazas.
Checklist antes de lanzar un agente a producción
- Lista blanca de herramientas en tiempo de ejecución con redirección suave en lugar de tumbar la sesión.
- Pausa Human-in-the-Loop en acciones con consecuencias; efecto secundario siempre después del nodo de confirmación.
- Sandbox con
deny_allyallow_listexplícita de dominios y puertos para el tráfico saliente. - Memoria actualizable de cuatro tipos más búsqueda híbrida por encima de directorios que caducan.
- Trazabilidad OpenTelemetry de pasos, latencias y coste de tokens con protección opt-in de PII.
Y un par de matices honestos sobre la plataforma de la demo. El análisis de Cole Medin se grabó en colaboración con MongoDB, y MongoDB Atlas Agent Engine sigue en estado Public Preview: la propia MongoDB lo recomienda para evaluaciones y prototipos, no para producción crítica. Por ahora soporta LangGraph de forma nativa, mientras que CrewAI y Google ADK están anunciados para más adelante. Aun así, las cinco capas son universales: puedes montar exactamente la misma arquitectura con un sandbox con filtro egress, interrupt() de LangGraph, memoria actualizable y OpenTelemetry (mediante Langfuse, Arize Phoenix o LangSmith) sobre un stack abierto sin atarte a una sola nube.


