failproofai 1.0.1-beta.1 → 1.0.1

package/.next/standalone/docs-old/es/agenteye/hermes-capture.mdx

@@ -0,0 +1,53 @@
+---
+title: "Captura de sesiones de Hermes"
+description: "Incorpora las sesiones del gateway Hermes de tu equipo — Slack, Telegram, CLI y ejecuciones programadas — en AgentEye como sesiones y eventos ordinarios."
+---
+
+[Hermes](https://hermes-agent.nousresearch.com) responde a tu equipo desde donde ya trabajan — Slack, Telegram, la CLI, ejecuciones programadas. La captura de sesiones de Hermes lleva todo eso a AgentEye como sesiones y eventos ordinarios, de modo que el asistente con el que tu equipo habla cada día sea tan observable como los agentes que tú mismo escribes.
+
+Un pequeño recolector en segundo plano lee el almacén de sesiones local de Hermes a medida que se va escribiendo y envía las sesiones a AgentEye. Funciona igual que la captura de [Codex](/es/agenteye/codex-capture) y [OpenClaw](/es/agenteye/openclaw-capture), y un único recolector puede capturar varios al mismo tiempo.
+
+---
+
+## Qué captura
+
+Se captura cada sesión de Hermes en la máquina, independientemente del canal por el que llegó. Cada una se convierte en una [sesión](/es/agenteye/sessions) de AgentEye; sus mensajes de usuario y asistente, llamadas a herramientas y resultados de herramientas se convierten en los [eventos](/es/agenteye/event-stream) correspondientes.
+
+El canal desde el que se inició una sesión — Slack, Telegram, CLI o una ejecución programada — queda registrado en la sesión, de modo que puedes distinguirlas y filtrar por una a la vez. Junto a esto se almacenan el modelo sobre el que se ejecutó la sesión, el chat y la persona desde la que se inició, y, cuando una sesión dio lugar a otra, el enlace de vuelta a su sesión padre.
+
+Las sesiones aparecen en cuanto Hermes las inicia, independientemente de si ya se ha dicho algo, y la respuesta de un turno y sus llamadas a herramientas se mantienen en el orden en que realmente ocurrieron. Cuando una sesión finaliza, también obtienes el motivo del cierre, su coste y cuántos tokens utilizó.
+
+---
+
+## Cómo activarlo
+
+La captura está desactivada hasta que la habilites. Instala el recolector con una clave de API que tenga el permiso `events:add` (consulta [API keys](/es/agenteye/api-keys)) y activa la captura de Hermes:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --hermes-enabled
+```
+
+Esto instala el recolector, lo registra como servicio en segundo plano y comienza la captura. Confirma que está en ejecución:
+
+```bash
+agenteye-collector health
+```
+
+¿Capturas más de un agente en la misma máquina? Añade el indicador de cada uno al mismo comando — por ejemplo `--hermes-enabled --codex-enabled`.
+
+En la primera ejecución, tus sesiones de Hermes existentes se importan retroactivamente una vez y la nueva actividad se transmite en segundos. Los datos propios de Hermes solo se leen — nunca se modifican ni eliminan — y cada mensaje se envía una sola vez, incluso tras reinicios.
+
+`health` también te indica si todo lo que capturó el recolector llegó realmente a AgentEye. Si un lote no pudo entregarse, se conserva y se reintenta en lugar de descartarse, y la comprobación reporta estado no saludable mientras haya algo pendiente — así que "saludable" significa que tus datos han llegado, no simplemente que el proceso está activo.
+
+---
+
+## Dónde aparece
+
+Las sesiones capturadas aparecen en **Sessions**, y sus eventos en el flujo **Events**, igual que cualquier otro agente que observes — de modo que la [reproducción de sesiones](/es/agenteye/sessions), la [búsqueda](/es/agenteye/queries), las [evaluaciones](/es/agenteye/evaluations) y las [alertas](/es/agenteye/alerts) funcionan sobre ellas. Filtra por el agente Hermes para verlas por separado.
+
+---
+
+## Privacidad
+
+Las sesiones de Hermes contienen la transcripción completa — incluyendo la salida de comandos, el contenido de archivos y todo lo que el agente leyó o escribió — y pueden contener secretos. Las sesiones capturadas se envían tal cual, así que activa la captura solo donde sea apropiado centralizar ese contenido en AgentEye, y proporciona al recolector una clave con alcance limitado a `events:add`. Consulta [Security](/es/agenteye/security) para saber cómo se mantienen aislados tus datos.

package/.next/standalone/docs-old/es/agenteye/incidents.mdx

@@ -0,0 +1,50 @@
+---
+title: "Incidentes"
+description: "Cuando se dispara una alerta, todos pueden ver que el incidente está abierto, quién lo gestiona y qué ha ocurrido hasta el momento — en una única línea de tiempo atribuida."
+---
+
+
+Cuando se dispara una alerta, la primera pregunta siempre es "¿quién lo está atendiendo?". Los incidentes responden esa pregunta: en el momento en que algo supera un umbral, todos pueden ver que el incidente está abierto, quién lo gestiona y exactamente qué ha ocurrido hasta ahora, con un registro limpio y atribuido que puedes entregar directamente a una revisión post-mortem.
+
+![La bandeja de incidentes: tarjetas de incidentes vinculadas a alertas y abiertas manualmente, agrupadas por estado, cada una con un indicador de severidad y un responsable asignado](/agenteye/images/incidents.png)
+*La bandeja agrupa los incidentes abiertos por estado y filtra por severidad y responsable, para que veas de inmediato qué requiere atención humana.*
+
+## Saber quién lo tiene, de un vistazo
+
+No más "¿alguien está mirando esto?" en un hilo de chat. Un incumplimiento abre un incidente automáticamente y lo coloca en una bandeja compartida, agrupada por estado. Acéptalo y tu nombre queda registrado, para que el resto del equipo sepa que está atendido. La aceptación es compartida: varios operadores pueden aceptar el mismo incidente y cada uno queda registrado de forma individual, de modo que todo el equipo de guardia aparece por nombre en lugar de pisarse unos a otros. Asigna un responsable para el triaje y filtra la bandeja por severidad o responsable para quedarte solo con lo que te corresponde.
+
+## Toda la historia, en una sola línea de tiempo
+
+Cuando el incidente termina, ya tienes el informe escrito. Abre cualquier incidente y verás la evidencia del incumplimiento, sus responsables y suscriptores, un hilo de comentarios para coordinar en el momento, y una línea de tiempo de actividad de solo escritura.
+
+![Vista detallada de un incidente: la alerta padre y el resumen del incumplimiento, responsables y suscriptores, una línea de tiempo de actividad atribuida y un hilo de comentarios](/agenteye/images/incident-detail.png)
+*Todo lo que ocurrió, en orden, cada línea firmada por quien lo hizo.*
+
+Cada acción (abierto, aceptado, resuelto, etc.) queda registrada en esa línea de tiempo y nunca se edita ni elimina. Cada entrada está atribuida: al operador que la realizó, por correo electrónico, o a **automated** para cualquier cosa que Failproof AI Observability hizo de forma autónoma, como abrir el incidente al detectar el incumplimiento. Nada es anónimo y nada se pierde, por lo que el post-mortem prácticamente se escribe solo.
+
+## Cómo progresa un incidente
+
+```mermaid
+stateDiagram-v2
+    [*] --> firing
+    firing --> acknowledged: an operator acks
+    firing --> resolved: an operator resolves
+    acknowledged --> resolved: an operator resolves
+    resolved --> [*]
+```
+
+- **Abierto (firing):** el incumplimiento abre el incidente y notifica tus canales una sola vez. Los incumplimientos posteriores se agrupan en el mismo incidente y actualizan su evidencia en lugar de notificarte repetidamente.
+- **Aceptado (acknowledged):** un operador lo toma. Permanece abierto, y los incumplimientos posteriores actualizan la evidencia sin generar ruido adicional.
+- **Resuelto (resolved):** un operador lo cierra. La resolución automática cuando la condición se normaliza está planificada pero aún no está habilitada, por lo que un incidente permanece abierto hasta que un humano lo resuelva — lo que mantiene a todos honestos sobre qué es lo que realmente se ha resuelto. Un nuevo incidente puede abrirse sobre la misma alerta más adelante.
+
+Una alerta puede tener como máximo un incidente abierto a la vez, por lo que una regla inestable no puede sepultarte en duplicados. También puedes abrir un incidente de forma manual: uno independiente para algo que ninguna alerta capturó, o uno vinculado a una alerta existente, si tienes el permiso `incidents:write`.
+
+## Dónde encontrarlo
+
+Los incidentes se encuentran en `/<org-slug>/incidents`. Para ver los incidentes se necesita **`incidents:read`**; para abrir un incidente manual se necesita **`incidents:write`**; aceptar, asignar, comentar y resolver requieren **`incidents:ack`**. Las claves antiguas que tenían el permiso retirado `alerts:ack` siguen funcionando, ya que se reconoce como `incidents:ack`, por lo que tu rotación de guardia no necesita ser reemitida.
+
+## Relacionado
+
+- [Alertas](/es/agenteye/alerts): las reglas que abren estos incidentes cuando se supera un umbral.
+- [Seguimiento de errores](/es/agenteye/error-tracking): ve todos los fallos en un solo lugar y promueve uno a alerta.
+- [Auditorías](/es/agenteye/audits): el analista programado que encuentra los fallos que ninguna regla estaba supervisando.

package/.next/standalone/docs-old/es/agenteye/observability.mdx

@@ -0,0 +1,23 @@
+---
+title: "Observar"
+description: "Las superficies de observación son donde vigilas lo que hacen tus agentes en tiempo real y profundizas en cualquier ejecución individual."
+---
+
+
+Las superficies de observación son donde vigilas lo que hacen tus agentes en tiempo real y profundizas en cualquier ejecución individual. Todo aquí es en vivo, limitado a tu organización y filtrable por rango de fechas, entorno, agente y sesión, para que pases de "algo no cuadra" a la ejecución exacta en segundos.
+
+![El flujo de eventos en vivo, con código de colores por tipo y filtrable por entorno, agente y sesión](/agenteye/images/events-stream.png)
+
+Cuatro superficies, cada una con su propia página:
+
+- **[Flujo de eventos](/es/agenteye/event-stream)**: el rastro en vivo, paso a paso, de cada ejecución de todos los agentes, del más reciente al más antiguo. El inicio de tu organización y el primer punto de triaje.
+- **[Sesiones y grafo de ejecución](/es/agenteye/sessions)**: esos eventos agrupados en una fila por ejecución, más una imagen estilo git de cómo se desarrolló cada ejecución.
+- **[Métricas de rendimiento](/es/agenteye/telemetry)**: mapas de calor de latencia y métricas p50/p95/p99 para tus modelos, herramientas y hooks, para que un pico en la cola destaque frente a la mediana.
+- **[Seguimiento de errores](/es/agenteye/error-tracking)**: una superficie de triaje unificada para todo lo que salió mal, a un clic de una alerta activa a la ejecución que falló.
+
+## Relacionado
+
+- [Evaluaciones](/es/agenteye/evaluations): puntúa cada ejecución en términos de calidad.
+- [Alertas](/es/agenteye/alerts): convierte cualquier umbral en una regla de notificación.
+- [Auditorías](/es/agenteye/audits): deja que Failproof AI Observability encuentre patrones de fallo en las sesiones por ti.
+- [CLI y agentes](/es/agenteye/cli-and-agents): la misma observabilidad desde tu terminal.

package/.next/standalone/docs-old/es/agenteye/openclaw-capture.mdx

@@ -0,0 +1,49 @@
+---
+title: "Captura de sesiones de OpenClaw"
+description: "Transmite las sesiones locales de OpenClaw de tu equipo a AgentEye como sesiones y eventos ordinarios, sin cambiar la forma en que OpenClaw se ejecuta."
+---
+
+Si tu equipo usa [OpenClaw](https://docs.openclaw.ai), la captura de sesiones de OpenClaw incorpora esas sesiones en AgentEye como sesiones y eventos ordinarios, para que puedas buscarlas, reproducirlas y evaluarlas junto al resto de lo que observas. Complementa el [SDK de Python](/es/agenteye/python-sdk): el SDK instrumenta los agentes que tú escribes, mientras que esto captura el trabajo de OpenClaw que tu equipo ya realiza, sin ningún cambio en cómo lo ejecuta.
+
+Un pequeño recolector en segundo plano lee los transcritos de sesión locales de OpenClaw conforme se van escribiendo y los envía a AgentEye. Funciona de la misma manera que la [captura de Codex](/es/agenteye/codex-capture), y un único recolector puede capturar ambos al mismo tiempo.
+
+---
+
+## Qué captura
+
+Cada agente configurado en la instalación de OpenClaw de una máquina es capturado por el recolector de esa máquina; no se requiere configuración por agente.
+
+Cada sesión de OpenClaw se convierte en una [sesión](/es/agenteye/sessions) de AgentEye; sus mensajes de usuario y asistente, llamadas a herramientas y resultados de herramientas se convierten en los [eventos](/es/agenteye/event-stream) correspondientes.
+
+---
+
+## Cómo activarlo
+
+La captura está desactivada hasta que la habilites. Instala el recolector con una clave de API que tenga el permiso `events:add` (consulta [Claves de API](/es/agenteye/api-keys)) y activa la captura de OpenClaw:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --openclaw-enabled
+```
+
+Esto instala el recolector, lo registra como un servicio en segundo plano y comienza a capturar. Para confirmar que está en ejecución:
+
+```bash
+agenteye-collector health
+```
+
+¿Capturas más de un agente en la misma máquina? Añade el indicador de cada uno al mismo comando; por ejemplo, `--openclaw-enabled --codex-enabled`.
+
+En la primera ejecución, tus sesiones de OpenClaw existentes se importan de forma retroactiva una sola vez, y la nueva actividad se transmite en cuestión de segundos. Los archivos propios de OpenClaw solo se leen; nunca se modifican, mueven ni eliminan, y cada sesión se envía exactamente una vez, incluso tras reinicios.
+
+---
+
+## Dónde aparece
+
+Las sesiones capturadas aparecen en **Sessions**, y sus eventos en el flujo de **Events**, igual que cualquier otro agente que observes; por lo tanto, la [reproducción de sesiones](/es/agenteye/sessions), la [búsqueda](/es/agenteye/queries), las [evaluaciones](/es/agenteye/evaluations) y las [alertas](/es/agenteye/alerts) funcionan con ellas. Filtra por el agente de OpenClaw para verlas de forma independiente.
+
+---
+
+## Privacidad
+
+Los transcritos de OpenClaw contienen la sesión completa, incluida la salida de comandos, el contenido de archivos y todo lo que el agente leyó o escribió, y pueden contener secretos. Las sesiones capturadas se envían tal cual, así que activa la captura únicamente en máquinas y para equipos donde centralizar ese contenido en AgentEye sea apropiado, y proporciona al recolector una clave con alcance limitado a `events:add`. Consulta [Seguridad](/es/agenteye/security) para conocer cómo se mantienen tus datos aislados.

package/.next/standalone/docs-old/es/agenteye/overview.mdx

@@ -0,0 +1,108 @@
+---
+title: "Failproof AI: Observa Agentes en Busca de Fallos"
+description: "Failproof AI Observability es una plataforma autoalojada para observar, evaluar y mejorar tus agentes de IA en producción."
+---
+
+
+Failproof AI Observability es una plataforma autoalojada para observar, evaluar y mejorar tus agentes de IA en producción. Registra todo lo que hacen tus agentes (cada llamada a herramientas, petición al modelo, hook y error), puntúa la calidad de cada ejecución y pone de manifiesto los fallos que no sabías que debías buscar, todo ello en un panel de control que ejecutas dentro de tu propia infraestructura.
+
+Si despliegas agentes de IA y estás cansado de adivinar por qué falló una ejecución, esta es la página por la que empezar. Explica qué te ofrece Failproof AI Observability y cómo encajan las piezas, antes de que instales nada.
+
+> **Failproof AI Observability es un producto empresarial de Failproof AI.** ¿Quieres verlo en acción? Solicita una demo: escribe a [nikita@befailproof.ai](mailto:nikita@befailproof.ai).
+
+![Una sesión de Failproof AI Observability dibujada como un grafo de ejecución estilo git junto a su cronología de eventos, con un desglose por ejecución de herramientas, modelos y hooks en el panel derecho](/agenteye/images/session-detail.png)
+
+*Cada ejecución del agente se representa como un grafo de ejecución estilo git (izquierda) junto a su cronología de eventos. Los subagentes paralelos tienen su propio carril; el panel derecho desglosa las herramientas, modelos, hooks y gasto en tokens de la ejecución.*
+
+---
+
+## Vélo en acción
+
+Dos vídeos cortos muestran las dos cosas a las que los equipos recurren primero: trazar una ejecución y detectar fallos automáticamente.
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/VWxukZc5k7s?autoplay=1&mute=1&loop=1&playlist=VWxukZc5k7s&rel=0&playsinline=1" title="Watch: Agent Tracing by Failproof AI (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*Trazado de agentes: sigue una única ejecución paso a paso, desde el objetivo hasta las herramientas y la respuesta final.*
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/C5nHKGQIqZQ?autoplay=1&mute=1&loop=1&playlist=C5nHKGQIqZQ&rel=0&playsinline=1" title="Watch: Automatically find where your agent is failing (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*Failproof Audit: deja que Failproof AI Observability analice tus registros entre sesiones y te indique qué debes corregir.*
+
+---
+
+## Por qué los equipos lo usan
+
+- **Ve lo que tu agente hizo realmente.** Cada ejecución se convierte en un grafo de ejecución legible estilo git: qué herramientas se ejecutaron en paralelo, qué subagentes se ramificaron, dónde se atascó y cuánto consumió.
+- **Detecta regresiones de calidad automáticamente.** Conecta un pequeño servicio de puntuación y Failproof AI Observability puntuará cada ejecución completada, de modo que una caída en utilidad o un pico en alucinaciones aparecerá por sí solo.
+- **Encuentra fallos para los que no escribiste ninguna regla.** Las auditorías recurrentes analizan tus registros entre sesiones en busca de clústeres de errores, valores atípicos de latencia, puntuaciones bajas y ejecuciones bloqueadas, y te entregan hallazgos clasificados y respaldados por evidencias.
+- **Recibe alertas cuando importa.** Las reglas de umbral se activan por tasa de error, latencia, coste o puntuaciones del evaluador, y abren incidentes que puedes reconocer, asignar y resolver.
+- **Haz preguntas en lenguaje natural.** Un asistente de IA integrado en el panel responde preguntas como «¿cómo evoluciona la calidad en producción esta semana?» sobre tus propios datos. Cualquier cambio que realice requiere aprobación.
+- **Mantén el control de tus datos.** Failproof AI Observability es autoalojada: los eventos, los prompts y los análisis permanecen en la infraestructura que tú controlas.
+
+---
+
+## Qué obtienes
+
+Failproof AI Observability se organiza en torno a tres conceptos (**observar**, **analizar** y **administrar**), reflejados en la barra lateral izquierda del panel de control.
+
+**Observar** (la verdad bruta de lo que ocurrió):
+
+- **[Flujo de eventos](/es/agenteye/event-stream)**: el rastro en tiempo real, paso a paso, de cada ejecución (llamadas a herramientas, llamadas al modelo, hooks, errores).
+- **[Sesiones](/es/agenteye/sessions)**: esos eventos agrupados en una fila por ejecución, cada una lista para ser puntuada, con un grafo de ejecución estilo git.
+- **[Métricas de rendimiento](/es/agenteye/telemetry)**: mapas de calor de latencia por superficie y valores p50/p95/p99 para modelos, herramientas y hooks, para que un pico en la cola destaque sobre la mediana.
+- **[Seguimiento de errores](/es/agenteye/error-tracking)**: una única superficie de triaje para todo lo que salió mal, a un clic de una alerta activa.
+
+![La página de observación de Tools: un mapa de calor de latencia, una banda de percentiles y una barra de distribución de herramientas en 24 intervalos de tiempo](/agenteye/images/tools.png)
+
+*Cada superficie de observación combina un minigráfico y valores p50/p95/p99 con un mapa de calor de latencia y una banda de percentiles. Mostrado aquí: Tools.*
+
+**Analizar** (convertir la actividad en respuestas):
+
+- **[Consultas](/es/agenteye/queries)** y **[paneles](/es/agenteye/dashboards)**: SQL guardado sobre tus eventos y evaluaciones, representado en paneles compartidos con ámbito de organización.
+- **[Evaluaciones](/es/agenteye/evaluations)**: puntuaciones de calidad producidas por tu propio servicio evaluador, con el razonamiento por puntuación.
+- **[Auditorías](/es/agenteye/audits)**: investigaciones recurrentes que detectan patrones de fallo entre sesiones.
+- **[Alertas](/es/agenteye/alerts)** e **[incidentes](/es/agenteye/incidents)**: reglas de umbral que te notifican, más un flujo de trabajo de incidentes para gestionarlos.
+
+**Interfaces** (accede a tus datos a tu manera):
+
+- **[CLI](/es/agenteye/cli-and-agents)**: gestiona todo tu despliegue desde el terminal o un script, y deja que un agente de codificación lo haga por ti en lenguaje natural.
+- **[Asistente de IA](/es/agenteye/assistant)**: haz preguntas sobre tus agentes en lenguaje natural, directamente desde el panel de control.
+- **REST API**: todo lo que hacen el panel y la CLI está respaldado por una REST API que puedes llamar directamente con una [clave de API](/es/agenteye/api-keys) con ámbito definido — ingesta eventos, consulta sesiones y evaluaciones, y gestiona paneles, alertas, auditorías, usuarios y claves, para poder integrar Failproof AI Observability en tus propias herramientas.
+
+**Administrar** (gestiónalo para tu equipo):
+
+- **[Claves de API](/es/agenteye/api-keys)**: tokens con ámbito para el colector, el panel y el asistente.
+- **Usuarios**: inicio de sesión sin contraseña, basado en correo electrónico, con lista de permitidos.
+- **Configuración**: configuración por organización, incluidas las anulaciones de ventana de contexto de los modelos.
+
+---
+
+## Cómo encajan las piezas
+
+Los datos fluyen en una sola dirección, desde el código de tu agente hasta el panel de control: tu agente (a través del SDK de Python) emite eventos al agenteye-collector, que los envía al servidor, que sirve el panel de control. Dos servicios opcionales completan el sistema: un servicio de puntuación (evaluaciones) y un servicio de asistente de IA (el chat integrado en el panel).
+
+- **SDK de Python**: añades unas pocas llamadas `agenteye.event.*` a tu agente; los eventos se almacenan en búfer localmente.
+- **agenteye-collector**: un demonio ligero en cada máquina de agente que agrupa los eventos y los envía al servidor.
+- **Servidor**: ingesta tus eventos, mantiene el estado operativo en tus propias bases de datos y sirve la REST API que usan el panel, la CLI y tus propias integraciones.
+- **Panel de control**: donde exploras todo.
+- **Servicios opcionales**: un servicio de puntuación (evaluaciones) y un servicio de asistente de IA (el chat integrado en el panel).
+
+Para el vocabulario utilizado en toda la documentación (*evento, sesión, evaluación, auditoría, hallazgo, incidente*), consulta [Conceptos](/es/agenteye/concepts).
+
+---
+
+## Cómo obtener Failproof AI Observability
+
+Failproof AI Observability es un producto empresarial de Failproof AI, y funciona junto con Failproof AI Enforcement — el producto de políticas y barreras de seguridad — bajo la marca Failproof AI. Se ejecuta completamente en tu propio entorno. Si aún no tienes acceso a los paquetes, solicita una demo y te ayudamos a ponerte en marcha: escribe a [nikita@befailproof.ai](mailto:nikita@befailproof.ai).
+
+---
+
+## Próximos pasos
+
+- [Conceptos](/es/agenteye/concepts): el vocabulario de Failproof AI Observability en un solo lugar.
+- [Observabilidad](/es/agenteye/observability): sigue lo que hacen tus agentes, ejecución a ejecución.
+- [Seguridad](/es/agenteye/security): cómo Failproof AI Observability mantiene tus datos aislados y bajo tu control.

package/.next/standalone/docs-old/es/agenteye/python-sdk-skill.mdx

@@ -0,0 +1,135 @@
+---
+title: "Skill del Agente Python SDK de Observabilidad de Failproof AI"
+description: "Pasa de un agente sin instrumentación a eventos que puedes ver, con tu agente de código encontrando los puntos de instrumentación, escribiéndolos y verificando que funcionan."
+---
+
+Dile a tu agente de código *"agrega Observabilidad de Failproof AI a este agente"* y deja que lea tu bucle, determine dónde corresponde la instrumentación, la escriba y verifique los eventos antes de dar el trabajo por terminado.
+
+El **skill de Python SDK** (`agenteye-python-sdk`) es un *Agent Skill*: una carpeta de instrucciones que un agente de código como Claude Code o Codex carga a demanda cuando una tarea coincide con él. Le enseña al agente a usar el [Python SDK](/es/agenteye/python-sdk) — no es una librería y no cambia nada sobre cómo funciona el SDK.
+
+## La instrumentación es fácil de escribir y fácil de hacer mal sin notarlo
+
+El SDK es pequeño: trece métodos de eventos, todos con argumentos nombrados. Un agente de código puede leer la referencia del [Python SDK](/es/agenteye/python-sdk) y producir instrumentación plausible en un minuto.
+
+El problema es que este SDK no lanza errores cuando algo está mal, y la instrumentación incorrecta se ve exactamente igual a la correcta hasta que alguien abre un dashboard y lo encuentra vacío. Los errores que cuestan tiempo real son todos silencios:
+
+| El error | Lo que ves |
+|---|---|
+| Sin `agent_start` | Todos los eventos llegan. Cero sesiones. |
+| Entorno nunca configurado | Todo funciona, archivado bajo `dev`. |
+| `outcome="failure"` | La ejecución muestra verde — solo `failed`, `error`, `timeout`, `rejected` cuentan. |
+| Un nombre de campo mal escrito | Aceptado y almacenado como un nuevo campo. |
+| Eventos emitidos desde un thread pool | Descartados silenciosamente. |
+
+Ninguno lanza errores. Ninguno aparece en las pruebas. Todos están en el skill, declarados como un contrato con la verificación que los detecta.
+
+## Lo que hace, en orden
+
+El skill ejecuta los mismos tres pasos que haría un ingeniero cuidadoso:
+
+1. **Planificar.** Lee tu bucle de agente y hace las dos preguntas que solo tú puedes responder: qué cuenta como una ejecución (tu `session_id`), y quiénes son los actores distinguibles (tu `agent_id`). Las acuerda antes de escribir código, porque cambiarlas después divide tu historial y rompe las tendencias.
+2. **Escribir.** Vincula la identidad una vez por ejecución en lugar de pasarla por cada punto de llamada, y elige una forma segura para concurrencia — un detalle importante, porque el atajo obvio mezcla silenciosamente dos ejecuciones superpuestas en una sola sesión.
+3. **Verificar.** Ejecuta tu agente y lee los archivos de eventos resultantes, comprobando que `agent_start` está presente, que el entorno es correcto y que una ejecución produjo una sesión.
+
+Ese tercer paso es el que la gente omite. El SDK escribe eventos en archivos locales, por lo que una integración completa puede probarse en una laptop sin servidor, sin clave de API y sin red — que es exactamente por qué el skill insiste en hacerlo.
+
+## Cómo se relaciona con los otros skills
+
+Tres skills, una división clara:
+
+| Skill | Úsalo cuando | Qué modifica |
+|---|---|---|
+| **Skill de Python SDK** (esta página) | Quieres que tu agente *emita* telemetría — "agrega observabilidad", "¿por qué no aparece mi agente?" | Escribe código en el repositorio de tu agente. No lee nada. |
+| **[Skill Evaluator](/es/agenteye/evaluator-skill)** | Quieres *puntuar* ejecuciones — "¿qué deberíamos medir?" | Escribe código en tu repositorio; lee telemetría |
+| **[Skill CLI](/es/agenteye/cli-skill)** | Quieres *leer* lo que ocurrió, u operar tu despliegue | Maneja la CLI en tu nombre, incluyendo cambios |
+
+Se encadenan en ese orden: este skill hace que los eventos fluyan, el evaluador los puntúa, la CLI los lee. No hay nada que evaluar ni nada que leer hasta que tu agente emita sesiones, así que si estás empezando desde cero, comienza aquí.
+
+## Requisitos previos
+
+1. **Python 3.10+** y el código base del agente que quieres instrumentar.
+2. **El SDK.** Se distribuye a los clientes como un wheel privado en lugar de desde un índice público — tu proceso de incorporación explica cómo obtenerlo e instalarlo. El skill conoce la ruta de instalación y te preguntará en lugar de adivinar si no puede encontrarla.
+3. **Nada más.** Sin inicio de sesión en el dashboard, sin clave de API, sin red. El skill verifica contra los archivos de eventos que escribe el SDK, por lo que puede terminar y demostrar su trabajo sin conexión.
+
+## Dónde obtenerlo
+
+El skill vive en la colección pública [`FailproofAI/skills`](https://github.com/FailproofAI/skills):
+
+```bash
+npx skills add FailproofAI/skills --skill agenteye-python-sdk -a claude-code
+```
+
+Agrega `-g` para instalarlo en todos los proyectos en lugar de solo en el actual, y `--copy` si tu entorno no sigue enlaces simbólicos. Para Codex, pasa `-a codex`.
+
+## Instalarlo manualmente
+
+Los Agent Skills son carpetas que contienen un `SKILL.md` más referencias. Si prefieres no usar el instalador:
+
+- **Claude Code**: copia la carpeta `agenteye-python-sdk/` en `~/.claude/skills/` (todos los proyectos) o `<tu-repo>/.claude/skills/` (solo ese repositorio). Claude Code la descubre automáticamente — revisa la lista `/skills`, o simplemente pregunta algo que coincida con ella.
+- **Codex**: Codex lee el mismo `SKILL.md`. El archivo `agents/openai.yaml` incluido establece `allow_implicit_invocation: true`, por lo que se selecciona automáticamente cuando una tarea coincide; de lo contrario, invócalo como `$agenteye-python-sdk`.
+
+Ejecuta tu agente **en el repositorio que contiene el código que quieres instrumentar** — el skill lee tu bucle de agente antes de proponer cualquier cosa.
+
+## Cómo luce una sesión
+
+```text
+tú    ▸ Agrega Observabilidad de Failproof AI a este agente.
+
+agente▸ Leo tu bucle — un despachador de herramientas en tools.py, un
+        wrapper de Anthropic en llm.py. Dos preguntas antes de escribir
+        cualquier cosa.
+
+        ¿Qué cuenta como una ejecución? Manejas solicitudes de forma
+        concurrente, así que usaría el id de solicitud que ya tienes en
+        ctx.request_id — así una sesión aquí y una solicitud en tus
+        logs son el mismo string.
+
+        ¿Y quiénes son los actores? Veo un camino de planificador y un
+        camino de investigador. ¿Los etiqueto por separado, o para ti
+        es un solo agente?
+
+tú    ▸ El id de solicitud está bien. Son un solo agente, llámalo
+        "assistant".
+
+agente▸ Listo. Envolví el despachador y el cliente LLM; agent_start y
+        agent_end delimitan handle_request, incluido el camino de error.
+        Usé un context-local para la identidad — tu despachador ejecuta
+        herramientas en un thread pool, y el enfoque más simple habría
+        mezclado ejecuciones concurrentes en una sola sesión sin avisar.
+
+        Verificado contra una ejecución real: 11 eventos en 4 archivos —
+        agent_start, model_request/response, tool_use/tool_result x3,
+        agent_end (outcome=success). environment=production, una sesión
+        por solicitud, duraciones emparejadas.
+
+        Una cosa que NO hice: tu pool de workers en batch.py envía
+        directamente al executor, así que los eventos de ahí se
+        descartarían. ¿Quieres que los corrija también?
+```
+
+El patrón a notar: leyó el código antes de proponer, hizo solo las preguntas que tú puedes responder, reutilizó un id que ya tenías, eligió la forma segura para concurrencia *porque* vio un thread pool, y **verificó leyendo los eventos reales** en lugar de declarar éxito — luego señaló el único lugar que sabía que fallaría silenciosamente.
+
+## Qué puedes pedirle
+
+- *"¿Por qué no aparece mi agente en el dashboard?"* → recorre la escalera: si los eventos se están escribiendo, si `agent_start` está ahí, si el entorno es correcto, si el colector está leyendo el mismo lugar.
+- *"Todo está llegando bajo dev."* → el entorno nunca se configuró, o fue restablecido por una llamada posterior.
+- *"Agrega seguimiento de tokens."* → encuentra tu wrapper LLM y registra modelo, razón de parada y uso.
+- *"Instrumenta los sub-agentes también."* → una sesión, etiquetas de agente distintas, anidadas bajo su padre.
+- *"Escribe pruebas para la instrumentación."* → apunta el SDK a un directorio temporal y hace aserciones sobre los eventos que escribió.
+
+## Qué tener en cuenta
+
+**Deja que verifique.** El paso que hace que valga la pena usar este skill es el último — ejecutar tu agente y leer los eventos de vuelta. Un agente que escribe instrumentación y se detiene ha hecho la mitad fácil, y la mitad que falla silenciosamente es la otra.
+
+**Acuerda los nombres antes del código.** `session_id` y `agent_id` son los ejes por los que agrupa cada vista. Renombrarlos después divide el historial: las ejecuciones antiguas conservan las etiquetas anteriores y tus tendencias se rompen. El skill preguntará; la respuesta vale un minuto de reflexión.
+
+**Si tu agente propone instalar el SDK desde un índice público, el skill no se cargó.** El SDK se distribuye de forma privada. Esa propuesta es una señal clara de que tu agente de código está adivinando en lugar de seguir el skill — detenlo ahí y verifica que el skill esté instalado.
+
+Más allá de eso, su radio de acción es pequeño: escribe código en tu directorio de trabajo y archivos de eventos donde tú le indiques. No lee nada de tu despliegue ni cambia nada en él.
+
+## Próximos pasos
+
+- **[Python SDK](/es/agenteye/python-sdk)**: la referencia completa de eventos — cada tipo de evento y campo — detrás de lo que automatiza este skill.
+- **[Sessions](/es/agenteye/sessions)**: lo que produce tu instrumentación una vez que los eventos llegan.
+- **[Evaluator Agent Skill](/es/agenteye/evaluator-skill)**: el siguiente paso una vez que las ejecuciones están llegando — puntuarlas.
+- **[CLI Agent Skill](/es/agenteye/cli-skill)**: leer tu telemetría de vuelta.