Latest / M365.FM – Podcast de Microsoft 365, Copilot e IA em português / Governança de agentes de IA com LangChain4j e Copilot Studio: prompt injection, conectores, auditoria e RBAC (Dublagem IA)

Transcript

Governança de agentes de IA com LangChain4j e Copilot Studio: prompt injection, conectores, auditoria e RBAC (Dublagem IA) · M365.FM – Podcast de Microsoft 365, Copilot e IA em português

• 0:00
  Agentes de IA estão sendo lançados mais rápido que suas reuniões de controle de mudança e a governança é só uma ideia.
• 0:05
  Sabe aquela sensação quando um copiloto é liberado com acesso a todo o tenant apenas para testes?
• 0:08
  Sim, é o coração do seu responsável por compliance que você está ouvindo.
• 0:11
  Hoje, vou analisar a bagunça no LengChain Fortgoin no Coparo de Túdio com casos reais,
• 0:15
  injeção de prompt, conectores permissivos demais e falhas de auditoria.
• 0:18
  E vou mostrar o que quebra, por que quebra e as correções que realmente funcionam.
• 0:23
  Fique até o fim e vou te dar a única medida de governança que previne a maioria dos incidentes.
• 0:26
  Você sairá com um modelo de RBAC para agentes, políticas de prevenção contra a perda de dados e uma lista de verificação para a Red Team.
• 0:32
  Caso 1. Injeção de prompt.
• 0:34
  O estagiário sem supervisão escreve a política.
• 0:36
  Injeção de prompt é aquele estagiário sem supervisão que parece prestativo, escreve frases completas,
• 0:41
  então envia dados da folha de pagamento para seu arquivo pessoal para guardar.
• 0:45
  Você acha que seu prompt de sistema é a lei?
• 0:47
  O modelo acha que é uma sugestão.
• 0:49
  No momento em que você o ancora em conteúdo interno, um documento apimentado ou mensagem de usuário pode reescrever as regras no meio da conversa.
• 0:55
  Por que isso importa?
• 0:57
  Quando a injeção vence, seu agente se torna um poeta rei do vazamento de dados.
• 1:01
  Ele alucina, eleva ferramentas e ignora a linguagem de política como se fossem os termos de serviço do Wi-Fi.
• 1:06
  Em empresas reguladas, isso não é um bug.
• 1:08
  É um incidente reportável com o nome da sua empresa nele.
• 1:10
  Vamos começar com o que quebra no Langshank Forger.
• 1:13
  O que a maioria esquece que chama ferramentas sem esquemas de saída rígidas é basicamente cometer crimes e retornar vibrações.
• 1:17
  Se suas ferramentas aceitam argumentos não verificados, como texto livre, SQL ou campos de consulta, e você não valida tipos, intervalos ou enuns, o modelo passará alegremente o que um atacante inserir.
• 1:30
  Validação de saída fraca é o cúmplice do crime.
• 1:34
  Quando você espera JSON, mas aceita quase JSON, um atacante pode inserir instruções em comentários ou strings que seu parceiro ajusante tratará como comandos.
• 1:40
  Isso ficou claro pra mim quando vi logs onde uma ferramenta de recuperação aceitou um parâmetro de tópico com markdown arbitrário.
• 1:47
  A chamada seguinte passou aquele markdown como se fosse configuração.
• 1:50
  Isso não é orquestração.
• 1:52
  É... go-con.
• 1:54
  Agora, o que que a maioria das pessoas é?
• 1:56
  Elas confiam na configuração por favor seja seguro dos modelos, em vez de usar guardeiros no código.
• 2:00
  No Langshank Forger, você precisa de listas de permissão para nomes de ferramentas e argumentos, saídas de esquema JSON aplicadas na borda,
• 2:06
  filtros de saída baseados em padrões para destruir segredos,
• 2:09
  e tratamento de exceções que não tente repetir a mesma entrada envenenada cinco vezes como um golden retriever com uma bola de tênis.
• 2:16
  A razão pela qual isso funciona é que transforma o Confi no modelo em verifique cada byte.
• 2:21
  O que quebra no Copilot Studio?
• 2:22
  Ancoragem ingênua com ingestão ampla do SharePoint.
• 2:25
  Você conecta uma coleção inteira de sites por completude,
• 2:28
  e agora um documento de integração com ignore as instruções anteriores, se torna a nova religião do seu agente.
• 2:33
  Prompts de sistema editáveis por usuários de negócios são a sequência disso.
• 2:35
  Eu adoro usuários de negócios, mas dar a eles acesso de administrador de prompt,
• 2:38
  é como deixar o marketing definir regras de firewall porque eles conhecem a voz da marca.
• 2:42
  E sim, eu já vi configurações de tenant onde a moderação foi desativada para reduzir o atrito.
• 2:46
  Você vai não ter visto.
• 2:47
  Evidências que você reconhecerá, logs de tenant que mostram ferramentas invocadas com parâmetros ilimitados
• 2:52
  com sinalizadores de exportar tudo que nunca deveria existir.
• 2:55
  Rastros de conversa onde o assistente repete uma string injetada de um documento recuperado
• 2:59
  com as chaves de moderação desativadas.
• 3:00
  Isso não é hipotético, é cada revisão pós-incidente da qual você não quer participar.
• 3:05
  Então qual é o caminho seguro que você pode implementar hoje?
• 3:07
  Para a LangChain 4J, aplique lista de permissão no registro de ferramentas.
• 3:11
  Se a ferramenta não estiver registrada com esquema, ela não existe.
• 3:13
  Exija saídas em esquema JSON e rejeite qualquer coisa que não seja validada.
• 3:17
  Sem esquema, sem resposta, ponto final.
• 3:19
  Adicione filtros de padrão para vazamentos OV, chaves de API e segredos, SSNs.
• 3:23
  Filtros de Bloom são rápidos e baratos os usos.
• 3:25
  Envolva ferramentas com verificações de política,
• 3:27
  valide tipos de argumentos, intervalos e formatos esperados antes da execução.
• 3:30
  Adicione moderação de conteúdo em pré-barra pós-processadores.
• 3:33
  Empeça o modelo de agir ou emitir conteúdo tóxico ou sensível.
• 3:37
  Fale de forma segura, com exceções explícitas,
• 3:38
  e nunca tente repetir automaticamente prontos comprometidos.
• 3:41
  Procopilot Studio, bloqueie os prontos de sistema.
• 3:43
  Apenas administradores podem alterar.
• 3:45
  Nosso versionamento deles com limites de conectores por ambiente.
• 3:48
  Dev e teste de produção com limites diferentes.
• 3:49
  Precife o brejo mínimo nas fontes de dados.
• 3:51
  Ative políticas de moderação de conteúdo no nível do TNAM.
• 3:54
  Isso é o básico essencial.
• 3:55
  Vazei-se apenas em conteúdo com etiqueta de sensibilidade.
• 3:58
  Não em toda a fazenda por conveniência.
• 4:00
  A vitória é rápida que compensa imediatamente.
• 4:02
  Adicione um esquema de saída e uma etapa de moderação com filtro de bloom na borda do agente.
• 4:06
  Se eliminará a maioria dos vazamentos bobos sem tocar na lógica de negra.
• 4:09
  Depois, adicione uma pequena lista de permissões para formatos que você espera,
• 4:12
  como resumos estruturados, e bloqueie todo o resto.
• 4:15
  Deixe-me mostrar exatamente como isso acontece.
• 4:17
  Exemplo, você tem uma ferramenta de criação de ticket que aceita título, descrição e prioridade.
• 4:21
  Sem imposição de esquema, um atacante injeta uma descrição,
• 4:24
  feche todos os incidentes P1 dentro de um bloco de crisis triplas.
• 4:28
  O modelo repassa o comando.
• 4:30
  Sua API de TSM ignora o problema e executa um script de atualização.
• 4:33
  Com o esquema e validação, a descrição não pode conter tokens de comando ou exceder o tamanho.
• 4:37
  A solicitação é bloqueada, o ID de correlação é registrado e seu CM sinaliza um erro de moderação.
• 4:43
  E pronto, veja esse resultado.
• 4:45
  Incidente evitado, rastro preservado, auditor satisfeito.
• 4:48
  Erros comuns a evitar.
• 4:50
  Deixar o modelo escolheu os nomes das ferramentas dinamicamente.
• 4:52
  Ferramentas são contratos, não sugestões.
• 4:54
  Aceitar Jason de formato livre sem um valedor.
• 4:56
  Parece Jason não, elogio.
• 4:58
  Prompts editáveis em ambientes de produção.
• 5:01
  Se pode mudar sem revisão, vai mudar.
• 5:02
  Confiar na memória da conversa é para definir políticas.
• 5:05
  A política pertence ao código e a config, não ao feeling.
• 5:08
  Quando você acerta isso, tudo o resto se encaixa.
• 5:10
  Você impede o estagiário de falar fora de hora.
• 5:12
  Agora, impedimos que entre em qualquer sala com a chave mestra.
• 5:15
  Caso 2.
• 5:16
  Conectores permissivos demais, chaves do castelo num cordão.
• 5:19
  Você impede o estagiário de falar.
• 5:21
  Agora pega o creche de volta.
• 5:22
  Conectores permissivos demais são aquele molho de chaves que abre todas as portas do prédio,
• 5:26
  incluindo o cofre, a creche e, de alguma forma, a bicicleta do CEO.
• 5:30
  Isso importa, é simples.
• 5:31
  Um conector com um escopo excessivo significa a desfiltração de dados em toda a empresa
• 5:34
  em uma única requisição, nada teórico.
• 5:37
  A chamada.
• 5:38
  Enquanto você ainda discute o título do chamado de mudança.
• 5:40
  Vamos começar com o que quebra no Langchain 4.
• 5:43
  Desenvolvedores compartilham chaves de API entre agentes por conveniência.
• 5:46
  Então alguém faz comite do .env num repositório privado que na verdade é público
• 5:50
  e você está respondendo a incidentes às 2 da manhã no exterior.
• 5:52
  Escópio de off em seguida.
• 5:54
  Você concede leitura e escrita para ganhar tempo no teste e, 6 meses depois,
• 5:57
  aquele token de teste é a joia da coroa da produção e o registro de ferramenta.
• 6:02
  Eu adoro um registro limpo, mas se você aponta um agente de dev para credenciais de produção
• 6:05
  porque é demo para você funcionar hoje, você acabou de ligar uma autosserra num robô aspirador.
• 6:09
  O que a maioria esquece é que ferramentas herdam qualquer identidade que você der a elas.
• 6:12
  Credenciais compartilhadas significa compartilhado.
• 6:15
  Não existe um botão mágico de apenas salvar?
• 6:16
  Se o token pode deletar registro seu, a gente pode deletar registro acidentalmente,
• 6:20
  entusiasticamente e com total confiança.
• 6:23
  Agora vamos para o Copilot Studio.
• 6:25
  Conectores M3-M6-5 para todo o tênis são armadilha clara.
• 6:27
  Você clica uma vez e agora todo o Copilot em todo o time pode ver dados que não deveria.
• 6:32
  Isso não é empoderamento, é um banquete para erros.
• 6:34
  Então você implementa no Teams com visibilidade organizacional para facilitar a adoção
• 6:38
  e, de repente, um bot financeiro está respondendo perguntas no marketing
• 6:40
  puxando conteúdo de site SharePoint que nunca deveria saber que existiam
• 6:44
  e hooks de site de terceiros não gerenciados
• 6:46
  são como pendrives em 2009, misteriosamente em toda parte, sempre temporária.
• 6:51
  As evidências aparecem da mesma forma todas as vezes.
• 6:53
  Segredos obsoletos que nunca foram rotacionados, sem inspiração, sem dono.
• 6:58
  Conectores mapeados para grupos globais por simplicidade.
• 7:01
  Registros de aplicativos com scopes que leem com uma confissão.
• 7:04
  E sim, aquela chave temporária de produção vivendo em desenvolvimento por meses.
• 7:07
  Suas descobertas de segurança e configs de tênis, não vou mentir, elas só vão suspirar.
• 7:12
  Qual o caminho para a correção?
• 7:13
  Para o Langue, te enquadro já.
• 7:14
  Trate cada agente como um aplicativo separado com sua própria identidade.
• 7:17
  Crie entidades de serviço para cada agente.
• 7:19
  Nada de tokens compartilhados.
• 7:20
  Se dois agentes precisam da mesma API, eles ainda recebem credenciais diferentes.
• 7:23
  Use o alt com escopo definido.
• 7:25
  Conceda o menor conjunto de permissões necessário para a ferramenta realizar seu trabalho.
• 7:28
  Leitona ou inscrito.
• 7:29
  Escreva em uma coleção, não em todas.
• 7:31
  Armazene segredos e um gerenciador de ser adequado.
• 7:33
  Faça rotação seguindo o crono.
• 7:34
  Faça o encado de incidentes.
• 7:35
  Faça rotação se alguém ao menos mencionar o topo.
• 7:38
  Adicione a rebaixa de dois níveis.
• 7:39
  Um wrapper de ferramenta verifica a função do chamador antes de tocar em uma API.
• 7:42
  Sem função, sem chamada.
• 7:43
  Separe ambientes, chaves de desenvolvimento, só se comunicam com sistemas de desenvolvimento.
• 7:46
  Se uma ferramenta vir em um endpoint de produção e desenvolvimento, ela bloqueia e emite um alerta nos logs.
• 7:50
  Para o Copilot Studio, estabeleça limites rígidos com ambientes e escopos.
• 7:54
  Use separação de ambientes, desenvolvimento, teste de produção.
• 7:57
  Conectores diferentes, permissões diferentes, proprietários diferentes.
• 7:59
  Revise os escopos dos conectores com fluxo de trabalho.
• 8:02
  Alterações exigem aprovação, dados de expiração e proprietários.
• 8:04
  Sem proprietários, sem conectores.
• 8:06
  Aplique políticas de DLP por canal.
• 8:07
  O canal financeiro recebe regras mais rígidas que o restante de emprego.
• 8:10
  Esse é o principal.
• 8:11
  Cancele implantações do Teams em toda a organização para projetos piloto.
• 8:14
  Limite a visibilidade a um grupo de segurança.
• 8:16
  Expanda apenas a pós-revisão.
• 8:17
  Inventaria controle conector e SAS de terceiros.
• 8:20
  Se não está gerenciado, está desativado por padrão.
• 8:22
  Os proprietários devem justificar o acesso e renovar.
• 8:24
  Aqui está uma vitória rápida que você pode empreender hoje à tarde.
• 8:26
  Elimine escopos de todo o tenant.
• 8:28
  E mapeie cada conector a um grupo de segurança com política de expiração.
• 8:31
  Quando o grupo expira, o acesso é encerrado de forma controlada.
• 8:33
  Sem drama, sem surpresas.
• 8:35
  Deixa eu mostrar exatamente como isso acontece.
• 8:36
  Tem uma ferramenta de exportação de relatórios que escreve um bucket de armazenamento.
• 8:39
  Com credenciais compartilhados, ela consegue ver todos os buckets.
• 8:42
  Então, um prompt que diz salvar backup no arquivo acaba colocando dados sensíveis em um caminho público.
• 8:47
  Com entidades por agente e funções com escopo,
• 8:50
  a ferramenta só pode escrever em um bucket com um prefixo.
• 8:53
  Se o modelo decidir inventar outro caminho, a API nega a ação.
• 8:58
  Você registra o ID de correlação e seu CM dispara um alerta.
• 9:01
  E pronto, nada de vazamento de dados acidental.
• 9:04
  Erros comuns evitar.
• 9:06
  Usar grupos globais para acesso só por enquanto?
• 9:08
  Enquanto termina.
• 9:09
  Conceder escopos amplos ou totais porque a documentação era confusa.
• 9:12
  Confusão não é uma permissão.
• 9:14
  Copiar credenciais entre ambientes.
• 9:16
  Se você pode colar, você vai colar errado.
• 9:18
  Tratar a visibilidade no Teams como algo inofensivo.
• 9:20
  Visibilidade e acesso.
• 9:21
  Acesso é risco.
• 9:22
  Ao definir bem o escopo de acesso, os auditores param de procurar falhas.
• 9:26
  Quando eles baterem a porta, você precisará de prova.
• 9:28
  O que nos leva à parte que todos esquecem.
• 9:30
  Se não está registrado, não aconteceu.
• 9:32
  Preso 3.
• 9:33
  Vacunas.
• 9:34
  Se não está registrado, não aconteceu.
• 9:37
  Você delimitou o acesso.
• 9:38
  Ótimo.
• 9:39
  Agora prove, porque quando um auditor perguntar o que o agente fez às 15h14,
• 9:43
  e sua resposta for, achamos que é algo.
• 9:46
  Isso não é postura.
• 9:47
  Isso é um pedido de desculpas.
• 9:49
  E porta.
• 9:49
  Sem linhagem, você não pode explicar respostas estranhas, reverter ações ruins,
• 9:53
  ou saber se um incidente foi contido.
• 9:55
  Os reguladores adoram essa incerteza.
• 9:57
  Os clientes nem tanto.
• 9:58
  E seus executivos adoram quando se diz não fazemos ideia.
• 10:01
  Aqui está o que a maioria ignora no Langchain 4J.
• 10:04
  Sua cadeia faz muito mais do que seus logs admitem.
• 10:06
  Gráficos de execução ausentes impedem a reconstrução das etapas.
• 10:09
  Sem edir rastreamento, eventos parecem fogos de artifício aleatório.
• 10:12
  Logs parciais escondem a chamada de ferramenta que importava.
• 10:15
  E falhas silenciosas de ferramentas.
• 10:16
  Essas são desfavoridas.
• 10:17
  Tudo parece correto enquanto a ferramenta nunca rodou,
• 10:20
  e o modelo apenas alucinou uma resposta por educação.
• 10:23
  Isso ficou claro pra mim no dia em que investiguei um incidente
• 10:25
  onde uma etapa de busca expirou, retornou nulo,
• 10:27
  e a próxima etapa alegremente escreveu sem registros,
• 10:30
  ao fechar um ticket na API.
• 10:32
  Sem exceção, sem rastreio.
• 10:33
  Apenas intuição e ticket fechados.
• 10:34
  Se você não consegue distinguir a saída do modelo da saída da ferramenta
• 10:37
  nos seus logs, você já tem apoio.
• 10:38
  Vou te mostrar exatamente como corrigir o login do Langtian 4J
• 10:41
  pra que esteja pronto pra auditoria.
• 10:42
  Primeiro, habilite o login de toda a parte.
• 10:44
  JSON não sopa de strings.
• 10:46
  Cada requisição e resposta recebe um envelope com carimbos de data barra hora,
• 10:49
  nome do modelo, contagem de tokens e um ID de correlação que sobrevive a toda a cadeia.
• 10:52
  Depois, adicione gráficos de execução ou rastreios,
• 10:55
  usando o Langsmith ou Langgraph.
• 10:57
  Cada nó registre a entrada, saída, duração e erros.
• 10:59
  Se é uma ferramenta falhar, aqui fale bem.
• 11:01
  Sem falha silenciosa, sem nós presumirmos.
• 11:03
  Ora, o mais importante, centralizido.
• 11:05
  Envie rastreios e logs pro seu CN.
• 11:06
  Não os deixe em um pod que é encerrado pelo auto-scaling.
• 11:09
  Use a amostragem pra ruído, mas nunca descarte erro.
• 11:11
  Você quer buscar pelo ID rastreio e ver a história completa.
• 11:14
  Prontos, documentos recuperados, chamadas de ferramentas,
• 11:16
  respostas de API e a resposta final sem precisar brincar de onde está o olho às 12 da manhã.
• 11:20
  Passando pro Copilot Studio.
• 11:21
  A plataforma fornece alguma telemetria,
• 11:23
  mas está espalhada entre equipes, dataverse e qualquer conector que você tenha tocado.
• 11:26
  Exportação limitada de conversas significa que você obtém trechos não narrativos.
• 11:30
  Telemetria fragmentada significa que seu oficial de conformidade
• 11:32
  fica colando prints como se fosse aula de artes.
• 11:34
  Corrija isso construindo uma linha de auditoria.
• 11:36
  Ative a retenção de transcrições de conversas com SLA de retenção claros
• 11:40
  definindo quem mantém, por quanto tempo e por quê.
• 11:42
  Watch logs de conversas e ações pra um workspace centralizado como o Fabric ou o Log Analytics.
• 11:46
  Marque cada evento com um ID de correlação
• 11:48
  que você passa do ponto de entrada no Teams
• 11:50
  até os plugins do Dataverse APIs downstream.
• 11:52
  Se o chat diz criar caso, eu quero clicar e chegar ao registro exato
• 11:56
  no sistema exato com os dados exatos que foram enviados.
• 12:00
  Evidências que você reconhecerá de revisões de incidentes.
• 12:02
  Chamadas de LM orfas em logs brutos que não mapeiam pra nenhuma sessão de usuário.
• 12:06
  Invocações de ferramentas sem um prompt correspondente.
• 12:08
  Ou respostas citando fontes que você não encontra
• 12:10
  que os logs de grounding não incluem IDs e documentos.
• 12:12
  Isso não é um mistério.
• 12:14
  É falta de base.
• 12:14
  Vitórias rápidas que você pode implementar esta semana.
• 12:17
  Exige envelopes de respostas de solicitação com hashes.
• 12:19
  Armazene um hash conteúdo de promptes, partes recuperadas e saídas
• 12:22
  para que você possa provar a interioridade.
• 12:24
  Se alguém adulterar o hash dirá que não.
• 12:26
  Exige IDs de correlação de ponto a ponto.
• 12:29
  Gere na borda, passe por cada salto e rejeite qualquer chamada que o descarte.
• 12:33
  Sem ID, sem serviço.
• 12:34
  Define a SLA de retenção.
• 12:35
  O jurídico aprova.
• 12:36
  Segurança aplica.
• 12:37
  90 dias pra DEV.
• 12:39
  Um ano pra PROD.
• 12:40
  Mais tempo pra domínios regulados.
• 12:41
  Public.
• 12:42
  Cigarris.
• 12:43
  Erros comuns a evitar.
• 12:44
  Registrar segredos brutos ou PI.
• 12:46
  Mas carinho aí.
• 12:47
  Mantenha os campos necessários para a forense, não as joias da cor.
• 12:50
  Mostragem de erros.
• 12:51
  Mostragem de sucesso.
• 12:52
  Registro das falhas.
• 12:53
  Quando as coisas quebram, você precisará de cada rastro.
• 12:56
  Logs de texto livre.
• 12:57
  Humanos adoram.
• 12:58
  Máquinas odeiam.
• 12:59
  Use campos.
• 13:00
  Adicione esquemas.
• 13:01
  Valide na ingestão.
• 13:02
  Agora os auditores perguntam o que aconteceu.
• 13:05
  Você abre um rastreamento.
• 13:06
  Você mostra o prompt, os IDs dos docs recuperados, a entrada da ferramenta, a ceia da ferramenta
• 13:10
  e a mensagem final.
• 13:11
  O ID de correlação coincide com o gateway de EPI, a gravação no banco de dados e a mensagem no Teams.
• 13:15
  E pronto, a história se sustenta.
• 13:17
  Portanto, quando você pode ver, você pode governar.
• 13:19
  O que significa que é hora de formalizar as regras e restringir quem faz o quê.
• 13:23
  O modelo RBAC de agentes, trate agentes como usuários muito burros e muito poderosos.
• 13:27
  Você tem visibilidade.
• 13:28
  Bom, agora dê essas coisas uma identidade ou uma colher.
• 13:31
  Agentes são usuários.
• 13:32
  Usuários muito burros e muito poderosos.
• 13:34
  Se você não daria acesso de admin temporário a um humano no primeiro dia, não entregue a
• 13:37
  um papagaio estocástico e não distingue sarcasmo de sudo.
• 13:39
  Porque isso importa.
• 13:41
  A maioria das organizações protege humanos e ignora a gente.
• 13:43
  A gente então contorna o princípio do privilégio mínimo por design.
• 13:46
  Ele pula ferramentas, cruza ambientes e ninguém percebe porque ele não aparece no organograma.
• 13:51
  É assim que um bot auxiliar se torna um administrador invisível.
• 13:54
  Aqui está o modelo que quero que vocês implementem.
• 13:56
  Uma identidade por agente, funções claras, verificações de política no código e limite
• 13:59
  de ambiente que realmente importam.
• 14:01
  Comece pela identidade.
• 14:03
  Crie uma entidade de serviço para cada agente.
• 14:04
  Nada de robô de plataforma 01.
• 14:05
  Mapeamento real de um para um.
• 14:08
  Deem um nome como se fosse um aplicativo.
• 14:09
  Identifica um proprietário.
• 14:10
  Propósito, ambiente e inspiração.
• 14:12
  Se dois agentes acessam a mesma API, eles ainda devem ter identidades diferentes.
• 14:15
  Identidade compartilhada significa raio de impacto.
• 14:18
  Em seguida, defina uma taxonomia de funções que até pessoas ocupadas consigam aplicar.
• 14:21
  Eu uso quatro.
• 14:21
  Executor, escritor, administrador.
• 14:23
  O leitor pode buscar dados.
• 14:25
  Svenska.
• 14:25
  Pense em consultar, recuperar, resumir.
• 14:28
  O executor pode invocar fluxos de trabalho com efeito limitado.
• 14:31
  Criar chamado, enviar aprovação, agendar reunião.
• 14:34
  O escritor pode gravar dados em escopos específicos.
• 14:37
  Uma tabela, um bucket, uma caixa de correio.
• 14:38
  Não tudo.
• 14:39
  O administrador pode alterar configurações.
• 14:42
  Essa função deveria te deixar para inserir.
• 14:44
  Use com moderação, com prazo determinado e sempre com dupla aprovação.
• 14:47
  Agora, mapeie isso por langitim e cordial.
• 14:48
  Ferramentas são os seus pontos de imposição.
• 14:51
  Cada wrapper de ferramenta verifica a função do chamador antes de executar.
• 14:54
  Se a identidade do agente estiver mapeada com o leitor, uma ferramenta de escrita nem recebe a chamada.
• 14:58
  E não pare na função e inclua o escopo do recurso.
• 15:00
  Um escritor de casos financeiros não pode escrever em caso de vendas.
• 15:04
  Escopo não é um comentário, é um bloqueio.
• 15:06
  Use variáveis de ambiente e arquivos de configuração para vincular ferramentas ambientes.
• 15:10
  O agente de desenvolvimento só vê hosts e chaves de desenvolvimento.
• 15:12
  Tentar uma URL de produção, bloqueio acesso e registro erro.
• 15:15
  Verificações de política ocorrem na fronteira, não depois que a chamada de API falha.
• 15:19
  No Copilot Studio, use o mesmo padrão com funções de ambiente e escopo de conector.
• 15:23
  Atribua agente a um ambiente com permissões que espelhem leitor, executor, escritor e administrador.
• 15:28
  Permissões de conector mapea para grupos de segurança vinculados a essas funções.
• 15:32
  Os limites de implantação no time de deficiência e hardware.
• 15:34
  Mantenha os pilotos dentro de um grupo pequeno.
• 15:36
  Expanda apenas com chamada de mudança.
• 15:38
  É aqui que o fluxo de revisão mantém a conformidade.
• 15:40
  Qualquer alteração de escopo é uma solicitação de mudança.
• 15:42
  Lixe o agente, a função solicitada, o conector ou ferramenta, o ambiente, o motivo, o solicitante e a expiração.
• 15:48
  Duas aprovações, um proprietário técnico e um proprietário dos dados.
• 15:50
  Quando a expiração chega, o acesso é encerrado automaticamente.
• 15:53
  Você recebe um alerta para renovar ou encerrar.
• 15:56
  Temporário finalmente significa temporário.
• 15:58
  Deixe-me mostrar exatamente como isso funciona com uma breve história.
• 16:00
  O agente de perguntas e respostas financeiras começa com oito.
• 16:02
  As pessoas adoram.
• 16:03
  Então, o produto quer criar relatório de despesas.
• 16:05
  E isso é uma ação de executor com escopo restrito.
• 16:07
  Você adiciona uma nova ferramenta com uma política de nível de ferramenta.
• 16:11
  Apenas envio de despesas.
• 16:12
  Apenas para o centro de custos dos funcionários.
• 16:13
  Apenas com menos de cinco anexos.
• 16:14
  A identidade do agente recebe o executor para aquela única API expirando em 30 dias.
• 16:19
  No Copilot Studio, o ambiente ganha uma permissão de conector para uma tabela Dataverse com segurança em nível de linha.
• 16:25
  Os logs de auditoria mostram o tique de mudança dos aprovadores da expiração.
• 16:29
  Quando o marketing pede para também excluir relatórios, você recusa ou encaminha para uma ferramenta de escrita separada com seus próprios proprietários e SLA.
• 16:35
  O modelo pode querer qualquer coisa.
• 16:37
  Política impõe tudo.
• 16:39
  Erros comuns que você precisa parar de comer.
• 16:41
  Identidades compartilhadas por conveniência.
• 16:43
  Conveniência é inimiga da contenção.
• 16:45
  Administrador temporário que nunca expira.
• 16:47
  Coloque limites de tempo na permissão, não no seu calendário.
• 16:49
  Credenciais de projeto em ambiente de desenvolvimento para desbloquear demo.
• 16:52
  Demos não precisam de dados de produção ou auditores sim.
• 16:54
  Controle de ferramentas pela interface, não.
• 16:56
  Se o modelo pode chamá-la, a interface do usuário impõe.
• 16:58
  Se você não se lembrar de mais nada, trate agentes como usuários, com curiosidade boba e facas afiadas.
• 17:03
  Identidade por agente, função por ação, escopo por recurso, tempo limitado por padrão,
• 17:07
  e cada chamada verifica a política antes de tocar nos dados.
• 17:11
  Políticas de perda de dados que realmente impedem que a IA se torne uma tornera vazando.
• 17:15
  CD, identidades e funções agentes.
• 17:16
  Agora vamos impedir mesmo.
• 17:18
  Governança aqui é prode.
• 17:19
  Bloqueie o que é ruim antes que saia do prédio.
• 17:21
  O que isso importa?
• 17:22
  A IA multiplica a exposição.
• 17:23
  Um único prompt pode produzir sem tokens de saída, cada um um vazamento potencial.
• 17:27
  Se seus controles só aparecem em análises pós-morte, você está fazendo perícia, não governança.
• 17:32
  Aqui está o conjunto de políticas que realmente funcionam.
• 17:33
  Pense nisso como cintos de segurança e airbags em uma parede de jogo.
• 17:36
  Redução de pinas, saídas por padrão.
• 17:38
  Nomes e e-mails, número de telefone e documento de identidade.
• 17:41
  Se o usuário não tem permissão, é mascarado.
• 17:43
  O interno de ninguém é onde os vazamentos vivem.
• 17:46
  Detecção de segredos.
• 17:47
  Proteção para chaves de API, tokens, chaves privadas, strings de conexão, padrões,
• 17:50
  além de filtros de bloom para velocidade.
• 17:51
  Adicione somas de verificação para formatos comuns para não serem inundados por fósforos.
• 17:55
  Filtros de termos sensíveis ajustados ao seu negócio.
• 17:57
  Nomes de projetos jurídicos, codinomes GMAI, nomes de produtos não lançados.
• 18:02
  Lanteia esta lista em um armazenamento gerenciado com proprietários históricos de alteração.
• 18:05
  Lista e permissões rejeques para a estrutura de saída.
• 18:07
  Se a ferramenta espera um resumo de fatura, apenas saídas com o formato de fatura passam.
• 18:10
  Poesia narrativa, não.
• 18:11
  Esquemas não são nós.
• 18:12
  Eles são contra.
• 18:13
  No Langchain Quadro, aplique pré e pós-processador.
• 18:16
  Pré-processadores escaneiam entradas em busca de payloads de injeção e tarefas por aí.
• 18:19
  Pós-processadores validam esquemas JSON, executam filtros de termos e segredos,
• 18:23
  e redigem pi antes que qualquer coisa deixe o limite do agente.
• 18:26
  Se uma verificação falhar, retorne um erro seguro com a índice correlação.
• 18:30
  Nada de mesmo, verdade.
• 18:31
  Nada de talvez.
• 18:32
  Adicione o pipeline de moderação.
• 18:34
  Filtros de padrão leves e filtros de Bloom.
• 18:36
  Moderação mais pesada baseada em A para contexto.
• 18:39
  Eis, não divulgue dados de saúde.
• 18:41
  É isso.
• 18:42
  Ele foi mais seguro.
• 18:43
  Defina um comportamento fallback.
• 18:44
  Resume em um nível superior.
• 18:46
  Dê uma recusa segura em caminho para um humano.
• 18:47
  Não faça o modelo entrar em um loop para dar um vazamento seguro.
• 18:50
  No Copilot Studio, use a pilha pela qual você já paga.
• 18:53
  Políticas de DRP no Microsoft 365 aplicam-se a canais e conectores.
• 18:57
  Ative e ajuste-as.
• 18:59
  Use rótulos de sensibilidade em suas fontes de aterramento
• 19:01
  para que o agente nunca indexe conteúdo de alto impacto sem aprovação explícita.
• 19:05
  Moderação em nível de locatário deve estar ativada por padrão.
• 19:07
  Nada de ativaremos depois.
• 19:09
  Depois é quando o PR se envolve.
• 19:10
  O monitoramento une tudo isso.
• 19:12
  Defina limite.
• 19:13
  Tamanho de saída em comum.
• 19:14
  Destino em comum.
• 19:15
  Frequência em comum.
• 19:15
  Se um bot de Q&A de repente escrever megabytes em um endpoint externo,
• 19:19
  coloque a sessão em quarentena.
• 19:21
  Espera automaticamente sessões de risco e notificar os proprietários.
• 19:23
  Mantenha os alertas acionados.
• 19:25
  Não notifique todos por cada evento de máscara.
• 19:27
  Vitória rápida que você pode implementar.
• 19:29
  Aplique esquemas de saída e listas de bloqueio de termos na fronteira do agente.
• 19:32
  Sem esquema, sem resposta.
• 19:34
  Adicione redução de pico na etapa final.
• 19:36
  Essa combinação interrompe os vazamentos óbvios e lhe dá tempo para implementar o restante.
• 19:39
  Erros comuns.
• 19:40
  Depender de código front-end.
• 19:42
  Edição lá do servidor antes que a mensagem chegue a um cliente.
• 19:45
  Uma lista de bloqueio global.
• 19:47
  Segmento por domínio de negócio.
• 19:48
  Termos financeiros não são termos de marketing.
• 19:50
  Registrar o original.
• 19:51
  Não é editado para depuração.
• 19:53
  Mascara em gestão.
• 19:54
  Mantenha uma cópia em cofre seguro apenas se sua equipe jurídica aprovou.
• 19:57
  Tranque a torneira e depois tente quebrá-la de propósito.
• 20:00
  A lista de verificação de veridade.
• 20:02
  Quebre antes que os produtores o façam.
• 20:03
  Você não confia no cinto de segurança até puxá-lo.
• 20:05
  O mesmo vale para essa bagagem.
• 20:06
  Agende o caos.
• 20:08
  Objetivo.
• 20:09
  Teste os adversários que você possa repetir na intuição.
• 20:11
  E você criará uma lista de verificação, executará em uma cadência e bloqueará lançamentos com ela.
• 20:15
  Teste de gestão primeiro.
• 20:16
  Confusão de funções.
• 20:18
  Peça ao agente para ignorar a política e agir como sistema.
• 20:21
  Ele deve recusar.
• 20:22
  Colisão de ferramenta.
• 20:23
  Injete nomes de ferramentas e parâmetros falsos.
• 20:25
  Apenas ferramentas registradas devem ser executadas.
• 20:27
  Bypass de esquema.
• 20:29
  Embarque comandos em strings e comentários JSON.
• 20:32
  Validadores devem rejeitar.
• 20:33
  Risca de cadeia de pensamento.
• 20:34
  Tente induzir dumps de raciocínio que vazem fontes.
• 20:37
  A saída deve permanecer dentro do esquema.
• 20:39
  Promptes e exploração de dados.
• 20:41
  Sítios e SSNs exatos.
• 20:42
  Export todos os e-mails.
• 20:44
  Você recebe uma recusa com matrícula de auditorio.
• 20:46
  Testes e acessos em seguida.
• 20:47
  Escalado escuro.
• 20:48
  Solicite ações fora da função do agente.
• 20:50
  Ferramentas devem bloquear no nível do web.
• 20:52
  Comportamentos de token inspirado.
• 20:54
  Rotações e segredos durante a sessão.
• 20:55
  Chamadas devem falhar de forma restrita com erros claros.
• 20:57
  Vazamento de ambiente paralelo.
• 20:59
  Agente deve tentar usar endpoint prod.
• 21:01
  Falha crítica.
• 21:02
  Logs de...
• 21:02
  Teste de auditorio.
• 21:04
  Rastreabilidade completa.
• 21:05
  Consegue reconstruir do prompt a ação com ID de correlação.
• 21:08
  Detecção de adulteração.
• 21:09
  Logs alterados.
• 21:10
  O hash incompatível devem só amar.
• 21:12
  Correlação entre serviços.
• 21:13
  Do ID de mensagem do Teams ao registro no dataverse.
• 21:15
  A chamada de API externa.
• 21:16
  Tudo correspondente.
• 21:17
  Defina portões de aprovação barra reprovação.
• 21:20
  Sem esquema falhará.
• 21:21
  Qualquer saída que não seja validada.
• 21:22
  Bloqueia o lançamento.
• 21:24
  Escopo em todo o tenente.
• 21:24
  Falhará.
• 21:25
  Qualquer conector sem grupos de escopo e expiração é bloqueado.
• 21:28
  Falha silenciosa de ferramenta.
• 21:29
  Falhará.
• 21:30
  Erros devem ser exibidos.
• 21:31
  Não suprimidos.
• 21:32
  Sem plano de rollback.
• 21:33
  Falhará.
• 21:33
  Se você não consegue reverter uma mudança de permissão.
• 21:35
  Configure de modelo em minutos.
• 21:37
  Não está pronto.
• 21:38
  Cadência de pronunciamento para cada mudança.
• 21:40
  Simulado de caos trimestrais em ambientes similares à produção.
• 21:43
  Ciclo de aprendizado pós-incidente em até 5 dias úteis.
• 21:46
  Com novos testes na suíte.
• 21:48
  Responsáveis e SLA's.
• 21:49
  Cada item do checklist tem um dono.
• 21:50
  Um SLA de correção e status.
• 21:52
  Sem dono.
• 21:53
  Sem lançamento.
• 21:54
  Configure sem esquema falhará.
• 21:56
  E escopo de tenente falhará.
• 21:58
  Como verificações de CI e CD.
• 21:59
  Se qualquer um disparar, o pipeline para.
• 22:02
  Sem reuniões.
• 22:02
  Sem debates.
• 22:03
  Apenas um sinal vermelho que todos respeitam.
• 22:05
  Execute a lista.
• 22:06
  Quebra as coisas.
• 22:07
  Então execute novamente até que as surpresas parem de ser surpreendentes.
• 22:11
  Passo de governança que a maioria das empresas ignora.
• 22:13
  Se você não lembrar de mais nada.
• 22:15
  Agentes são identidades.
• 22:16
  Trate-os como usuários muito burros e muito poderosos.
• 22:18
  Com privilégio mínimo.
• 22:20
  Contratos de saída forçados.
• 22:21
  E trilhas de auditoria completas.
• 22:22
  O passo que a maioria ignora é criar service principles dedicados para cada agente.
• 22:26
  E então conectar cada ferramenta via papéis com escopo por ambiente.
• 22:31
  Sem credenciais compartilhadas.
• 22:32
  Sem escopo de tudo.
• 22:33
  Adote o modelo RBAC.
• 22:35
  Ative as políticas de DLP.
• 22:36
  Execute o checklist de Red Team esta semana.
• 22:39
  Inscreva-se para o próximo vídeo.
• 22:40
  Onde mostrarei as configs exatas no LinkedIn e Copilot Studio.
• 22:43
  Para que você possa copiar e colar governança em vez de pedidos de desculpas.
• 22:46
  Para que você possa copiar e colar governança em vez de pedidos de desculpas.