Tu IA acaba de filtrar tus secretos

Los AI agents, anunciados como la vanguardia de la automatización inteligente, albergan un secreto profundamente inquietante: una falla de seguridad generalizada que deja los datos sensibles expuestos abiertamente. Investigadores acaban de completar una auditoría exhaustiva de más de 17.000 AI agent skills, descubriendo una vulnerabilidad sorprendente y extendida en todo el ecosistema. Sus hallazgos son inequívocos: 520 de estas herramientas estaban filtrando activamente secretos críticos durante operaciones rutinarias, socavando fundamentalmente la confianza en estos sistemas.

Esto no era una preocupación teórica o un fallo menor; estas agent skills estaban transmitiendo información real y altamente sensible. Los datos expuestos incluían: - API keys - OAuth tokens - Database passwords

Tales revelaciones otorgan acceso no autorizado a sistemas backend, cuentas de usuario y bases de datos propietarias, lo que representa una amenaza inmediata y grave para la integridad de los datos corporativos e individuales. La magnitud de esta exposición involuntaria no tiene precedentes para este sector tecnológico en rápida emergencia, lo que indica una supervisión sistémica.

Crucialmente, estas filtraciones no se originaron por intentos de hacking maliciosos o jailbreaks sofisticados. La exposición de datos sensibles ocurrió durante un uso totalmente normal, mientras los agents ejecutaban sus funciones diseñadas. Esto apunta a una supervisión arquitectónica fundamental dentro de los propios AI agent frameworks, en lugar de un ataque externo, lo que hace que el problema sea insidioso y difícil de detectar solo a través de auditorías de seguridad convencionales.

Esto representa una clase novedosa de vulnerabilidad, específicamente endémica de la arquitectura central de los AI agents modernos. A diferencia del desarrollo de software tradicional, donde las salidas de depuración podrían simplemente imprimirse en una consola efímera, los AI agent frameworks a menudo capturan la salida estándar y la alimentan directamente en la ventana de contexto persistente del modelo. Una simple impresión de depuración, destinada a una visión temporal del desarrollador, se convierte así en una memoria duradera y recuperable para la IA.

El agent efectivamente "recuerda" estos secretos, haciéndolos accesibles a cualquiera que sepa cómo solicitarlos. Lo que los desarrolladores asumieron que era una entrada de registro inofensiva y efímera se transforma en una responsabilidad de seguridad permanente, inextricablemente ligada a la memoria operativa del agent. Este mecanismo remodela fundamentalmente el panorama de seguridad para las implementaciones de IA, convirtiendo las prácticas benignas de depuración interna en vectores críticos para la exfiltración sigilosa de datos y el compromiso generalizado.

Un asombroso 73% de las filtraciones de datos provino de una fuente sorprendentemente mundana: simples debug print statements. Los desarrolladores insertan rutinariamente comandos `print` o `console.log` para rastrear la ejecución o inspeccionar variables, un hábito generalmente inofensivo en aplicaciones tradicionales.

Sin embargo, en el intrincado mundo de los AI agents, esta práctica común se transforma en una vulnerabilidad crítica. Un agent framework captura la salida estándar, pasándola directamente a la context window del modelo. Esto significa que una línea de depuración aparentemente inofensiva ya no es solo un registro; la IA puede recordarla activamente y repetirla más tarde.

El mecanismo es brutalmente simple: una skill carga un token sensible, como una API key o una database password, lo imprime para una rápida verificación de depuración, y luego procede normalmente. Ese secreto ahora reside dentro de la memoria accesible del agent, listo para ser recuperado mediante un simple prompt.

Este error generalizado proviene de una psicología de desarrollador omnipresente: la creencia de que el código de depuración 'temporal' se eliminará antes de la producción. Sin embargo, bajo la presión de los plazos o durante las actualizaciones rutinarias, estas líneas olvidadas persisten, convirtiéndose en puertas traseras permanentes en los sistemas de IA implementados.

La magnitud de este problema es similar a dejar las llaves de tu casa debajo del felpudo, pero a una escala digital y distribuida globalmente. En lugar de una única llave física, estamos hablando de miles de claves digitales — API keys, OAuth tokens y contraseñas de bases de datos — expuestas en 520 de las 17.000 habilidades de agentes de IA auditadas.

los investigadores descubrieron que no se trataba de jailbreaks sofisticados ni de exploits complejos. Estas filtraciones ocurrieron durante un uso totalmente normal, sin requerir un hack avanzado. Un usuario solo necesita preguntar: "¿Cuál fue la última salida de depuración?" y el secreto aparece en texto plano.

Los modelos de IA operan con una ventana de contexto, un búfer de memoria dinámica crítico que registra todos los turnos conversacionales, entradas y salidas dentro de una sesión determinada. Esta ventana sirve como la memoria de trabajo inmediata de la IA, crucial para mantener la coherencia y comprender la interacción en curso. Los frameworks de agentes, diseñados para orquestar habilidades complejas de IA, capturan meticulosamente *cada* bit de standard out generado por sus herramientas integradas y lo alimentan directamente en este contexto.

Esto no es solo una simple operación de registro; es una tubería directa a la comprensión de la IA. Lo que los desarrolladores pretendían como un mensaje de depuración temporal e interno, como una sentencia `print` o `console.log` que revela una API key, se convierte instantáneamente en un elemento permanente en la memoria operativa de la IA. El diseño inherente de la IA dicta que procesa y "recuerda" todo dentro de su contexto, tratando estas salidas de depuración como piezas integrales de información para la interacción en curso.

Imagina la ventana de contexto como una taquígrafa incansable y perfectamente precisa presente en cada interacción entre la IA y sus herramientas. Esta escriba digital transcribe diligentemente todo lo dicho, cada comando emitido y cada susurro del funcionamiento interno de una herramienta. Captura no solo las respuestas previstas o las consultas del usuario, sino también cualquier dato sensible "susurrado" inadvertidamente a través de una sentencia de impresión de depuración, almacenándolo textualmente para una posible referencia futura.

Una vez que un secreto —ya sea una API key, un OAuth token o una contraseña de base de datos— entra en este contexto, permanece accesible durante toda la sesión. La IA puede entonces recordar y reutilizar estos datos sensibles en cualquier momento, haciendo que la fuga sea persistentemente explotable, incluso si la sentencia de depuración original se ejecutó solo una vez. los investigadores descubrieron un método de recuperación escalofriantemente simple: simplemente preguntando a la IA "¿Cuál fue la última salida de depuración?" a menudo revela estos secretos en texto plano, lo que subraya la profunda gravedad de este error generalizado. Para una comprensión más profunda del desafío omnipresente de la exposición de datos sensibles, recursos como el State of Secrets Sprawl Report 2025 - GitGuardian ofrecen información completa.

Los secretos rara vez escapan a través de brechas sofisticadas en los agentes de IA; en cambio, un asombroso 73% de las filtraciones provienen de una práctica de desarrollo brutalmente simple, casi inocente: la sentencia de impresión de depuración. Este error común transforma la salida de diagnóstico temporal en conocimiento permanente de la IA, creando una vulnerabilidad crítica y fácilmente evitable. Comprender esta "Anatomía de una Traición" revela cómo el propio código de un agente puede comprometer datos sensibles. El ciclo de vida de un secreto filtrado sigue una secuencia predecible de tres pasos.

Considere una habilidad de agente de IA basada en Python que necesita una clave API para interactuar con un servicio externo, quizás una pasarela de pago de terceros o un almacén de datos propietario. Los desarrolladores suelen cargar estas credenciales sensibles desde variables de entorno para mantenerlas fuera del control de código fuente y garantizar una implementación segura. Una línea como `api_key = os.getenv('API_KEY')` recupera eficazmente la clave del entorno del sistema, un paso inicial estándar y seguro.

El error fatal a menudo ocurre inmediatamente después de esta recuperación segura. Durante el desarrollo o las pruebas, para verificar que la clave se cargó correctamente o para depurar la autenticación de una llamada API, un desarrollador podría añadir una instrucción aparentemente inofensiva `print(f'Using key: {api_key}')`. Esta línea envía la clave secreta real, en texto plano completo, a la salida estándar, una práctica común, casi instintiva, para comprobaciones de diagnóstico rápidas en la programación tradicional.

Aquí es precisamente donde el framework del agente de IA se convierte en un cómplice involuntario, pero altamente efectivo, en la fuga de datos. A diferencia de las aplicaciones tradicionales donde las instrucciones `print` simplemente escriben en una consola o en un archivo de registro local para revisión humana, los frameworks modernos de agentes de IA están diseñados para capturar *toda* la salida estándar. Ingestionan esta salida de manera integral, tratando cada carácter como una pieza potencial de información relevante para la interacción continua y el estado operativo del agente.

La salida capturada, incluyendo esa impresión de depuración crítica de su clave API, se inyecta directamente en la ventana de contexto del LLM. Esta ventana de contexto sirve como la memoria a corto plazo principal de la IA para la conversación o tarea actual, definiendo esencialmente lo que el modelo "sabe" y puede referenciar. Cada pieza de información que se le introduce, independientemente de su intención original, se vuelve inmediatamente accesible al modelo de lenguaje grande subyacente.

Una vez dentro de la ventana de contexto, el secreto ya no es un mensaje de depuración fugaz; ahora es una parte indeleble de la "base de conocimiento" activa de la IA para toda esa sesión. Un atacante, o incluso un usuario desprevenido, puede entonces solicitar fácilmente a la IA con una consulta como, "¿Cuál fue la última salida de depuración?" o "Háblame de las claves que estás usando", y la IA repetirá fácilmente la credencial expuesta en texto plano completo. Esto convierte la línea de depuración aparentemente inocente en una parte permanente de la base de conocimiento de la IA para esa interacción, una traición profunda y fácilmente prevenible de datos sensibles.

Recuperar un secreto filtrado de la memoria de un agente de IA resulta sorprendentemente trivial, sin requerir habilidades de hacking avanzadas ni jailbreaks elaborados. Una vez que una instrucción de depuración errónea de un desarrollador incrusta datos sensibles dentro de la ventana de contexto de la IA, cualquier usuario puede simplemente pedirlos. Esto no es un exploit sofisticado; es una solicitud directa de información, aprovechando la función de la IA como un sistema obediente de recuperación de información.

Los usuarios solo necesitan emplear prompts aparentemente inocuos para extraer estos detalles ocultos. Consultas como “¿Cuál fue la última salida de depuración?” o “Resume el registro de ejecución de la herramienta” suelen ser suficientes para sonsacar datos sensibles de la IA. El agente, operando precisamente según lo diseñado, recupera y presenta diligentemente la información solicitada, que podría incluir claves API reales, tokens OAuth o incluso contraseñas de bases de datos que encontró durante sus procesos operativos.

Fundamentalmente, la IA en sí actúa sin malicia, careciendo de cualquier comprensión inherente de la sensibilidad de los datos. Simplemente sigue instrucciones, proporcionando datos que le fueron explícitamente dados para procesar o recordar dentro de su contexto. Esto resalta un malentendido fundamental entre los desarrolladores: tratan las impresiones de depuración como salidas temporales y efímeras. Sin embargo, para una IA, esa salida estándar se convierte en una parte integral de su memoria central, indistinguible de otros datos críticos que utiliza para cumplir solicitudes.

Esta vulnerabilidad se agrava drásticamente para los agentes de IA de cara al público, donde la base de usuarios es amplia y a menudo anónima. Cualquier usuario, independientemente de su intención o habilidad técnica, puede interrogar potencialmente el sistema en busca de registros internos. Imagine un bot de soporte al cliente o un agente de análisis de datos público exponiendo inadvertidamente credenciales de backend porque un desarrollador olvidó eliminar una declaración `print()` o `console.log` durante las pruebas. La facilidad de recuperación significa que un solo usuario curioso puede comprometer un sistema completo.

investigadores descubrieron este patrón generalizado en más de 17,000 habilidades de agentes de IA, con 520 que demostrablemente estaban filtrando secretos durante el uso normal. Más del 73% de estas filtraciones críticas se originaron a partir de impresiones de depuración tan simples que los desarrolladores olvidaron eliminar. Esta supervisión generalizada transforma lo que debería ser una conveniencia para el desarrollador en una falla de seguridad crítica, haciendo que los datos confidenciales estén disponibles para cualquiera que sepa cómo preguntar. La simplicidad de este "hack" socava fundamentalmente la seguridad de los sistemas que dependen de estos agentes.

Más allá de las declaraciones de depuración inmediatas, acecha una vulnerabilidad más insidiosa: las filtraciones entre modelos. Estos secretos no aparecen en texto plano dentro de la salida de la IA; en cambio, emergen al combinar respuestas de agentes aparentemente inofensivas con documentación externa del proyecto. Esto las hace significativamente más difíciles de detectar mediante una simple observación.

Considere una herramienta de agente de IA que imprime un ID o GUID aparentemente aleatorio después de una operación. Este identificador podría entrar en la ventana de contexto del modelo sin datos sensibles obvios adjuntos. Por sí sola, la cadena parece inofensiva, no ofreciendo una ruta inmediata a la explotación.

Sin embargo, el secreto se vuelve flagrantemente obvio cuando un atacante cruza esa salida con el README público del proyecto, la documentación de la API o incluso wikis internos. Ese ID "aleatorio" podría, por ejemplo, ser descrito explícitamente como un token de sesión temporal o un ID de cliente que se combina con un secreto precompartido, documentado en otro lugar, para formar una clave API válida.

Este pipeline, desde una salida de aspecto benigno hasta un secreto completamente revelado, subraya una falla crítica en el pensamiento de seguridad tradicional. Los desarrolladores deben realizar revisiones de seguridad holísticas que abarquen no solo el código, sino también cada pieza de documentación adjunta. Para obtener más información sobre las amplias implicaciones de estas vulnerabilidades, explore conocimientos como los que se encuentran en [AI Secret Leaks in Public Code Repos: Warning to Developers | Wiz Blog].

Ignorar la interacción entre el código y la documentación deja un vector abierto para la exfiltración de datos. La IA recuerda lo que ve; la documentación proporciona la Piedra Rosetta para que los atacantes traduzcan la salida benigna en secretos accionables.

Viejos hábitos de los desarrolladores ahora representan un riesgo de seguridad crítico en la era de los AI agents. Durante décadas, los ingenieros confiaron en el registro detallado (verbose logging) como pilar de la depuración (debugging). En aplicaciones tradicionales monolíticas o de microservicios, una sentencia `print` o `console.log` dirigía la salida a archivos de registro privados e internos. El acceso a estos registros permanecía estrictamente controlado, a menudo restringido a personal autorizado a través de sistemas seguros y herramientas de monitoreo. Estos registros servían como herramientas de diagnóstico invaluables, guardadas de forma segura lejos de los usuarios finales y del internet público.

Los AI agent systems rompen fundamentalmente este perímetro de seguridad establecido. La context window de un AI model no diferencia entre la salida del código de producción y una declaración de depuración temporal de un desarrollador. A diferencia de las aplicaciones tradicionales donde los registros son efímeros o se almacenan de forma segura, la salida estándar de un agent framework se captura y se pasa directamente al contexto del modelo. Esto significa que la IA puede "recordar" activamente y repetir cualquier información, transformando una nota privada en una posible divulgación pública.

Investigadores revelaron la cruda realidad: más del 73% de los 520 secretos reales filtrados de las 17,000 Tools auditadas provenían directamente de estas aparentemente inofensivas `print` statements. Lo que antes era un diagnóstico interno ahora forma parte de la memoria activa de la IA, lista para ser recordada por cualquiera que interactúe con el agente. Este mecanismo, donde una habilidad carga un token, lo imprime para depuración, y luego ese secreto permanece en la context window del agente, subraya la grave vulnerabilidad.

Esto exige un cambio profundo en el modelo mental del desarrollador. La confianza implícita en la privacidad de los registros, arraigada durante años de desarrollo de software, simplemente no se aplica al construir AI agents. Los desarrolladores deben desaprender el reflejo de imprimir datos sensibles para una inspección rápida, entendiendo que dicha salida alimenta directamente el modelo de cara al público. La suposición de que una línea de depuración temporal es inofensiva se convierte rápidamente en una responsabilidad.

En consecuencia, lo que alguna vez se consideró una best practice para la depuración rápida –el registro extenso y sin censura– ha evolucionado rápidamente hacia un anti-pattern significativo. Las mismas técnicas que mejoraron la depurabilidad en paradigmas anteriores ahora crean vulnerabilidades evidentes. Cada línea impresa, cada variable temporal registrada, conlleva el potencial inmediato de exponer datos críticos como API keys, OAuth tokens y database passwords. Esto redefine el significado de "depuración segura" para toda una generación de AI engineers, forzando una reevaluación inmediata y urgente de cada estrategia de registro.

- Los desarrolladores deben repensar fundamentalmente sus prácticas de registro y adoptar una nueva y estricta regla de oro: never print secrets, nunca. La auditoría de más de 17,000 AI agent skills reveló que más del 73% de los incidentes donde se filtraron secretos provenían directamente de simples impresiones de depuración, como `print` statements o `console.log`. Estas salidas no son meramente mensajes temporales de consola; la context window del AI model las captura inmediatamente, haciéndolas parte de su memoria persistente y fácilmente recuperables bajo petición. En su lugar, utiliza registradores seguros diseñados específicamente que ofrecen sólidas capacidades de redacción. Estas herramientas identifican y enmascaran automáticamente datos sensibles –como API keys, OAuth tokens y database passwords– antes de que lleguen a un flujo de registro, al contexto del AI model o a cualquier sistema externo. Este enfoque proactivo previene la exposición no intencionada desde la primera línea de código.

- A continuación, implemente el escaneo automatizado de secretos de forma temprana y frecuente a lo largo de todo su ciclo de vida de desarrollo. Integre los escaneos previos a la publicación y previos al commit directamente en sus pipelines de Integración Continua/Despliegue Continuo (CI/CD) y flujos de trabajo de control de versiones. Este paso crucial detecta inclusiones accidentales de credenciales antes de que salgan de su máquina local o se envíen a un repositorio remoto. Herramientas como GitGuardian y TruffleHog destacan en el escaneo autónomo de bases de código completas, historiales de commit y configuraciones en busca de API keys, tokens, database credentials y otra información sensible codificada. Marcan posibles fugas, forzando la remediación antes del despliegue y proporcionando una red de seguridad automatizada esencial contra el error humano, protegiendo contra las mismas vulnerabilidades que los investigadores identificaron.

- Finalmente, eleve su proceso de revisión de código exigiendo una revisión exhaustiva y combinada tanto del código fuente como de la documentación. Haga que la revisión conjunta de código y READMEs sea una parte innegociable de cada solicitud de extracción y revisión por pares. Esta práctica aborda directamente las insidiosas fugas 'entre modelos', un tipo de vulnerabilidad donde la verdadera importancia de un secreto, o incluso su mera presencia, solo se hace evidente cuando se lee el contexto descriptivo en un README junto con sus detalles de implementación en el código. Sin este enfoque holístico, las vulnerabilidades críticas pueden permanecer ocultas a simple vista, permitiendo que los secretos persistan en el contexto de la IA porque los revisores solo examinan una pieza del rompecabezas. Esta revisión integrada garantiza una postura de seguridad más exhaustiva.

Si bien las sentencias `print` y `console.log` representaron más del 73% de las fugas que los investigadores descubrieron en las 17,000 AI agent skills auditadas, el panorama de amenazas se extiende mucho más allá de la simple salida de depuración. Los desarrolladores deben examinar cada punto de datos que entra en la ventana de contexto de una IA, ya que otros vectores también revelan activamente información sensible. La brecha silenciosa es multifacética y exige una postura de seguridad integral.

Los mensajes de error detallados, por ejemplo, plantean un riesgo significativo que a menudo pasa desapercibido. Los rastreos de pila completos suelen exponer intrincados funcionamientos internos, incluyendo cadenas de conexión a bases de datos, authentication tokens, API endpoints, o incluso environment variable names que insinúan ubicaciones de secretos. Los desarrolladores configuran con frecuencia el registro para capturar estos detalles completos para la resolución de problemas, haciéndolos inadvertidamente accesibles a la memoria persistente del modelo de IA. Esta práctica, si bien es útil para depurar aplicaciones tradicionales, se convierte en una vulnerabilidad crítica en los sistemas de agentes de IA.

Las entradas de usuario no sanitizadas representan otra vulnerabilidad insidiosa. Los actores maliciosos pueden elaborar entradas diseñadas específicamente para activar el registro detallado o condiciones de error, con el objetivo de engañar al sistema para que muestre el estado interno o los detalles de configuración. Esta forma de prompt injection no se trata meramente de manipular la respuesta inmediata de la IA; puede convertir en arma el propio logging pipeline, extrayendo información que debería permanecer oculta. Imagine una entrada diseñada para causar el fallo de un módulo específico, revelando sus secretos cargados en el registro de errores subsiguiente.

Además, las bibliotecas y dependencias de terceros introducen una capa completamente nueva de complejidad y posible compromiso. Estos componentes externos, a menudo integrados sin auditorías de seguridad profundas, frecuentemente emplean sus propios mecanismos de registro, que pueden no adherirse a los mismos estándares de seguridad estrictos. Una dependencia de apariencia inocente podría estar registrando datos sensibles sin el conocimiento de un desarrollador, pasándolos sin saberlo al contexto de la IA. Este riesgo de la cadena de suministro significa que incluso el código de primera parte meticulosamente asegurado sigue siendo vulnerable si sus dependencias no son igualmente robustas. Para más información sobre estos problemas generalizados, incluyendo cómo las propias herramientas de codificación de IA pueden contribuir a las filtraciones, lea Your Next Secrets Leak is Hiding in AI Coding Tools - DevOps.com. Salvaguardar los agentes de IA exige un enfoque holístico, yendo más allá de las soluciones superficiales hacia una profunda conciencia arquitectónica y una vigilancia continua.

La era de los agentes de IA exige una reevaluación completa de los paradigmas de seguridad. Lo que antes constituía una depuración inofensiva en el desarrollo de software tradicional ahora plantea vulnerabilidades críticas, como lo demuestran los investigadores que encontraron que 520 habilidades de agentes de IA estaban filtrando secretos de 17,000 Tools auditadas. Debemos ir más allá de las soluciones reactivas y adoptar una filosofía proactiva y de seguridad primero desde cero.

Los futuros frameworks de agentes de IA no pueden permitirse tratar la salida como una ocurrencia tardía. Imagine frameworks diseñados con sanitización automática de salida, redactando dinámicamente información sensible antes de que entre en la ventana de contexto del modelo. Las implementaciones podrían incluir detección y ofuscación de secretos integradas, haciendo que las impresiones de depuración simples sean inherentemente más seguras y eliminando el 73% de las filtraciones rastreadas hasta ellas.

Los desarrolladores necesitan herramientas robustas e integradas que impongan prácticas de codificación seguras por defecto. Esto requiere características de seguridad estandarizadas, como APIs obligatorias de gestión de secretos y utilidades de registro conscientes del contexto, directamente dentro de los SDKs centrales del agente. Dichas características abstraerían la complejidad del manejo seguro, asegurando que los desarrolladores nunca expongan accidentalmente claves API críticas o contraseñas de bases de datos.

Un cambio fundamental en la educación de los desarrolladores es igualmente crucial. Los planes de estudio universitarios y los bootcamps deben integrar principios de seguridad específicos de la IA desde el primer día, no como una asignatura optativa avanzada. La capacitación debe enfatizar los riesgos únicos de la ventana de contexto de la IA y las profundas implicaciones de las declaraciones de depuración aparentemente inofensivas. Comprender que la "memoria" de una IA es una superficie de ataque persistente es primordial.

Este desafío trasciende a los desarrolladores individuales o incluso a frameworks específicos. Construir un ecosistema de agentes de IA inhackeables verdaderamente requiere un esfuerzo colectivo en toda la industria. Los creadores de frameworks, los proveedores de herramientas y los colaboradores de código abierto deben colaborar en nuevos estándares de seguridad, mejores prácticas compartidas y mecanismos de validación robustos.

Cada desarrollador tiene una responsabilidad crítica en este panorama en evolución. Deje de imprimir secretos, para siempre. Adopte la redacción de registros, ejecute escaneos previos a la publicación y revise meticulosamente su `readme` y código juntos. Solo a través de un compromiso unificado con la seguridad por diseño podremos forjar un futuro confiable y resiliente para la inteligencia artificial.

¿Qué es una filtración de secretos de un agente de IA?

Una filtración de secretos de un agente de IA ocurre cuando información sensible como claves API, contraseñas o tokens se exponen involuntariamente a través de la operación normal del agente, a menudo al ser capturada en la ventana de contexto del modelo de IA.

¿Por qué las impresiones de depuración causan filtraciones en los agentes de IA?

En los frameworks de agentes de IA, la salida estándar (de 'print' o 'console.log') a menudo se introduce directamente en la ventana de contexto de la IA como información. Si un desarrollador imprime un secreto para depuración, la IA lo 'recuerda' y puede repetírselo a un usuario más tarde.

¿Cómo puedo evitar que mi agente de IA filtre secretos?

Nunca imprimas secretos en la salida estándar. Utiliza el registro seguro con redacción, ejecuta escaneos automatizados previos a la publicación en busca de secretos en tu código, y siempre revisa tu código y documentación juntos para identificar posibles exposiciones.