Seu problema com o Copilot, na verdade, não é um problema de funcionamento dele. É um problema de confiança no modelo por trás dele. A maioria das equipes ainda acha que a segurança reside em prompts, permissões e alguns filtros na borda. Mas o ponto é, os invasores não precisam vencer seu prompt, eles só precisam envenenar o contexto ao redor dele. E é aí que as coisas falham. Filtros básicos podem pegar lixo óbvio, mas ignoram a carga maliciosa escondida em um e-mail, um arquivo do SharePoint ou um campo de formulário. Esse conteúdo recuperado permanece lá, silenciosamente, até que o Copilot o traga e o trate com uma instituição direta. Já vimos sinais de alerta com o vazamento Echo no Microsoft 365 ou Copilot e o vazamento Share no Copilot Studio. E a realidade é que os patches não acabaram com esse padrão. Como o Copilot pode pesquisar, resumir e agir em todo o seu ambiente Microsoft 365, um caminho de instrução ruim pode se espalhar rapidamente. Portanto, não se trata de adicionar mais um painel à sua pilha, mas de colocar o Azure Logic Apps no caminho para inspecionar, pontuar e bloquear cargas maliciosas antes mesmo do Copilot rodar. O perigo real é a arquitetura, não o prompt. O modelo antigo pressupõe que você pode manter o sistema seguro escrevendo instruções melhores ao redor do modelo. Você fornece um prompt de sistema forte, adiciona delimitadores e diz aos usuários o que não devem fazer. Isso parece sensato na teoria, mas na realidade, o modelo não impõe limites de confiança como um sistema de segurança faria, porque ele lê a linguagem em um canal compartilhado onde instruções e dados competem por atenção. Essa premissa é a falha. Se um modelo não consegue distinguir com segurança entre um usuário pedindo ajuda e um documento dizendo silenciosamente para ignorar instruções anteriores, então o ponto de controle não pode estar apenas na camada do prompt. Você está tentando garantir o comportamento na borda enquanto o risco real reside no fluxo de contexto que entra no modelo. Isso ficou claro para muitas equipes assim que surgiram cargas de trabalho do Copilot com o uso intenso de... No momento em que o Copilot começa a extrair meias, arquivos e histórico de chat do Microsoft Graph, a superfície de ataque muda completamente. Você não está mais protegendo apenas uma conversa, você está protegendo um fluxo ao vivo de entradas com diferentes níveis de confiança. No nível mais profundo, o Copilot aumenta o alcance. Ele não apenas responde a perguntas, ele recupera, resume e segue referências. Em algumas configurações ele pode até acionar ferramentas ou fluxo de trabalho. Portanto, quando o conteúdo não confiável entra nessa cadeia, o modelo pode levar essa influência adiante para ações sensíveis. É por isso que a injeção indireta de prompt é tão importante agora. Em sistemas de produção, o ataque comum nem sempre é um usuário digitando ignore suas regras na caixa de chat. A versão mais perigosa reside no conteúdo recuperado muitas vezes semanas antes que alguém note sua presença. Um documento infectado, um e-mail forjado ou uma entrada de formulário podem parecer inofensivos para humanos, mas contém instruções direcionadas diretamente ao modelo. Mais tarde, o Copilot recupera esse conteúdo como contexto relevante. Mistura ou com material confiável, o modelo segue a orientação errada. A cadeia de ataque é simples e é isso que a torna perigosa. Primeiro, o atacante planta conteúdo onde o Copilot possa acessar depois. Então a recuperação traz esse conteúdo para a sessão e o modelo trata a carga como instrução em vez de dados. Depois disso, ele pode começar a preparar informações sensíveis, mudar respostas ou enviar dados para um caminho de desfiltração via links ou uso de ferramentas. Portanto, para os líderes, isso não é apenas higiene de AI, é controle em tempo de execução diretamente ligado à governança de acesso. Se o Copilot tem amplo alcance no tenente e o modelo consome contextos de confiança mista sem separação rígida, seu modelo de segurança deve considerar o que entra no fluxo antes da execução. À vez que percebe isso, a solução tem muito. Você para de se preocupar excessivamente com prompts perfeitos e começa a implementar controles onde o contexto se ocupa. Por que as defesas básicas falam em produção? A maioria das equipes comete um erro fundamental logo de início. Elas presumem que os controles de segurança usados por anos no desenvolvimento de aplicações funcionarão tão bem para o Copilot. Elas escrevem um prompt de sistema mais forte, envolvem a entrada do usuário em caracteres especiais e publicam diretrizes para funcionários, sentindo-se tão seguras. Esses passos não são ruins. Eu não diria para parar de fazê-los, mas eles não criam uma barreira de segurança real. Eles apenas tentam persuadir o modelo a se comportar, e em segurança a persuasão não é o mesmo que imposição. É aí que reside a lacuna. Um prompt de sistema diz ao modelo que você prefere que ele faça, mas não pode impedir que um arquivo malicioso dispute a atenção do modelo assim que for puxado para o espaço de trabalho. Usar delimitadores pode ajudar a estruturar o texto, mas não dá ao modelo uma forma de verificar credenciais de segurança. Orientações para funcionários são ótimas para evitar erros honestos, mas não fazem absolutamente nada contra um documento infectado com um documento infectado ou uma carga oculta nos dados recuperados. Controle existe como uma sugestão, não como uma regra rígida aplicada na execução. Regex tem um problema semelhante. É rápido e barato, então vale a pena usar como uma primeira verificação rápida. Se um usuário digitar e ignore todas as instruções anteriores, seu sistema deve detectar isso em poucos milissegundos. Você também pode usá-lo para sinalizar frases óbvias de violação de privacidade ou caracteres do tipo SQL nos argumentos de sua ferramenta. Essa parte funciona bem, mas Regex só reconhece padrões que você já definiu, então falha quando o texto muda ligeiramente ou quando o ataque é baseado no significado e não em palavras específicas. Diz que você precisa de camadas de classificação, o Azure AI Content Safety possui escudos de prompt que podem detectar ataques de injeção diretos e indiretos. Em um WODCAP, você pode chamar uma API para verificar o prompt antes que o modelo veja, mudando o caminho do fluxo de trabalho caso um ataque seja detectado. Este é um controle muito mais forte que uma simples correspondência de strings, pois busca a intenção por trás das palavras em todo o prompt e nos documentos de um. Mesmo assim, a detecção não basta sozinha, porque ver um risco não importa se você não tiver como impedi-lo. Equipes de segurança costumam subestimar essa parte específica do processo. Um aviso em um arquivo de log não é contenção, e um gráfico bonito no painel também não é. Também não é. Mesmo um alerta de alta prioridade no seu CM, falha se o payload já passou pelo copilot e disparou uma ação em um sistema posterior. Revisar o que aconteceu depois do fato é útil para investigações, mas não é o bastante quando um ataque ocorre em segundos. Você está lidando com um modelo que pode agir dentro de sistemas que sua organização já confia. Há também um problema com falsos negativos, que a maioria do marketing de produto ignora. Ataques indiretos causam uma grande parte das detecções perdidas no mundo real, pois a instrução perigosa parece normal até o modelo combiná-la com o resto da conversa. Quando um humano revisa o resultado e percebe que algo está errado, a entrada maliciosa já terminou seu trabalho. O erro prático aqui é muito simples. As equipes passam todo o tempo monitorando o que o copilot diz, mas não controlam o que entra nele com o mesmo nível de disciplina. Eles inspecionam a resposta depois de gerada, enquanto permitem que material não confiável entre antes do início do trabalho. Essa ordem está completamente invertida. Uma vez que você reconhece essa falha, o objetivo central da sua estratégia de segurança muda. Você para de perguntar como escrever um prompt mais seguro e começa a perguntar onde pode interceptar os dados antes da execução do mundo. Modelo de Logic App Fire. Se a interceptação é objetivo, precisamos analisar como esse controle realmente funciona na prática. Deve usar o Azure Logic Apps como uma camada de política que fica à frente da fase de execução. Não deve ser uma ferramenta passiva que envia um relatório após o dano ter sido causado. Você precisa colocá-la diretamente no caminho onde a entrada do usuário, os dados recuperados residem, para que possam ser inspecionados antes que o modelo comece. Essa mudança é poderosa, porque o Logic Apps é feito para a orquestração. Ele pode ser acionado por eventos específicos, chamar outras APIs e tomar decisões baseadas em condições complexas. Você pode rotear dados e enviar alertas ao Microsoft Sentinel e enriquecer o processo com informações externas sem criar um gateway de segurança do zero. Você não está tentando substituir o copilot aqui. Você está apenas inserindo uma camada de controle no fluxo ao redor dele. A lógica por trás deste modelo é propositamente sim. Primeiro você aciona o processo, depois normaliza os dados. Você inspeciona, avalia o risco, toma uma decisão e finalmente roteia ou registra o resultado. Esse é o padrão completo. Quando uma solicitação ou um conteúdo entra no fluxo de trabalho, o Logic App captura esse payload e o padroniza. Entradas brutas geralmente são desorganizadas, porque diferentes conectores lidam com dados de maneira diferente. Um e-mail é diferente de um formulário e conteúdos de arquivos ou argumentos de ferramentas vêm com metadados e campos distintos. Se você tentar executar uma inspeção antes de normalizar esses dados, seu sistema de detecção será extremamente ruidoso. Uma vez que o payload é nivelado em um formato consistente, a primeira rodada de inspeção começa. É aqui que seu rejexo personalizado ainda tem um papel amputado. E não é o juiz final nem uma solução mágica, mas funciona como um filtro muito rápido na borda do seu sistema. Você pode buscar rapidamente por linguagens de substituição, dicas de codificação ou padrões suspeitos em parâmetros de ferramentas para obter uma triagem instantânea da situação. Então você passa para a segunda rodada de inspeção, que analisa o conteúdo com muito mais profundidade. É aqui que se chama os escudos de prompt do Azure AI Content Safety. O Logic App envia o prompt do usuário e quaisquer documentos recuperados para a API e, em seguida, ramifica dependendo se um ataque foi detectado. Isso é importante porque injeções de prompt nem sempre parecem um código de computador óbvio. Às vezes o perigo só se torna claro quando o prompt e o documento são avaliados como uma unidade única. Existe mais uma camada que transforma isso de um filtro simples em um controle de segurança real, a inteligência contra ameaças. Se um conteúdo faz referência a um domínio malicioso conhecido ou uma URL suspeita que sua equipe já viu antes, isso deve mudar sua decisão. Os Logic Apps podem verificar o evento contra a inteligência contra ameaças do Defender ou outros feeds de terceiros para adicionar uma pontuação de confiança ao risco. Isso significa que um padrão estranho de uma fonte confiável pode ser permitido, enquanto esse mesmo padrão associado a uma reputação hostil é bloqueado imediatamente. É bloqueado imediatamente. Isso transforma sua árvore de decisão em algo além de uma simples escolha de sim ou não. Você pode permitir a solicitação se a pontuação de risco for baixa, ou pode higienizá-la removendo os fragmentos de seus seguros. Você pode optar por colocar os dados em quarentena se a fonte precisar de uma revisão. Se a ação envolver dados confidenciais, você pode até exigir a aprovação de um humano antes que ela prossiga. Claro, se o sinal for forte o suficiente, você simplesmente bloqueia a solicitação e dispara um alerta. Essa gama de opções é o que faz este modelo realmente funcionar para uma empresa. Equipes de segurança muitas vezes impedem a adoção ao negar todo caso que pareça um pouco incerto. Quando os controles são rígidos demais, as pessoas encontram formas de contorná-los. Um fluxo de trabalho pontuado lhe dá espaço para responder com base no risco real, em vez de pânico. É exatamente por isso que o Logic Apps é mais adequado do que uma coleção de ferramentas separadas. Ele já se conecta ao restante do ecossistema Microsoft e funciona perfeitamente com os playbooks do Sentinel. Você pode solicitar uma verificação de segurança de conteúdo, consultar dados de ameaças e enviar eventos de auditoria tudo em um solo. Você não precisa de um longo ciclo de desenvolvimento toda vez que o invasor muda sua fraseologia ou uma nova forma de entrar no sistema aparece. A regra que faz tudo isso funcionar é muito simples. Você deve tratar cada fragmento de contexto como não confiável até que ele tenha sido pontuado. Isso não significa apenas o prompt do usuário, significa o corpo do e-mail, o arquivo carregado e o campo de formulário do SharePoint. Isso inclui o payload do conector, os pedaços de documentos recuperados e até mesmo os argumentos da ferramenta. Tudo isso precisa se verificar. No momento em que você assume que uma dessas fontes é segura por padrão, você criou uma nova lacuna para um invasor explorar. Uma vez que seu fluxo de trabalho aplica essa regra de forma consistente, você não precisa mais depender do copilot para separar dados bons de ruins por conta própria. O processo se torna um sistema de entrada controlado. No papel isso soa como uma ótima teoria, mas o que as pessoas realmente se importam é o que acontece quando um payload perigoso atinge o fluxo de trabalho no mundo real. O que o fluxo de trabalho realmente faz em tempo de execução quando o sistema entra em operação não é apenas escanear texto por palavras ruins, ele constrói um panorama completo da solicitação antes que qualquer decisão seja tomada. Um evento atinge seu ponto de entrada, talvez um envio de formulário, um fluxo de e-mail ou um carregamento de documento vinculado a um processo do copilot, e o Logic App se envolve imediatamente a esse evento com metadados. Ele rastreia quem enviou a solicitação, qual aplicativo acessou, onde o arquivo se originou e o que o sistema está prestes a fazer a seguir. Esse contexto extra vital, porque a mesma frase pode significar algo completamente diferente dependendo de onde ela vem. Assim que esses dados são capturados, o payload é dividido em zonas de confiança específicas. Você precisa manter a separação clara. O prompt do usuário vai para um grupo, os documentos recuperados para outro e o histórico da conversa ou parâmetros de ferramentas ganha seu próprio espaço. Se você misturar tudo cedo demais, perde a capacidade de identificar onde uma instrução de risco realmente começou e seu processo de revisão vira um palpite. Muitas equipes pulam essa etapa porque combinar tudo parece mais rápido, mas na realidade isso apenas oculta o caminho que você precisa seguir. Em seguida, o fluxo de trabalho passa para a manualização. Essa é a parte entediante do trabalho, mas é também o que torna sua detecção realmente utilizável. Você precisa remover marcações que adicionam ruído, decodificar URL ou base 64 e nivelar campos alinhados para que a inspeção ocorra em uma estrutura estável. Se um conector envia texto rico enquanto o outro envia fragmentos JSON, você quer todos reduzidos a campos que suas verificações leiam de forma consistente. Sem isso, sua lógica gasta mais tempo combatendo a variação de formato do que encontrando ataques reais. Após limpar os dados, a verificação rápida de padrões é executada primeiro. Isso precisa ser barato, direto e rápido. Você procura frases que tentam substituir o comportamento do sistema, como variações de ignore todas as instruções anteriores ou substituição de sistema. Você também busca por linguagem de extração onde alguém pede para revelar material confidencial, despejar segredos ou ignorar configurações de privacidade. Em aplicativos lógicos, as equipes geralmente lidam com isso por meio de expressões ou etapas de composição que definem sinalizadores, em vez de bloquear a solicitação imediatamente a cada um conhece. Essa sinalização é importante, pois uma única frase nem sempre significa que alguém está sendo abusivo. Alguém trabalhando em um fluxo de segurança válido pode precisar literalmente perguntar sobre a revisão do manuseio de conteúdo confidencial. Para resolver isso, o fluxo envia o payload mais rico para os escudos de prompt do Azure AI Content Safety para uma análise mais profunda. A chamada de API inclui tanto o prompt do usuário quanto os documentos recuperados, porque a relação entre eles é onde o problema real costuma se esconder. O serviço retorna um sinal simples e, se um ataque for detectado, o fluxo apenas altera o caminho antes mesmo que a chamada do modelo ocorra. Então, você precisa adicionar contexto externo. Consultas de inteligência de ameaças dão ao fluxo de trabalho outra lente de anel. Você pode consultar a inteligência de ameaças do Microsoft Defender ou qualquer fonte táxi confiável para verificar domínios, URLs ou indicadores de origem associados a abusos. Você deve incluir pontuações de confiança quando disponíveis, porque a reputação de uma fonte deve influenciar a pontuação final não substituída inteiramente. Uma carga útil fraca de uma fonte de risco deve sempre ser classificada acima da mesma carga vinda de um processo interno bem compreendido. Finalmente, o sistema cria uma pontuação composta. Ele analisa a força da correspondência de padrões, o resultado do prompt shield, a reputação da fonte e a sensibilidade da ação solicitada. Uma solicitação de baixo risco, para resumir um artigo público, não tem o mesmo peso que uma solicitação que poderia expor arquivos protegidos. Essa pontuação combinada é o que direciona a mificação. Eventos limpos seguem conforme planejado. Casos de risco médio são higienizados ou encaminhados para uma alternativa segura. E casos de alto risco são bloqueados antes mesmo que o Copilot seja executado. Tudo é registrado em uma trilha de auditoria com o caminho da decisão preservado. Esses eventos bloqueados são o que lhe ensinam onde a pressão está aumentando e quais fontes continuam causando problema. Ao ver quais padrões estão escapando para seus fluxos de trabalho, você finalmente tem os dados necessários para ajustar o sistema para a próxima rodada. Como ajustar para baixo ruído e uso comercial real? Assim que o sistema está em execução, a natureza do trabalho muda. Construir o fluxo é, na verdade, a parte fácil. Ajustá-lo para que as pessoas confiem e não tentem encontrar contornos é o que decide se isso se tornará um controle de segurança real ou apenas mais uma experiência fracassada. Se o sistema criar muito atrito, os usuários simplesmente encontrarão uma maneira de contorná-lo, o que torna todo o projeto inútil. Você deve começar de forma restritação. Não tente monitorar cada ponto de contato do Copilot logo no primeiro dia. Em vez disso, escolha os lugares onde o risco é maior e o caminho é claro, como ações habilitadas por ferramentas ou fontes de dados de alto valor. Você pode começar com um processo baseado no SharePoint e um fluxo de trabalho de formulário específico para obter um sinal que você possa realmente ler. Um escopo pequeno lhe dá espaço para aprender sem se afogar em dados. Ao configurar suas verificações iniciais, ajuste suas rejeições para recall em vez de certeza absoluta. A primeira passagem deve capturar a linguagem suspeita precocemente e não provar intenção maliciosa, além de qualquer dúvida razoável. Se você forçar seus padrões a serem perfeitos e se tornam frágeis e começam a perder justamente as coisas com as quais você se importa, é melhor deixar o sistema sinalizar demais no início e depois deixar que verificações posteriores adicionem contexto para reduzir o ruído. É por isso que a pontuação importa mais do que ocorrências únicas. Uma correspondência de frase por si só nem sempre deve interromper uma solicitação, mas quando você combina essa correspondência com um aviso do Prompt Shield, uma fonte de risco, o cenário muda. Sinais fracos devem se acumular e sinais fortes devem acelerar o bloqueio. Essa é a diferença fundamental entre um filtro rígido e irritante e um modelo de política que realmente funciona para um negócio. Você também precisa definir um limite máximo para falsos positivos. Tente manter abaixo de 2%, que assim que as pessoas sentem que o controle bloqueia seu trabalho normal, elas param de confiar no sistema. É nesse momento que as alternativas começam. Usuários copiaram textos para ferramentas não gerenciadas, equipes criarão fluxos paralelos e administradores pedirão exclusões gerais. O controle entrará em colapso por dentro, não porque a detecção falhou, mas porque o atrito se tornou excessivo. Para evitar isso, você deve observar as métricas certas. Esqueça painéis de vaidade e foque no tempo médio de detecção. Você deve mantê-lo abaixo de 15 minutos para qualquer coisa que exija uma revisão anual. Você também deve rastrear seu tempo de contenção automatizada e buscar menos de 5 minutos onde o bloqueio possa segurança. Se o fluxo de trabalho dispara constantemente, mas nunca influencia uma decisão, é apenas ruído. O custo é outro fator que precisa de achos constantes. Logic Apps baseados em consumo são ótimos para cargas de trabalho variáveis ou projetos piloto, pois você só paga pelo que executa. No entanto, o plano padrão faz mais sentido quando o volume de eventos é previsível e alto o suficiente para que os custos por execução comecem a pesar. Na dia de dia, é isso. Mestre as suas contagens reais de gatilho e tamanhos de carga antes de escolher um modelo de classificação. Cuidado com a forma que você gerencia o armazenamento. Você precisa de histórico e de execução suficiente para revisões de incidência e evidência de governança, mas não de um banco de dados enorme cheio de conteúdo sensível. Mantenha os campos específicos que explicam por que uma decisão foi tomada e descarte o excesso que cria risco de retenção. Armazenar dados demais pode transformar a sua ferramenta de segurança em um passivo de privacidade se você não tiver cuidado. Por fim, conecte todo esse ajuste à sua governança mais ampla. Mapeie o fluxo de trabalho para funções do nicho ARMF como medida de gerenciar e vincule aos seus rótulos de sensibilidade de dados do perfil. Às vezes, a melhor solução não é um detector mais inteligente, mas simplesmente remover o alcance desnecessário do fluxo antes que se torne um problema. Quando você chega a esse ponto, não está mais apenas debatendo a segurança de IA de forma abstrata. Você está operando um modelo real com limites e compensações que o negócio consegue gerenciar de fato. O que isso muda para líderes e arquitetos? Assim que você implementa isso, o corporate deixa de agir como um sistema de confiança cega. E é aí que a verdadeira mudança acontece. Antes dessa mudança, o modelo recebia uma mistura de contextos enquanto sua equipe esperava que as instruções certas prevalecessem. Agora, esse contexto é filtrado, pontuado e roteado antes que o modelo tenha qualquer chance de tocá-lo. O resultado de segurança não é mais apenas uma política abstrata, pois agora funciona como uma execução controlada. Para os arquitetos, isso altera onde a segurança realmente reside em seu design. Já não reside apenas nas configurações de locatário, permissões ou modelos de prompt, mas sim diretamente no caminho da transação. Cada solicitação importante recebe um ponto de interceptação e toda ação sensível segue um caminho de decisão específico. Isso significa que cada novo conector agente ou plugin torna-se algo que você avalia como um caminho de entrada, em vez de apenas mais um recurso de produtividade. Isso é vital porque o desvio de arquitetura é geralmente a razão pela qual esses programas falham. Uma equipe implementa o copilot para um caso de uso único, depois outra equipe conecta um formulário e, eventualmente, alguém adiciona um fluxo de trabalho ou dá acesso a ferramentas a um agente. Cada uma dessas mudanças parece pequena individualmente, mas juntas elas criam um caminho de ataque muito maior do que qualquer um planejou. Se você não incorporar interceptação ao seu modelo operacional, o ambiente se expandirá muito mais rápido do que seus controles podem acompanhar. Para líderes de segurança, essa abordagem finalmente resolve um problema de propriedade confuso que a só a maioria das organizações. Atualmente, o risco do copilot geralmente cai nas lacunas entre diferentes equipes. O SOC vê os alertas, os administradores do Microsoft 365 veem a configuração e o responsável pela IA só se preocupa com a adoção. Ao usar um caminho de controle no Logic Apps, todos esses grupos podem finalmente trabalhar a partir de um único modelo de resposta. Eles usam o mesmo rastro de eventos, a mesma lógica de pontuação e o mesmo histórico de ramificação, o que reduz a confusão total quando um prompt de risco ou um documento malicioso parece um fluxo de trabalho ativo. O lado comercial disso é muito mais direto do que as pessoas esperam. Bloquear uma ameaça precocemente é sempre mais barato do que tentar limpá-la mais tarde. A limpeza envolve investigações, análises jurídicas e interrupções de usuários e geralmente termina com uma rodada desagradável de revisões de acesso que deveriam ter ocorrido antes da implantação. Os líderes não precisam de uma longa palestra sobre a ética em A para entender isso, basta ver que o controle em tempo de execução custa menos do que permitir que o risco não gerenciado se espalhe pelos sistemas que sua equipe usa todos os dias. Para os executivos, isso levanta um ponto desconfortável sobre onde o risco reside. As pessoas já assumem que esses lugares são seguros o suficiente para se mover rápido e essa confiança emprestada é exatamente o que aumenta os riscos para a empresa. Um fluxo de trabalho ruim em um aplicativo experimental é um problema contido, mas um fluxo de trabalho ruim dentro da sua pilha diária de produtividade é uma história completamente diferente. Seu caminho de implementação deve permanecer pequeno e muito deliberado. Comece com um caso de uso, um gatilho, um modelo de pontuação. Escolha um caminho onde os dados realmente importam e o comportamento seja fácil de observar. Você precisa provar que o fluxo de trabalho detecta entradas arriscadas e direciona seguras, oferecendo algo útil aos humanos quando uma revisão for necessária. Assim que provar que funciona, você pode começar a expandir. Mais tarde, você pode adicionar a detecção de anomalias ou controle de saída onde couberem. Você pode até adicionar um monitoramento mais profundo para mais profundo para mau uso de ferramentas, mas deve manter o primeiro portão exatamente o contexto não consistente. Se esse primeiro portão continuar fraco, cada controle que você adicionar depois estará apenas tentando compensar um ponto a partir da ruim. A mudança aqui é na verdade muito simples. Pare de tratar a injeção de prompt como se fosse apenas um problema de redação e comece a tratá-la com um controle de tempo de execução sobre o contexto não confiável que circula pelo copado. Reserve um tempo para mapear um fluxo de trabalho do Copilot ponto a ponto. Encontre o último ponto de interceptação segura antes da execução e crie um aplicativo lógico que pontua e bloqueia e registra esse caminho específico. Se você quiser mais sobre segurança do Copilot sem enrolação, inscreva-se e deixe uma avaliação. Você também pode se conectar comigo, Mirko Peters, no LinkedIn para me contar sobre o cenário de teném específico que você está tentando proteger. E aí