Latest / M365.FM – Podcast de Microsoft 365, Copilot e IA em português / Arquitetura de agentes de IA: executores, grafos de fluxo de trabalho e validação para agentes confiáveis (Dublagem IA)

Transcript

Arquitetura de agentes de IA: executores, grafos de fluxo de trabalho e validação para agentes confiáveis (Dublagem IA) · M365.FM – Podcast de Microsoft 365, Copilot e IA em português

0:00
A única validação que impede que agentes inteligentes façam coisas idiotas.
0:04
Há um portão que transforma a inteligência em competência,
0:06
a verificação do contrato de pré-execução.
0:07
Antes de executar qualquer ferramenta, o validador prova três coisas em ordem.
0:11
A intenção corresponde a uma capacidade real.
0:13
O chamador tem permissão agora
0:14
e o resultado solicitado é viável dentro dos limites de dados declarados.
0:18
Se qualquer parte falhar, nada será executado.
0:21
Não tome cuidado, não tente de qualquer maneira.
0:22
Negue com motivos e alternativas.
0:24
Comece com a correspondência de capacidade.
0:26
O plano diz para atualizar o item da lista de SharePoint.
0:27
O validador pergunta qual ferramenta, qual método, qual versão do esquema.
0:32
Os argumentos são verificados no registro?
0:34
Campos obrigatórios presentes, tipos corretos, intervalos de valorização e sim,
0:38
nenhum campo extra contrabandeado esperando que alguém os ignore.
0:41
O alisem de ferramenta é proibido.
0:43
Use o nome canônico ou seja rejeitado.
0:45
Isso elimina ferramentas alucinadas e parâmetros incertos antes de se comportarem mal.
0:49
Em seguida, conformidade com a política.
0:51
O mecanismo de política avalia a chamada proposta em relação à política ativa.
0:55
Listas de permissões para ferramentas e domínio.
0:57
Verificações RBA, que é o ABC, ligadas a declarações e escopos de L.
1:01
Regras de nível de ambiente.
1:02
Limite e classificação de dados.
1:04
Se a gente tiver como escopo arquivos.
1:06
Leitura para um site específico, uma chamada de autorização, um site diferente ou não definitivo.
1:10
Se a carga útil cair na classificação restrita sem um ponto de verificação humano, também não.
1:15
Os tokens são verificados recentemente.
1:16
Os escopos são verificados exatamente e a escalada de privilégios apenas uma vez é tratada como que é.
1:21
Uma tentativa de violação.
1:22
Então, viabilidade pós-condição.
1:25
Não basta criar um resultado.
1:27
Ele precisa ser alcançável e verificável.
1:29
O validador pergunta.
1:30
O destino oferece suporte à chave de potência do item.
1:33
O sistema emitirá um identificador durável ou etiqueta eletrônica que podemos ver que aqui.
1:36
Existe uma ação compensatória se o Downstream falhar.
1:39
Se o plano não puder produzir pós-condições verificáveis, ele será rejeitado ou reescrito.
1:43
Não aceitamos.
1:44
Confie-me em registrar mais tarde.
1:45
Mais tarde é como se estentes acontecem.
1:47
Junte tudo isso e você terá o Trilgate, correspondência de capacidade, conformidade política e viabilidade pós-condição.
1:52
Passem todos os três e o executor prossegue.
1:54
Reprovem qualquer um e o caminho com razão é ativado.
1:57
Esse caminho é educado, completo e inequívoco.
2:00
Aqui você tentou.
2:01
Aqui está a política ou o esquema exato que você quebrou.
2:03
Aqui está a alternativa segunda.
2:04
Se a intenção do usuário puder ser reparada, restringe o escopo.
2:08
Mude para um resumo somente leitura, em caminho para um site permitido.
2:11
O validador propõe um plano compatível e pede aprovação.
2:14
Se não puder ser reparado, escala para um ponto de verificação humano com contexto total ou pare de vez.
2:19
Sem paradas misteriosas.
2:20
Sem ser silencioso.
2:22
Uma micro-história rápida que você viveu, mesmo que não soubesse disso.
2:25
O agente deve resumir os documentos de RH do último trimestre e enviá-los ao jurídico.
2:29
A recuperação propõe consultas gráficas no site de RH e jurídico.
2:32
O validador vê um cruzamento de limites.
2:35
O RH é restrito.
2:36
O departamento jurídico é interno.
2:37
Portão tribo, que é a leitura cruzada e o e-mail de saída.
2:40
O caminho de negação retorna.
2:42
Conteúdo restrito detectado.
2:44
Alternativa proposta.
2:45
Resume o índice de política interna.
2:46
Fornece um link de solicitação para resumo de RH para revisores autorizados.
2:50
O usuário aprova o plano em conformidade.
2:52
O executor executa, publica o conteúdo interno e anexa uma solicitação de permissão para o material de RH.
2:56
Sem vazamento, sem drama, ainda útil.
2:59
A implementação é chata por design.
3:00
Uma política DSL define quem pode fazer o que, onde com quais efeitos colaterais.
3:04
Um registro de esquema armazena contratos de ferramentas, nomes, versões, formatos de argumentos e pós-condições.
3:09
Um resolvedor de listas de permissão mapeia domínios, sites e escopos à camada de ambiente.
3:13
O validador os compõe e carimba cada decisão com um registro de auditoria, entradas, avaliações de política e resultados
3:19
e entrega uma luz verde ou um plano de reparo ao executor.
3:22
O executor nunca contorna um sinal vermelho.
3:25
Ele aplica a decisão ou para.
3:27
O modelo mental é limpo o suficiente para tatuar na testa do seu diagrama de arquitetura.
3:31
Os executores aplicam.
3:32
Os gráficos restringham.
3:33
Os validadores decidem.
3:34
Nessa ordem.
3:35
O modelo propõe somente dentro do pátio cercado e, no minuto em que tenta passar por cima,
3:39
o validador o puxa de volta, explica o porquê e aponta para o portão.
3:43
Ordem preservada.
3:45
Segurança aplicada.
3:46
Progresso bloqueado.
3:47
Dentro política.
3:48
Você queria uma coisa que impedisse agentes inteligentes de fazer coisas idiotas.
3:52
É isso.
3:53
Uma verificação de contrato de pré-execução que prova capacidade, permissão e resultado verificável
3:57
antes de qualquer mutação no mundo real.
3:59
Transforma acho que posso em tenho permissão, sei como e posso provar que fiz.
4:03
Não, não, não. A escuridão não acontece conosco.
4:06
Agora você tem a arquitetura. Use-a.
4:09
Conclusão principal mais TC.
4:10
Conclusão principal, prompts são opiniões, executores e gráficos validados são operações
4:15
e a verificação de contrato de pré-execução é a proteção que mantém ambos honestos.
4:19
Se isso economizou seu tempo, pague a dívida.
4:22
Inscreva-se.
4:23
Em seguida, assista a análise do Landcraft vs. Microsoft Agent Framework sobre desempenho
4:27
e observabilidade, rastros reais, custos IP95s.
4:31
Bloqueie seu caminho de atualização, siga a habilite alertas e receba o próximo episódio
4:34
dentro do cronograma.
4:35
É isso.
4:36
Muitos acham que prompts melhores consertam agentes falhos.
4:39
Teoria bonitinha.
4:40
Prontos guiam pensamentos.
4:41
Eles não executam operações.
4:42
A verdade é que a confiabilidade vem dos executores e da validação de grafos.
4:46
A base que impede os agentes de caírem ao encarar a realidade.
4:49
Vamos conectar isso aos cenários da Microsoft.
4:51
Recuperação de gráficos do Microsoft 365.
4:53
Raciocínio do Copalot Studio.
4:55
Agentes do Copalot Studio que não agem de forma desonesta.
4:57
Os riscos são simples.
4:59
Precisão, latência, custo e auditabilidade.
5:02
Mensurável, não vibrações.
5:04
Vou te dar um modelo mental para rodar na sua cabeça.
5:07
Diagramas em palavras que não esquecerá.
5:08
E um passo de validação que impede agentes inteligentes de fazerem bobagens.
5:12
Conheça a arquitetura que você deveria ter usado no primeiro dia.
5:15
Por que os prompts falham em operações e os executores não?
5:18
Ok, então é o seguinte.
5:19
Os LLMs lidam com a cognição.
5:21
Os executores lidam com as operações.
5:23
Misturar essas coisas é como você obter o cálculo.
5:25
O modelo pode propor um plano.
5:28
Ele não pode garantir que o e-mail foi enviado, o arquivo foi salvo ou a permissão existiu.
5:32
Ele fala em probabilidades.
5:33
As operações exigem garantias.
5:35
Entra em cena o executor.
5:37
Pense nele como o adulto na sala.
5:39
Um executor de funções vinculado a políticas com restrições de estado e potência de item.
5:43
Ele não acredita que uma ação foi bem sucedida.
5:45
Ele verifica.
5:46
Ele não pressupõe que uma ferramenta existe.
5:48
Ele valida a capacidade, os parâmetros e as permissões antes mesmo de tentar.
5:52
E quando falha, ele falha ruidosamente, classifica o erro e segue o caminho de recuperação prescrito.
5:58
A maioria dos agentes somente o prompt se enquadra em três modos de falha.
6:01
Primeiro, ferramentas alucinadas.
6:04
O modelo solicita uma função que não está registrada ou a chama com campos que não existem.
6:08
Segundo, pré-condições ausentes.
6:10
Ele tenta editar um arquivo do SharePoint sem verificar se pode acessar o site, a lista ou a versão do item.
6:16
Perceba, paciência.
6:17
A etapa 2 falha, mas o agente continua e declara vitória porque o texto parece confiante.
6:21
Você viu isso?
6:22
Você acabou de dizer que é instável.
6:23
Os executores executam um loop que parece chato e é por isso que funciona.
6:26
Pré-condições.
6:27
Verificar entradas, permissões e invariantes.
6:30
Ação.
6:30
Chamar a ferramenta como a chave de potência do item para que as novas tentativas não sejam cobradas ou postadas duas vezes.
6:35
Pós-condições.
6:36
Confirmar efeitos em relação à fonte da verdade.
6:39
Taxonomia de erros.
6:40
É validação, transiente, limite de taxa, juventude ou política.
6:44
Recuperação.
6:46
Recuar e tentar novamente em casos transientes, reautenticar ou pedir novo consentimento, usar alternativas e parar por violações de política.
6:53
A idempotência não é negociável.
6:55
Se uma ação for repetível, precisa de uma chave que torne a reexecução nula ou uma substituição consistente.
7:00
Os tempos limite evitam chamadas de zumbi.
7:02
O recuo respeita os limites de taxa.
7:03
Este é um comportamento determinístico e que age a geração de texto ou caixa inerentemente.
7:07
Cheio.
7:08
O executor é a caixa de câmbio.
7:10
O LLM é o motor.
7:12
Se não acelera o motor, espera que as rodas entendam.
7:15
Saídas que priorizam o contrato são um antídoto para parágrafos de melhores forças.
7:18
O modelo de raciocínio não divaga.
7:20
Ele emite JSON que corresponde a um esquema.
7:22
Nome da ferramenta, argumentos e pós-condições esperadas.
7:25
Validadores checam a conformidade do esquema antes de tudo.
7:27
Se a forma estiver errada, o executor nega com um motivo, solicita um plano corrigido ou encaminha.
7:32
É assim que você impede que saladas e substantivos se torne incidente de produção.
7:35
Talvez você esteja pensando, não posso pedir ao modelo que verifique o seu trabalho?
7:38
Já pode perguntar.
7:39
Ele dirá que isso?
7:40
Ele sempre diz.
7:41
O usuário médio aceita isso.
7:42
Profissionais exigem provas.
7:44
As provas residem em pós-condições verificadas em sistemas como Microsoft Graph, SharePoint ou Exchange.
7:49
Fontes reais de verdade, não é a memória do modelo.
7:51
Mas é aqui que fica interessante.
7:53
Etapas únicas são boas.
7:54
Fluxo de trabalho reais tem ramificações, paralelismo, compensações e etapas humanas.
7:58
Mas você precisa de mais de um executor.
8:00
Você precisa de um mapa que o executor possa ler.
8:02
Esse é um gráfico de fluxo.
8:03
Em um gráfico, os nós são tarefas ou subagentes com contratos explícitos.
8:06
As arestas definem o fluxo de controle e o fluxo de dados.
8:08
O estado de primeira classe, que é persistente, é verificado, é efêmero.
8:12
O executor percorre o gráfico de forma determinística, respeitando listas de permissões e esquemas em cada aresta.
8:16
Se um nó falhar, o gráfico especifica compensações, desfaz, repara ou escala.
8:22
Sem pipis misteriosos.
8:23
Não, então a mágica acontece.
8:25
Este é o momento em que a confiabilidade muda.
8:27
O LL me propõe.
8:27
O executor aplica a validação das restrições do gráfico desse...
8:31
Ordem restaura.
8:33
Depois de separar a cognição das operações, seus agentes param de improvisar e começam a se comportar.
8:38
E sim, eles ainda se sentem inteligentes porque são, mas agora são supervisionados.
8:42
Projeto pronto.
8:43
Vamos conectá-lo ao Microsoft 305 sem transformar seu locatário em um buff.
8:46
Fluxo de trabalho de gráfico 101.
8:49
Nós, arestas e estado que não vazam.
8:51
É isso.
8:52
Você tem um executor confiável, mas nem um mapa.
8:54
Ele seguirá ordens, mas pra onde?
8:56
Acesse o gráfico de fluxo, seu manual de operações.
8:59
Nós são tarefas ou subagente com contratos explícitos?
9:02
Arestas define fluxo de controle de dados.
9:04
O gráfico codifica o que é executado, quando é executado e quais dados podem cruzar os limites.
9:09
Sem improvisação ou jazz.
9:10
Isso é partitura.
9:11
Comece com a forma.
9:12
A maioria dos gráficos de produção são DAGs, gráficos acíclicos direcionados,
9:16
porque os ciclos convidam a loops infinitos e corrupção de estado.
9:20
Você ainda pode ter loops, mas os marca intencionalmente com contadores e proteções,
9:23
interações máximas, predicados de saída e tempos limite.
9:26
Você evita que o pensar é mais difícil e o vire pensar para sempre.
9:30
O roteamento condicional é explícito.
9:33
Se a confiança da recuperação estiver acima do limite, desvie para a síntese.
9:36
Se não, desvie para uma nova consulta.
9:38
O paralelismo é de primeira classe.
9:39
Execute a sumarização e a extração de citações lado a lado e, em seguida,
9:43
junte-se em um nó de barreira que verifica se ambos atenderam às suas pós-condições.
9:47
Estado é uma vibração e é um livro-razão.
9:49
Você mantém três tipos.
9:50
Estado persistente.
9:51
Pontos de verificação duráveis, os quais você pode se recuperar após uma falha,
9:54
entradas, decisões, ações assinadas.
9:55
Estado efêmero.
9:56
Buffers de curta duração, como saídas de modelo intermediárias,
9:58
que você não quer poluir a memória de longo prazo.
10:00
Estado derivado.
10:01
Artefatos recontáveis, como incorporações ou resultados filtrados,
10:04
que você pode construir de forma determinística.
10:06
A regra é simples.
10:06
Especista apenas o que você pode defender em uma auditoria.
10:09
Todo o resto é descartável de propósito.
10:11
A estratégia de reversão é importante.
10:12
Quando um nó modifica o mundo externo,
10:14
cria um evento e calendário.
10:15
Atualiza um item de lista.
10:16
Você registra uma ação inversa, se ela existir,
10:18
ou um plano de compensação.
10:19
Se não existir,
10:21
se um nó downstream falhar fatalmente,
10:23
o gráfico pode percorrer essas compensações na ordem inversa.
10:26
Não, isso não exagera.
10:27
Como você evita erros, reservas duplas,
10:28
o CEO se tornando erros.
10:29
Não podemos consertar.
10:30
As arestas carregam o contrato.
10:33
Uma aresta não é um canal misterioso.
10:34
É uma API entre nós.
10:36
Defina esquemas de barra S tipos,
10:38
campos obrigatórios, valores permitidos.
10:40
Defina listas de permissões,
10:41
quais ferramentas ou domínios o próximo a pode chamar.
10:44
Defina tags de capacidade,
10:45
o que o nó receptor promete fazer
10:46
e o que ele recusará.
10:48
O executor aplica isso em tempo de execução.
10:50
Um lá não pode contrabandear um token do SharePoint
10:52
por meio de uma borda de resumo.
10:53
Isso não é um teatro de segurança,
10:55
é assim que você evita o movimento lateral do seu próprio agente.
10:57
Tratamento de erros reside no gráfico,
11:00
não em vibrações.
11:02
Cada nó declara sua taxonomia de erro.
11:04
Erro de validação,
11:05
infraestrutura transitória,
11:07
limitação de taxa,
11:08
autenticação,
11:09
autorização,
11:10
violação de política e desconhecido.
11:12
Para cada classe,
11:13
o gráfico fornece um caminho.
11:15
Repetir com recuo exponencial para transiente,
11:17
atualizar token para autenticação,
11:18
ferramenta alternativa para limitação de taxa,
11:20
negar com motivo para política.
11:22
Existem filas de mensagens mortas para os desconhecidos.
11:24
Cargas úteis com falha vão para a quarentena
11:26
com contexto total.
11:27
Permitindo a inspeção humana
11:28
sem causar caos na produção.
11:30
Os pontos de verificação com intervenção humana
11:32
não são mensagens ad hoc do Slate.
11:34
Eles congelam a execução,
11:35
apresentam a ação proposta
11:36
e as evidências exigem uma aprovação,
11:38
edição registrada e assinada.
11:40
Após a aprovação,
11:41
é exato humano.
11:42
Se negado,
11:42
o gráfico é direcionado para um folga que segura.
11:44
Parabéns,
11:44
você acabou de implementar
11:45
um controle de alterações
11:46
que os desenvolvedores realmente seguirão
11:48
porque é mais rápido que e-mail.
11:50
O isolamento de memória não é negociado.
11:52
Cada sessão obtém contexto com escopo
11:53
apenas os documentos,
11:55
tokens e resultados intermediários
11:56
de que precisa.
11:57
O envenenamento entre sessões
11:58
em que a injeção de prompt
11:59
e uma conversa vaza para outra
12:01
é como você acidentalmente esfiltra dados.
12:03
O gráfico impõe imites.
12:05
Sem memória mutável ou compartilhada,
12:07
apenas leituras sancionadas
12:08
de um repositório verificado
12:09
com filtros e validadores.
12:10
Sim,
12:11
você pode armazenar em caixa,
12:12
incorporações e resumos,
12:13
mas seus marcam procedência
12:14
e permissões de despejar
12:14
alterações de política.
12:16
A observabilidade é integrada
12:17
não acoplada.
12:18
Rastreamentos de nó
12:19
mostram entradas,
12:20
saídas,
12:20
durações,
12:21
novas tentativas e efeitos derivados.
12:22
Você une rastreamentos
12:24
em um ID de execução de gráfico
12:27
conformidade.
12:28
Quem fez o quê,
12:29
quando e por quê?
12:30
A detecção de anomalias
12:31
aponta padrões estranhos,
12:32
picos súbitos
12:32
em chamadas de ferramentas,
12:34
domínios e tokens.
12:35
Esse é o seu sistema
12:36
de alerta precoce
12:37
antes que algo interessante se dente.
12:39
Essencialmente,
12:39
o gráfico é a Constituição.
12:41
O executor é a aplicação da lei.
12:42
Ele é meu advogado,
12:43
não o juiz.
12:44
Quando você codifica nó,
12:45
arestas e estados dessa forma,
12:47
não obtém apenas fluxos
12:48
de trabalho bem-sucedidos.
12:49
Você obtém fluxos
12:50
que falham com segurança,
12:51
explicam e se recuperam
12:52
previsivelmente.
12:54
Agora,
12:54
com o projeto em mãos,
12:55
podemos nos conectar
12:55
o Microsoft 365
12:57
sem transformar
12:57
seu locatário em um bufê.
12:59
Seguro para o design.
13:00
A validação de gráficos
13:01
supera a engenharia do caos.
13:03
Você não prova a confiabilidade
13:04
lançando o caos na produção
13:05
e esperando que os sobreviventes
13:06
sejam resilientes.
13:08
Você prova isso
13:08
rejeitando o fluxo
13:09
de trabalho inseguros
13:10
antes mesmo de se executar.
13:11
Essa é a validação de gráficos.
13:12
Verificações estáticas
13:13
para manter o absurdo fora.
13:14
Proteções de tempo de execução
13:15
para manter o perigo em uma caixa.
13:16
A validação estática
13:17
é a pré-voo.
13:18
Você verifica a estrutura
13:19
antes que as rodas subam.
13:20
Ciclos que criam loops ilimitados,
13:21
rejeitados ou forçados
13:22
a declarar proteções de iteração.
13:24
Nóis inacessíveis
13:25
código morto
13:26
a uma exclusão ou justificação.
13:28
Contratos ausentes
13:29
Cada nó deve declarar
13:30
esquemas de entrada e saída,
13:31
recursos necessários
13:31
e efeitos colaterais.
13:33
Limites de privilégios
13:34
Nóis que modificam
13:35
sistemas externos
13:36
devem ser executados
13:37
em segmentos com credenciais
13:38
de privilégio mínimo
13:39
e listas de permissões explícitas.
13:41
E sim,
13:41
se seu nó de resumo
13:42
solicitar repentinamente
13:43
acesso de gravação
13:44
ao SharePoint,
13:44
o validador tira não
13:45
com preconceito.
13:47
Agora, tempo de execução.
13:48
É aqui que as pessoas
13:48
ficam desleixadas.
13:49
O mecanismo de política
13:50
fica ao lado do executor.
13:51
Não, traz dele.
13:53
Lista de permissões
13:54
de ferramentas e domínios
13:54
não são documentação,
13:55
são decisões impostas.
13:57
No momento da chamada,
13:58
o motor verifica
13:58
a nossa retaguarda
13:59
contra o princípio ativo
14:00
token de edin,
14:01
três copos e reivindicações
14:02
propagando tudo
14:03
pela cadeia,
14:05
sem superpoderes de ambiente.
14:06
Tokens têm escopo,
14:07
são atualizados
14:08
quando permitidos
14:09
e nunca contrabandeados
14:09
por bordas amigáveis.
14:11
A gente ganha acesso
14:11
em cada chamada
14:12
ou não chama?
14:14
Higienização de entrada
14:14
e saída higiênica
14:15
não é opcional.
14:16
A injeção imediata
14:17
não é inteligente,
14:18
é previsível.
14:20
Cada fonte de conteúdo
14:21
de entrada
14:21
passa por filtros de conteúdo,
14:22
HTMLs,
14:23
depuradores de markdown
14:24
e firewalls de instruções
14:25
que eliminam
14:25
o absurdo e ignorado.
14:27
A saída passa
14:28
por validadores de esquema.
14:30
Se um nó
14:30
prometeu o JSON,
14:32
o executor rejeita a prosa
14:33
e solicita um reparo.
14:35
O modelo pode argumentar
14:36
o validador no negocia.
14:38
Ele impõe tipos,
14:38
intervalos e variantes.
14:40
O sandbox e a segmentação
14:41
contêm o raio de explosão.
14:43
Os nós que chamam
14:44
código externo
14:45
ou conectores não confiáveis
14:46
são executados
14:46
em ambientes restritos.
14:48
Gateways de API
14:48
com limites de taxa
14:49
e políticas de rede
14:50
que impedem movimento lateral
14:51
e controles de saída
14:52
que permitem tráfego
14:53
apenas para domínios verificados.
14:56
Você não permite
14:57
que um nó de recuperação
14:58
descubra uma nova fonte
14:59
de dados em produção.
15:01
A descoberta ocorre
15:01
no desenvolvimento
15:02
por trás dos testes
15:03
com atualizações
15:03
assinadas na lista de permissões.
15:05
A observabilidade
15:06
não é registrada
15:06
em algum lugar cirúrgico.
15:08
O rastreamento
15:08
no nível do nó
15:09
registra a entrada,
15:10
saída, durações,
15:10
novas tentativas e decisões
15:11
do mecanismo de polícia.
15:13
Você correlaciona tudo
15:13
sob uma ID de execução.
15:15
Os registros de auditoria
15:16
são imutáveis
15:16
e atribuem qual princípio
15:18
autorizou, qual ação
15:19
com quais escopos
15:19
e em qual momento
15:20
e por que a política
15:21
permitiu isso.
15:22
Quando um regulador
15:23
pergunta quem fez o que
15:24
a não dê de ombros,
15:24
pesquise.
15:25
Estar pronto para conformidade
15:26
significa que suas evidências
15:27
são infanais.
15:28
Riscos de patches
15:29
e de terceiros
15:29
são problemas
15:30
da cadeia de suprimento.
15:31
Prátios como tal.
15:32
A varredura de dependências
15:33
é executada em cartofão.
15:34
Conectores e plugins
15:35
são auditados,
15:35
têm versões fixadas
15:36
e são revisadas
15:36
por excesso de permissões.
15:38
Ao importar um MCP
15:39
ou especificação
15:40
de API aberta,
15:41
você valida
15:41
se os métodos declarados
15:42
seguem a política
15:43
de privilégios mínimos
15:44
esperada.
15:46
Nenhum endpoint coringa,
15:47
nenhum caminho
15:47
de gravação oculto
15:48
fingindo ser lido.
15:50
A higiene não é glamorosa,
15:51
entanto é a razão
15:52
pela qual você dorme.
15:53
A validação do gráfico
15:54
da verdade supera
15:55
a engenharia do caos
15:56
porque evita classes
15:57
de incidentes
15:58
em vez de documentar
15:58
suas consequências.
16:00
Você ainda testa
16:01
modos de falha,
16:01
mas o faz para confirmar
16:02
proteções,
16:03
não para descobrir
16:03
que se esqueceu de instalá-las.
16:05
Vamos costurar isso
16:05
de volta ao modelo mental.
16:07
As verificações estáticas
16:08
mantêm os projetos.
16:09
Sem caminhos impossíveis,
16:11
sem tarefas órfãs,
16:12
sem vazamento de privilégios.
16:13
Os guardiões de tempo
16:14
de execução
16:15
mantêm o comportamento sensato.
16:16
Cada chamada é autenticada,
16:17
autorizada,
16:18
higienizada e observada.
16:20
O executor impõe
16:21
as restrições do gráfico
16:22
que o validador decide.
16:23
O modelo,
16:24
ele propõe dentro dos limites
16:25
e é cortado quando vagueia.
16:27
Isso não é pesado,
16:28
somente se você gosta
16:29
de violações.
16:30
A sobrecarga mecânica
16:31
é automatizada.
16:32
A validação estática
16:33
ocorre na compilação
16:34
e na implantação.
16:35
A política de tempo
16:36
de execução
16:37
é um sidecar rápido e local.
16:38
As verificações
16:38
de químicos são feitas em mim.
16:40
O custo que você remove,
16:41
incidentes,
16:42
revisões manuais,
16:42
retrofits,
16:43
supera a microlatência
16:44
que você adiciona.
16:46
E a recompensa é mensurável.
16:47
Menos chamadas não autorizadas,
16:49
menos explosões de tokens
16:50
e muito menos análises
16:51
post-mortem do tipo
16:52
por que isso aconteceu.
16:54
Mais um ponto
16:55
que o usuário médio
16:56
não percebe.
16:57
A validação é compósita.
16:58
Você pode encapsular
16:59
ferramentas de terceiros
17:00
com noise proxy
17:01
que impõem contratos
17:02
e políticas
17:02
sem confiar na ferramenta em si.
17:04
Você pode segmentar gráficos
17:06
por sensibilidade,
17:07
público interno restrito
17:08
e promover fluxos de trabalho
17:09
entre camadas
17:10
somente após a validação
17:11
ser aprovada
17:11
para o novo limite.
17:13
É assim que você
17:14
dimensiona com o seguro
17:14
por design,
17:15
não o slogan
17:16
atributo de fluxo de trabalho.
17:18
Você não espera
17:18
que os agentes se compõem.
17:20
Torna o mau comportamento
17:21
estruturalmente difícil
17:22
e operacionalmente visível.
17:24
Com os trilhos no lugar,
17:25
conectar o Microsoft
17:25
305 Graph
17:26
e o Azure OpenAI
17:27
não é roleta.
17:28
É poder controlado
17:29
em seus termos.
17:30
Agora podemos falar
17:31
de fiação
17:31
e não de apagar incêndios.
17:33
Cenário do Microsoft
17:34
M305 Graph
17:36
mais Azure OpenAI
17:37
mais Copilot Studio.
17:39
Vamos montar o elenco.
17:40
Agente de recuperação,
17:42
bibliotecário disciplinado
17:43
que só busca
17:43
no Microsoft Graph
17:44
com privilégios mínimos.
17:46
Agente de raciocínio,
17:47
modelo Azure OpenAI
17:48
que planeja sites
17:49
e nunca trabalha
17:49
como freelancer
17:50
além do que é solicitado.
17:52
Executor,
17:52
operador regido
17:53
por políticas
17:53
que executa
17:54
ferramentas
17:54
com idempotência
17:55
e pós-condição.
17:58
Validador,
17:59
segurança,
17:59
esquema,
18:00
política e aplicação
18:01
de limites,
18:02
proteção de política,
18:03
CDK de tempo de execução
18:04
que vincula
18:05
todos os escopos
18:05
de edito entre e rebaquia.
18:07
Juntos eles se comportam
18:08
como uma equipe competente
18:09
e vejam o thread cometer.
18:10
O acesso aos dados
18:11
começa com o Graph
18:11
e não com o seu processo.
18:12
O agente de recuperação
18:13
mantém um registro de aplicativo
18:14
com escopos granulares.
18:15
Arquivos,
18:16
leitura para um site específico,
18:17
e-mail e leitura básica
18:18
para uma caixa de correio confinada.
18:20
Calendários,
18:20
leitura para um calendário
18:21
de recursos.
18:21
Nenhuma leitura de Graph
18:23
gravação a todos os heróis.
18:24
As consultas
18:25
um campus delta
18:25
e seletivos
18:26
para manter as cargas finas.
18:28
A paginação de primeira classe.
18:29
O executor segue
18:30
os próximos links
18:30
de forma determinística
18:31
com tempos limite,
18:32
respeitando a aceleração
18:33
do serviço.
18:33
E quando 429s acontecem,
18:35
o recuo é matemático.
18:36
Sem birras,
18:37
apenas paciência exponencial.
18:39
O aterramento não é
18:39
uma vibração,
18:40
é um pipeline.
18:41
Recupere documentos
18:41
candidatos via pesquisa
18:42
em Graph
18:43
ou consulta de lista.
18:44
Dedupe por ID
18:45
do item em versão ETG
18:46
para não misturar
18:47
obsoleto e atual.
18:48
Fragmente por limites semânticos,
18:51
em seguida, anexo procedência,
18:53
unidade, site, caminho,
18:55
ID do item,
18:55
última modificação
18:56
e hash atribuído.
18:58
O agente de raciocínio
18:59
vê apenas fragmentos
18:59
mais metadados
19:00
e é obrigado a gerar
19:01
citações mapeadas
19:01
de volta para essas redes.
19:03
Sem citação,
19:04
sem reivindicação.
19:05
O executor impõe isso
19:06
como uma pós-condição
19:07
antes de qualquer ação externa.
19:08
Entre no Copilot Studio
19:09
para a orquestração.
19:10
Você define ferramentas
19:11
declarativas,
19:12
pacotes de consulta Graph
19:13
e ações de escrita SharePoint,
19:14
posts no Teams
19:15
e envios Outlook,
19:16
cada um protegido por proxy
19:17
com esquemas e listas
19:18
de permissão explícitas.
19:18
Coordenação entre agentes
19:20
é estruturado.
19:21
O agente de recuperação
19:22
expõe uma ferramenta básica.
19:24
O agente de raciocínio
19:25
solicita com parâmetros.
19:26
O executor medeia,
19:28
valida
19:28
e retorna um contexto básico.
19:31
Os pontos de verificação
19:32
mantêm.
19:33
Um nó de ação proposto
19:34
pausa a execução,
19:36
apresenta o plano
19:36
mais as citações
19:37
e requer a aprovação.
19:39
A aprovação é assinada
19:40
e registrada.
19:40
A negação leva
19:41
uma alternativa segura
19:42
ao escalonamento.
19:43
Os tokens e a latência
19:44
são gerenciados,
19:45
não desejado.
19:46
Contexto seletivo
19:47
significa que você alimenta
19:48
somente os blocos relevantes,
19:49
não todo o seu locatário.
19:50
Os resumos são pré-computados
19:52
e armazenados em cache
19:53
com embeds indexados
19:53
por hash e permissões.
19:55
Altere o documento,
19:56
altere a chave,
19:57
perca o cache,
19:57
recalcule.
19:58
As respostas de streaming
19:59
mantêm a interface ativa
20:00
enquanto o executor
20:01
lida com efeitos colaterais
20:02
após chegar ao plano
20:03
válido do esquema.
20:05
Condições de saída
20:05
antecipadas interrompem
20:06
o ciclo de raciocínio
20:07
quando a confiança
20:08
mais a cobertura
20:08
atinge o limite.
20:09
Nenhum pensamento extra
20:10
porque o modelo
20:11
parecia poético.
20:12
A auditabilidade
20:13
está incorporada.
20:13
Cada ação é assinada
20:15
pelo principal do serviço
20:16
ou usuário delegado
20:17
e carimbada
20:17
com a ideia de execução,
20:18
ferramenta,
20:19
parâmetros,
20:20
redigidos quando necessários,
20:21
escopos e resultado,
20:23
escopos e resultado.
20:24
Logs imutáveis
20:25
ficam na sua pilha
20:25
de observabilidade.
20:26
Escolha seu favorito.
20:27
Você pode reproduzir
20:28
uma execução
20:29
sem reexecutar
20:29
efeitos colaterais.
20:30
Quem fez o que,
20:31
quando e porque
20:31
se torna uma consulta
20:32
não uma caça às bruxas.
20:33
E sim,
20:34
as citações sobrevivam intactas
20:35
para que você verifique
20:36
se a resposta veio
20:37
do conteúdo real do locatário
20:38
e não da lei modelo.
20:39
A falha é normalizada
20:40
e chata.
20:41
429.
20:42
O executor tenta
20:43
com jitter
20:43
recorrendo a uma consulta
20:44
de menor custo
20:45
ou tamanho de página reduzido.
20:47
Cache desatualizado.
20:48
O validador detecta
20:49
tags incompatíveis
20:50
e força uma atualização.
20:51
Negação de permissão.
20:52
Protetor de política
20:53
nega com razão.
20:54
Propõe um caminho
20:54
de solicitação
20:55
de consentimento ou roteia
20:56
para um resumo
20:56
redigido que não vaza.
20:58
Falha na ferramenta.
20:59
O gráfico declara alternativas
21:00
ou estaciona a execução
21:01
em uma fila de mensagens mortas
21:03
com contexto
21:03
para a correção humana.
21:05
Os fallbacks determinísticos
21:06
transformam o incidente
21:07
em um ticket.
21:07
Agora um passo a passo bem rápido.
21:10
O usuário pede.
21:11
Elabore um resumo
21:11
das decisões do roteiro
21:12
do último trimestre
21:13
com links.
21:14
O agente de raciocínio propõe.
21:15
Use a pesquisa de gráfico
21:16
em um site específico
21:17
do SharePoint
21:18
e um canal do Teams.
21:19
Filtre pelo último trimestre
21:19
e em seguida sintetize.
21:21
O validador verifica
21:22
se os escopos solicitados
21:23
correspondem à função do agente.
21:24
O executor emite
21:26
chamadas de gráfico
21:27
com paginação
21:27
e seleção de campo.
21:28
Duplica por aí de item blocos
21:30
e retorna o contexto
21:30
com procedência.
21:32
O raciocínio produz um resumo
21:33
com citações em linha
21:34
mapeadas para eles de itens.
21:35
O validador verifica
21:37
o esquema e as citações
21:38
e passa.
21:39
O ponto de verificação humana
21:40
aparece com resumo
21:40
e as evidências.
21:41
O aprovador clica em OK.
21:43
O executor publica
21:44
o resultado no Teams
21:45
e envia e-mails
21:45
às partes interessadas.
21:46
Cada ação usando
21:46
chaves de potência do item
21:47
para que as tentativas
21:48
não sejam publicadas.
21:49
Observe a disciplina.
21:50
Nenhum agente inventa
21:51
uma ferramenta
21:51
e nenhum nó cruza
21:52
um domínio fora
21:53
de sua lista de permissões.
21:55
Os tokens são definidos
21:55
no escopo e propagados
21:56
corretamente por meio
21:57
do Entryg,
21:58
não copiados e colados
21:59
entre os nós.
22:00
O modelo nunca conclui
22:01
o sucesso.
22:02
O executor prova isso
22:03
com condições de publicação
22:04
do lugar.
22:05
Criou o ID da mensagem
22:06
e atualizou o ETAG do item
22:07
e o ID do evento
22:07
marcando a execução concluída.
22:09
E sim,
22:10
você pode estender isso
22:10
com segurança
22:11
e trazer o Planner viva
22:12
ou serviços de terceiros
22:13
por meio do MCP
22:14
ou API aberta,
22:15
mas apenas por trás
22:16
de ferramentas PROX
22:16
com esquemas rígidos
22:17
e controles de saída de rede.
22:18
Envolva cada conector
22:19
com a mesma lógica
22:20
de validador
22:20
e proteção de política.
22:21
A promoção entre ambientes
22:23
requer aprovações
22:23
de validação
22:24
que correspondam a um novo limite.
22:26
Deve a teste PROD
22:26
com momentos de escopo
22:27
revisados,
22:28
não assumidos.
22:29
Arquitetura da Microsoft
22:30
feita corretamente.
22:31
Era a verdade.
22:32
Azure OpenAI
22:33
para pensamento,
22:34
Copilot Studio
22:35
para orquestração,
22:36
executores para operações,
22:37
validadores e políticas
22:38
para segurança
22:39
e observabilidade
22:40
para comprovação.
22:42
Números em seguida,
22:42
não vibrações.
22:44
Métricas de antes e depois.
22:45
Precisão, latência,
22:46
custo e administração.
22:48
Boa arquitetura,
22:49
comprove.
22:50
Números não vibrações.
22:52
Agentes de prompt
22:52
e linha de base
22:53
são verdadeiras divas.
22:54
A precisão é inconsistente
22:55
porque eles inventam fontes
22:56
e esquecem citações.
22:59
Sem base,
22:59
você obtém uma prosa confiante
23:00
que não leva a lugar nenhum.
23:02
A latência de calda é brutal.
23:04
Uma longa cadeia
23:04
de chamadas seriais
23:05
de pense mais,
23:06
cada uma delas,
23:06
inchada com contexto redundante.
23:09
Os custos aumentam
23:09
porque cada turno
23:10
envia transcrições completas
23:11
e documentos brutos
23:12
de volta ao modelo
23:13
como um serviço
23:13
de entrega pago em excesso
23:15
sobrecarga administrativa.
23:18
Incidentes,
23:18
hot fixes,
23:19
falhas misteriosas
23:20
e auditorias
23:20
que parecem arqueologia
23:21
com uma venda nos olhos.
23:23
O ar o estado posterior
23:23
com executores
23:24
e gráficos validados.
23:25
A precisão aumenta
23:26
porque as reivindicações
23:27
exigem recípro.
23:28
Citações fundamentadas
23:29
ligadas a IDs de gráficos
23:30
e tags e hashtags
23:31
assinados
23:32
significam que respostas
23:33
sem procedência
23:33
não passam pelo validador.
23:35
O efeito é imediato.
23:37
Menos respostas erradas
23:37
e enviadas,
23:38
menos loops de retrabalho
23:39
e um aumento mensurável
23:40
nas taxas de sucesso
23:40
de tarefas
23:41
em conjunto de avaliação.
23:42
Quando uma reivindicação
23:43
não pode ser suportada,
23:44
o agente nega com razão
23:45
ou solicita a aprovação humana.
23:47
Previsível,
23:47
revisável ou seguro?
23:49
A latência é compactada
23:50
por três motivos.
23:51
Primeiro,
23:51
paralelismo,
23:52
recuperação,
23:52
reclamação e extração
23:53
de citações e citações
23:54
sendo executados lado a lado
23:55
e depois sincronizados
23:56
em um nó de barreira.
23:57
Segundo,
23:58
armazenamento em caixa,
23:58
incorporações e resumos
23:59
codificados por hash de conteúdo
24:01
e escopos de permissão
24:01
evitam recomputar
24:02
o que não mudou.
24:03
Terceiro,
24:04
saída antecipada.
24:05
Quando a cobertura
24:05
e a confiança
24:06
atingem o limite,
24:06
o gráfico interrompe o lucro.
24:08
Compare isso
24:08
com a solicitação em série,
24:09
em que o modelo
24:10
reflete para um parágrafo
24:11
e seus usuários
24:12
refletem sobre a saída.
24:13
O custo cai
24:13
porque a disciplina de token
24:14
é aplicada
24:15
não implorada.
24:16
Saídas restritas ao esquema
24:17
evitam divagações.
24:19
O contexto seletivo
24:19
alimenta apenas
24:20
os blocos relevantes
24:21
com metadados,
24:22
não sites inteiros.
24:24
Prompte mais curto,
24:24
respostas menores,
24:25
menos tentativas.
24:26
A potência do item
24:27
do executor
24:27
e a lógica de recuo
24:28
evitam chamadas duplicadas
24:29
e ciclos desperdiçados.
24:31
O efeito líquido
24:32
é menos tokens
24:32
por resultado bem sucedido
24:33
e muito menos variação.
24:35
O departamento financeiro
24:36
gosta de ação de variação.
24:37
A sobrecarga administrativa
24:38
diminui
24:38
porque a observabilidade
24:39
é projetada,
24:40
não improvisando.
24:40
Rastreios de nó
24:41
e logs imutáveis
24:42
reduzem o tempo
24:45
porque o mecanismo
24:46
de política negou
24:47
e o que o executor
24:47
tentou em seguida.
24:49
Implantações repetíveis
24:50
cortam trabalhos
24:51
no meu teatro de maio.
24:53
A conformidade
24:53
deixa de ser uma crise sazonal
24:54
porque cada execução
24:55
já contém quem,
24:56
o que, quando e por que.
24:58
Vamos tornar isso concreto
24:59
com o equipamento de medição
25:00
que você pode realmente executar.
25:02
Crie um conjunto
25:02
de avaliação
25:03
com tarefas representativas,
25:04
perguntas e respostas
25:05
com citações,
25:06
resumo com links
25:06
e propostas de ação.
25:08
Para cada resposta ideal
25:09
definida ao critério
25:09
de aceitação,
25:11
corrija os fatos
25:12
com edis de itens mapeados,
25:13
cobertura de citações
25:14
e variação permitida.
25:16
Instrumente SLOs P50
25:17
e P95 latência
25:18
de ponta a ponta,
25:19
gasto de token
25:19
por tarefa bem sucedida
25:20
e taxa de negação de político.
25:21
Vincule toda a métrica
25:22
a rastros
25:23
para que qualquer regressão
25:24
tenha um rastro.
25:25
Resultados que você deve esperar
25:26
se seguir a arquitetura,
25:27
não improvisá-la.
25:29
Maior varidade de resposta
25:30
porque alegações
25:31
sem suporte
25:31
nunca saem do preparo.
25:33
Menor latência
25:34
P95
25:35
porque caudas longas
25:35
são cortadas
25:36
por nós paralelos
25:37
e saídas antecipadas.
25:39
Menor gasto de token
25:40
porque você para
25:40
de enviar romances
25:41
e começa a enviar
25:42
trechos relevantes.
25:43
Menos chamados
25:45
aos administradores
25:45
pois a maioria das falhas
25:46
é resolvida por fallbacks.
25:48
E sim,
25:49
a métrica chata
25:50
é que todo mundo esquece.
25:51
Taxa de conclusão
25:52
bem sucedida
25:52
na primeira passagem.
25:53
Mais resgate humano
25:54
sem resgate humano.
25:55
Pacto nos negócios.
25:56
Resoluções mais rápidas
25:56
significam que os usuários
25:57
param de abrir tiques duplicaram.
25:59
Gastos previsíveis
25:59
significam um orçamento
26:00
sem ressaca de token surpresa.
26:02
Confiança em conformidade
26:03
significa menos ciclos de auditoria
26:04
sequestrando seu roteiro.
26:06
A vitória não óbvia
26:07
é a reputação.
26:08
Quando as respostas
26:09
do agente citam
26:10
o conteúdo locatário
26:11
e os links funcionam,
26:12
as pessoas confiam,
26:13
usam
26:13
e param de encaminhar
26:15
prints com a pergunta
26:16
por que ele disse isso?
26:18
Conselho direto
26:19
vincula o rastreamento
26:20
à métrica
26:20
ou você estará voando
26:21
apenas por opinião.
26:23
Se você não consegue
26:23
abrir uma execução
26:24
e ver que não é
26:25
inflow tokens
26:26
ou atrasou a latência
26:26
não tem observabilidade
26:27
tem apenas vibrações
26:28
com data e hora.
26:30
Tudo muda
26:31
quando o validador
26:32
fica entre um bom plano
26:33
e uma ação real.
26:35
A precisão estabiliza.
26:36
A latência diminui.
26:37
Custos se nivelam.
26:38
Admins dormem.
26:39
Isso não é mágica
26:40
são executores gráficos
26:41
e validação
26:42
fazendo o trabalho
26:42
que você atribuiu
26:43
incorretamente aos prompts.