Latest / M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano / Architettura degli agenti IA: executor, grafi di workflow e validazione per agenti davvero affidabili (Doppiaggio IA)

Transcript

Architettura degli agenti IA: executor, grafi di workflow e validazione per agenti davvero affidabili (Doppiaggio IA) · M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano

• 0:00
  L'unica convalida che impedisce agli agenti intelligenti di fare cose stupide.
• 0:04
  C'è un gate che trasforma l'intelligenza in competenza e il controllo del contratto di preesecuzione.
• 0:07
  Prima che venga eseguito qualsiasi strumento, il validatore dimostra tre cose in ordine.
• 0:11
  L'intento corrisponde a una capacità reale chiamante all'autorizzazione in questo momento
• 0:15
  e il risultato richiesto è fattibile entro i limiti di dati dichiarati.
• 0:18
  Se una parte non riesce, non viene eseguito a nulla.
• 0:21
  Non fare attenzione, non provare comunque.
• 0:22
  Nega con motivazioni alternative.
• 0:24
  Inizia con la corrispondenza della capacità.
• 0:26
  Il piano dice di elemento dell'elenco di SharePoint.
• 0:27
  Il validatore chiede quale strumento, quale metodo, quale versione dello schema.
• 0:32
  Gli argomenti vengono verificati rispetto ai registri.
• 0:34
  I campi obbligatori sono presenti, i tipi sono corretti, gli intervalli di valori sono sani
• 0:37
  e se nessun campo extra è introdotto di nascosto nella speranza che qualcuno li ignori.
• 0:41
  L'aliasing degli strumenti è vietato.
• 0:43
  Usa il nome canonico verrà rifiutato.
• 0:45
  Ciò elimina strumenti allucinatori e parametri inaffidabili prima che possano comportarsi in modo da no.
• 0:49
  Successivamente è conformità ai criteri.
• 0:51
  Il motore dei criteri valuta la chiamata proposta rispetto ai criteri a T.
• 0:55
  Elenchi consentiti per strumenti e domini.
• 0:56
  Controlli RBX o ABC collegati a richieste di missione di ID e ambiti.
• 1:01
  Regole di livello ambientale.
• 1:03
  Limiti di classificazione dei dati.
• 1:04
  Se l'agente è limitato ai file, letto per un sito specifico, una chiamata di aggiornamento
• 1:08
  o un sito diverso è un no assoluto.
• 1:10
  Se il payload rientra nella classificazione limitata senza un checkpoint umano, anche questo no.
• 1:14
  I token vengono verificati fresco.
• 1:16
  Gli ambiti vengono verificati esatti e l'escalation dei privilegi solo questa volta
• 1:20
  viene trattata come ciò che è un tentativo di violazione.
• 1:23
  Quindi fattibilità post-condizione.
• 1:24
  Non è sufficiente con il risultato.
• 1:27
  Deve essere realizzabile e verificabile.
• 1:29
  Il validatore chiede.
• 1:30
  La destinazione supporta le chiavi di potenza dei elementi.
• 1:33
  Il sistema emetterà un identificatore durevole o un e-tag che possiamo verificare dopo.
• 1:36
  Esiste un'azione compensativa in caso di fallimento a val.
• 1:38
  Se il piano non riesce a produrre post-condizioni verificabili, viene rifiutato e riscritto.
• 1:43
  Non accettiamo i dati di me, lo registrerò più tardi.
• 1:45
  E come si verificano gli incidenti?
• 1:47
  Metti insieme questi elementi e ottieni il trio gate, la corrispondenza delle capacità,
• 1:50
  la conformità alle polisi e la fattibilità post-condizioni.
• 1:52
  Supera tutti e tre i test e l'esecutore procede.
• 1:54
  Se ne fallisce uno, si attiva il percorso con motivo.
• 1:57
  Tale percorso è educato, completo e inequivocabile.
• 2:00
  Ecco cosa è provato.
• 2:01
  Ecco la polisi o lo schermo esatto che è violato.
• 2:03
  Ecco delle alternative sicure.
• 2:04
  Se l'intento dell'utente può essere riparato, restringi l'ambito,
• 2:07
  passa a un riepilogo di sola lettura e indirizza un sito consentito.
• 2:11
  Il validatore propone un piano conforme e chiede l'approvazione.
• 2:14
  Se non può essere riparato, passa a un checkpoint umano con contesto completo
• 2:17
  e interrompi del tutto.
• 2:19
  Nessun mistero si blocca.
• 2:20
  Nessun successo silenzio.
• 2:22
  Breve microstoria che hai vissuto, anche se non lo sapevi.
• 2:25
  All'agente viene chiesto di riassumare tutti i documenti delle risorse umane
• 2:28
  dell'ultimo trimestre e di inviare l'ufficio legale.
• 2:29
  Il recupero propone query grafiche tra i siti dell'ufficio legale.
• 2:32
  Il validatore rieva a un superamento dei confini.
• 2:34
  Le risorse umane sono limitate.
• 2:36
  L'ufficio legale è interno.
• 2:37
  Il gate trio blocca la lettura incrociata e l'email in uscita.
• 2:40
  Viene restituito il percorso di rifiuto.
• 2:42
  Rilevato contenuto è limitato.
• 2:44
  Alternativa proposta.
• 2:45
  Riassume l'indice delle polisi interne e fornisce un collegamento di richiesta
• 2:47
  per il revilogo delle risorse umane e revisore autorizzati.
• 2:50
  L'utente approva il piano conforme.
• 2:52
  L'esecutore lo esegue, inserisce il contenuto interno
• 2:54
  e lega una richiesta di autorizzazione per il materiale delle risorse umane.
• 2:57
  Nessuna perdita, nessun dramma, comunque.
• 2:58
  L'implementazione è noiosa per progettazione.
• 3:01
  Un DSL di polisi definisce chi può fare cosa, dove e con quali effetti collaterali.
• 3:04
  Un registro di schema archivi a contratti, nomi, versioni, forme di argomenti
• 3:07
  e condizioni di post degli strumenti.
• 3:09
  Un risolutore di elenchi consentiti, mappa, domini, siti e ambiti a livelli di ambiente.
• 3:14
  Il validatore li compone, timbra ogni decisione con un record di audit, input,
• 3:17
  valutazioni delle polisi, risultati e consegna un semaforo verde
• 3:20
  o un piano di riparazione all'esecutore.
• 3:23
  L'esecutore non si muove mai in modo autonomo quando c'è un semaforo.
• 3:25
  Fa rispettare la decisione e si ferma.
• 3:27
  Il modello mentale è abbastanza pulito da essere tatuato sulla fronte del diagramma dell'architettura.
• 3:31
  Gli esecutori fanno rispettare.
• 3:32
  I grafici vincono.
• 3:33
  I validatori decidono.
• 3:34
  In quest'ordine, il modello propone solo all'interno del cortile recintato
• 3:38
  e nel momento in cui cerca di scavalcarlo, il validatore lo tira indietro,
• 3:41
  spiega il motivo e indica il cancello.
• 3:43
  Ordine preservato.
• 3:45
  Sicurezza applicata.
• 3:46
  Progresso sbloccato.
• 3:47
  Il rispetto delle polisi.
• 3:47
  Volevi qualcosa che impedisse agli agenti intelligenti di fare cose stupide.
• 3:52
  Ecco qua, un controllo del contratto preesecuzione
• 3:54
  che dimostra capacità, autorizzazione e risultato verificabile
• 3:57
  prima di qualsiasi mutazione nel mondo reale.
• 3:59
  Trasforma, penso di potercela fare in suono autorizzato,
• 4:01
  so come fare e posso dimostrare averlo fatto.
• 4:03
  No, no, l'oscurità non ci capita.
• 4:06
  Ora è l'architettura.
• 4:08
  Usala.
• 4:09
  Conclusione chiave, più ct.
• 4:10
  Conclusione chiave, i prompt sono opinioni,
• 4:13
  gli esecutori grafici convalidati sono operazioni
• 4:15
  e il controllo del contratto preesecuzione
• 4:16
  è il parapetto che mantiene entrambi onesti.
• 4:19
  Se questo ti ha fatto risparmiare tempo, ripaga il tempo.
• 4:22
  Iscriviti.
• 4:23
  Successivamente, guarda la ripartizione di Landcraft
• 4:25
  rispetto a Microsoft Agent Framework
• 4:27
  su prestazioni e osservabilità, tracce effettive, costi e P95.
• 4:31
  Blocca il tuo percorso di aggiornamento,
• 4:32
  segui abilità gli avvisi e ricevi i prossimi episodi nei tempi previsti.
• 4:35
  Procedi.
• 4:36
  La maggior parte delle persone pensa che i prompt migliori risolvano gli agenti.
• 4:39
  Belle teorie.
• 4:39
  I prompt guidano i pensieri, non eseguono operazioni.
• 4:42
  In realtà, l'affidabilità deriva dagli esecutori
• 4:44
  e dalla convalida dei grafici,
• 4:46
  la spina dorsale che impedisce agli agenti di cadere a terra
• 4:48
  quando la realtà si presenta.
• 4:49
  Collegheremo questo agli scenari Microsoft
• 4:51
  al recupero dei grafici di Microsoft 365
• 4:53
  al ragionamento di Azure OpenAI
• 4:54
  e agli agenti Copilot Studio che non diventano canaglia.
• 4:57
  La posta in gioco è semplice.
• 4:59
  Accuratezza, latenza, costi e verificabilità.
• 5:02
  Misurabili, non vibrazioni.
• 5:04
  Ti fornirò un modello mentale che puoi elaborare mentalmente,
• 5:07
  diagrammi a parole che non dimenticherai,
• 5:08
  è un passaggio di convalida che impedisce agli agenti intelligenti
• 5:11
  di fare cose stupide.
• 5:12
  Inserisci l'architettura che avresti dovuto usare il primo giorno.
• 5:15
  Perché i prompt falliscono nelle operazioni, gli esecutori no.
• 5:18
  Ok, ecco il punto.
• 5:19
  Gli LLM gestiscono la cognizione.
• 5:21
  Gli esecutori gestiscono l'operazione.
• 5:23
  Mescolando queste cose si ottiene il caos.
• 5:26
  Il modello può proporre un piano.
• 5:28
  Non può garantire che l'immensa è stata inviata,
• 5:29
  il file sia stato salvato, che l'autorizzazione esista.
• 5:32
  Parla in base alle probabilità.
• 5:33
  Le operazioni richiedono garanzie.
• 5:35
  Entra in gioco l'esecutore.
• 5:37
  Consideralo come l'adulto nella stanza,
• 5:39
  un esecutore di funzione vincolato a criteri con vincoli di stato e potenza degli elementi.
• 5:43
  Non ritiene che un'azione abbia avuto successo.
• 5:45
  Verifica.
• 5:46
  Non presuppone che uno strumento esista.
• 5:48
  Con varia capacità, parametri e utilizzazioni.
• 5:51
  Prima ancora.
• 5:51
  Di provarci.
• 5:53
  E quando fallisce, fallisce rumorosamente,
• 5:54
  classifica l'errore e adotta il percorso di ripristino prescritto.
• 5:58
  La maggior parte degli agenti prompt-only rientra in tre modalità di errore.
• 6:01
  Innanzitutto strumenti allucinati.
• 6:04
  Il modello richiede una funzione che non è registrata
• 6:06
  o la chiama con campi che non esistono.
• 6:08
  In secondo luogo precondizioni mancanti.
• 6:10
  Cerca di modificare un file di SharePoint
• 6:12
  senza verificare se può accedere al sito, all'elenco
• 6:14
  o alla versione dell'elemento.
• 6:16
  Terzo, par silenziosi.
• 6:17
  Il secondo passaggio fallisce,
• 6:18
  ma la gente continua e dichiara vittoria
• 6:20
  perché il testo sembra sicuro.
• 6:21
  È visto.
• 6:22
  L'ha appena definito una fidata.
• 6:23
  Gli esecutori seguono un ciclo che sembra noioso
• 6:25
  ed è per questo che funziona.
• 6:26
  Precondizioni.
• 6:27
  Verifica input, autorizzazioni, invarianti.
• 6:30
  Azione.
• 6:30
  Chiama lo strumento con una chiave di potenza dell'elemento
• 6:32
  in modo che i nuovi tentativi non vengano fatturati
• 6:34
  o pubblicati due volte.
• 6:35
  Post-condizioni.
• 6:36
  Conferma gli effetti rispetto alla fonte della verità.
• 6:39
  Tassonomia degli errori.
• 6:40
  È convalida, transitorio, limite di frequenza,
• 6:43
  giovinezza o policy.
• 6:45
  Recupero.
• 6:46
  Arretra e riprova per transitorio.
• 6:48
  Reautenticazione, nuovo consenso per autenticazione,
• 6:50
  fallback per alternative note
• 6:51
  e resti forzati con motivazioni della policy.
• 6:53
  L'idepotenza non è negoziabile.
• 6:55
  Se un'azione può essere ritentata,
• 6:56
  ha bisogno di una chiave
• 6:57
  che renda il secondo tentativo un hop
• 6:58
  o un override coerente.
• 7:00
  I timeout impediscono le chiamate zoom.
• 7:02
  L'arretramento rispetta i limiti di frequenza.
• 7:03
  Questo è un comportamento deterministico
• 7:05
  che regola la generazione di testo
• 7:06
  intrinsicamente stocastica.
• 7:08
  L'esecutore è il cambio.
• 7:10
  LLM, motore.
• 7:12
  Non si schiaccia il motore,
• 7:13
  si spera che le ruote capiscano.
• 7:14
  Gli output che mettono il contratto a primo posto
• 7:16
  sono l'antidoto ai paragrafi best effort.
• 7:18
  Modello di ragionamento non può divagare.
• 7:20
  Emette JSON corrispondenti a uno schema.
• 7:22
  Nome dello strumento, argomenti,
• 7:23
  post-condizioni previste.
• 7:24
  Deridatori verificano la conformità dello schema
• 7:26
  prima che venga eseguito qualsiasi schiena.
• 7:27
  Se la forma è sbagliata,
• 7:28
  l'esecutore nega con una motivazione,
• 7:30
  richiede un piano corretto,
• 7:31
  esegue l'escalation,
• 7:32
  così che si impedisce che l'insalata di sostantivi
• 7:38
  inizialmente lui chiede.
• 7:39
  Il radice lo fa sempre.
• 7:41
  L'utente medio lo accetta.
• 7:43
  I professionisti richiedono prove.
• 7:44
  Le prove risiedono nelle post-condizioni verificate
• 7:46
  rispetto a sistemi come Microsoft Graph,
• 7:48
  SharePoint o Exchange,
• 7:49
  fonti di verità reali,
• 7:50
  non la memoria del modello.
• 7:51
  Ma è qui che diventa interessante.
• 7:53
  I singoli passaggi vanno.
• 7:54
  Flussi di lavoro reali hanno diramazioni,
• 7:56
  parallelismo, compensazioni e checkpoint umani.
• 7:59
  Hai bisogno di più di un esecutore.
• 8:00
  Hai bisogno di una mappa che l'esecutore sia in grado di redire.
• 8:02
  Ecco, un gran flusso di lavoro.
• 8:03
  In un grafico i nodi sono attività o subagenti
• 8:05
  con contratti espliciti.
• 8:06
  I bordi definiscono il flusso di controllo e il flusso di video.
• 8:08
  Lo stato è di prima classe.
• 8:09
  Cosa è persistente?
• 8:10
  Cosa è sottoposta a checkpoint?
• 8:11
  Cosa è effimero?
• 8:12
  L'esecutore percorre il grafico in modo deterministico
• 8:14
  rispettando elenchi di autorizzazione e schemi a ogni board.
• 8:16
  Se un nodo fallisce,
• 8:17
  il grafico specifica compensazioni,
• 8:19
  annulla, ripara o esegue l'escalation.
• 8:22
  Nessun tubo misteri.
• 8:23
  No, e poi avviene la magia.
• 8:25
  Questo è il momento in cui l'affidabilità cambia.
• 8:27
  LM propone.
• 8:28
  L'esecutore applica.
• 8:29
  E com'è ridere che era...
• 8:31
  Allora di me, Cristo.
• 8:32
  Iniziano delle operazioni,
• 8:35
  operazioni, tiro-operazioni,
• 8:36
  tieni, tieni, tieni.
• 8:37
  E si sentono ancora intelligenti perché lo sono,
• 8:41
  ma non sono supervisionati i progetti.
• 8:42
  Pronti per il progetto.
• 8:43
  Colleghiamolo a Microsoft 365
• 8:44
  senza trasformare il tuo tenant in un baffi.
• 8:47
  Flussi di lavoro del grafico 101.
• 8:49
  Nodi, bordi e stato che non perdono.
• 8:51
  E ma...
• 8:52
  Hai un esecutore affidabile, ma nessuna mappa.
• 8:54
  Seguirai gli ordini.
• 8:55
  Ma dove?
• 8:56
  Inserisci il grafico del flusso di lavoro,
• 8:58
  il tuo mani operativo.
• 8:59
  I nodi sono attività o subagenti
• 9:00
  con contratti espliciti.
• 9:01
  I bordi definiscono il flusso di controllo.
• 9:04
  Il grafico codifica quando viene eseguito
• 9:06
  e quali dati possono oltrepassare i confini.
• 9:09
  Nessuna improvvisazione, Jess.
• 9:10
  Questo è spartito.
• 9:12
  Inizia con la forma.
• 9:13
  La maggior parte dei grafici di produzione
• 9:14
  sono DAG, grafici e ciclici diretti,
• 9:16
  perché i cicli invitano cicli infiniti
• 9:18
  e corruzione dello Stato.
• 9:20
  Puoi comunque avere cicli,
• 9:21
  ma li contrassegni intenzionalmente
• 9:22
  con contatori e protezioni,
• 9:23
  iterazioni massime predicati di uscita e timeout.
• 9:26
  Così che impedisce a pensare di più
• 9:27
  o di diventare pensare per sempre.
• 9:29
  Mi stradamento condizionale esplicito.
• 9:33
  Se la confidenza di recupero è superiore alla soglia,
• 9:35
  passa alla sintesi.
• 9:36
  In caso contrario, passa alla nuova query.
• 9:38
  Parallelismo è di prima classe.
• 9:40
  Esegui il riepilogo
• 9:41
  e l'estrazione delle citazioni fianco a fianco,
• 9:43
  quindi unisciti a un nodo barriera
• 9:44
  che verifica che entrambi soddisfino
• 9:46
  le loro condizioni poste.
• 9:47
  Stato non è una vibrazione, è un registro.
• 9:49
  Puoi gestirne tre tipi.
• 9:50
  Stato persistente,
• 9:51
  checkpoint durevoli da cui puoi recuperare
• 9:53
  dopo un arresto anomalo,
• 9:54
  input, decisioni e azioni firmate.
• 9:56
  Stato effimero,
• 9:56
  buffer di breve durata come output
• 9:58
  di modelli intermedi che non vuoi inquinare la memoria a lungo termine.
• 10:00
  Stato derivato,
• 10:01
  artefatti ricalcolabili
• 10:02
  come incorporamenti o risultati filtrati
• 10:04
  che puoi creare in modo deterministico.
• 10:06
  La regola è semplice,
• 10:06
  rendi persistente solo ciò che puoi difendere in un audio.
• 10:09
  Tutto il resto è eliminabile di proposito.
• 10:11
  La strategia di rollback è importante.
• 10:12
  Quando un nodo modifica il mondo esterno,
• 10:14
  crea un evento di calendario,
• 10:16
  aggiorna l'elemento di elenco,
• 10:17
  registri un'azione inversa se esiste
• 10:18
  o un piano di compensazione se non esiste.
• 10:20
  Se un nodo valle fallisce irreversibilmente,
• 10:23
  il grafico può percorrere con le compensazioni in ordine inverso.
• 10:26
  No, non è esagerato.
• 10:27
  È il modo in cui eviti che il cio per noti due volte
• 10:28
  e che diventi ops,
• 10:29
  non possiamo risolverlo.
• 10:31
  Gli spigoli trasportano contratti.
• 10:33
  Uno spigolo non è un tubo misterioso,
• 10:35
  è un api tra nodi.
• 10:36
  Definisci schemi IOTP,
• 10:38
  campi obbligatori,
• 10:38
  valori consentiti.
• 10:40
  Definisci lenchi consentiti.
• 10:41
  Quali strumenti o domini può chiamare il nodo successivo?
• 10:44
  Definisci i tag di capacità,
• 10:45
  cosa promette di fare il nodo ricevente
• 10:46
  e cosa rifiuterà.
• 10:47
  L'esecutore li applica in fase di esecuzione.
• 10:50
  Un nodo non può far passare di nascosto
• 10:51
  un token di SharePoint attraverso un board review.
• 10:53
  Questa non è una questione di sicurezza
• 10:55
  e il modo in cui impedisci il movimento laterale
• 10:56
  da parte del tuo agente.
• 10:58
  La gestione degli errori siede nel grafico,
• 11:00
  non nelle vibrazioni.
• 11:02
  Ogni nodo dichiara la propria tassonomia di errore,
• 11:04
  errore di convalida,
• 11:05
  infrastruttura temporanea,
• 11:06
  limitazione della velocità,
• 11:08
  autenticazione,
• 11:09
  autorizzazione,
• 11:10
  violazione delle policy sconosciuto.
• 11:12
  Per ogni classe il grafico fornisce un percorso.
• 11:15
  Riprova con backoff esponenziale per temporaneo,
• 11:17
  aggiorna il token per l'autenticazione,
• 11:18
  strumento alternativo per la limitazione della velocità,
• 11:20
  nega con motivo per la policy.
• 11:22
  Esistono accordi di messaggi non recapitabili per sconosciuto.
• 11:24
  I payload non riusciti vanno in quarantena
• 11:26
  con un contesto completo,
• 11:27
  in modo che gli esseri umani possano ispezionare
• 11:28
  senza riprodurre il caos in produzione.
• 11:30
  I checkpoint umani nel ciclo
• 11:32
  non sono messaggi slack ad hoc.
• 11:34
  Bloccano l'esecuzione,
• 11:35
  presentano l'azione proposta e le prove,
• 11:37
  richiedono un'approvazione e una modifica
• 11:38
  che viene registrata e firmata.
• 11:40
  Una volta approvata l'esecuzione ripiena.
• 11:42
  Se negata il grafico si radica in un fallback sicuro.
• 11:44
  Congratulazione è appena implementato
• 11:45
  il controllo delle modifiche che gli sviluppatori seguiranno
• 11:47
  perché è più veloce della posta elettronica.
• 11:50
  L'isolamento della memoria è non negoziabile.
• 11:52
  Ogni sessione ottiene un contesto definito,
• 11:54
  solo i documenti, i token e i risultati intermedi
• 11:55
  di cui ha bisogno.
• 11:57
  L'avvelenamento tra sessioni
• 11:58
  in cui l'iniezione di prompt di una conversazione
• 12:00
  si riversa in un'altra
• 12:00
  e il modo in cui si sfiltrano accidentalmente i dati.
• 12:03
  Il grafico impone dei limiti.
• 12:05
  Nessuna memoria è condivisa,
• 12:06
  solo letture autorizzate da un archivio verificato
• 12:08
  con filtri di contenuto e validatori di schema.
• 12:10
  Sì, puoi memorizzare nella cache incorporamenti e riepiloghi
• 12:13
  ma li taghi con provenienza e autorizzazioni
• 12:14
  li espelli in caso di modifiche delle polisi.
• 12:16
  L'osservabilità è integrata, non aggiunta.
• 12:18
  Le tracce a livello di nodo mostrano input, output,
• 12:21
  durate, nuovi tentativi ed effetti a valle.
• 12:22
  Unisci le tracce e non i didi di esecuzione del grafico
• 12:24
  in modo da poter riprodurre, diagnosticare e dimostrare la conformità.
• 12:28
  Che ha fatto cosa, quando e perché?
• 12:29
  Il rievamento delle anomalie segnala schemi strani,
• 12:32
  picchi improvvisi nelle richiamate degli strumenti,
• 12:33
  domini insoliti, esplosioni di token.
• 12:35
  Questo è il tuo sistema di allarme precoce
• 12:37
  prima che ciò che è interessante diventi un incidente.
• 12:39
  In sostanza, il grafico è la costituzione.
• 12:41
  L'esecutore è l'applicazione della legge.
• 12:42
  L'LLM è un consulente, non giudice.
• 12:44
  Quando codifichi no di bordi e stati in questo modo,
• 12:47
  non ottieni solo flussi di lavoro che hanno successo.
• 12:50
  Ottieni flussi di lavoro che falliscono in modo sicuro,
• 12:51
  si spiegano da solo e si riprendono in modo prevedibile.
• 12:53
  Ora, con il progetto in mano possiamo connetterci a Microsoft 365
• 12:56
  senza trasformare il tuo tenant in un buffet.
• 12:59
  Sicuro progettazione.
• 13:00
  La convalida del grafico batte l'ingegneria del caos.
• 13:03
  Non dimostri l'affidabilità creando caos nella produzione,
• 13:05
  sperando che i sopravvissuti siano resilienti.
• 13:08
  La dimostri rifiutando flussi di lavoro
• 13:09
  non sicuri prima ancora che vengano esibili.
• 13:11
  Questa è la convalida del grafico.
• 13:12
  Controlli statici per tenere fuori la sordità,
• 13:14
  protezione in fase di esecuzione per tenere il pericolo in scala.
• 13:16
  La convalida statica è la fase preliminare.
• 13:18
  Controlli la struttura prima di avviare ruote.
• 13:20
  Cicli che creano cicli limitati, rifiutati o costretti
• 13:22
  a dichiarare protezioni di iterazione.
• 13:24
  Nodi raggiungibili, codice morto, un'eliminazione, una giustificazione.
• 13:28
  Contratti mancanti.
• 13:29
  Ogni nodo deve dichiarare schemi di input e output,
• 13:31
  funzionalità richieste ed effetti collaterali.
• 13:33
  Limiti di privilegio.
• 13:34
  I nodi che modificano i sistemi esterni
• 13:36
  devono essere eseguiti in segmenti con credenziali di privilegio minimo
• 13:39
  ed elenchi di autorizzazione espliciti.
• 13:41
  E sì, se il tuo nodo di riepilogo richiede improvvisamente
• 13:43
  l'accesso in scrittura a SharePoint,
• 13:44
  il validatore dice di no con pregiudizio.
• 13:47
  Ora, runtime?
• 13:48
  È qui che le persone diventano shut.
• 13:49
  Un motore di policy si trova accanto all'esecutore,
• 13:51
  non dietro di esso.
• 13:53
  Gli elenchi di autorizzazione di strumenti e domini
• 13:54
  non sono documentazione, sono decisioni imposte.
• 13:57
  Al momento della chiamata, il motore controlla il nostro back
• 13:59
  e il nostro back rispetto al principio attivo,
• 14:00
  token ID, intraambiti, attestazioni
• 14:02
  e si propaga correttamente lungo la catena.
• 14:05
  Nessun superpotere ambientale.
• 14:06
  I token sono delimitati,
• 14:07
  aggiornati quando consentito
• 14:08
  e mai introdotti di nascosto attraverso bordi amichevoli.
• 14:11
  La gente ottiene accesso a ogni chiamata oppure non chiama.
• 14:13
  La sanificazione di input e output è igienica, non facoltà di.
• 14:16
  L'iniezione rapida non è intelligente, è prevedibile.
• 14:20
  Ogni fonte di contenuto in entrata
• 14:21
  passa attraverso filtri di contenuto HTML,
• 14:23
  scrubber di markdown e firewall di istruzioni
• 14:25
  che eliminano le assurdità ignorate.
• 14:27
  L'output supera i validatori di schema.
• 14:30
  Se un nodo ha promesso JSON,
• 14:31
  l'esecutore rifiuta la prosa e richiede una riparazione.
• 14:35
  Il modello può discutere,
• 14:36
  il validatore non negozia.
• 14:38
  Impone tipi, intervalli e invarianti.
• 14:39
  Il sandboxing e la segmentazione contengono il raggio di esplosione.
• 14:43
  I nodi che chiamano codice esterno connettori non attendibili
• 14:46
  vengono eseguiti in ambienti vincolati.
• 14:48
  Gateway e API con limiti di velocità e policy di rete
• 14:50
  che impediscono lo spostamento laterale
• 14:52
  e controlli in uscita
• 14:53
  che consentono solo il traffico verso domini verificati.
• 14:57
  Non si consente al nodo di recupero
• 14:58
  di scoprire una nuova fonte di dati in produzione.
• 15:01
  La scoperta viene in fase di sviluppo dietro i test
• 15:03
  con aggiornamenti firmati all'elenco consentito.
• 15:05
  L'osservabilità non viene registrata da qualche parte chirurgica.
• 15:07
  Il tracciamento a livello di nodo registra input, output, durate,
• 15:10
  nuove tentativi e decisioni dal motore dei criteri.
• 15:12
  Metti in correlazione tutto con un ID di esecuzione.
• 15:15
  I registri di controllo sono immutabili
• 15:16
  e attribuiscono quale principio ha autorizzato,
• 15:18
  quale azione con quali ambiti, in quale momento
• 15:20
  e perché il criterio lo ha consentito.
• 15:22
  Quando un regolatore chiede chi ha fatto cosa
• 15:24
  non scrolli le spalle, cerchi.
• 15:25
  Pronto per la conformità significa che le tue prove sono noiose e completi.
• 15:28
  I rischi di patch e terze parti sono problemi della supply chain.
• 15:31
  Trattali come tali.
• 15:32
  La scansione delle dipendenze viene eseguita su ogni build.
• 15:34
  I connettori ai plugin non sottoposti a verifica
• 15:35
  e la versione viene bloccata e rivista per verificare l'eventuale presenza di autorizzazioni desiderate.
• 15:38
  Se importi una specifica MCP o APA aperta,
• 15:41
  convalidi che i metodi dichiarati corrispondano al criterio di privilegio minimo previsto.
• 15:46
  Nessun endpoint jolly, nessun percorso di scrittura nascosto che finge di essere letto.
• 15:50
  L'igiene non è affascinante.
• 15:52
  Tuttavia è il motivo per cui dormi.
• 15:53
  La convalida del grafico della verità supera l'ingegneria del caos
• 15:56
  perché previene classi di incidenti anziché documentarne le conseguenze.
• 16:00
  Testi ancora le modalità di errore,
• 16:01
  ma lo fai per confermare i guardrail, non per scoprire di aver dimenticato di installarli.
• 16:04
  Ricolleghiamo questo a un modello mentale.
• 16:07
  I controlli statici mantengono sani progetti.
• 16:10
  Nessun percorso impossibile, nessun lavoro orfano, nessuna perdita di privilegi.
• 16:13
  I guardrail in fase di esecuzione mantengono sani comportamenti.
• 16:16
  Ogni chiamata autenticata, autorizzata, sanificata e osservata.
• 16:20
  L'esecutore applica i vincoli del grafico decisi dal validatore.
• 16:23
  Modello.
• 16:24
  Propone entro i limiti e viene tagliato quando si allontana.
• 16:27
  Non è pesante.
• 16:28
  Solo se ti piacciono le violazioni.
• 16:29
  Il sovraccarico è meccanico automatizzato.
• 16:32
  La convalida statica viene eseguita in fase di compilazione e distribuzione.
• 16:35
  La policy in fase di esecuzione è un sidecar veloce e locale.
• 16:38
  I controlli dello schema sono un milsico.
• 16:40
  Il costo che rimuovi, incidenti, revisioni manuali, adattamenti e clissa la micro latenza che aggiungi.
• 16:46
  Il guadagno è misurabile.
• 16:47
  Meno chiamate non autorizzate.
• 16:49
  Meno esplosioni di token.
• 16:50
  E molti meno post-mortem sul perché lo ha fatto.
• 16:53
  Un altro punto che l'utente medio non coglie.
• 16:57
  La convalida è componibile.
• 16:58
  È possibile integrare strumenti di terza parte con nodi proxy che applicano contratti e policy senza fidarsi dello strumento stesso.
• 17:04
  È possibile segmentare i grafici in base alla sensibilità pubblico interno limitato e promuovere flussi di lavoro tra livelli solo dopo che la convalida ha superato il nuovo limite.
• 17:13
  È così che si scala in modo sicuro.
• 17:15
  Sicuro per progettazione non è uno slogan, è una proprietà del flusso di logo.
• 17:17
  Non si spera che il geaginti si compri.
• 17:19
  Si rende il comportamento scorretto strutturamente difficile e operativamente visibile.
• 17:24
  Con i binari in posizione, collegare Microsoft 365 Graph e Azure OpenAI non è una roulette.
• 17:28
  È un potere controllato alle proprie condizioni.
• 17:30
  Ora possiamo parlare di cablaggio, non di spegnimento di incendi.
• 17:33
  Lo scenario Microsoft M365 Graph più Azure OpenAI più Copilot Studio.
• 17:39
  Assembliamo il cast.
• 17:40
  Agente di recupero, bibliotecario disciplinato che recupera solo da Microsoft Graph con privilegi minimi.
• 17:45
  Agente di ragionamento, modello Azure OpenAI che pianifica, localizza e non lavora mai come freelancer oltre il suo incarico.
• 17:52
  Esecutore, operatore vincolato alle policy che esegue strumenti con controlli di depotenza e post-condizioni.
• 17:58
  Validatore, il bouncer, schema, policy e applicazioni dei limiti.
• 18:02
  Policy guard, sidecard di runtime che collega tutto agli ambiti ID Entra e RBH.
• 18:07
  Insieme si comportano come un team competente anziché come un thread di comitato.
• 18:10
  L'accesso ai dati inizia con graph non con supposizioni.
• 18:12
  L'agente di recupero conserva una registrazione dell'app con ambiti granulari.
• 18:15
  File, letti per un sito specifico, posta, lettura di base per una casella di posta limitata.
• 18:19
  Calendari, letti per un calendario di risorse.
• 18:22
  Nessuna lettura di graph, tutti gli errorismi di scrittura.
• 18:24
  Le query utilizzano campi delta e selettivi per mantenere sottili i peli.
• 18:28
  La paginazione è di prima class.
• 18:29
  L'esecutore segue i collegamenti successivi in modo deterministico con timeout rispettando la limitazione dei servizi.
• 18:33
  E quando si verifica un errore 429, il back-off è matematico.
• 18:36
  Nessuna crisi di nervi, solo pazienza esponenziale.
• 18:39
  La messa a terra non è una vibrazione, è una pipeline.
• 18:40
  Recupera i documenti candidati tramite query di ricerca o elenco di graph.
• 18:44
  Deduplica in base alle elementi e alle tag di versione in modo da non mischiare elementi obsoleti e attuali.
• 18:48
  Suddividi in blocchi in base a limiti semantici, intestazioni di sezioni, interruzioni di diapositiva,
• 18:53
  quindi allega provenienza, unità, sito, percorso, id elemento, ultima modifica, hash assegnato.
• 18:58
  L'agente di ragionamento vede solo blocchi più metadati ed è tenuto a produrre citazioni mappate su tali di...
• 19:03
  Nessuna rivendicazione.
• 19:05
  L'esecutore impone ciò come post-condizione prima di qualsiasi azione esterna.
• 19:08
  Entra in copello studio per l'orchestrazione.
• 19:11
  Definisci strumenti dichiarativi, pacchetti di query graph, azioni di scrittura SharePoint,
• 19:14
  post-teams, invia, outlook, ognuno dietro un proxy con schemi espliciti ed elenchi consentiti.
• 19:19
  Il coordinamento tra agenti è strutturato.
• 19:21
  L'agente di recupero espone uno strumento di base.
• 19:24
  L'agente di ragionamento lo richiede con parametri.
• 19:26
  L'esecutore media convalida e restituisce un contesto di base.
• 19:31
  I checkpoint umani sono nati.
• 19:33
  Un nodo di azione proposto interrompe l'esecuzione,
• 19:36
  presenta il piano più le citazioni e richiede l'approvazione.
• 19:38
  L'approvazione viene firmata a registrare.
• 19:40
  Il rifiuto indirizza verso un'alternativa sicura o un'escalation.
• 19:43
  I token alla tenza vengono gestiti, non eliminati.
• 19:46
  Contesto selettivo significa che fornisce solo i blocchi rilevanti, non l'intero tenant.
• 19:50
  I ripiloghi vengono precalcolati e memorizzati nella cache con incorporamenti codificati in base a lasciare il contenuto e le autorizzazioni.
• 19:55
  Modifica il documento, modifica la chiave, salta la cache e ricalcola.
• 19:58
  Le risposte in streaming mantengono attiva l'interfaccia utente,
• 20:01
  mentre l'esecutore gestisce gli effetti collaterali solo dopo l'arrivo del piano valido allo schema completo.
• 20:05
  Le condizioni di uscita anticipate interrompono il ciclo di ragionamento quando la confidenza più la copertura raggiungono solo.
• 20:09
  Nessun pensiero aggiuntivo perché il modello sembrava poetico.
• 20:12
  La verificabilità è integrata.
• 20:14
  Ogni azione è firmata dal responsabile del servizio o dall'utente delegato e contrassegnata con ID,
• 20:19
  esecuzione, strumento, parametri, redatti ove necessario, ambiti e risultato.
• 20:23
  I registri immutabili sedano nel tuo stack di osservabilità.
• 20:26
  Scegli il tuo preferito.
• 20:27
  In questo modo puoi riprodurre un'esecuzione senza reseguire gli effetti collaterali.
• 20:30
  Chi ha fatto cosa? Quando e perché diventa una query, non una caccia alle streghe.
• 20:33
  Sì, le citazioni sopravvivono intatte, quindi puoi verificare che la risposta sia riconducibile al contenuto effettivo del tenant,
• 20:38
  non alla legge modello.
• 20:40
  L'errore normalizzato è noioso.
• 20:42
  429. L'esecutore riprova con jitter, quindi ricorre a una query a costo inferiore o a una dimensione di pagina ridotta.
• 20:47
  Caccia obsoleta. Il validatore rileva i tag non corrispondenti e forza un aggiornamento.
• 20:51
  Negazione dell'autorizzazione e la protezione delle policy nega con motivazione propone un percorso di richieste di consenso e indirizzo a un riepilogo redatto che no.
• 20:58
  Interruzione dello strumento. Il grafico dichiara alternativo o parcheggia l'esecuzione in una coda di messaggi e in una coda di messaggi non recapitabili con contesto umano.
• 21:05
  I fallback deterministici trasformano l'incidente in un ticket.
• 21:08
  Ora, una breve procedura a dettagliare.
• 21:09
  L'utente chiede scrivi.
• 21:11
  Una bozza di riepilogo delle decisioni della roadmap dell'ultimo trimestre con collegamento.
• 21:14
  L'agente di ragionamento propone.
• 21:15
  Usa la ricerca del grafico in un sito SharePoint specifico, un canale Teams, filtra in base all'ultimo trimestre e quindi sintetizza.
• 21:21
  Validatore verifica che gli ambiti richiesti corrispondano al cuore dell'agente.
• 21:25
  Fun.
• 21:25
  L'esecutore mette chiamate grafiche con selezione di paginazione e camp.
• 21:28
  Reduplica in base all'edie elemento e blocchi e restituisce contesto con la provenienza.
• 21:32
  Il ragionamento produce un riepilogo con citazioni in linee mappate agli edie elemento.
• 21:36
  Validatore verifica schema e citazioni.
• 21:38
  Supera.
• 21:39
  Viene visualizzato un checkpoint umano con riepidenza.
• 21:41
  L'approvatore fa clic su.
• 21:42
  L'esecutore pubblica il risultato in Teams e invia la parte interessata.
• 21:45
  Ogni azione utilizza chiave di potenza dell'elemento in modo che i nuovi tentativi e i nuovi tentativi non vengano pubblicati due volte.
• 21:49
  Notta la disciplina.
• 21:50
  Nessun agente inventa uno strumento, nessun nodo attraverso un dominio al di fuori del suo erenco consentito.
• 21:55
  I token vengono definiti nell'ambito e propagati correttamente tramite ID Entra, non copiati e incollati tra i nodi.
• 22:00
  Il modello non conclude mai con successo.
• 22:02
  L'esecutore lo dimostra con condizioni di pubblicazione del gra.
• 22:05
  ID messaggio creato, ID tag elementi aggiornato e ID evento calendario, quindi timo l'esecuzione come completata.
• 22:09
  E sì, puoi estenderlo in modo sicuro, importare planner, viva o servizi di terze parti tramite MCP o API aperta,
• 22:15
  ma solo dietro strumenti proxy con schemi rigorosi e controlli di uscita dalla rete.
• 22:18
  Avvoggini il connettore con la stessa logica di convalida e la stessa protezione delle policy.
• 22:22
  La promozione tra ambienti richiede passaggi di convalida che corrispondano a un nuovo confine.
• 22:26
  Sviluppo per testare e produrre con aumenti di ambito esaminati non presunti.
• 22:29
  Questa è l'architettura di Microsoft realizzata correttamente.
• 22:31
  Grafico per la verità.
• 22:32
  Numeri successivi, non vibrazioni.
• 22:44
  Metriche prima e dopo.
• 22:45
  Accuratezza, latenza, costi, spese generali di amministrazione.
• 22:48
  Bella architettura, dimostralo.
• 22:50
  Numeri, non vibrazioni.
• 22:51
  Prima la linea di base, gli agenti solo prompt sono regine del dram.
• 22:54
  L'accuratezza è incoerente perché inventano fonti e dimenticano citazioni.
• 22:58
  Senza fondamenta si ottiene una prosa sicura che non punta da nessuna parte.
• 23:02
  La latenza di code è brutale.
• 23:04
  Una lunga catena di chiamate seriali dipensa più a fondo, ciascuna gonfia di contesto ridondante.
• 23:09
  I costi aumentano vertiginosamente perché ogni turno rispedisce trascrizioni complete e documenti non elaborati al modello come un servizio di corriere strapagato.
• 23:15
  Le generali di amministrazione.
• 23:18
  Incidenti, hotfix, errori misteriosi, audit che sembrano archeologia con gli occhi bendati.
• 23:22
  Ora lo stato successivo con esecutori grafici convalidati.
• 23:25
  La precisione aumenta perché richieste richiedono ricevuto.
• 23:27
  Le citazioni fondate e legate agli ID degli elementi del grafico, agli tag e agli hash firmati indicano che una risposta priva di provenienza semplicemente non supera il validatore.
• 23:35
  L'effetto immediato.
• 23:37
  Meno risposte sbagliate inviate, meno cicli di rilaborazione e un aumento misurabile nei tassi di successo delle attività sui set di valutazione.
• 23:42
  Quando una richiesta non può essere supportata, l'agente nega con motivazione e richiede l'approvazione umana.
• 23:47
  Prevedibile, revisionabile e sicuro.
• 23:48
  La latenza si comprime per tre motivi.
• 23:51
  Innanzitutto, parallelismo, recupero, riclassificazione e distrazione delle citazioni vengono eseguiti parallelamente e quindi sincronizzati in un nodo di varie.
• 23:57
  In secondo luogo, la memorizzazione nella cache, gli incorporamenti e i riepiloghi codificati in base al hash del contenuto e all'ambito delle autorizzazioni.
• 24:03
  In terzo luogo, uscita anticipata.
• 24:05
  Una volta che la copertura e l'affidabilità raggiungono la soglia, il grafico interrompeci.
• 24:08
  Confronta questo con i prompt seriali, in cui il modello riflette per un paragrafo e i tuoi utenti riflettono sull'abbandono.
• 24:12
  I costi diminuiscono perché la disciplina di token viene applicata ma non supplicata.
• 24:16
  Gli output vincolati allo schema impediscono il divagato.
• 24:19
  Il contesto selettivo alimenta solo i blocchi rilevanti con metadati, non interi siti.
• 24:24
  Prompt più brevi, risposte più piccole, meno tentativi.
• 24:26
  La potenza degli elementi dell'esecutore e la logica di back-off evitano chiamate duplicate e cicli sprecati.
• 24:31
  L'effetto netto è un minor numero di token per risultato positivo e una varianza molto inferiore.
• 24:35
  Alla finanza piace la riduzione della varia.
• 24:37
  Sovraccarico amministrativo si riduce perché l'osservabilità è progettata non improvvisata.
• 24:40
  Le tracce a livello di nodo e i registri mutabili riducono il tempo di diagnosi degli incidenti.
• 24:44
  Puoi vedere quale nodo ha avuto esito negativo, perché il motore dei criteri ha negato e cosa ha provato l'esecutore dopo.
• 24:49
  Le distribuzioni ripetibili riducono i lavori sul mio teatro di mano.
• 24:53
  La conformità smette di essere una crisi stagionale perché ogni esecuzione contiene già chi, cosa, quando e perché.
• 24:58
  Rendiamolo concreto con un impianto di misurazione che puoi effettivamente eseguire.
• 25:02
  Crea un set di valutazioni di attività rappresentative, domande, risposte con citazioni, ripiloghi con collegamenti e proposte di azioni con approvazione.
• 25:07
  Per ogni risposta Aurea è definita un criterio di accettazione.
• 25:11
  Fatti corretti con ID elementi mappati, copertura delle citazioni e varianza consentita.
• 25:16
  SLO di strumento P50 e P95, latenza end-to-end, spesa di token per attività riuscita e tassi di rifiuto delle policy.
• 25:21
  Collega ogni metrica alle tracce in modo che ogni regressione abbia una traccia di navigazione.
• 25:25
  Risultati che dovresti aspettarti se segui l'architettura non saranno improvvisi.
• 25:29
  Maggiore validità delle risposte perché le affermazioni non supportate non escono mai dalla fase staging.
• 25:32
  Minore latenza P95 perché le code lunghe vengono suddivise da nodi paralleli e uscite anticipate.
• 25:39
  Minore spesa di token perché interrompi la distribuzione di romanzi e inizia a distribuire snippet 29.
• 25:44
  Meno pagine agli amministratori perché la maggior parte degli errori viene gestita da fallback di terministici.
• 25:48
  E sì, la noiosa metrica che tutti dimenticano.
• 25:51
  Tasso di completamento al primo passaggio riuscito per esecuzioni vengono completate senza intervento.
• 25:54
  Impatto aziendale, risoluzioni più rapide significano che gli utenti smettono di aprire ticket duplicati.
• 25:59
  Spesa prevedibile significa budget senza intoppia sorpresa ad uti e tu.
• 26:02
  La sicurezza della conformità significa meno cicli di Audi che dirottono la tabella di marcia.
• 26:06
  La vittoria non ovvia è la reputazione.
• 26:08
  Quando le risposte della gente citano il contenuto dell'inquilino, i link funzionano.
• 26:12
  Le persone si fidano, lo usano e smettono di notare screenshot che iniziano con
• 26:16
  Perché ha detto questo?
• 26:18
  Consigli imperativi diretti, collegamento tra traccia e metrica o ti stai basando su opinioni.
• 26:22
  Se non riesci ad aprire un'esecuzione e vedere esattamente quale nodo ha gonfiato i token
• 26:26
  o bloccato la latenza, non hai osservabilità, hai vibrazioni con timestamp.
• 26:30
  Tutto cambia quando il validatore si trova tra un bel piano e un'azione reale.
• 26:35
  La precisione si stabilizza, la latenza si riduce, i costi si appiattiscono, gli amministratori dormono.
• 26:40
  Questa non è magia, sono esecutori grafici e convalida che svolgono il lavoro che ha segnato in modo errato i prompt.