Latest / M365.FM – Podcast de Microsoft 365, Copilot e IA em português / Sistemas multiagente com Azure AI Foundry: planejamento, colaboração e ferramentas sem derrubar a produção (Dublagem IA)

Transcript

Sistemas multiagente com Azure AI Foundry: planejamento, colaboração e ferramentas sem derrubar a produção (Dublagem IA) · M365.FM – Podcast de Microsoft 365, Copilot e IA em português

0:00
Subchat, bots, conversam, agentes, agentes, sistemas multiagentes realmente fazem as coisas acontecerem.
0:04
Se você já implorou para um bot consertar o Intune e ele respondeu com um poema, isso é para você.
0:08
O esquema é o seguinte, estilo Netflix, mão na massa.
0:10
Você assiste com uma coisa.
0:11
Eu cuido da parte perigosa do service principal para que ninguém destrua a produção.
0:14
Vamos construir um mini sistema multiagente autocurável e governado com Azure AI Foundry e Semantic Kernel,
0:20
ou de contato reais.
0:22
Intune entra Graph Azure Automation Log Analytics.
0:26
Um agente versus multiagente, frente a frente, 12 minutos contra 3.
0:28
E a única vítima é o crédito da minha assinatura.
0:32
Primeiro, porque um agente trava enquanto times decola.
0:34
Porque um agente só não é suficiente.
0:36
Agentes únicos são como aquele canivete suíço que você compra em posto de gasolina.
0:39
Tecnicamente tem ferramentas, mas na prática ele entorta no primeiro parafuso.
0:42
Você empilha planejamento, raciocínio, execução, aprovações e relatórios em um prompt só,
0:46
e agora ele fica sem contexto lento e estranhamente confiante no que está errado.
0:50
A maioria das pessoas acha que modelo maior, cérebro maior, pronto, problema resolvido.
0:53
Mas a verdadeira falha é a confusão de papéis.
0:55
Um agente tentando planejar uma mudança, chamar o Graph, escrever um script de remediação,
0:59
pedir aprovação, verificar o resultado e documentar tudo.
1:03
É como gerenciar um helpdesk, um comitê de mudanças e uma análise pós-incidente com um único estagiário muito cansado.
1:08
Veja o que realmente é bom.
1:09
O agente único tenta equilibrar estado demais.
1:11
Seu prompt vira um romance.
1:12
A janela de contexto se enche de logs, políticas e metade do glossário de MDM.
1:16
Então ele ou corta as partes importantes ou alucina detalhes faltantes.
1:19
A latência dispara, os tokens queimam e as tentativas de repetição parecem um déjà vu com uma conta.
1:23
Aí entram os multiagentes, papéis, limites e paralelismo.
1:28
O planejador foca na intenção e nas restrições.
1:30
O operador foca nas ferramentas e na execução.
1:33
O revisor foca nas diretrizes e aprovações e estamos baseados em fatos.
1:37
Cada agente mantém um conjunto de instruções curto e limpo, com a memória mínima necessária.
1:42
Eles passam mensagens, resultados de ferramentas ou um resumo curto na internet inteira.
1:46
Por que isso importa na empresa?
1:47
Você precisa de fluxos de trabalho completos com supervisão humana, ações baseadas em identidade, tentativas e trilha de auditoria.
1:52
Isso não é um chat de linha única.
1:54
Isso é um trabalho em equipe.
1:55
Padrão planejador, executor e revisor reduz riscos e retrabalho porque cada etapa tem um segundo par de olhos automatizados
2:01
e que não precisam de uma reunião rápida no Team Sims.
2:04
Custe latência também sem ganhando.
2:06
Use modelos de linguagem pequenos para extração e classificação.
2:09
Use modelos de raciocínio premium apenas onde o planejamento ajuda.
2:12
Use processamento em lote para resumos enquanto os usuários dormem.
2:14
Você terá menos alucinações, resultados mais rápidos e contas menores.
2:18
Uma breve história.
2:19
Vem um bot faz tudo tentar rotacionar um segredo.
2:22
Ele atualizou a chave.
2:24
Esqueceu a configuração do app e consertou, deletando o recurso.
2:27
Foi nesse dia que inventamos o agente revisor.
2:30
Sistemas multiagentes 101, claro e simples.
2:32
Ok, então o que é um sistema multiagente que você realmente consegue entregar?
2:35
Pense em uma equipe digital, não em um super-servo.
2:37
Cada agente tem uma função, conjunto restrito de instruções e ferramentas limitadas.
2:41
Planejador.
2:43
Entende objetivas, restrições e o ambiente.
2:46
Produz um plano com chamadas de ferramentas que o operador pode executar.
2:50
Operador.
2:51
Chama ferramentas, graph, logic apps, funções, runbooks do Azure Automation e retorna resultados estruturados.
2:58
Revisor.
2:58
Verifica fundamentação, conformidade, aprovações e segurança antes de qualquer ação de risco.
3:03
Mensageiro barra conciagem cuida de notificações humanas, aprovações e resumos para trilhas de auditoria.
3:10
Eles se comunicam por mensagens e contexto compartilhado como adultos.
3:13
Curto, claro e apenas o necessário.
3:15
Sequencial quando ações dependem de resultados anteriores.
3:18
Paralelo quando subtarefas podem ser distribuídas com segurança.
3:21
Você não envia uma política de 50 páginas.
3:23
Envia o trecho relevante.
3:24
Usa edis do dispositivo e a alteração pretendida.
3:26
As ferramentas são as mãos.
3:27
API's REST para Microsoft Graph.
3:29
Hag via Azure AI Search para conhecimento curado.
3:32
Interpretador de código para snippets.
3:33
Logic Apps para sequências, funções como cola e Azure Automation para tarefas repetitivas.
3:38
Mantenha as entradas das ferramentas estruturadas com esquemas para que o operador não delete seu tenant criativamente.
3:43
Memória não é mágica, é um orçamento.
3:45
Minimize a memória por agente.
3:47
Use estado externo, índices de busca, bancos vetoriais ou um pequeno armazenamento de estado para metadose track.
3:51
Mantenha janela de contexto em chão.
3:53
Se não é necessário para a próxima decisão, não deve ser carregado junto.
3:55
O planejamento versus execução é onde o semantic kernel brilha.
3:58
O planejador delega ou o operador escolhe a ferramenta certa com catálogo de funções.
4:02
O revisor critica saídas com promptes de avaliação e segurança de conteúdo.
4:06
Se o revisor sinalizar um risco de escopo, o planejador revisa.
4:09
Ao entender esse ciclo, você para de escrever promptes de 800 palavras e começa a definir papéis claros.
4:14
Limites de segurança são inegociáveis.
4:16
Identidade limitada em chamadas de ferramentas com identidade gerenciada.
4:19
Permissões de agente divididas entre leitura e gerenciamento.
4:22
PIN para elevação em ações destrutivas.
4:24
Todas as chamadas de ferramentas registradas no Ognari.
4:27
Segurança de conteúdo tanto na entrada quanto na saída.
4:29
Prom shields para jailbreaks e injeções indiretas de fontes de conhecimento.
4:33
Hora da analogia.
4:34
Pesquisador, analista, operador, QA.
4:37
Cada um é responsável por sua parte.
4:39
O operador não aprova sua própria alteração.
4:41
O analista não mexe na produção.
4:43
O QA não escreve o código que está aprovando.
4:46
Honório.
4:46
Segundo.
4:46
O QA e Júriar e Founder mais Semantic Kernel.
4:50
O Founder é a extração de agentes, escolhas de modelos, fundamentação de conhecimento, conexão de ferramentas, segurança de conteúdo, rastreamento, avaliações e coordenações no seu lugar.
4:58
O Semantic Kernel oferece planejadores, habilidades, pipelines, novas tentativas e cancelamento em código.
5:02
Juntos, você mistura modelos por função.
5:06
SLMs para extração, classe GPT-4 para planejamento, processamento em lote para resumos, mantendo promptes curtos, raio de impacto pequeno e seus fins de semana livres.
5:15
Agora vamos construir isso.
5:16
Como o Azure AI Founder possibilita fluxo de trabalho multiagentes?
5:19
É aqui que o Azure AI Founder deixa de ser apenas um portal atraente e começa a agir como um ambiente de produção.
5:24
O Founder oferece locais para definir agentes, conectar modelos, adicionar conhecimento, conectar ações e observar tudo sem precisar navegar em seis abas diferentes contando com a sorte.
5:31
É a orquestração sem improvisos.
5:34
Comece pelas definições dos agentes.
5:36
No Founder, cada agente recebe instruções, uma orientação de função precisa, não um manifesto.
5:41
Implantação, modelo real por trás dele.
5:43
Misture modelos, classe GPT-4 para planejamento com SLMs, classifique para extração.
5:47
Conhecimento, índices do Azure AI Search, arquivos carregados ou fundamentação no Bing quando desejar contexto da web.
5:52
Ações, ferramentas de API aberta, logic apps, funções, graphy, runbooks do Azure Automation ou interpretador de código para cálculos e análises rápidos.
6:00
Agentes conectados.
6:01
Sim, um agente pode tratar outro agente como uma ferramenta se isso mantiver as funções claras.
6:06
Isso é importante porque o Semanticern se conecta a esse mesmo universo.
6:10
No código, você cria planejadores, define habilidades e registra ferramentas em catálogos de funções.
6:14
Você coreografa o ciclo de planejador, operador e revisor, deixando o Founder cuidar dos tópicos históricos e travas de segurança.
6:21
Você mantém os prontos curtos e coloca o trabalho pesado em ferramentas com esquemas.
6:24
Tradução, menos alucinações, menos erros, mais fim de semana.
6:27
Escolha de modelos importa.
6:28
O Foundry abstrai a inferência ao primeiro do endpoint do modelo, para que você possa trocar modelos sem reescrever todo o seu aplicativo.
6:34
Dois caminhos comuns.
6:35
Endpoints sem servidor para modelos premium e iteração rápida.
6:38
Você paga por token em escala sob demanda e não precisa cuidar de GPUs como em 2018.
6:42
Computação gerenciada para modelos abertos e específicos que você deseja manter dentro do limite do seu tempo.
6:46
Você paga pelo tempo de atividade e controla o formato, mas a Microsoft cuida da infraestrutura de implantação.
6:50
Misture modelos por função.
6:52
Planejador no GPT-4 ou 4.1 Mini para raciocínio.
6:54
Operador em um modelo pequeno que se destaca em extração e estruturação de parâmetros.
6:58
Processe seus resumos longos durante a noite para que as pessoas recebam relatórios para amanhã.
7:02
E se um modelo for desativado, você quiser experimentar variantes do DeepSeq ou LAMA,
7:06
a API de inferência do Foundry permite manter seu código estável enquanto você experimenta.
7:09
Ferramentas e ações são onde o operador ganha seu mérito.
7:13
É aqui que você oferece poder real sem dar ao agente as chaves do seu reino.
7:17
Ferramentas de API aberta para serviços internos com sua águia.
7:20
Mantenha o contrato RIR.
7:21
Se o esquema diz que o dispositivo é uma stringa, é melhor que seja uma ID de dispositivo.
7:24
Lodge Caps para fluxo de aprovação e bloqueios humanos.
7:27
Deixe o revisor encaminhar as mudanças para um aprovador e então retomar a execução após o SIM.
7:31
Azure Functions para código de integração e transformações coerentes.
7:33
API de grafo pequena, testável e versionada para tarefas do Intune entre acesso condicional de dispositivos.
7:40
Deixe copos de leitura para agentes de monitoramento e apenas scopes de gerenciamento para remediadores.
7:44
Azure Automation para scripts de dispositivos e runbooks.
7:47
Trate isso como objetos cortantes e uma gaveta trancada.
7:50
Apenas o agente de reparo pode olhar.
7:52
Assim como o grounding e mantém-se curado,
7:54
use o Azure AI Search com classificação híbrida e reclassificação semântica.
7:58
Seguimente o conhecimento por domínio.
7:59
Políticas do Intune separadas dos POPs de integração.
8:02
Para não enviar tudo o que você tem de uma vez.
8:04
O operador deve passar um trecho, não a enciclopédia inteira.
8:07
Defina o tamanho dos fragmentos, armazena e citações e peça ao revisor que verifique a fundamentação antes que chegue à produção.
8:12
Segurança não é opcional.
8:14
Foundry já inclui filtros de segurança de conteúdo para entrada e saída,
8:16
proteção contra jailbreak e injeção indireta, além de verificações de material protegido.
8:20
Execute a segurança antes e depois do modelo para não pagar por entradas ruins ou gerar ações públicas.
8:25
Combine isso com identidade gerenciada por agente, R-back de privilégio mínimo,
8:29
e PM para elevação temporária em ferramentas destrutivas.
8:31
Cada chamada de ferramenta é rastreada.
8:33
Cada aprovação é registrada.
8:35
Se alguém perguntar quem executou o quê, você não precisa ver o Outlook.
8:38
O Log Analytics já sabe.
8:40
Observabilidade é modo profissional.
8:41
Ative o rastreamento para ver o histórico de execução.
8:44
Qual agente chamou?
8:45
Qual ferramenta?
8:46
Com quais parâmetros?
8:47
Qual latência?
8:47
E qual foi o retorno?
8:49
Conecte o application insights para padrões de desempenho, logs de aplicativo para auditoria
8:53
e envie avaliações para CI para detectar desvios em relevância, fundamentação e fluência
8:57
antes do usuário.
8:58
Se a fundamentação cair, o revisor sinaliza, o planejador refina a consulta de busca e o
9:02
operador tenta novamente.
9:03
Não é necessário o pânico humano.
9:05
Primitivas de implantação não têm tudo a organizar.
9:07
Use projetos do Foundry, pacotas de escopo de equipe e linhas de base de política.
9:10
Coloque o Azure API Management na frente do seu serviço de ferramentas para versionar,
9:13
limitar, implementar disjuntores e rotear entre PTU e inferências sob demanda.
9:17
Endpoints privados onde a residência de dados ou conformidade exige seriedade.
9:21
Regiões que correspondam aos seus usuários, não apenas às suas aspirações.
9:24
E sim, o Semantic Care não fecha o pacote.
9:27
Se inscreve o fluxo e trabalha em conta.
9:28
Decompõe as tarefas.
9:29
O operador escolhe as ferramentas com base em catálogos de funções e disponibilidade.
9:33
O revisor aplica verificações com prompts de avaliação e resultados de segurança de
9:37
conteúdo, e você obtém novas tentativas com back-off e tokens de cancelamento quando
9:41
uma API externa finge estar em manutenção.
9:44
O SK lhe dá o cérebro de execução, o Foundry lhe dá a sala de cirurgia.
9:48
Junte tudo e você terá um padrão prático.
9:50
Defina agentes no Foundry com instruções e identidades estritas,
9:53
orquestra funções no SK Fundamente com Pesquisa Curada.
9:56
Conecte ações com APIs abertas, logic apps, funções, automação, aplique segurança
10:00
antes e depois da inferência e observe tudo.
10:03
Entra diante da melhor maneira possível.
10:05
Como cinto de segurança ou não dar privilégios.
10:07
De administrador global ou estagiário chamado chave padrão.
10:11
Cenário de demonstração 1.
10:12
Limpeza de dispositivos, unidade de dispositivos fantasma do CS Intune.
10:16
Sabe aqueles dispositivos que aparecem como gerenciados, retirados e mortos-vivos ao mesmo tempo?
10:20
Bem-vindo ao CS Intune.
10:22
Nosso trabalho.
10:23
Encontra hardware obsoleto, duplicado ou não escrito e remediar com segurança e aprovação
10:27
para que ninguém envie e-mails furiosos para o jurídico.
10:29
Elenco de agentes.
10:31
Monitor.
10:31
Consultas.
10:32
Microsoft Graph e Log Analytics.
10:34
Classifica estados de dispositivos.
10:35
Sinaliza amalias.
10:36
O remediador chama o Intune e a automação do Azure para colocar em quarentena ou retirar dispositivos.
10:42
O auditor registra tudo, notifica os humanos e escreve o relatório pós-ação para conformidade.
10:48
O fluxo funciona assim.
10:49
O monitor extrai do Graph, registra os dispositivos, último check-in, estado de conformidade e tipo de inscrição.
10:54
O usuário principal é o sinalizador de retirada.
10:56
Ele também captura sinais do Log Analytics, pulsação do Defender, conformidade de atualização e eventos da extensão de gerenciamento do Intune.
11:03
Ele funde isso em um registro curto e estruturado por dispositivo.
11:06
Última visualização em ETC é inscrito, compatível, candidato a duplicata, sinais de risco.
11:10
Sem romances, apenas campos.
11:11
Agora a passagem do cérebro, o músculo.
11:13
O monitor envia uma classificação proposta.
11:15
Obsoleto, duplicado, sem pulsação normal.
11:17
O revisor verifica a fundamentação.
11:20
Esses campos realmente vieram do Graph e do LE.
11:22
A segurança de conteúdo é executada antes do modelo para bloquear a injeção de prompt de qualquer arquivo carregado ou fundamentação leve.
11:27
Se a classificação for aprovada, o remediador prepara as ações.
11:31
Primeira fase é a remediação leve, marcar e colocar em quarentena.
11:35
Aplicamos uma categoria de candidato a dispositivo retirado.
11:37
Removemos vínculos de grupos dinâmicos que disparam a expansão de políticas
11:40
e, se necessário, movemos o dispositivo para um grupo de quarentena do Azure AD que bloqueia o acesso.
11:45
As exclusões, por enquanto.
11:47
As aprovações caem em um logic app.
11:49
O revisor inclui um plano compacto, ID's de dispositivo, motivos, ações propostas e reversão.
11:55
O aprovador vê um resumo no Teams com citações para consultas do Graph e QQL do Log Analytics.
12:00
Ao aprovar, o token de sensor retorna, o remediador executa a retirada,
12:04
limpa como justificado ou remove duplicatas,
12:06
mantendo o dispositivo com a pulsação mais recente e desvinculando fantasmas.
12:10
A identidade herenciada mantém nossas mãos limpas.
12:12
Um monitor executado com permissão de leitura total de dispositivo.
12:14
O remediator usa uma identidade separada com permissões de leitura e escrita de dispositivo
12:18
e exatamente as permissões necessárias no intune.
12:20
A exclusão é protegida.
12:21
O agente remediador não pode elevar seus privilégios.
12:24
Quando a elevação é solicitada, o logic app exige um humano
12:27
e o temporizador da permissão começa a correr.
12:29
A observabilidade é a parte séria do processo.
12:31
Cada chamada de ferramenta é rastreada.
12:33
Quem chamou o quê? Parâmetros, latência, resposta.
12:35
O auditor grava registros de eventos no Log Analytics com IDs de correlação
12:39
para que você reconstrua a cena sem arqueologia no Slack.
12:42
É.
12:42
Também executamos uma etapa de avaliação, pós-alteração, fundamentação, relevância e fluidez.
12:46
Se a fundamentação cai, o revisor bloqueia ações destrutivas
12:49
e devolve o plano ao planejador para refinar a recuperação ou restringir o escopo.
12:53
Os modelos são misturados intencionalmente.
12:55
A classificação usa um modelo pequeno para manter o custo e a latência baixos.
12:58
Casos extremos, como dois dispositivos onde o Autopilot renomeou um e o Azure AD acha que são gêmeos,
13:03
recebem um caminho de raciocínio com o GPT-4 Mini.
13:06
Os campos acessados e noices.
13:07
Ninguém precisa de um relatório shakesperiano às 14 horas apenas uma micro-história.
13:10
Semana passada, o teste de agente único tentou corrigir um dispositivo inativo,
13:13
aposentando tudo no mesmo grupo dinâmico.
13:15
O revisor em nosso fluxo multiagente sinalizou a incompatibilidade de escopo,
13:18
pediu confirmação em nível de dispositivo e interrompiu o processo.
13:20
É por isso que separamos planejar a GIVK.
13:23
Resultado final. Dispositivos fantasmas, para onde assombrar a conformidade.
13:26
Você reduz desperdício de licença, corta falsos positivos e para de explicar a liderança
13:30
porque é falha na aposentadoria. Virou um estilo de vida.
13:33
E sim, a trilha de auditoria é legível.
13:34
O que é mais do que posso dizer sobre metade dos seus chamados de mudança.
13:38
Cenário de demonstração 2. Integração zero-touch.
13:41
Realmente zero-touch.
13:42
Zero-touch para o usuário. 500 toques para a engenharia antes dos agentes.
13:46
Objetivo. De um evento de RH a um usuário e dispositivo pronto, sem alternância manual.
13:51
Fluido, governado e reversível quando o RH escreve o sobrenome de três formas diferentes.
13:55
Alinhamento aqui.
13:56
O intake. Escuta o webhook do RH, normaliza payloads e valida os campos obrigatórios.
14:02
O provisioner cria o usuário no entra, atribui grupos e licenças e registra perfis de autopilot.
14:07
O validator verifica a conformidade de políticas e o acesso condicional antes de entregar-nos um laptop novo.
14:13
Concierge. Envia o pacote de boas-vindas. Links do SharePoint e a lista de verificação do primeiro dia.
14:18
Hora do fluxo.
14:19
O intake recebe o payload do RH. Nome, data de início, cargo, departamento, gestor, região.
14:23
Um modelo pequeno extrai e normaliza os dados. Ele mapeia para campos canônicos e detecta absurdos com uma data de início em 2022.
14:29
Se campos obrigatórios faltarem, notifica RH com um erro estruturado via Logic Apps. Nada de textos livres.
14:34
O provisioner chama o gráfico uma identidade gerenciada com o escopo de usuário.
14:38
Ele cria o usuário no entra, define o local de uso e aplica um grupo base.
14:43
Em seguida, ele reúne as atribuições de licença com base na região.
14:46
Rá, seu senhor ajuda aqui.
14:47
Esta pessoa precisa do I5 Security ou do Business Premium.
14:50
Codificamos a política em dados e permitimos que o modelo escolha esses pacotes permitidos.
14:54
Nenhum modelo pode inventar licenças. É um menu rigoroso.
14:56
O autopilot vem a seguir.
14:57
O provisionador registra um hash de hardware que já temos ou prepara um perfil just-in-time vinculado ao grupo do usuário.
15:04
Ele marca os grupos de dispositivos para políticas de linha de base. Então, o validador é ativado.
15:08
Ele consulta o Graph e o Defender por sinais de conformidade, verifica se o acesso condicional não impedirá o primeiro login
15:13
e confere se as políticas de configuração de dispositivo correta serão aplicadas.
15:16
Se o acesso condicional bloquear o novo funcionário no primeiro dia,
15:19
o validador abre uma aprovação com uma exceção por tempo limitado e a justificativa.
15:22
O conselho cuida das tarefas humano.
15:25
Ele envia uma mensagem no Teams ao gerente com o PN do novo funcionário e o status de atribuição do dispositivo
15:29
em um link para um kit inicial do SharePoint.
15:32
Ele envia um e-mail ao novo funcionário com os passos para o primeiro dia,
15:34
orientações de configuração de MFA e onde encontrar o portal de T.
15:37
Ele não cola seus intervalos de IP internos no e-mail.
15:41
A segurança de conteúdo verifica as saídas quanto a vazamentos.
15:43
A governança segue o mesmo tema de segurança.
15:45
A identidade gerenciada do provisionador tem direito à licença, mas não à exclusão.
15:49
O intake não pode provisionar, ele é apenas valido.
15:51
O PM bloqueia quaisquer ações de alto risco, como adicionado usuários a um grupo sensível.
15:55
Todas as ações são rastreadas no App Insights e no Log Analytics.
15:58
Se o RH enviar um payload corrigido, o planejador recalcula a diferença
16:01
e o operador atualiza apenas o que mudou, sem oscilações nas associações de grupo.
16:06
A observabilidade fornece marcos.
16:08
Ingestão de RH, criação no entra, atribuição de licença, perfil de autopilot,
16:11
notificação de veredito de conformidade enviada.
16:14
Você obtém métricas de SLA e novas tentativas automáticas em os transitórios do Graphicom Backoff.
16:17
Se o sistema de RH falhar, o thread não morre.
16:21
Ele pausa, registra e retoma quando corrigido.
16:24
As avaliações são executadas em si em payloads de integração sintéticos
16:27
para detectar regressões em relevância e fundamentação, antes que um funcional sova.
16:31
A combinação de modelos mantém a conta em nível de licença.
16:33
SLM para extração e normalização.
16:35
Uma etapa de raciocínio apenas nas decisões de seleção de política.
16:38
Resumos e e-mails de boas-vingas são agrupados quando possível.
16:41
O objetivo é um provisionamento de baixa latência com clareza de nível humano na trilha de auditorio.
16:45
História rápida.
16:46
A integração com agente único tentou adicionar um usuário a todos os funcionários e contratados,
16:50
porque o cargo dizia equipe de contratados.
16:53
O multiagente detectou a regra de exclusividade mútua no validador,
16:56
pediu uma decisão humana e evitou um problema imediato no acesso condicional.
16:59
Resultado verdadeiramente zero toque para o usuário.
17:01
Um thread, quatro agentes, aprovações limpas e uma trilha de auditoria
17:05
que você pode mostrar ao seu CISO sem precisar rezar para os deuses das demonstrações.
17:08
E sim, quando o RH inevitavelmente altera a data de início,
17:10
o sistema recalcula sem estourar o orçamento de licenças.
17:13
Cenário de demonstração 3. Fortalecimento de segurança automatizado.
17:17
Por favor, mantenha o BitLocker ativado.
17:19
O desvio de segurança é como ervas da linha.
17:21
Se a ranca 3 e 5 aparece e uma delas desativa o BitLocker por pura maldade.
17:25
Nosso objetivo, detectar desvios de configuração continuamente
17:28
e remediar com segurança com salvaguardas que o advogado respeitaria.
17:30
O detector de desvios consulta o Graph e o Defender.
17:34
Secure Score extrai a conformidade do Intune e as linhas de base de configuração de dispositivo,
17:37
criando um delta desvio.
17:39
O corretor aplica mudanças de política do Intune e configurações de BitLocker
17:42
e anéis de atualização do Windows e Endos.
17:45
Executa scripts de dispositivo via Azure Automation,
17:47
quando a política não é suficiente.
17:50
O revisor impõe limite, define o escopo das mudanças,
17:52
executa verificações de base e exige aprovação humana para passos de risco.
17:56
O mensageiro notifica os responsáveis no Teams ou e-mail com planos compactos e comprovantes.
18:02
Fluxo, detecta o desvios executado de forma agendada ou sob demanda.
18:06
Ele extrai via Graph a conformidade do dispositivo,
18:08
status do BitLocker, status do TPM, versão do SO,
18:11
anéis de atualização e atribuições de política.
18:14
Ele compara cada dispositivo com um perfil ideal como dados estruturados,
18:17
não como um documento vago.
18:19
Ele marca as descobertas, BitLocker ausente,
18:21
método de criptografia fraco, política não aplicada,
18:23
se criboot desativado, anel de atualização fora dos limites.
18:26
A etapa de planejamento entra em ação propondo um plano mínimo por grupo de dispositivo.
18:30
Para o BitLocker, use a política de BitLocker no intone se o dispositivo for compatível.
18:34
Se a política já estiver direcionada, mas o status estiver desativado,
18:37
propõe um script de automação para reiniciar as proteções e salvar a chave no Azure AD.
18:41
Para desvio de atualização, propõe mover o dispositivo para um anel de atualização gradual
18:44
em vez de aplicar agora e torcer.
18:47
Para problemas de acesso condicional, propõe uma exceção temporária com a devida justificativa.
18:51
O revisor avalia a fundamentação.
18:54
O detector de desvios realmente citou os campos do Graph e do Defender.
18:58
Ele verifica o escopo, a digipositiva, a digipolítica e tipo de alteração.
19:02
Se algo sugerir todos os dispositivos, é bloqueado imediatamente.
19:05
A segurança de conteúdo é aplicada na entrada e saída
19:07
para evitar a injeção de prompt de qualquer conhecimento externo ou logs colados.
19:11
Ações de alto risco, como remover uma política local conflitante,
19:14
exigem aprovação do gerente produto.
19:16
A identidade do corretor não pode se auto-elevar.
19:17
A aprovação ocorre em um aplicativo lógico com cartão organizado.
19:20
Errado.
19:21
O que mudará?
19:22
Passos de reversão e citações.
19:23
Aprove e o corretor executa.
19:25
As atualizações de política do Intune são ainda impotentes e direcionadas.
19:28
A correção do BitLocker usa um handbook com parâmetros explícitos e uma verificação de integridade.
19:32
TPM presente, SO, suporta XTS, AS, 256, caminho e custódia verificado.
19:38
Se qualquer pré-verificação falhar, ele falha com um erro compreensível e sem efeitos colaterais.
19:42
Mensageiro fecha o ciclo.
19:43
Dispositivo corrigido.
19:44
Um resumo enxerga o Teams com contagens, links para rastreamentos do App Insights e
19:48
um CSV para a pessoa que ainda ama o Excel mais do que a própria família.
19:52
Se um dispositivo se recusou a cumprir, o revisor abre um tópico de exceção com um cronômetro
19:55
e novas tentativas agendadas.
19:57
Observabilidade.
19:58
Cada chamada de ferramenta é rastreada e correlacionada para o tópico.
20:01
Bloqueamos os deltas antes e depois para que a auditoria possa ver o que não está em
20:04
conformidade sem precisar ficar no KQE.
20:06
Também executamos um agente de avaliação nos resumos pós-alteração para verificar a fundamentação
20:10
e clareza.
20:10
Se a fundamentação cair ou as taxas de falha aumentarem, o planejador restringe a recuperação,
20:16
reduz o tamanho do lote ou pausações destrutivas.
20:18
Combinação de modelos, SLM para extração e classificação, modelo de raciocínio para
20:22
síntese de planos apenas quando necessário.
20:24
Agrupio relatório no Tupo.
20:25
Adicione sobre IAS.
20:26
Resultado final, o BitLocker está realmente ativado.
20:28
Os anéis de atualização apresentam menos.
20:29
As exceções são documentadas com prazo definido e revisável.
20:31
E ninguém conserta um dispositivo reformatando os notebooks do financeiro durante o fechamento
20:35
do trimestre.
20:36
Vamos abrir o capô sem derramar óleo do motor na sua cota.
20:45
Pense em quatro camadas que mantêm tudo sob controle.
20:47
Foundry, Semantic Kernel, Ferramentas e Identidade.
20:50
Foundry é a base.
20:52
Você define agentes com instruções rígidas, escolhe implantações por função,
20:55
anexa conhecimento via Azure AI Search e registrações.
20:58
Ferramentas, OpenAPI, Logic Apps, Funções, Graph, Azure Automation, Interpretador de
21:04
Código, Ameaças, Histórico de Execução, Rastreamento, Avaliações e Segurança vivem
21:08
aqui.
21:09
Os contos de prompt de segurança de conteúdo e verificações de material protegido são
21:12
executados antes e depois dos modelos, para que entradas ruins não custem tokens e saídas
21:15
ruins não custem empregos.
21:17
O Semantic Kernel é um maestro.
21:18
No código, você conecta o loop de planejador, operador e revisor.
21:21
Você registra catálogos de funções para ferramentas, define o tempo de espera de novas tentativas
21:25
e adiciona tokens de cancelamento.
21:27
Você mantém os promptos curtos, transfere a complexidade para esquemas e deixa o SK
21:29
decidir qual ferramenta chamar com base na disponibilidade e na política.
21:33
Se o Graph atingir o tempo limite, o SK trata com o JIT.
21:35
Se a fundamentação diminuir, ele retorna ao planejador para refinamento.
21:39
As ferramentas.
21:40
Mantenha contratos rígidos com OpenAPI.
21:43
Coloque o AP Management na frente para limitar a controlar a versões e interromper o circuito.
21:46
Logic Apps lidam com aprovações e fluxos de longa duração.
21:49
As funções fazem a integração e a transformação.
21:50
O Azure Automation executa scripts com proteções e verificações posterior.
21:53
O Graph é sua fonte da verdade para Intune e entra conformidade Secure Score.
21:58
O Azure AI Search fornece conhecimento curado por domínio.
22:01
Nada de bagunça de um isso mesmo.
22:02
A identidade é o cinto de segurança.
22:04
Cada agente tem sua própria identidade gerenciada.
22:06
Agente de monitoramento obtém scope.
22:08
Agentes de remediação obtêm scope descrita.
22:10
PM bloqueia coisa destrutiva.
22:12
A elevação requer um ano e expira.
22:15
Endpoints privados onde os limites de dados são importantes.
22:16
As políticas de referência nos projetos do Foundry aplicam os modelos, regiões e cotas permitidos.
22:21
O App Insights e Log Analytics coletam rastreamentos, métricas e auditorias para que você possa
22:26
responder quem fez o que sem precisar fazer arqueologia no Slack.
22:29
Modelos são conectados via endpoint de diferença do FAM.
22:32
Use serverless para raciocínio premium, gerencia e computação para modelos abertos fixos.
22:36
Troque modelos sem reescrever código, mas avalie relevância, embasamento e fluidez no CIE
22:40
antes de promover.
22:42
As regiões correspondem aos seus usuários, zonas de dados aos seus reguladores.
22:44
Juntando tudo, temos uma máquina confiável e previsível.
22:47
Agentes definidos no Foundry, orquestrados pelo SK, movidos por ferramentas rígidas,
22:52
bloqueados por identidade.
22:53
Medidos por observabilidade e protegidos por segurança.
22:56
Previsível vence.
22:57
Previsível escapa.
22:58
Previsível te deixa dormir.
23:00
Boas práticas permitem lançamento sempre.
23:03
Construa sabedoria de tempo para não passar o domingo desfazendo sábado.
23:06
Dê a cada agente uma única tarefa.
23:07
Planejador planeja.
23:08
Operador opera.
23:09
O revisor revisa.
23:10
Se um agente começar a escrever um romance emocionante, corte o prompt e dê o texto
23:14
a uma ferramenta.
23:15
Mantenha as instruções curtas e copadas e simples, para você terá menos surpresas.
23:19
Prefira chamadas de ferramenta a textos longos.
23:21
Coloque contratos em APIs abertas, esquemas nas entradas e guardrails nas saídas.
23:25
Se uma ferramenta espera um ID de dispositivo, envie um ID.
23:27
Não, talvez este dispositivo nas finanças.
23:29
Modelos são criativos, ferramentos longos.
23:31
Esse é o ponto.
23:32
Aplique o privilégio mínimo, como se seu emprego dependesse disso, porque depende.
23:35
Separe as identidades.
23:37
Leitura apenas para monitor, escrita apenas para remediador e nenhuma identidade deleta.
23:40
Sem PM.
23:41
A elevação é temporária, justificada e registrada.
23:44
Se alguém pedir admin global permanente, dê uma bola anti-estresse e um documento de
23:47
política.
23:48
Comece pequeno, dois agentes, executor e ficador.
23:50
Adicione um planejador quando o ciclo de FaceTime.
23:52
Então, se precisar expandir, não comece com um time screen digital de 12.
23:55
É assim que você recria seu organograma em emo e acaba chorando.
23:57
Misture modelos para executar.
23:59
SLMs, prestação, classe GPT-4, apenas para raciocínio onde importa.
24:03
Resume um lote durante a noite.
24:04
Você não está pagando taxas premium para formatar uma string de dados.
24:07
Guarde um modelo pesado para decisões, não para narração.
24:09
Adicione memória cruda.
24:11
Use estado externo como busca de IA ou um pequeno armazenamento de estado antes de lotar
24:15
janelas de contexto como uma aula de mão.
24:17
Meta dados de thread, vc minúsculo.
24:19
Se não for necessário para o próximo turno, não entra.
24:21
Registre tudo.
24:22
Ative o rastreamento.
24:23
IDs de thread, parâmetros de ferramentas e estado de latência.
24:26
Envie avaliações para o CI para detectar quedas de relevância e embasamento antes
24:29
que cheguem à produção.
24:31
Alerte quando o embasamento cair, não quando o Twitter cair.
24:34
Guardrails, antes da velocidade e aprovações para ferramentas destrutivas.
24:36
Modos de teste de armazenamento sem efeitos colaterais.
24:39
Rollouts faseados por grupo de dispositivos ou região.
24:41
Se seu plano de rollout é tudo de uma vez, espero que seu currículo esteja atualizado.
24:44
Tranjete para falhas.
24:45
Tente novamente com GIT.
24:46
Reduza o estrangulamento de grafo.
24:48
Circuit breakers no gerenciamento de API.
24:50
Armbooks e impotentes.
24:51
Se uma etapa pode ser refeita com segurança, cedo é melhor.
24:54
Por fim, documente suas políticas como dados.
24:56
Regras de exclusividade mútua, pacotes de licença, baselines de dispositivos.
24:59
Coloque-se em formato estruturado.
25:01
Modelos podem selecionar, eles não devem inventar.
25:02
É assim que você mantém os agentes úteis e seu raio de impacto pequeno.
25:06
Se for para lembrar de uma coisa, agentes únicos ajudam.
25:09
Mas equipes de agentes, planejadas, orientadas por ferramentas e com permissões delimitadas,
25:13
transformam silenciosamente seu ambiente enquanto você finge dormir.
25:16
Se isso faz sentido para você, inscreva-se e assista ao próximo vídeo,
25:18
onde disponibiliza o repositório do seu monte de kernel e o template Bicep para você copiar sem vergonha.
25:22
Quer o episódio sobre agentes de avaliação que mantém suas promessas íntegras?
25:25
Já está na fila na próxima semana.