Sua IA Acabou de Vazou Seus Segredos

AI agents, anunciados como a vanguarda da automação inteligente, guardam um segredo profundamente perturbador: uma falha de segurança generalizada que deixa dados sensíveis abertamente expostos. Pesquisadores acabaram de concluir uma auditoria exaustiva de mais de 17.000 AI agent skills, descobrindo uma vulnerabilidade surpreendente e generalizada em todo o ecossistema. Suas descobertas são inequívocas: 520 dessas tools estavam vazando ativamente segredos críticos durante operações de rotina, minando fundamentalmente a confiança nesses sistemas.

Esta não era uma preocupação teórica ou uma falha menor; essas agent skills estavam transmitindo informações reais e altamente sensíveis. Os dados expostos incluíam: - API keys - OAuth tokens - Database passwords

Tais revelações concedem acesso não autorizado a sistemas de backend, contas de usuário e bancos de dados proprietários, representando uma ameaça imediata e grave à integridade dos dados corporativos e individuais. A escala pura dessa exposição não intencional é sem precedentes para este setor de tecnologia em rápida ascensão, sinalizando uma falha sistêmica.

Crucialmente, esses vazamentos não se originaram de tentativas de hacking maliciosas ou jailbreaks sofisticados. A exposição de dados sensíveis ocorreu durante o uso totalmente normal, enquanto os agents executavam suas funções projetadas. Isso aponta para uma falha arquitetônica fundamental dentro dos próprios AI agent frameworks, em vez de um ataque externo, tornando o problema insidioso e desafiador de detectar apenas por meio de auditorias de segurança convencionais.

Isso representa uma nova classe de vulnerabilidade, especificamente endêmica à arquitetura central dos modernos AI agents. Ao contrário do desenvolvimento de software tradicional, onde as saídas de debug podem simplesmente printar para um console efêmero, os AI agent frameworks frequentemente capturam a saída padrão e a alimentam diretamente na context window persistente do modelo. Um simples debug print, destinado a uma visão temporária do desenvolvedor, torna-se assim uma memória duradoura e recuperável para a IA.

O agent efetivamente "lembra" esses segredos, tornando-os acessíveis a qualquer pessoa que saiba como solicitá-los. O que os desenvolvedores assumiram ser uma entrada de log inofensiva e efêmera transforma-se em uma responsabilidade de segurança permanente, inextricavelmente ligada à memória operacional do agent. Esse mecanismo remodela fundamentalmente o cenário de segurança para implementações de IA, transformando práticas benignas de debugging interno em vetores críticos para exfiltração furtiva de dados e comprometimento generalizado.

Impressionantes 73% dos vazamentos de dados vieram de uma fonte surpreendentemente mundana: simples debug print statements. Desenvolvedores rotineiramente inserem comandos `print` ou `console.log` para rastrear a execução ou inspecionar variáveis, um hábito geralmente inofensivo em aplicações tradicionais.

No entanto, no mundo intrincado dos AI agents, essa prática comum transforma-se em uma vulnerabilidade crítica. Um agent framework captura a saída padrão, passando-a diretamente para a context window do modelo. Isso significa que uma linha de debug aparentemente inócua não é mais apenas um log; a IA pode ativamente lembrá-la e depois repeti-la.

O mecanismo é brutalmente simples: uma skill carrega um token sensível, como uma API key ou database password, printa-o para uma verificação rápida de debug, e então prossegue normalmente. Esse segredo agora reside na memória acessível do agent, pronto para ser recuperado por um simples prompt.

Essa supervisão generalizada decorre de uma psicologia de desenvolvedor difundida: a crença de que o código de depuração 'temporário' será removido antes da produção. No entanto, sob pressão de prazos ou durante atualizações de rotina, essas linhas esquecidas persistem, tornando-se backdoors permanentes em sistemas de AI implantados.

A escala desse problema é semelhante a deixar as chaves de sua casa debaixo do capacho, mas em uma escala digital e globalmente distribuída. Em vez de uma única chave física, estamos falando de milhares de chaves digitais — API keys, OAuth tokens e senhas de banco de dados — expostas em 520 das 17.000 AI agent skills auditadas.

pesquisadores descobriram que não se tratavam de jailbreaks sofisticados ou exploits complexos. Esses vazamentos ocorreram durante o uso totalmente normal, sem exigir nenhum hack avançado. Um usuário só precisa perguntar: "Qual foi a última saída de depuração?" e o segredo aparece em texto simples.

Modelos de AI operam com uma context window, um buffer de memória dinâmica crítico que registra todas as interações conversacionais, entradas e saídas dentro de uma determinada sessão. Essa janela serve como a memória de trabalho imediata da AI, crucial para manter a coerência e a compreensão da interação em andamento. Agent frameworks, projetados para orquestrar complexas AI skills, capturam meticulosamente *cada* bit de standard out gerado por suas ferramentas integradas e o alimentam diretamente nesse contexto.

Isso não é apenas uma simples operação de registro; é um pipeline direto para a compreensão da AI. O que os desenvolvedores pretendiam como uma mensagem de depuração temporária e interna, como uma instrução `print` ou `console.log` revelando uma API key, instantaneamente se torna uma parte permanente da memória operacional da AI. O design inerente da AI dita que ela processa e "lembra" tudo dentro de seu contexto, tratando essas saídas de depuração como peças integrais de informação para a interação em andamento.

Imagine a context window como um estenógrafo incansável e perfeitamente preciso, presente em cada interação entre a AI e suas ferramentas. Esse escriba digital transcreve diligentemente tudo o que é falado, cada comando emitido e cada sussurro dos funcionamentos internos de uma ferramenta. Ele captura não apenas as respostas pretendidas ou as consultas do usuário, mas também quaisquer dados sensíveis inadvertidamente "sussurrados" por meio de uma instrução de impressão de depuração, armazenando-os literalmente para possível referência futura.

Uma vez que um segredo — seja uma API key, OAuth token ou senha de banco de dados — entra neste contexto, ele permanece acessível durante toda a sessão. A AI pode então recordar e reutilizar esses dados sensíveis a qualquer momento, tornando o vazamento persistentemente explorável, mesmo que a instrução de depuração original tenha sido executada apenas uma vez. pesquisadores descobriram um método de recuperação assustadoramente simples: basta perguntar à AI "Qual foi a última saída de depuração?" muitas vezes revela esses segredos em texto simples, sublinhando a profunda gravidade dessa supervisão generalizada. Para uma compreensão mais aprofundada do desafio generalizado da exposição de dados sensíveis, recursos como o State of Secrets Sprawl Report 2025 - GitGuardian oferecem insights abrangentes.

Segredos raramente escapam por meio de violações sofisticadas em AI agents; em vez disso, impressionantes 73% dos vazamentos decorrem de uma prática de desenvolvimento brutalmente simples, quase inocente: a instrução de impressão de depuração. Essa supervisão comum transforma a saída diagnóstica temporária em conhecimento permanente da AI, criando uma vulnerabilidade crítica e facilmente evitável. Compreender esta "Anatomia de uma Traição" revela como o próprio código de um agente pode comprometer dados sensíveis. O ciclo de vida de um segredo vazado segue uma sequência previsível de três etapas.

Considere uma skill de agente de IA baseada em Python que precisa de uma API key para interagir com um serviço externo, talvez um gateway de pagamento de terceiros ou um armazenamento de dados proprietário. Os desenvolvedores normalmente carregam essas credenciais sensíveis de variáveis de ambiente para mantê-las fora do controle de versão e garantir uma implantação segura. Uma linha como `api_key = os.getenv('API_KEY')` efetivamente recupera a chave do ambiente do sistema, um passo inicial padrão e seguro.

O erro fatal frequentemente ocorre imediatamente após essa recuperação segura. Durante o desenvolvimento ou teste, para verificar se a chave foi carregada corretamente ou para depurar a autenticação de uma chamada de API, um desenvolvedor pode adicionar uma instrução aparentemente inofensiva `print(f'Using key: {api_key}')`. Esta linha exibe o segredo real, em texto simples completo, para a saída padrão – uma prática comum, quase instintiva, para verificações de diagnóstico rápidas na programação tradicional.

É precisamente aqui que o framework de agente de IA se torna um cúmplice involuntário, mas altamente eficaz, na fuga de dados. Ao contrário das aplicações tradicionais onde as instruções `print` apenas escrevem para um console ou um arquivo de log local para revisão humana, os frameworks modernos de agente de IA são arquitetados para capturar *toda* a saída padrão. Eles ingerem essa saída de forma abrangente, tratando cada caractere como uma potencial peça de informação relevante para a interação contínua e o estado operacional do agente.

A saída capturada, incluindo aquela impressão de depuração crítica da sua API key, é injetada diretamente na janela de contexto do LLM. Esta janela de contexto serve como a memória de curto prazo primária da IA para a conversa ou tarefa atual, essencialmente definindo o que o modelo "sabe" e pode referenciar. Cada pedaço de informação alimentado nela, independentemente de sua intenção original, torna-se imediatamente acessível ao modelo de linguagem grande subjacente.

Uma vez dentro da janela de contexto, o segredo não é mais uma mensagem de depuração passageira; agora é uma parte indelével da "base de conhecimento" ativa da IA para aquela sessão inteira. Um atacante, ou mesmo um usuário desavisado, pode então facilmente solicitar à IA com uma consulta como, "Qual foi a última saída de depuração?" ou "Fale-me sobre as chaves que você está usando," e a IA prontamente repetirá a credencial exposta em texto simples completo. Isso torna a linha de depuração aparentemente inocente uma parte permanente da base de conhecimento da IA para aquela interação, uma traição profunda e facilmente evitável de dados sensíveis.

Recuperar um segredo vazado da memória de um agente de IA prova ser chocantemente trivial, não exigindo habilidades avançadas de hacking ou jailbreaks elaborados. Uma vez que uma instrução de depuração errônea de um desenvolvedor incorpora dados sensíveis na janela de contexto da IA, qualquer usuário pode simplesmente pedir por eles. Isso não é um exploit sofisticado; é um pedido direto de informação, aproveitando a função da IA como um sistema obediente de recuperação de informações.

Os usuários só precisam empregar prompts aparentemente inócuos para extrair esses detalhes ocultos. Consultas como “Qual foi a última saída de depuração?” ou “Resuma o log de execução da ferramenta” são frequentemente suficientes para extrair dados sensíveis da IA. O agente, operando precisamente como projetado, recupera e apresenta diligentemente as informações solicitadas, que podem incluir API keys reais, OAuth tokens ou até mesmo senhas de banco de dados que ele encontrou durante seus processos operacionais.

Crucialmente, a própria IA age sem malícia, sem qualquer compreensão inerente da sensibilidade dos dados. Ela simplesmente segue instruções, fornecendo dados que lhe foram explicitamente dados para processar ou lembrar dentro de seu contexto. Isso destaca um mal-entendido fundamental entre os desenvolvedores: eles tratam as impressões de depuração (debug prints) como saídas temporárias e efêmeras. No entanto, para uma IA, essa saída padrão torna-se uma parte integrante de sua memória central, indistinguível de outros dados críticos que ela usa para atender a solicitações.

Esta vulnerabilidade aumenta drasticamente para agentes de IA voltados para o público, onde a base de usuários é ampla e muitas vezes anônima. Qualquer usuário, independentemente de sua intenção ou habilidade técnica, pode potencialmente interrogar o sistema em busca de logs internos. Imagine um bot de suporte ao cliente ou um agente de análise de dados público expondo inadvertidamente credenciais de backend porque um desenvolvedor se esqueceu de remover uma instrução `print()` ou `console.log` durante os testes. A facilidade de recuperação significa que um único usuário curioso pode comprometer um sistema inteiro.

pesquisadores descobriram esse padrão generalizado em mais de 17.000 habilidades de agentes de IA, com 520 comprovadamente vazando segredos durante o uso normal. Mais de 73% desses vazamentos críticos se originaram de simples impressões de depuração (debug prints) que os desenvolvedores negligenciaram remover. Essa supervisão generalizada transforma o que deveria ser uma conveniência do desenvolvedor em uma falha de segurança crítica, tornando dados confidenciais disponíveis para qualquer pessoa que saiba como perguntar. A simplicidade deste "hack" mina fundamentalmente a segurança dos sistemas que dependem desses agentes.

Além das instruções de depuração (debug statements) imediatas, uma vulnerabilidade mais insidiosa espreita: vazamentos entre modelos (cross-model leaks). Esses segredos não aparecem em texto simples na saída da IA; em vez disso, eles surgem ao combinar respostas de agentes aparentemente inócuas com a documentação externa do projeto. Isso os torna significativamente mais difíceis de detectar por meio de simples observação.

Considere uma ferramenta de agente de IA que imprime um ID ou GUID aparentemente aleatório após uma operação. Esse identificador pode entrar na janela de contexto (context window) do modelo sem nenhum dado sensível óbvio anexado. Por si só, a string parece inofensiva, não oferecendo nenhum caminho imediato para exploração.

No entanto, o segredo torna-se flagrantemente óbvio quando um atacante cruza essa saída com o README público do projeto, a documentação da API ou até mesmo wikis internas. Esse ID "aleatório" pode, por exemplo, ser explicitamente descrito como um token de sessão temporário ou um ID de cliente que se combina com um segredo pré-compartilhado, documentado em outro lugar, para formar uma chave de API válida.

Este pipeline, de uma saída de aparência benigna a um segredo totalmente revelado, ressalta uma falha crítica no pensamento de segurança tradicional. Os desenvolvedores devem conduzir revisões de segurança holísticas que abrangem não apenas o código, mas também cada peça da documentação que o acompanha. Para mais informações sobre as amplas implicações dessas vulnerabilidades, explore insights como os encontrados em [AI Secret Leaks in Public Code Repos: Warning to Developers | Wiz Blog].

Ignorar a interação entre código e documentação deixa um vetor amplamente aberto para exfiltração de dados. A IA lembra o que vê; a documentação fornece a Pedra de Roseta para os atacantes traduzirem a saída benigna em segredos acionáveis.

Antigos hábitos de desenvolvedores agora representam um risco crítico de segurança na era dos AI agents. Por décadas, engenheiros confiaram no registro verboso (verbose logging) como um pilar da depuração (debugging). Em aplicações monolíticas (monolithic) ou de microsserviços (microservice) tradicionais, um `print` statement ou `console.log` direcionava a saída para arquivos de log privados e internos. O acesso a esses logs permanecia estritamente controlado, muitas vezes restrito a pessoal autorizado através de sistemas seguros e ferramentas de monitoramento. Esses logs serviam como ferramentas de diagnóstico inestimáveis, guardados com segurança longe dos usuários finais e da internet pública.

Os AI agent systems quebram fundamentalmente este perímetro de segurança estabelecido. A context window de um AI model não diferencia entre a saída de código de produção (production code output) e uma declaração de depuração temporária (debug statement) de um desenvolvedor. Ao contrário das aplicações tradicionais onde os logs são efêmeros ou armazenados de forma segura, a saída padrão (standard output) de um agent framework é capturada e passada diretamente para o contexto do modelo. Isso significa que a IA pode ativamente "lembrar" e repetir qualquer informação, transformando uma nota privada em uma potencial divulgação pública.

Pesquisadores revelaram a dura realidade: mais de 73% dos 520 segredos reais vazados das 17.000 Tools auditadas vieram diretamente dessas `print` statements aparentemente inócuas. O que antes era um diagnóstico interno agora se torna parte da memória ativa da IA, pronto para ser recuperado por qualquer pessoa que interaja com o agente. Este mecanismo, onde uma skill carrega um token, o imprime para depuração (debugging), e então esse segredo permanece na context window do agente, sublinha a grave vulnerabilidade.

Isso exige uma profunda mudança no developer mental model. A confiança implícita na privacidade dos logs, enraizada ao longo de anos de desenvolvimento de software, simplesmente não se aplica ao construir AI agents. Os desenvolvedores devem desaprender o reflexo de imprimir dados sensíveis para inspeção rápida, compreendendo que tal saída alimenta diretamente o modelo voltado para o público. A suposição de que uma linha de depuração temporária é inofensiva rapidamente se torna um passivo.

Consequentemente, o que antes era considerado uma best practice para depuração rápida – registro extenso e não editado (unredacted logging) – evoluiu rapidamente para um significativo anti-pattern. As mesmas técnicas que aprimoravam a capacidade de depuração (debuggability) em paradigmas anteriores agora criam vulnerabilidades gritantes. Cada linha impressa, cada variável temporária registrada, carrega o potencial imediato de expor dados críticos como API keys, OAuth tokens e database passwords. Isso redefine o significado de "safe debugging" para toda uma geração de AI engineers, forçando uma reavaliação imediata e urgente de cada estratégia de logging.

- Desenvolvedores devem repensar fundamentalmente suas práticas de logging e adotar uma nova e rigorosa regra de ouro: never print secrets, nunca. A auditoria de mais de 17.000 AI agent skills revelou que mais de 73% dos incidentes onde segredos estavam vazando vieram diretamente de simples debug prints, como `print` statements ou `console.log`. Essas saídas não são meramente mensagens temporárias do console; a context window do AI model as captura imediatamente, tornando-as parte de sua memória persistente e facilmente recuperáveis mediante solicitação. Em vez disso, use loggers seguros e construídos para essa finalidade que ofereçam robustas capacidades de redação (redaction). Essas ferramentas identificam e mascaram automaticamente dados sensíveis – como API keys, OAuth tokens e database passwords – antes que cheguem a um log stream, ao contexto do AI model ou a qualquer sistema externo. Essa abordagem proativa evita a exposição não intencional desde a primeira linha de código.

- Em seguida, implemente a varredura automatizada de segredos cedo e frequentemente ao longo do seu ciclo de vida de desenvolvimento. Integre varreduras de pré-publicação e pré-commit diretamente em seus pipelines de Integração Contínua/Implantação Contínua (CI/CD) e fluxos de trabalho de controle de versão. Este passo crucial detecta inclusões acidentais de credenciais antes que elas saiam da sua máquina local ou sejam enviadas para um repositório remoto. Ferramentas como GitGuardian e TruffleHog se destacam na varredura autônoma de bases de código inteiras, históricos de commit e configurações em busca de API keys, tokens, credenciais de banco de dados e outras informações sensíveis codificadas. Elas sinalizam vazamentos potenciais, forçando a remediação antes da implantação e fornecendo uma rede de segurança automatizada essencial contra erros humanos, protegendo contra as mesmas vulnerabilidades que os pesquisadores identificaram.

- Finalmente, eleve seu processo de revisão de código, exigindo uma revisão abrangente e combinada tanto do código-fonte quanto da documentação. Torne a revisão de código e READMEs juntos uma parte não negociável de cada pull request e revisão por pares. Esta prática aborda diretamente os vazamentos insidiosos de 'cross-model', um tipo de vulnerabilidade onde a verdadeira significância de um segredo ou mesmo sua própria presença só se torna aparente quando você lê o contexto descritivo em um README junto com seus detalhes de implementação no código. Sem esta abordagem holística, vulnerabilidades críticas podem permanecer ocultas à vista, permitindo que segredos persistam no contexto da IA porque os revisores examinam apenas uma peça do quebra-cabeça. Esta revisão integrada garante uma postura de segurança mais completa.

Embora as declarações `print` e `console.log` tenham sido responsáveis por mais de 73% dos vazamentos que os pesquisadores descobriram nas 17.000 habilidades de agentes de IA auditadas, o cenário de ameaças se estende muito além da simples saída de depuração. Os desenvolvedores devem examinar cada ponto de dados que entra na janela de contexto de uma IA, pois outros vetores também traem ativamente informações sensíveis. A violação silenciosa é multifacetada, exigindo uma postura de segurança abrangente.

Mensagens de erro verbosas, por exemplo, representam um risco significativo que muitas vezes passa despercebido. Stack traces completos comumente expõem funcionamentos internos intrincados, incluindo strings de conexão de banco de dados, tokens de autenticação, API endpoints, ou até mesmo nomes de variáveis de ambiente que sugerem locais de segredos. Os desenvolvedores frequentemente configuram o registro (logging) para capturar esses detalhes abrangentes para solução de problemas, tornando-os inadvertidamente acessíveis à memória persistente do modelo de IA. Esta prática, embora útil para depurar aplicações tradicionais, torna-se uma vulnerabilidade crítica em sistemas de agentes de IA.

Entradas de usuário não sanitizadas representam outra vulnerabilidade insidiosa. Atores maliciosos podem criar entradas especificamente projetadas para acionar logging verboso ou condições de erro, com o objetivo de enganar o sistema para que ele exiba o estado interno ou detalhes de configuração. Esta forma de prompt injection não se trata apenas de manipular a resposta imediata da IA; ela pode transformar o próprio pipeline de logging em uma arma, extraindo informações que deveriam permanecer ocultas. Imagine uma entrada projetada para fazer com que um módulo específico falhe, revelando seus segredos carregados no log de erro subsequente.

Além disso, bibliotecas e dependências de terceiros introduzem uma nova camada inteira de complexidade e potencial comprometimento. Esses componentes externos, frequentemente integrados sem auditorias de segurança aprofundadas, empregam frequentemente seus próprios mecanismos de registro (logging), que podem não aderir aos mesmos padrões de segurança rigorosos. Uma dependência aparentemente inocente poderia estar registrando dados sensíveis sem o conhecimento de um desenvolvedor, passando-os inadvertidamente para o contexto da IA. Este risco da cadeia de suprimentos significa que mesmo um código de primeira parte meticulosamente seguro permanece vulnerável se suas dependências não forem igualmente robustas. Para mais informações sobre esses problemas generalizados, incluindo como as próprias ferramentas de codificação de IA podem contribuir para vazamentos, leia Your Next Secrets Leak is Hiding in AI Coding Tools - DevOps.com. Proteger os agentes de IA exige uma abordagem holística, indo além de correções superficiais para uma profunda consciência arquitetônica e vigilância contínua.

A era dos agentes de IA exige uma reavaliação completa dos paradigmas de segurança. O que antes constituía depuração inofensiva no desenvolvimento de software tradicional agora representa vulnerabilidades críticas, como evidenciado por pesquisadores que descobriram que 520 habilidades de agentes de IA estavam vazando segredos de 17.000 ferramentas auditadas. Devemos ir além de correções reativas e abraçar uma filosofia proativa e de segurança em primeiro lugar, desde o início.

Os futuros frameworks de agentes de IA não podem se dar ao luxo de tratar a saída como um item secundário. Imagine frameworks projetados com sanitização automática de saída, redigindo dinamicamente informações sensíveis antes que elas entrem na janela de contexto do modelo. As implementações poderiam incluir detecção e ofuscação de segredos incorporadas, tornando as impressões de depuração simples inerentemente mais seguras e eliminando os 73% dos vazamentos rastreados até elas.

Os desenvolvedores precisam de ferramentas robustas e integradas que imponham práticas de codificação seguras por padrão. Isso exige recursos de segurança padronizados, como APIs obrigatórias de gerenciamento de segredos e utilitários de registro (logging) sensíveis ao contexto, diretamente nos SDKs principais do agente. Tais recursos abstrairiam a complexidade do tratamento seguro, garantindo que os desenvolvedores nunca exponham acidentalmente chaves de API críticas ou senhas de banco de dados.

Uma mudança fundamental na educação de desenvolvedores é igualmente crucial. Currículos universitários e bootcamps devem integrar princípios de segurança específicos de IA desde o primeiro dia, não como uma disciplina eletiva avançada. O treinamento deve enfatizar os riscos únicos da janela de contexto da IA e as profundas implicações de declarações de depuração aparentemente inócuas. Compreender que a "memória" de uma IA é uma superfície de ataque persistente é fundamental.

Este desafio transcende desenvolvedores individuais ou mesmo frameworks específicos. Construir um ecossistema de agentes de IA invioláveis verdadeiramente exige um esforço coletivo em toda a indústria. Criadores de frameworks, fornecedores de ferramentas e contribuidores de código aberto devem colaborar em novos padrões de segurança, melhores práticas compartilhadas e mecanismos de validação robustos.

Todo desenvolvedor tem uma responsabilidade crítica neste cenário em evolução. Pare de imprimir segredos, para sempre. Adote a redação de logs, execute varreduras pré-publicação e revise meticulosamente seu `readme` e código em conjunto. Somente através de um compromisso unificado com a segurança por design podemos forjar um futuro confiável e resiliente para a inteligência artificial.

O que é um vazamento de segredo de agente de IA?

Um vazamento de segredo de agente de IA ocorre quando informações sensíveis como chaves de API, senhas ou tokens são expostas involuntariamente através da operação normal do agente, muitas vezes sendo capturadas na janela de contexto do modelo de IA.

Por que as impressões de depuração causam vazamentos em agentes de IA?

Em estruturas de agente de IA, a saída padrão (de 'print' ou 'console.log') é frequentemente alimentada diretamente na janela de contexto da IA como informação. Se um desenvolvedor imprime um segredo para depuração, a IA 'lembra' dele e pode repeti-lo de volta para um usuário mais tarde.

Como posso evitar que meu agente de IA vaze segredos?

Nunca imprima segredos na saída padrão. Use registro seguro com redação, execute varreduras automatizadas pré-publicação em busca de segredos em seu código e sempre revise seu código e documentação juntos para identificar exposições potenciais.