Latest / M365.FM – Podcast de Microsoft 365, Copilot e IA em português / Crie um sistema de aprovação com IA no Microsoft Copilot Studio: Agent Flows em várias etapas e validação de recibos (Dublagem IA)

Transcript

Crie um sistema de aprovação com IA no Microsoft Copilot Studio: Agent Flows em várias etapas e validação de recibos (Dublagem IA) · M365.FM – Podcast de Microsoft 365, Copilot e IA em português

0:00
Você passa metade do dia esperando por aprovações.
0:02
Alguém está de férias, o outro não viu o e-mail,
0:04
e quando a decisão finalmente chega, o contexto que justificava o pedido já esperou.
0:09
Purgatório corporativo, progresso pausado por pessoas que juram estar ocupado.
0:13
Agora, imagina um sistema que simplesmente não espera.
0:15
Um fluxo de trabalho que avança assim que as condições são atendidas.
0:18
Apresentamos o Agent Flows do Microsoft Copilot Studio disfarçado de automação.
0:22
Aqui a IA se torna sua primeira aprovadora.
0:24
Ela lê os dados, avalia conforme a política e decide aprovar ou rejeitar,
0:28
antes que qualquer humano pisque.
0:31
Apenas casos complexos chegam à caixa de entrada de um gerente,
0:33
o que significa velocidade sem sacrificar o controle.
0:36
E, ao contrário dos fluxos de aprovação legados que colapsam sob complexidade condicional,
0:41
estes orientados por IA escalam, ramificam, validam e se auditam.
0:45
Neste passo a passo, mostrei como construir um sistema de aprovação condicional
0:48
que decide mais rápido do que seus colegas encontram o botão Responder a Todos.
0:53
Você aprenderá a configurar uma etapa de IA com lógica personalizada,
0:57
adicionar revisões humanas direcionadas e criar condições dinâmicas
1:01
que redirecionam de forma inteligente.
1:05
Ao final, você terá um processo automatizado que sabe quando pensar como uma máquina
1:08
e quando recorrer ao julgamento humano.
1:09
Pare de seguir uma fila.
1:11
Comece a deixar a lógica liderar.
1:13
Problema das aprovações tradicionais.
1:15
Cadeias de aprovação tradicionais são um remix trágico da mesma ineficiência.
1:19
Alguém envia um formulário.
1:20
E-mails voam, planilhas se desencontram e, entre loops de encaminhamento,
1:24
ninguém lembra qual era a versão final.
1:26
Cada participante adiciona atraso no valor.
1:28
O processo não gerencia o trabalho e ele fabrica latência.
1:32
Fluxos de aprovação típicos do Power Automate tentam resolver isso,
1:34
mas travam ao introduzir nuances.
1:37
Um caminho de aprovação único funciona bem se você só precisa de um sim ou não.
1:41
No momento em que você adiciona níveis gerenciais,
1:43
limites de gastos ou regras especializadas, o design começa a fragmentar.
1:46
Você acaba aninhando condições como bonecas russas,
1:48
deselegante, frágil e impossível de depurar seis meses depois.
1:51
Um conector quebrado e todo o sistema falha silenciosamente.
1:55
Humanos tornam-se gargalos, ou, sendo brutalmente preciso, nós de latência.
1:59
Cada mensagem que recebem torna-se mais uma rodada assíncrona.
2:02
E-mail como mecanismo de aprovação é como usar pombos correio em um mundo de fibra óptica.
2:06
Tecnicamente funciona, mas não deveria.
2:08
Conheça o Microsoft Copilot Studio.
2:10
Não é apenas uma versão incremental do Power Automate.
2:13
Ele introduz fluxos de agentes, sistemas de aprovação impulsionados por IA,
2:17
totalmente integrados às fontes de dados, papéis e estruturas lógicas da sua organização.
2:22
Ele une a aplicação de políticas determinísticas com a tomada de decisão adaptativa.
2:26
O brilhantismo reside em como ele separa as etapas.
2:29
Automatizado onde você quer velocidade.
2:30
Humano onde você ainda precisa de validação.
2:33
Pense nisso como uma hierarquia modelada.
2:35
O estágio de IA avalia regras fixas,
2:37
limites de valor, tipos de categoria,
2:39
intervalos de dados com eficiência clínica.
2:40
Então, se uma decisão oscila na ambividade,
2:43
o processo escala para a supervisão humana
2:45
sem forçar que cada caso trivial entre em uma fila.
2:47
Isso por si só elimina atrasos exponenciais.
2:49
Em vez de 10 pessoas realizando revisões em série,
2:52
a IA lida com 80% instantaneamente,
2:53
caminhando apenas os casos fora da curva.
2:56
E sim, o Copilot Studio rastreia tudo através de sua estrutura Dataverse,
2:59
gerando registros verificáveis sem que sua equipe precise vasculhar arquivos de e-mail.
3:03
Fluxos de trabalho anteriores foram construídos para o mundo.
3:06
Fluxos de agentes são construídos em torno deles,
3:07
mantendo as pessoas no circuito apenas quando interpretação e não repetição é necessária.
3:11
Assim que você vê como essa arquitetura funciona,
3:13
provações tradicionais parecerão primitivas,
3:14
como conferir talões de cheque à luz de velas.
3:17
O que está em jogo é simples, conformidade, consistência e escala.
3:20
Operações modernas se afogam sem validação automatizada,
3:23
e a lógica assistida por IA é agora a base para a confiabilidade.
3:26
Quando você migra de fluxos estáticos para fluxos de agentes condicionais e auditáveis,
3:29
você para de gerenciar provações reativamente
3:31
e começa a tratá-las como sistemas vivos.
3:34
A diferença não é apenas velocidade, a sanidade estrutural.
3:36
Construindo o estágio de IA, ensinando o primeiro aprovador.
3:40
Agora vem a parte interessante, treinar seu primeiro burocrata digital.
3:44
O estágio de IA é o guardião lógico do seu processo de aprovação.
3:47
Seu trabalho não é pensar como um humano,
3:49
mas realizar raciocínio estruturado com consistência sobre a humana.
3:53
Ele lê instruções, as verifica em relação às entradas
3:55
e produz um de dois vereditos, aprovado ou rejeitado.
3:58
Sem política, sem pausas para o café.
4:00
Você começa definindo um novo fluxo de agente.
4:01
Na criação, o estágio de IA fica em destaque como uma prova em branco,
4:05
esperando pelo seu gabarito.
4:07
O gatilho geralmente vem do Dataverse,
4:08
um registro adicionado ou modificado em sua tabela de solicitações ou despesas.
4:11
Assim que uma solicitação é criada, este estágio é ativado,
4:14
avalia os dados e decide de acordo.
4:16
Dentro do estágio, o campo mais importante é o prompt de instrução,
4:19
o cérebro da operação.
4:20
É aqui que você descreve a lógica de aprovação,
4:22
em linguagem simples, porém rigorosa.
4:24
Creva como se estivesse instruindo um advogado que nunca improvisa.
4:26
Por exemplo, aprove a solicitação se o valor for inferior a 500,
4:31
a descrição apoiar saúde física ou mental
4:32
e a data da compra estiver dentro de 30 dias do envio.
4:36
Rejeite-se qualquer regra falhar.
4:38
É isso, clareza binária.
4:40
Em seguida, defina suas entradas dinâmicas.
4:42
Pense nelas como variáveis alimentando dados reais em sua lógica.
4:45
Muito provavelmente você incluirá um valor,
4:46
uma descrição e uma data de compra.
4:48
Cada um é adicionado como conteúdo,
4:50
texto ou entradas numéricas
4:52
que a IA passará ao tomar uma decisão.
4:54
O Copilot Studio classifica essas entradas por tipo texto,
4:57
número ou documento de imagem.
4:59
Escolha corretamente, pois misturar tipos,
5:02
digamos um número armazenado como texto,
5:04
confunde humanos e máquinas,
5:05
abaixo de cada entrada forneça dados de amostra para teste.
5:08
Isso funciona como um suporte enquanto você calibra a lógica.
5:11
Por exemplo, insira uma solicitação de exemplo
5:12
com um tapete de OGA valor 300,
5:14
data de compra 22 de agosto.
5:17
Ao clicar em testar,
5:18
o Copilot Studio executa o modelo de raciocínio,
5:21
baseado em GPT internamente,
5:22
e gera uma decisão com uma explicação
5:24
se o resultado corresponder à sua expectativa.
5:26
Ótimo.
5:27
Se não, suas instruções carecem de determinismo.
5:30
E é aí que a maioria dos iniciantes é.
5:32
Frases amplas ou ambíguas,
5:34
como despesa razoável ou compra recente,
5:36
são um veneno.
5:37
Para IA.
5:38
O sistema não consegue ler humor corporativo,
5:39
ele precisa de definições matemáticas.
5:41
Portanto, refine suas instruções incansavelmente
5:43
até que os resultados dos testes sejam consistentes.
5:45
Cada vez que você reescreve,
5:46
está ajustando o motor de julgamento para a reprodutibilidade.
5:49
O padrão que você deseja
5:50
é uma entrada idêntica,
5:51
produzindo uma saída idêntica sempre.
5:53
Lógica de máquina, não fofoca de escritório.
5:55
Uma vez que seu prompt gera decisões confiáveis
5:57
em vários casos de teste,
5:58
você treinou seu aprovador de IA.
6:01
Agora, injete os dados dinâmicos reais
6:02
usando tokens do Dataverse,
6:04
detalhes do valor da solicitação,
6:05
data de compra ou envio.
6:07
Eles substituirão seus valores de teste
6:08
durante as execuções ré.
6:09
A partir desse ponto,
6:10
a IA avalia cada solicitação no contexto,
6:12
retornando.
6:13
Um veredito de aprovação
6:14
no momento em que novos dados aparecem.
6:15
Antes de declarar a vitória,
6:17
execute testes interativos.
6:18
Altere o valor para 600,
6:19
ele rejeita.
6:20
Altere a data para 3 meses atrás,
6:22
ele sinaliza como invale.
6:23
Adicione uma solicitação sem sentido
6:24
com compra de iPad.
6:25
Ele detecta incompatibilidade.
6:27
Cada passagem deve demonstrar
6:28
causa e efeito consistentes.
6:30
Se as respostas flutuarem,
6:31
o problema é a clareza do seu prompt
6:32
no modelo de A.
6:33
Quando padrões consistentes surgirem,
6:35
estabeleça uma convenção de nomenclatura
6:37
para suas variáveis de conteúdo.
6:38
Prefixos como STR para valor da solicitação
6:40
ou NUM para data de compra
6:41
e valores numéricos.
6:42
Essa pequena disciplina evita o caos
6:44
quando você expandir
6:45
para uma lógica de múltiplas ramificações.
6:48
Nesta fase,
6:49
seu aprovador automatizado
6:50
pode tomar decisões independentes
6:51
com base na política sem supervisão.
6:53
Mas automação não é ditadura,
6:55
é delegação.
6:56
A máquina lida com velocidade e precisão
6:57
num julgamento.
6:58
Para cenários limítrofes,
7:00
você precisará de escalonamento.
7:01
Um humano no circuito
7:02
para revisar o que a EA recusa
7:03
ou considera incerto.
7:05
É aí que a próxima fase entra em cena
7:06
e é assim que a autoridade
7:07
é compartilhada entre o silício e a equipe.
7:10
Adicionando supervisão humana.
7:11
Lógica de vários estágios e condicionado.
7:13
Uma vez que sua EA julgue solicitações
7:15
com confiança,
7:15
você pode adicionar o que a burocracia
7:17
ironicamente chama de toque humano.
7:19
No Copilot Studio,
7:20
isso significa um estágio manual,
7:22
um ponto de verificação
7:23
onde uma pessoa real
7:23
pode exercer seu discernimento.
7:25
Pense nisso como sua válvula de segurança.
7:27
Tudo que é previsível
7:28
flui automaticamente.
7:30
Qualquer coisa com nuances
7:31
vai para a mesa de um gerente.
7:32
Você começa no design de aprovação
7:34
adicionando um estágio manual
7:35
logo após o estágio da EA.
7:36
Isso cria uma segunda barreira
7:37
no fluxo do seu agente.
7:39
A transferência condicional.
7:39
Somente se o veredito da EA for aprovado,
7:42
seguimos para o estágio humano.
7:44
Se a EA de ser rejeitada,
7:45
o processo termina ali mesmo.
7:47
Por que perder tempo pedindo aos gerentes
7:48
para confirmar o que a política
7:49
já desqualificou?
7:51
Eficiência e atenção seletiva
7:52
disfarçada de automação.
7:54
Vou montar um cenário de exemplo.
7:55
Suponha que um funcionário envia
7:56
uma solicitação de reembolso
7:57
para a academia.
7:58
A EA aprova o que todos os critérios
8:00
estão de acordo com a política.
8:01
Agora, essa decisão aciona
8:03
um estágio manual de nível gerencial
8:04
chamado aprovação de gerente.
8:05
Por baixo dos panos,
8:07
você configura esse estágio
8:08
com o título como
8:09
Solicitação de aprovação
8:10
de despesa de quem enviou.
8:12
Essas variáveis
8:12
extraem dados dinamicamente
8:13
do Dataverse.
8:15
O campo atribuído
8:16
é onde você define
8:17
quem recebe a tarefa,
8:18
geralmente o gerente
8:18
do solicitante.
8:20
Para automatizar esse roteamento,
8:21
o Copilot Studio permite
8:22
integrar o conector de usuários
8:24
do Office 365.
8:25
Primeiro,
8:26
obtenha um registro do usuário
8:27
de quem criou a solicitação,
8:28
usando a ação
8:29
obter linha por ID
8:30
na tabela de usuários
8:30
no Dataverse.
8:32
Isso recupera as informações
8:33
de quem enviou.
8:34
Em seguida,
8:34
a ação obter gerente,
8:35
busque o gerente daquele usuário
8:36
através do e-mail principal.
8:38
Passe esse resultado
8:39
de volta para seu estágio manual
8:40
com uma variável
8:40
com o e-mail do gerente STR.
8:42
Resultados sem codificação fixa,
8:43
sem hierarquias obsoletas.
8:45
Gerentes mudam,
8:46
a hierarquia se atualiza sozinha.
8:48
Agora vem a ramificação condicional,
8:49
verdadeiro motivo
8:50
da existência de aprovações
8:51
e várias etapas.
8:52
Você pode introduzir lógica
8:53
diretamente dentro do fluxo do agente.
8:55
Se o valor da solicitação
8:56
for maior ou igual a 150,
8:57
adicione um estágio adicional
8:58
para aprovação administrativa.
9:00
Caso contrário,
9:00
isso transforma
9:02
uma rotina simples
9:03
de duas etapas
9:03
em uma árvore de decisão
9:05
de vários níveis
9:05
que se adapta ao contexto.
9:07
Solicitações de baixo valor
9:08
passam a pessoa.
9:09
Solicitações de maior valor
9:10
ou risco
9:10
são escaladas para um olhar extra.
9:12
No designer,
9:12
insira uma ação de condição
9:13
antes de fechar o fluxo.
9:15
Referencia sua variável numérica,
9:16
talvez o valor numérico
9:17
da solicitação.
9:18
Escolha o operador maior
9:19
ou igual a
9:20
e defina o limite
9:22
como 150.
9:24
No ramo se verdadeiro,
9:25
adicione outro estágio manual
9:26
chamado aprovação administrativa.
9:27
Atribua um aprovador fixo
9:29
como administrador de conformidade.
9:30
Num ramo se falso,
9:31
finalize como aprovado.
9:33
O efeito,
9:33
o fluxo de trabalho
9:34
se comporta como
9:35
uma organização racional
9:36
em vez de um gargalo universal.
9:38
Pouco de humor prático
9:39
se aplica aqui.
9:40
Sim,
9:40
a delegação ainda exige confiança,
9:42
não apenas otimismo.
9:43
Não atribua funções
9:44
de segurança amplas
9:45
que permitam aprovar tudo.
9:46
Restringe as permissões
9:47
aos usuários
9:47
ou grupos relevantes
9:48
por meio do controle de acesso
9:49
baseado em funções do Dataverse.
9:50
Caso contrário,
9:51
você automatizou a anarquia.
9:52
Testar a estrutura
9:53
revela com suavemente
9:54
cada peça e se encaixa.
9:56
Quando uma solicitação
9:56
abaixo de US$ 150
9:57
passa pela revisão da IA,
9:59
o fluxo termina
9:59
após a aprovação do gerente.
10:01
Quando ultrapassa
10:01
o US$ 150,
10:02
o sistema gentilmente
10:03
a coloca na fila
10:04
para a revisão do administrador
10:05
antes de finalizar.
10:06
Cada caminho
10:06
deixa uma trilha de auditoria,
10:07
o registro de raciocínio da IA,
10:09
aprovações com carimbo
10:09
de data barra hora
10:10
e resultados registrados
10:11
no Dataverse.
10:12
Ninguém poderá alegar depois,
10:13
eu nunca vi isso.
10:14
O banco de dados
10:15
é o contrário.
10:15
A medida que refina
10:16
mantém as convenções
10:17
de nomenclatura disciplinada.
10:18
Prefixe as etapas humanas
10:20
claramente,
10:20
como aprovado pelo gerente
10:21
ou aprovado pelo administrador
10:22
para que você possa
10:23
rastrear as ramificações de zonho.
10:24
O fluxograma
10:25
deve ser lido como lógica,
10:26
não como arte misteriosa.
10:28
Uma vez satisfeito,
10:28
publique teste
10:29
com cenários reais.
10:31
Observe a cadeia
10:31
se desenrolar.
10:32
A IA avalia instantaneamente.
10:34
O gerente recebe
10:34
uma tarefa de aprovação
10:35
direcionada.
10:36
O administrador entra
10:37
apenas quando as condições exigem.
10:39
O resultado
10:39
parece menos
10:40
com uma automação
10:40
fazendo tudo e mais
10:41
com uma hierarquia
10:42
transparente
10:43
que se auto-gestiona.
10:45
Essa orquestração
10:45
em camadas também
10:46
expõe uma nova fronteira,
10:47
a validação de documentos.
10:49
Porque é às vezes
10:50
um campo de formulário
10:50
mente, mas o recibo não.
10:52
O próximo passo
10:53
é fazer com que a IA
10:54
examine a evidência física
10:55
antes mesmo de chegar
10:55
à sua caixa de entrada.
10:57
É aí que entra
10:57
a validação de recibos,
10:58
transformando a burocracia
10:59
em ciência verificada.
11:01
Entradas dinâmicas,
11:02
validação de documentos.
11:03
Vamos falar sobre recibos,
11:04
aqueles pequenos pedaços
11:05
de papel amassados
11:06
que misteriosamente
11:07
se tornam evidências cruciais
11:08
quando alguém quer reembolso?
11:10
Em um processo
11:10
de aprovação manual,
11:12
humanos os verificam visualmente.
11:14
Sim, isso parece
11:14
um tapete de yoga,
11:15
um IA. Em um processo
11:17
automatizado, fazemos a IA
11:18
realizar a mesma verificação
11:19
sem fadiga de julgamento.
11:21
Nos fluxos de agentes
11:21
do Copilot Studio,
11:22
a validação de documentos
11:23
ganha vida por meio
11:24
de entradas de conteúdo dinâmico,
11:26
especificamente a capacidade
11:27
de passar uma imagem
11:27
ou arquivo para sua lógica
11:28
de aprovação.
11:30
Isso adiciona um terceiro sentido
11:31
ao seu aprovador de IA Visão.
11:32
Em vez de confiar
11:33
apenas em campos de texto,
11:34
o modelo lê o documento
11:35
e compara o que está escrito
11:36
com o que foi enviado.
11:38
Aqui está estrutura.
11:39
Dentro do seu estágio de IA,
11:40
você adiciona um novo tipo
11:41
de entrada chamado
11:42
imagem ou documento.
11:43
Dê um rótulo claro
11:44
ou algo como
11:45
arquivo de recibo doc.
11:46
Envie um recibo de exemplo
11:47
para teste.
11:48
Isso não entra em produção,
11:49
apenas treine o layout da lógica.
11:51
Agora, ajuste seu prompt
11:52
de instrução para incluir
11:53
a validação cruzada do documento.
11:55
Você amplia sua lógica anterior.
11:56
Aprove a solicitação
11:57
se tudo o seguinte for verdade,
11:58
valor de 500.
11:59
Detalhes da solicitação
12:00
suportam saúde física ou mental,
12:01
data da compra dentro de 30 dias,
12:02
e o documento de 30 dias
12:03
e o documento de recibo
12:04
corresponde ao item,
12:05
valor e data declarados.
12:06
Essa quarta condição
12:07
transforma-se ao aprovador de IA
12:08
de um executor de políticas
12:09
em um contador forense.
12:10
Quando o teste é executado,
12:12
o modelo extrai texto
12:13
legível do documento
12:14
e verifica a consistência
12:16
com suas entradas estruturadas.
12:18
Se o recibo listar
12:18
um tapete de yoga
12:19
por US$ 300 em 22 de agosto
12:21
e sua solicitação
12:22
disser qualquer outra coisa,
12:23
o veredito muda para rejeitado.
12:25
Agora, para a implementação.
12:26
Antes que a aprovação ocorra,
12:27
você precisará buscar esse documento.
12:29
Use a ação de baixar
12:29
um arquivo ou a imagem
12:30
do Dataverse.
12:32
Ponte para a mesma tabela
12:32
em que o registro
12:33
da solicitação reside,
12:34
provavelmente sua ação está.
12:35
Na coluna de arquivo,
12:36
escolha o campo de anexo,
12:37
frequentemente nomeado
12:38
como recibo.
12:39
Em seguida,
12:40
especifique o ID da linha
12:41
dinamicamente a partir do gatilho,
12:42
o identificador único
12:43
da solicitação.
12:45
Essa ação retorna metadados
12:46
e conteúdo do arquivo,
12:47
mas aqui está a armadilha sutil.
12:49
A saída do conteúdo
12:49
precisa de um pequeno ajuste
12:51
para que a IA
12:51
interprete corretamente.
12:53
Ao mapear o conteúdo
12:54
do arquivo na entrada
12:55
do seu recibo,
12:56
abra o editor de expressões
12:57
e adicione content
12:58
à referência do corpo.
13:00
Esse último ajuste
13:01
entrega os bytes reais
13:02
do arquivo
13:02
em vez do invólucro
13:03
de metadados.
13:04
Se ignorar isso,
13:05
sua IA aprovará
13:06
entusiasticamente
13:06
recibos em branco.
13:07
Vamos abordar
13:08
a sincronização
13:09
ou calcanhar de Aquiles
13:10
dos fluxos de trabalho
13:10
e documentos.
13:11
A maioria das tabelas
13:12
do Dataverse
13:13
não armazena anexos
13:14
até que o registro
13:14
seja salvo,
13:15
o que significa
13:16
que se seu fluxo
13:16
for acionado
13:17
na criação do registro
13:18
ele pode disparar
13:18
antes que o arquivo exista.
13:21
Sintoma
13:21
O fluxo falha
13:22
ou o conteúdo do recibo
13:23
fica nulo.
13:24
O remédio elegante
13:24
altere a condição de gatilho
13:26
para a não modificação
13:27
do item,
13:28
mas restringe-a
13:28
para disparar apenas
13:29
quando a coluna de recibo
13:30
for alterada.
13:31
Dessa forma,
13:31
no momento em que alguém envia
13:33
ou substitui um arquivo,
13:34
a validação
13:34
entra em ação.
13:36
Para configurar isso,
13:37
abra as configurações
13:38
do gatilho,
13:38
escolha as colunas modificadas
13:40
e cole o nome lógico
13:41
da sua coluna de recibo,
13:42
obtido nos detalhes
13:43
da coluna do Dataverse
13:43
em ferramentas avançadas.
13:46
Uma vez definido o public,
13:47
agora sua automação
13:48
se comporta de maneira educada.
13:50
Ela espera até que
13:50
haja algo de fato
13:51
para validar.
13:52
Quando a solicitação
13:53
é atualizada
13:54
com o novo recibo,
13:54
o fluxo reinicia.
13:56
Ele baixa o arquivo,
13:57
processa através
13:57
da etapa de IA
13:58
e verifica todas as entradas.
14:01
Se houver discrepâncias,
14:02
incompatibilidade de valores,
14:03
data desatualizada
14:04
ou descrições inconsistentes,
14:06
a IA rejeita
14:06
e inclui uma explicação.
14:08
O registro de raciocínio
14:09
pode dizer
14:09
o valor solicitado
14:10
de US$ 305
14:11
difere do total
14:12
do documento de US$ 300.
14:13
Isso é conformidade
14:13
sem reclamações.
14:14
Um impacto prático.
14:16
Cada envio
14:16
torna-se autoaditável.
14:18
Os funcionários
14:18
não conseguem mais
14:19
passar recibos questionáveis
14:20
ou descrição em vagas.
14:22
A IA fornece o julgamento,
14:23
o Dataverse fornece
14:24
as evidências
14:25
e nenhum deles
14:25
faz pausas para o café.
14:27
Tanto não,
14:28
a validação de documentos
14:29
não é um exagero.
14:30
É uma memória imune
14:30
para seus fluxos de trabalho.
14:32
As anomalias
14:33
são detectadas
14:34
no nível molecular,
14:35
nos caracteres
14:35
impressos nos recibos
14:36
e o revisor humano
14:37
é promovido
14:38
de verificador manual
14:38
a gestor de sessões.
14:40
Parabéns,
14:41
você automatizou
14:41
a própria honestidade
14:42
construindo confiabilidade,
14:45
testando,
14:45
versionando
14:46
e publicando.
14:47
Qualquer automação
14:48
pode parecer perfeita
14:49
até começar a rodar.
14:50
É por isso que a confiabilidade
14:51
não é uma fase,
14:52
é uma disciplina.
14:53
Copilot Studio
14:54
torna essa disciplina
14:54
surpreendente
14:55
com controles de versão,
14:56
teste e publicação
14:57
incorporados diretamente
14:58
nos fluxos do agente.
14:59
Comece com testes iterativos.
15:01
Todo fluxo de aprovação
15:02
é um ecossistema miniatura.
15:04
Até um nome de variável
15:05
fora de lugar
15:05
pode criar o caos.
15:07
Tanto trate os testes
15:07
como um processo científico,
15:10
isole as mudanças,
15:10
aplique os dados,
15:11
observe o resultado.
15:13
No editor de fluxo,
15:14
o Copilot Studio
15:14
permite simular dados
15:15
de amostra
15:16
sem implantar gatilhos
15:17
de produção.
15:18
Alimente cenários variantes,
15:20
valores muito altos,
15:21
datas obsoletas,
15:22
nomes de itens irrelevantes
15:23
e garanta que cada um
15:23
produza o veredito correto.
15:25
Depois,
15:26
parte convenções de nome em cartão.
15:27
Chato?
15:28
Não.
15:28
Existe?
15:29
Mais um.
15:30
Coloque prefixes
15:31
em todas as variáveis
15:31
de formos.
15:32
STR para strings,
15:33
NUM para numéricos,
15:34
DOC para arquivos.
15:35
Da mesma forma,
15:36
rotule as ações explicitamente.
15:37
Baixe arquivo de recibo,
15:38
verifique a aprovação do gerente,
15:39
atualize a aprovação de reivindicação.
15:40
Porque daqui a três meses,
15:41
quando alguém perguntar
15:42
por que a ação 7 quebrou,
15:43
você agradecerá por trilhas
15:44
serem melhores que a arqueologia.
15:46
Uma vez que os testes individuais
15:48
tenham sucesso,
15:48
expanda para a validação
15:49
de cenários críticos.
15:50
Finja ser usuário incompetente.
15:52
Não envie recibo,
15:53
mude uma data para o ano que vem.
15:57
Confirme se a IA explica
15:58
e rejeita sem travar.
16:00
Esses não são erros hipotéticos,
16:01
são ensaios da realidade.
16:03
Quanto mais casos de falha
16:04
você neutralizar de antemão,
16:06
menos mensagem no Teams
16:06
às 2 da manhã,
16:07
você receberá dizendo
16:08
que o fluxo parou de novo.
16:10
A publicação introduz a governança.
16:12
Toda vez que você salva
16:13
uma mudança importante,
16:14
o Copilot Studio
16:14
cria silenciosamente
16:15
uma nova versão.
16:16
Você pode reverter qualquer um,
16:18
sem ansiedade de substituição.
16:19
Use isso para manter
16:20
ambientes de lógica experimental,
16:21
separados da produção.
16:23
Um fluxo chamado
16:24
aprovação de reivindicação DEV,
16:25
outra aprovação de reivindicação PRO.
16:26
Teste em DEV,
16:27
publique apenas quando estiver estável.
16:29
Lembre-se,
16:30
confiabilidade não é apenas
16:31
sobre correção,
16:31
é sobre controle durante mudanças.
16:34
Após a aplicação,
16:36
aproveite os logs de atividade.
16:37
Eles não são decorativos,
16:38
são registros com valor legal
16:39
das interações entre IA e humanos.
16:41
Carimbo de data barra hora,
16:42
identidade dos aprovadores,
16:43
resumo de raciocínio.
16:44
Revise esses logs periódicamente.
16:46
Os padrões se revelarão.
16:48
Quais regras geram mais rejeições?
16:49
Quais gerentes substituíram a IA
16:50
com que frequências
16:51
as etapas de conformidade
16:52
são acionadas?
16:53
Esses insights refinam
16:54
tanto a política quanto o design.
16:56
Outra prática recomendada e sutil,
16:58
automatize atualizações
16:59
de status de volta
16:59
nos registros do Dataverse
17:00
ao final de cada ramificação.
17:02
A ação de atualizar uma linha
17:03
define um campo claro
17:04
como status da reivindicação
17:05
igual, aprovado, rejeitado.
17:07
Esse ponto de extremidade visível
17:08
reforça a confiança.
17:09
Os usuários veem as decisões
17:10
dentro de suas próprias
17:11
visuações de tabela.
17:12
Sem planilhas de rastreamento
17:13
separadas,
17:13
sem aprovações de fantasmas.
17:15
Quando seu sistema passar
17:15
em todos os testes,
17:16
clique em publicar
17:17
com total confiança.
17:18
Diferente das gerações anteriores
17:19
de fluxos do Power Automate,
17:21
os fluxos de agente
17:21
retém metadados contextuais,
17:23
esquema de decisão da IA,
17:24
associações de conteúdo dinâmico
17:25
e tags de versão.
17:27
O resultado não é apenas
17:28
um processo em execução,
17:29
mas um artefato reproduzível,
17:30
uma automação editável.
17:32
A verificação final
17:33
de confiabilidade mental.
17:34
Resista à superengenharia.
17:36
Às vezes, um fluxo com falha
17:37
revela regras complexas demais
17:38
no bugs técnicos.
17:40
Simplifique a lógica
17:40
sempre que possível.
17:41
Menos etapas,
17:42
instruções mais claras,
17:43
ambiguidade mínima.
17:44
O inimigo da automação
17:46
não é a aleatoriedade
17:47
e a esperteza desnecessária.
17:49
Ao concluir esta etapa,
17:50
seu sistema de aprovação
17:51
alcança a maturidade operacional.
17:53
Testado, versionado,
17:54
fácil de reverter,
17:54
verificável.
17:56
Cada resultado,
17:57
desde o julgamento da IA
17:57
até a assinatura do administrador,
17:59
deixa um registral
17:59
resistente a escrutínios.
18:01
Isso é confiabilidade quantificada,
18:02
não é um sentimento,
18:03
não é sorte,
18:03
é apenas raciocínio estruturado,
18:05
registrado fielmente
18:05
pelas ferramentas que você criou
18:07
para pensar em quanto você dorme.
18:09
Resultados e retorno
18:10
no mundo real.
18:11
O que acontece
18:11
quando você entrega
18:11
a burocracia matemática?
18:13
As aprovações esperaram.
18:14
Um fluxo de agente
18:15
de vários estágios
18:16
orientado por IA
18:17
reduz o tempo de resposta
18:18
de dias para minutos
18:18
porque as decisões
18:19
não dependem mais
18:20
da disponibilidade na agenda.
18:22
Cada solicitação
18:22
que atende a política objetiva
18:23
é aprovada instantaneamente.
18:25
Cada caso excepcional
18:26
cai perfeitamente
18:27
na fila do gerente,
18:28
já com o contexto anexado.
18:30
Os humanos fazem julgamentos
18:31
de valor,
18:31
não confirmações burocráticas.
18:33
O impacto aparece primeiro
18:34
como compressão de tempo.
18:35
Um reembolso
18:36
que antes exigia 4 e-mails
18:37
e 2 lembretes agora
18:38
é resolvido antes do almoço.
18:40
Os departamentos
18:40
experimentam ciclos
18:41
um pensamento mais curtos,
18:42
menos tempo ocioso
18:43
e trilhas de raciocínio
18:44
perfeitamente registradas.
18:45
O mecanismo de aprovação
18:47
deixa de ser uma interrupção
18:48
e se torna infraestrutura.
18:51
Depois vem a redução de erros.
18:52
Ao impor regras determinísticas
18:53
por meio da IA,
18:54
você elimina o desvio subjetivo,
18:55
o grande problema,
18:56
das aprovações manuais.
18:58
Chega de eu achei
18:58
que isso contava
18:59
como saúde e bem-estar.
19:01
A IA interpreta os critérios
19:02
da mesma forma todas as vezes.
19:03
A consistência escala melhor
19:05
do que a compaixão
19:05
na lógica administrativa.
19:07
Os gerentes lidam apenas
19:08
com anomalias
19:08
e até mesmo elas vêm
19:09
com uma trilha
19:10
de auditoria completa.
19:11
Entradas de dados,
19:12
histórico de decisões,
19:13
explicação do lugar.
19:14
As auditorias se transformam
19:15
de exercícios de pânico
19:16
em verificações cordiais.
19:17
Em nível organizacional
19:18
isso não é apenas mais rápido,
19:19
é mais seguro,
19:20
é mais seguro.
19:21
A conformidade não depende
19:22
de memória ou humor.
19:23
Ela é integrada.
19:24
Os logs do Dataverse
19:25
mostram quem aprovou,
19:26
quando e porquê.
19:28
Essa transparência
19:28
desencoraja a cultura de atalhos
19:30
porque toda decisão agora
19:30
vive em permanência pesquisável.
19:33
E, filosoficamente,
19:34
o fluxo de trabalho
19:35
muda de humano primeiro
19:35
com assistência de IA para IA,
19:37
primeiro com correção humana.
19:38
Governança prática,
19:39
não ficção científica.
19:40
IA cuida da aplicação das regras
19:42
que os humanos cuidam do julgamento.
19:43
O híbrido produz sistemas
19:44
mais justos, rápidos
19:45
e, por fim, mais confiáveis.
19:47
Imagine explicar isso
19:48
a um auditor.
19:49
O sorriso que vem depois disso
19:50
já faz automação
19:51
valer a pena por si só.
19:52
É isso.
19:53
O Microsoft Copilot Studio
19:54
não é apenas mais
19:55
uma ferramenta de automação.
19:56
É o lugar onde a indecisão
19:57
da sua organização
19:58
finalmente se aposenta.
19:59
Você cria um mecanismo
20:00
de aprovação capaz
20:01
de pensar em condições,
20:02
escalar com responsabilidade,
20:03
validar recibos com a realidade
20:04
e documentar
20:05
cada movimento realizado.
20:07
Isso não é um fluxo,
20:07
é um modelo de governança.
20:09
Se não se lembrar de mais nada,
20:10
lembre-se disso.
20:11
A IA deve tornar
20:12
as decisões previsíveis
20:13
e os humanos excepcionais.
20:15
Pare de encaminhar tudo
20:16
para as pessoas
20:16
por por hábito.
20:17
Deixe a lógica cuidar da rotina
20:19
para que os gestores
20:19
cuidem das exceções.
20:21
Agora, se este passo a passo
20:22
te salvou de mais uma semana,
20:23
aguardando a revisão
20:24
de um gestor,
20:25
considere se inscrever.
20:26
O próximo tutorial
20:27
mergulha mais fundo
20:28
em automações avançadas
20:29
do Copilot Studio,
20:30
onde esses fluxos de agentes
20:31
se conectam com as análises
20:32
da Power Platform
20:32
e políticas adaptáveis.
20:33
Garanta seu caminho
20:35
de atualização,
20:36
inscreva-se,
20:36
ative os alertas
20:37
e deixe que novos episódios
20:38
sejam implantados automaticamente.
20:39
Sem verificações manuais,
20:40
sem perder lançamentos,
20:41
apenas entrega contínua
20:42
de conhecimento útil.
20:43
Tchau, tchau.