Latest / M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano / Sistemi multi-agente con Azure AI Foundry: pianificazione, collaborazione e strumenti senza rompere la produzione (Doppiaggio IA)

Transcript

Sistemi multi-agente con Azure AI Foundry: pianificazione, collaborazione e strumenti senza rompere la produzione (Doppiaggio IA) · M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano

• 0:00
  Sai, i chatbot parlano, gli agenti agiscono nei sistemi multiagente e riescono effettivamente a fare le cose.
• 0:04
  Se hai implorato un bot di riparare Intune e ti ha risposto con una poesia, questo è per te.
• 0:08
  Ecco l'accordo. Netflix in azione? Guardi, mangi snack.
• 0:11
  Io seguo il principio del servizio pericoloso in modo che nessuno sfruttirà prodotto.
• 0:15
  Stiamo creando un mini sistema multiagente autoriparante e governato con Azure AI Foundry e Semantic Kernel.
• 0:20
  Punti di contatto reali.
• 0:22
  Intune entra Graph Azure Automation, Log Analytics, Log Analytics.
• 0:26
  Un agente contro più agenti testa a testa, 12 minuti contro 3.
• 0:29
  E l'unica vittima è il mio credito di abbonamento.
• 0:32
  Innanzitutto perché un agente si blocca mentre i team su.
• 0:34
  Perché un agente non basta.
• 0:36
  I singoli agenti sono il coltellino svizzero che hai preso in una stazione di servizio.
• 0:39
  Tecnicamente, agli strumenti praticamente, si piega alla prima vite.
• 0:42
  Si stipano pianificazione, ragionamento, esecuzione, approvazioni e reporting in un unico prompt.
• 0:46
  E ora è carente di contesto, lento e estremamente sicuro della cosa sbagliata.
• 0:49
  La maggior parte delle persone pensa a un modello più grande, a un cervello più grande e via, problema risolto.
• 0:53
  Ma il vero fallimento è la confusione dei ruoli.
• 0:55
  Un agente che cerca di pianificare una modifica, chiamare il grafico, scrivere uno script di correzione,
• 1:00
  verificare l'approvazione, verificare il risultato e documentarlo.
• 1:03
  È come gestire un help desk, una bacheca delle modifiche e un'autopsia con uno stagista molto stanco.
• 1:08
  E cosa succede?
• 1:09
  L'unico agente gestisce troppi stati?
• 1:11
  Prompti vento racconto.
• 1:13
  La finestra del contesto si riempie di registri, policy e metà del glossario MDM,
• 1:16
  quindi tronca le parti importanti o allucina i dettagli mancanti.
• 1:19
  Picchi di latenza, token bruciati e nuovi tentativi sembrano déjà vu con una bolletta.
• 1:23
  Entrano in gioco più agenti, ruoli, confini, parallelismo.
• 1:28
  Il pianificatore si concentra su intenti e vincoli.
• 1:30
  L'operatore si concentra su strumenti ed esecuzione.
• 1:33
  Il revisore si concentra su protezioni, approvazioni e siamo basati sui fatti.
• 1:37
  Ogni agente mantiene un set di istruzioni breve e pulito con la memoria minima di cui ha bisogno.
• 1:42
  Trasmettono messaggi e risultati degli strumenti a un breve repilogo, non intera intera.
• 1:46
  Perché questo è importante in azienda.
• 1:47
  Sono necessari flussi di lavoro end-to-end con controlli umani nel ciclo, azioni basate sull'identità,
• 1:51
  nuovi tentativi e audit trail.
• 1:52
  Questa non è una chat thread singola, è uno sporty squad.
• 1:55
  Il modello pianificatore, esecutore, revisore, riduce rischi e le rilavorazioni
• 1:59
  perché ogni passaggio ha un secondo paio di occhi,
• 2:00
  quelli automatizzati che non sono sui nostri undici di una rapida riunione di teams.
• 2:04
  Anche i costi e latenza ne trago 90.
• 2:06
  Utilizza piccoli modelli linguistici per l'estrazione e la classificazione.
• 2:09
  Utilizza modelli di ragionamento premium solo dove la pianificazione è effettivamente.
• 2:12
  Esegui i processi batch per i repiloghi mentre gli utenti dot.
• 2:14
  Otterai meno allucinazioni, risultati più rapidi e fatture più basse.
• 2:17
  MicroStoryam, ho visto un bot che faceva tutto e ha provato a ruotare un segreto.
• 2:22
  Ha aggiornato la chiave, ha dimenticato l'impostazione dell'app e l'ha risolta eliminando la risorsa.
• 2:27
  Quello è stato il giorno in cui abbiamo inventato l'agente di revisione.
• 2:30
  Sistemi multiagente 101, chiari e semplici?
• 2:32
  Ok, quindi cos'è un sistema multiagente che puoi effettivamente distribuire?
• 2:35
  Pensa a un team digitale, non a un grande cervello.
• 2:37
  Ogni agente ha un ruolo, un set di istruzioni rigolose, una cassetta degli attrezzi limitata.
• 2:43
  Pianificatore, comprende l'obiettivo, i vincoli e l'ambiente.
• 2:46
  Produce un piano con chiamate di strumenti che l'operatore può eseguire.
• 2:50
  L'operatore, chiama strumenti, grafici, app logic e funzioni.
• 2:53
  Runbook di automazione di Azure e restituisce risultati strutturati.
• 2:57
  Il revisore, verifica la fondatezza, l'ambito di conformità, le approvazioni e gli output di sicurezza prima che accada qualcosa di rischioso.
• 3:03
  Il concierge di Messenger gestisce notifiche umane, approvazioni e riepiloghi per il registro di controllo.
• 3:10
  Comunicano tramite messaggi e contesto condiviso come dovrebbero fare gli adulti, in modo breve e chiaro è solo ciò che è necessario.
• 3:15
  Sequenziale quando le azioni dipendono dai risultati precedenti.
• 3:18
  Parallelo quando le sottoattività possono essere distribuite in modo sicuro.
• 3:21
  Non invia una polizia di 50 pagine, invia il frammento pertinente, gli dei dispositivi e la modifica prevista.
• 3:26
  Gli strumenti e le mani.
• 3:27
  API REST per Microsoft Graph.
• 3:29
  RAG tramite Azure AI Search per informazioni curate.
• 3:32
  Interprete di codice per frammenti.
• 3:33
  App logiche per sequenze orchestrate.
• 3:35
  Funzioni per blu.
• 3:36
  Automazioni di Azure per attività ripetibili sui dispositivi.
• 3:38
  Mantieni gli input degli strumenti strutturati con schemi, in modo che l'operatore non possa eliminare in modo creativo il tenant.
• 3:43
  La memoria non è magia, è un budget.
• 3:45
  Riduce al minimo la memoria per agenti.
• 3:47
  Usa stato esterno, indici di ricerca, archivi vettoriali o un piccolo archivio di stato per i metadati dei thread.
• 3:51
  Mantieni se nelle finestre di contesto.
• 3:53
  Se non è necessario per la decisione successiva, non scrive insieme.
• 3:55
  Pianificazione ed esecuzione sono i punti in cui semantic carnele c'è.
• 3:58
  Il pianificatore delega, l'operatore sceglie lo strumento giusto con cataloghi di funzioni.
• 4:02
  Il revisore esamina criticamente gli output con prompt di valutazione e sicurezza dei contenuti.
• 4:06
  Se il revisore segnano un rischio di ambito, il pianificatore lo rivede.
• 4:09
  Una volta compreso questo ciclo, smetti di scrivere prompt di 800 parole e inizia a collegare ruoli chiari.
• 4:14
  I limiti di sicurezza non sono negoziabili.
• 4:16
  Chiamate gli strumenti con ambito di identità gestita.
• 4:19
  Un'identità gestita.
• 4:20
  Le autorizzazioni del suo agente sono suddivise tra lettura e gestione.
• 4:22
  PM per l'elevazione delle azioni distruttive.
• 4:24
  Tutte le chiamate degli strumenti registrati nell'analisi delega.
• 4:27
  Sicurezza dei contenuti sia in input che in output.
• 4:29
  Protezione dei prompt per jailbreak e iniezione in diretta di prompt da fonti di conoscenza.
• 4:33
  Tempo di analogia.
• 4:34
  Ricercatore, analista, operatore, QA.
• 4:37
  Ognuno è responsabile della propria parte.
• 4:39
  L'operatore non approva la propria modifica.
• 4:41
  L'analista non interferisce con la produzione.
• 4:43
  Il QA non scrive il codice che sta approvando.
• 4:46
  Rioso.
• 4:46
  Sicuro.
• 4:47
  Perché Azure AI Foundry più Semantic Kernel?
• 4:50
  Foundry ti offre orchestrazione degli agenti, scelte di modelli, knowledge base, scablaggio degli strumenti, sicurezza dei contenuti, tracciamento, valutazione e governance in unico posto.
• 4:58
  Semantic Kernel ti offre pianificatori, competenze, pipeline, nuovi tentativi e annullamenti nel codice.
• 5:04
  Insieme combini modelli per ruolo, SLM per l'estrazione, classe GPT-4 per la pianificazione, batch per i riepiloghi e mantieni i tuoi prompt brevi, il tuo raggio di azione ridotto e i tuoi fine settimana.
• 5:15
  Ora costruiamo la cosa.
• 5:16
  In che modo Azure AI Foundry abilita i flussi di lavoro multiagenti?
• 5:19
  Ecco dove Azure AI Foundry smette di essere un portale patinato e inizia a comportarsi come un'officina di produzione.
• 5:24
  Foundry ti offre spazi in cui definire agenti, connettere modelli, aggiungere informazioni, collegare azioni, osservare tutto senza dover vivere in sei diverse lame e un desiderio.
• 5:32
  È un'orchestrazione senza naso ad adesivo.
• 5:34
  Inizia con le definizioni degli agenti.
• 5:36
  In Foundry ogni agente riceve istruzioni, linee guida rigide sui ruoli, non un manifesto.
• 5:41
  Distribuzione, modello effettivo alla base.
• 5:43
  Combina la classe GPT4 per la pianificazione con SLM di classe FI per l'estrazione.
• 5:47
  Informazioni, indici di ricerca di Azure AI, file caricati o backgrounding quando desideri un contesto web.
• 5:52
  Azioni, strumenti API aperti, app logiche, funzioni, grafici, runbook di Azure Automation o interprete di codice per calcoli e analisi rapidi.
• 6:00
  Agenti connessi.
• 6:01
  Sì, un agente può trattare un altro agente come uno strumento se ciò mantiene puliti i ruoli.
• 6:06
  Però questo è importante perché il kernel semantico si collega allo stesso universo.
• 6:09
  Nel codice crei pianificatori, definisci competenze e registri strumenti nei cataloghi delle funzioni.
• 6:14
  Coreografi il ciclo di pianificazione, operatore, revisione e lasci che Foundry gestisca i thread, la cronologia e le linee di sicurezza.
• 6:21
  Mantieni brevi prompt e metti lavoro pesante negli strumenti con schemi.
• 6:24
  Traduzione, meno allucinazioni, meno errori, più weekend.
• 6:27
  Le scelte del modello sono importanti.
• 6:28
  Foundry astrae l'inferenza tramite l'endpoint del modello, così puoi cambiare modello senza riscrivere l'intera app.
• 6:34
  Due corsie comuni, endpoint senza server per modelli premium e iterazione rapida.
• 6:38
  Paghi per token, ridimensioni su richiesta e non fai da babysitter al GPU come se fossi nel 2018.
• 6:42
  Calcolo gestito per modelli aperti specifici che vuoi bloccare il confine del tuo tenant.
• 6:46
  Paghi in base al tempo di attività e controlli la forma ma Microsoft gestisce l'impianto di distribuzione.
• 6:50
  Combina modelli per ruolo.
• 6:52
  Planner su GPT4, 4.1 o mini per il ragionamento.
• 6:55
  Operatore su un piccolo modello che eccella nell'estrazione dell'estrazione dei parametri.
• 6:58
  Raggruppa i tuoi lunghi riepiloghi durante la notte in modo che gli umani ricevano report luci di entromani.
• 7:02
  E se un modello viene ritirato o vuoi provare le varianti di PSI con Lama,
• 7:05
  l'API di PSI con Lama, l'API di inferenza di Foundry ti consente di mantenere stabile il tuo codice mentre sperimenti.
• 7:10
  Strumenti e azioni sono dove l'operatore guadagna il suo badge.
• 7:13
  È qui che ottieni il vero potere senza fornire alla gente le chiavi del tuo regno.
• 7:17
  Strumenti API aperti per servizi interni con Swagger.
• 7:20
  Mantieni il contratto di euro.
• 7:21
  Se lo schema dice dispositivo, è una stringa, è meglio che siano i dispositivi.
• 7:24
  App logiche per flussi di approvazione get umani.
• 7:26
  Lascia che il revisore installa delle modifiche e un approvatore delle modifiche, quindi riprendi l'esecuzione su.
• 7:31
  Funzioni di Azure per codici di unione e trasformazioni sane.
• 7:34
  APD grafici con versione testabile di piccole dimensioni per Intune e intraattività di accesso condizionale al dispositivo utente.
• 7:40
  Assegni ambiti di lettura agli agenti di monitoraggio.
• 7:42
  Gestisci gli ambiti solo ai remediatori.
• 7:44
  Automazione di Azure per script di dispositivo e runbook.
• 7:46
  Trattalo come oggetti appuntiti in un cassetto chiuso a chiave.
• 7:50
  Solo l'agente riparatore può aprirlo.
• 7:52
  Come la messa a terra mantieni il curato.
• 7:54
  Usa la ricerca di Azure AI con classificazione ibrida e riclassificazione semantica.
• 7:58
  Suddividi la conoscenza in base al dubbio.
• 7:59
  Policy di sintonizzazione separata dalle procedure operative standard di onboard.
• 8:02
  Questo modo non spedisci il livello della cucina.
• 8:04
  L'operatore dovrebbe passare uno snippet, non l'enciclopedia.
• 8:06
  Dimensiona i tuoi blocchi, archivia le citazioni e fai in modo che il revisore verifichi la fondatezza prima che tocchi la produzione.
• 8:12
  Sicurezza non è facoltativa.
• 8:14
  Foundry integra filtri di sicurezza dei contenuti per input e output, protezioni rapide per jailbreak e iniezioni in diretta oltre a controlli sui materiali protetti.
• 8:20
  Esegui il premodello e il postmodello di sicurezza in modo da non pagare per input errati o disastri PR di output.
• 8:26
  Abbina l'identità gestita per agente al privilegio minimo, RBAC e PM, per rilevazione temporanea sugli strumenti distruttivi.
• 8:31
  Ogni chiamata allo strumento viene tracciata.
• 8:33
  Ogni approvazione viene registrata.
• 8:34
  Se qualcuno chiede chi ha eseguito cosa, non apre output.
• 8:38
  L'analisi del registro lo sa già.
• 8:39
  L'osservabilità è una modalità per attivare.
• 8:42
  Attiva il tracciamento in modo da poter vedere la cronologia delle esecuzioni, quale agente ha chiamato, quale strumento con quali parametri, a quale latenza e cosa è tornato indietro.
• 8:49
  Collega informazioni dettagliate sulle applicazioni per modelli di prestazione, i registri delle app per l'audit e invia valutazioni in CI per rilevare deviazioni in termini di pertinenza, fondatezza e fluidità prima che lo faccia un utente.
• 8:58
  Se la fondatezza diminuisce, il revisore lo segnala, il pianificatore restringerà quelli di recupero e l'operatore riprova.
• 9:03
  Non è necessario il panico umano, le primitivi di distribuzione mantengono tutto in ora.
• 9:07
  Usa i progetti Foundry per le quote di ambito del team e le linee di base di critica.
• 9:10
  Metti la gestione dell'API di Azzur davanti al tuo servizio di strumenti in modo da poter controllare le versioni, limitare e implementare interruttori automatici, indirizzare interruttori automatici, indirizzare trappettivo, inferenza con pagamento o in base al consumo.
• 9:18
  Endpoint privati in cui la residenza di dati o la conformità dicono che facciamo su serio.
• 9:21
  Regioni che corrispondono ai tuoi utenti, non solo alle tue aspirazioni.
• 9:25
  E sì, il kernel semantico lega l'arco.
• 9:27
  Descrivi il flusso di lavoro nel colpo.
• 9:28
  Il pianificatore scompone.
• 9:29
  L'operatore esce gli strumenti in base ai cataloghi delle funzioni e alla disponibilità.
• 9:33
  Il revisore applica controlli con prompt di valutazione e risultati di sicurezza dei contenuti e ottieni nuovi tentativi con token di backoff e annullamento quando un'API esterna finge di essere inattiva per manutenzione.
• 9:44
  SK ti fornisce cervello esecutivo, Foundry ti fornisce la sala operatoria.
• 9:48
  Mettili insieme e avrai uno schema pratico.
• 9:49
  Definisci gli agenti in Foundry con istruzioni e identità rigorose, orchestra i ruoli in SK, esegui ricerche mirate, collegazioni con API aperte, applogiche, funzioni, automazione, applica la sicurezza prima e dopo l'inferenza e osserva tutto, è noioso nel migliore dei modi.
• 10:03
  Come le cinture di sicurezza o il fatto di mandare l'amministratore globale alla chiave predefinita denominata stagista?
• 10:11
  Scenario dimostrativo 1, pulizia del dispositivo, unità dispositivo fantasma CSI Intune.
• 10:16
  Sai quei dispositivi che vengono visualizzati come gestiti e ritirati e non morti allo stesso tempo?
• 10:21
  Benvenuti in CSI Intune.
• 10:22
  Il nostro lavoro è trovare hardware obsoleto, duplicato o non registrato e ripristinarlo in modo sicuro con approvazione in modo che nessuno invime il dirabia legato.
• 10:29
  Cast di agenti, monitoraggio, query, analisi di Microsoft Graph e log, classificazione degli stati di dispositivi, segnalazione di anomalie.
• 10:37
  Remediator chiama Intune l'automazione di Azure per mettere in quarantena o ritirare i dispositivi.
• 10:42
  Il revisore registra tutto, notifica gli esseri umani e scrive il racconto post-azione per la conformità.
• 10:48
  Flusso funziona in questo modo.
• 10:49
  Il monitor estrae dai record del dispositivo grafico, l'ultimo check-in, lo stato di conformità, il tipo di registrazione, l'utente principale e i flag di ritiro.
• 10:55
  Acquisisce inoltre, segnali di analisi dei registri, heartbeat di Defender, conformità di aggiornamento ed eventi di estensione della gestione di Intune.
• 11:03
  Di fondo in un breve record, strutturato per dispositivo.
• 11:06
  Ultima visualizzazione in UTC, scritto conforme ai candidati duplicati, segnali di rischio.
• 11:10
  Nessun romanzo, solo campi.
• 11:11
  Ora il passaggio dal cervello alla forza blu.
• 11:13
  Il monitor invia una classificazione proposta, obsoleta, duplicata, nessun heartbeat o corretta.
• 11:18
  Il revisore verifica la fondatezza.
• 11:20
  Questi campi provengono effettivamente dal grafico daily.
• 11:21
  La sicurezza dei contenuti esegue un premodello per bloccare l'iniezione rapida da qualsiasi file caricato o messo a terra.
• 11:27
  Se la classificazione viene superata, il remediatore prepara le azioni.
• 11:31
  La fase 1 è la correzione soft, ovvero etichettatura e quarantena.
• 11:35
  Applichiamo un candidato per la categoria di dispositivi ritirati.
• 11:38
  Rimuoviamo i binding di gruppo dinamici che attivano la proliferazione dei criteri
• 11:41
  e se necessario spostiamo il dispositivo in un gruppo Azure AD di quarantena che blocca l'accesso.
• 11:45
  Nessuna eliminazione ancora.
• 11:46
  Le approvazioni arrivano in un app per logico.
• 11:49
  Il revisore include un piano compatto, ID dispositivo, motivi, azioni proposte, rollback.
• 11:55
  L'approvatore vede un digest in teams con citazioni per rappresentare graficamente le query e registrare l'analisi che è quella.
• 12:00
  Approva il token del sensore.
• 12:02
  Il remediatore esegue il ritiro.
• 12:03
  Cancella quando giustificato o pulisce i duplicati.
• 12:06
  Mantenendo il dispositivo con l'artbeat più recente e scollegando i ghost.
• 12:10
  L'identità gestita ci tiene le mani pulite.
• 12:12
  Monitor viene eseguito con il dispositivo in lettura completa.
• 12:14
  I remediatore utilizzano l'identità separata con il dispositivo in lettura completa e esattamente le autorizzazioni in tune di cui ha bisogno.
• 12:20
  L'eliminazione è dietro P.
• 12:21
  L'agente del remediatore non può elevare se stesso.
• 12:24
  Quando viene richiesta l'elevazione, l'app per la logica richiede un essere umano e il tempo inizia a scorrere per l'autorizzazione temporanea.
• 12:29
  L'osservabilità è la parte adulta.
• 12:31
  Ogni chiamata allo strumento è tracciato.
• 12:33
  Chi ha chiamato cosa, parametri, latenza, risposta.
• 12:35
  Il revisore scrive i record degli eventi per registrare le analisi con ID di correlazione in modo da poter ricostruire la scena del crimine senza l'archeologia di Slack.
• 12:42
  Eseguiamo anche una fase di valutazione dopo la modifica di fondatezza, pertinenza e fluidità.
• 12:46
  Se la fondatezza diminuisce, il revisore blocca ulteriori azioni distruttive e rimanda al piano al pianificatore per perfezionare il recupero o restringere l'ambito.
• 12:53
  I modelli vengono mischiati intenzionalmente.
• 12:55
  La classificazione utilizza un modello di piccole dimensioni per mantenere bassi costi e latenti.
• 12:59
  I casi limite, come i due dispositivi in cui Autopilot ne ha rinominato uno e Azzuradili considera gemelli,
• 13:03
  ottengono un percorso di ragionamento con CPT4 mini.
• 13:06
  I rapiloghi vengono regolpati in bene.
• 13:07
  Nessuno ha bisogno di un rapporto Shakespeareano all'Equatorio.
• 13:09
  Microstoria.
• 13:10
  La scorsa settimana il test con un agente singolo ha provato a correggere un dispositivo obsoleto ritirando tutto nello stesso gruppo dinamico.
• 13:15
  Il revisore del nostro flusso multiagente ha segnalato la mancata corrispondenza dell'ambito e ha chiesto la conferma a livello dispositivo e non ha interrotto.
• 13:21
  Ecco perché separiamo pianificazione e controllo.
• 13:23
  Risultato finale.
• 13:24
  I dispositivi fantasma smettono di infestare la conformità.
• 13:26
  Riduci lo spiego di licenze, tagli ai falsi positivi e smetti di spiegare alla dirigenza perché il fallimento in pensione è uno stile di vita.
• 13:32
  E se la traccia di controllo è leggibile, il che è più di quanto possa dire per metà dei tuoi ticket in modifica.
• 13:38
  Scenario dimostrativo 2.
• 13:39
  Onboarding senza contatto.
• 13:41
  In realtà zero contatto.
• 13:42
  Zero contatto per l'utente.
• 13:43
  500 tocchi per l'ingegneria fino agli agenti.
• 13:46
  Obiettivo.
• 13:47
  Da un evento HR a un utente e a un dispositivo pronti senza assistenza girevole.
• 13:51
  Semplice, governato e reversibile quando HR scrive il cognome in tre modi diversi.
• 13:55
  Formazione del team.
• 13:56
  L'assunzione.
• 13:57
  Ascolta il webhook HR e normalizza i payload e convalida i campi obbligatori.
• 14:01
  Il provisioner crea l'utente in entra, assegna gruppi e licenze, registra i profili autopilot.
• 14:07
  Il validatore verifica la conformità alle policy e la postura di accesso condizionale prima di consegnare un laptop scintillante.
• 14:13
  Il concierge invia il pacchetto di benvenuto e i link di SharePoint e la checklist del primo giorno.
• 14:18
  Tempo di flusso.
• 14:19
  L'assunzione ottiene il pelo da HR, il nome, la data di inizio, il ruolo, il reparto e il responsabile della regione.
• 14:24
  Il modello piccolo estrae e normalizza.
• 14:26
  Esegue il mapping sui campi canonici e rileva sordità come una data di inizio nel 2099.
• 14:29
  Se mancano campi obbligatori invia un ping alle risorse umane con un errore risorse umane con un errore strutturato tramite logic apps senza alcuna posizione in formato libero.
• 14:35
  Il provisioner chiama graph con un'identità gestita con l'ambito di diritto utente.
• 14:38
  Crea l'utente, entra, imposta la posizione di utilizzo e applica un gruppo di base.
• 14:42
  Quindi assembla le assegnazioni di licenze in base al ruolo e alla regione.
• 14:46
  Il ragionamento aiuta in questo caso.
• 14:47
  Questa persona ha bisogno di sicurezza e 5 business premium.
• 14:50
  Codifichiamo la policy nei dati e lasciamo che il modello scelga tra i bundle consentiti.
• 14:54
  Nessun modello può inventare licenze e un menu rigido.
• 14:56
  Successivamente arriva l'autopilot.
• 14:57
  Il provisioner registra una hardware che abbiamo già o prepara un profilo just in time collegato al gruppo dell'utente.
• 15:04
  Contrassegna i gruppi di dispositivi per le policy di base, quindi il validatore si riattiva.
• 15:08
  Interroga graph e defender per i segnali di conformità.
• 15:10
  Verifica che l'accesso condizionale non interrompa il primo accesso e controlla che vengano applicate le policy di configurazione del dispositivo corretto.
• 15:16
  Se l'accesso condizionale bloccasse il nuovo assunto il primo giorno,
• 15:19
  il validatore apre un'approvazione con un'eccezione limitata nel tempo e la relativa motivazione.
• 15:23
  Concierge ci stesse la parte umana.
• 15:24
  Invia un messaggio Teams responsabile con l'UPN del nuovo assunto, lo stato di assegnazione del dispositivo, un collegamento, uno starter kit di SharePoint.
• 15:32
  Invia un'email al nuovo assunto con i passaggi del primo giorno, le istruzioni per la configurazione, gli MFI e dove trovare il portale IT.
• 15:37
  Non incola gli intervalli pinterni nell'email.
• 15:40
  I controlli di sicurezza dei contenuti rilevano perdite e toni.
• 15:43
  La governance segue lo stesso tema di SIDBAL.
• 15:45
  L'identità gestita del provisionerà il diritto di licenza ma non di eliminazione.
• 15:49
  L'assunzione non può effettuare il provisioning ma solo la command.
• 15:51
  PM controlla tutte le azioni ad alto rischio come l'aggiunta di utenti a un gruppo sensibile.
• 15:55
  Tutte le azioni vengono tracciate in app insights e analisi dei registri.
• 15:58
  Se le risorse umane inviano un payload corretto, il planner ricalcola il delta e l'operatore aggiorna solo ciò che è cambiato.
• 16:04
  Nessuna appartenenza a gruppi che si alterna.
• 16:05
  L'osservabilità fornisce traguari.
• 16:08
  Acquisizione HR, creazione entra, assegnazione licenza, profilo autopilota, notifica verdetto di conformità inviata.
• 16:14
  Ottieni metrica SLA e nuovi tentativi automatici su errori grafici temporanei con backoff.
• 16:18
  Se il sistema HR si blocca, il thread non muore.
• 16:21
  Si interrompe, registra e riprende quando viene risolto.
• 16:24
  Le valutazioni vengono eseguite in CI su piloto di onboarding sintetici per rilevare regressioni in termini di pertinenza e fondatezza prima che una vera assunzione ne risenta.
• 16:31
  Mix di modelli mantiene la fattura sana.
• 16:33
  SLM per estrazione e normalizzazione.
• 16:34
  Un passaggio di ragionamento solo sulle decisioni di selezione delle poli.
• 16:38
  Riepiloghi di mail di benvenuto in batch quando possibile.
• 16:41
  L'obiettivo è un provisioning a bassa latenza con chiarezza di livello umano nel registro di controllo.
• 16:45
  Breve storia.
• 16:46
  L'onboarding di un singolo agente ha tentato di aggiungere un utente a tutto il personale e collaboratori perché il titolo indicava personale dei collaboratori.
• 16:53
  Il multiagente ha rilevato la regola di esclusività reciproca nel validatore, ha chiesto una decisione umana ed ha evitato un immediato incendio nell'accesso condizionale.
• 16:59
  Risultato davvero zero touch per l'utente.
• 17:01
  Un thread, quattro agenti, approvazioni pulite e una traccia cartacea che puoi mostrare il tuo ciso senza pregare l'idea della demo.
• 17:08
  E sì, quando le risorse umane cambiano inevitabilmente la data d'inizio, il sistema ricalcola senza intaccare il budget delle licenze.
• 17:14
  Scenario dimostrativo 3, rafforzamento automatico della sicurezza.
• 17:17
  Lasciate che BitLocker sia attivo.
• 17:19
  La deriva della sicurezza è come l'herbaccio.
• 17:21
  Ne tiri fuori 3, 5 pop-up e uno di questi disabilita BitLocker per dispetto.
• 17:25
  Il nostro obiettivo è rilevare continuamente la deriva della configurazione e porvi rimedio in modo sicuro con The Gate che un avvocato rispetterebbe.
• 17:31
  Cast Drift Detector interroga Graph Defender.
• 17:34
  Secure Score estrae le linee di base di conformità e configurazione del dispositivo di Intune e crea un delta di deriva.
• 17:38
  Fixer invia le modifiche ai criteri di Intune, le impostazioni di BitLocker e gli anelli di aggiornamento di Windows.
• 17:45
  Esegui gli script del dispositivo tramite Azure Automation quando i criteri non riescono ad arrivare abbastanza lontano.
• 17:50
  Reviewer applica delle protezioni, definisce l'ambito delle modifiche, esegue controlli di fondatezza e blocca le approvazioni umane per i passaggi rischiosi.
• 17:56
  Messenger spinge gli umani in Teams o tramite email con piani ricevute compatti.
• 18:02
  Flow Drift Detector viene eseguito in base a una pianificazione su richiesta.
• 18:05
  Estrae la conformità del dispositivo, lo stato di BitLocker, lo stato del TPM, la versione del sistema operativo, l'anello di aggiornamento e le assegnazioni dei criteri tramite Graph.
• 18:14
  Confronta ogni dispositivo con un profilo Golden come dati strutturati, non un documento Vibes.
• 18:19
  Contrassegni ai risultati.
• 18:20
  BitLocker mancante.
• 18:21
  Metodo di crittografia debole.
• 18:23
  Criterio non applicato.
• 18:24
  Avvio sicuro disattivato.
• 18:25
  Anello di aggiornamento fuori dai limiti.
• 18:26
  Viene avviato il passaggio del pianificatore e propone un piano minimo per il gruppo di dispositivi.
• 18:30
  Per BitLocker usa il criterio BitLocker di Intune se il dispositivo è compatibile.
• 18:33
  Se il criterio è già stato preso di mira ma lo stato è disattivato, propone uno script di automazione per riavviare i protettori e depositare la chiave in Azure AD.
• 18:41
  Per l'aggiornamento del drift, propone di spostare il dispositivo in un anello di aggiornamento graduale, non sperando di applicare subito la patch.
• 18:47
  Per gli errori di accesso condizionale, propone un'eccezione con il limite di tempo con la giustificazione richiesta.
• 18:52
  Il revisore valuta la fondatezza.
• 18:53
  Drift Detector ha effettivamente citato i campi da Graph e Defender.
• 18:58
  Controlla l'ambito, il di dispositivo, il di criterio e il tipo di modifica.
• 19:02
  Se qualcosa puzza di tutti i dispositivi, viene bloccato con pregiudizio.
• 19:05
  La sicurezza dei contenuti è su input e output per impedire l'inserimento immediato di informazioni esterne o registri incollati.
• 19:11
  Le azioni ad alto rischio, come la rimozione di una policy locale in conflitto, vengono sottoposte a PM.
• 19:16
  L'identità del fixer non può auto-elevarsi.
• 19:17
  L'approvazione risiede in un'app logica con una scheda ordinata.
• 19:20
  Cosa c'è che non? Cosa cambierà?
• 19:22
  Passaggi di rollback e citazioni.
• 19:23
  A prova, il fixer esegue.
• 19:25
  Gli aggiornamenti delle policy di Intune sono potenti e mirati.
• 19:28
  La correzione di BitLocker utilizza un runbook con parametri espliciti e un controllo di integrità.
• 19:32
  TPM è presente.
• 19:33
  Il sistema operativo supporta XTS-AS256 S-Group Path Verified.
• 19:38
  Se un controllo preliminare non riesce, fallisce con un errore intuitivo e senza effetti collaterali.
• 19:42
  Messenger chiude il ciclo.
• 19:43
  Il dispositivo è riparato.
• 19:44
  Un digest raggiunge Teams con conteggi e collegamenti a tracce di App Insights
• 19:48
  e un CSV per la persona che ama ancora Excel più della propria famiglia.
• 19:52
  Se un dispositivo si rifiuta di essere conforme, il revisore apre un thread di eccezione con un oro roggio e riprova pianificato.
• 19:57
  Osservabilità di unichiamata allo strumento tracciato e correlato dal thread.
• 20:01
  Blocchiamo i delta prima dopo in modo che l'audit possa vedere la conformità non conforme senza camparsi in cacchi well.
• 20:06
  Eseguiamo anche un agente di valutazione sui riepiloghi post-modifica per verificare la chiarezza.
• 20:10
  Se la fondatezza diminuisce e i tassi di errore aumentano, il pianificatore restringe il recupero, riduce le dimensioni del batch o sospende le azioni distruttive.
• 20:17
  Combinazione di modelli SLM per estrazione e classificazione, modello di ragionamento per la sintesi del piano solo quando necessario, raggruppamento da reperto.
• 20:25
  Nessun esercito di esercito.
• 20:26
  Risultato finale, BitLock effettivamente.
• 20:28
  Le anelli di aggiornamento si spostano a me.
• 20:29
  Le eccezioni sono documentate nei tempi revisionabili.
• 20:32
  E nessuno ripara un dispositivo ricrando l'immagine dei laptop finanziari durante la chiusura del trimestre.
• 20:37
  Analise dell'architettura.
• 20:38
  Foundry più SK più strumenti più identità.
• 20:41
  Apriamo il cofano senza versare olio e motore sulla tua quota.
• 20:44
  Pensa a quattro livelli che mantengono tutto sano.
• 20:47
  Foundry, kernel semantico, strumenti, identità.
• 20:50
  Foundry la base di partenza.
• 20:52
  Definisci gli agenti con istruzioni rigorose.
• 20:54
  Scegli le distribuzioni per ruolo.
• 20:56
  Alleghi le conoscenze tramite la ricerca di Azure azioni.
• 20:59
  Strumenti API aperti.
• 21:00
  App logiche.
• 21:01
  Funzioni.
• 21:02
  Grafici.
• 21:02
  Automazione di Azure.
• 21:03
  Interprete di codice.
• 21:06
  Minacce.
• 21:06
  Cronologia di esecuzione.
• 21:07
  Tracciamento.
• 21:08
  Valutazioni.
• 21:08
  Sicurezza qui.
• 21:09
  Le protezioni per i prompti di sicurezza dei contenuti e controlli del materiale protetto eseguono modelli pre-posti
• 21:13
  in modo che gli input errati non costino token, non costino token e gli output errati non costino lavoro.
• 21:17
  Kernel semantico e il conduttore.
• 21:18
  Nel codice colleghi il ciclo di revisione dell'operatore e del pianificatore.
• 21:21
  Registri i cataloghi di funzioni per gli strumenti, disattiva la ripetizione e aggiungi i token di annullamento.
• 21:27
  Mantieni i brevi prompt, inserisci la complessità negli schemi e lasci che SK decida quale strumento chiamare in base alla disponibilità e ai criteri.
• 21:33
  Se il grafico scade SK lo gestisce con jitter.
• 21:35
  Se la messa a terra diminuisce, torna al pianificatore per perfezionarlo.
• 21:39
  Gli strumenti sono M-Line.
• 21:40
  Mantieni rigorosi i contatti con API aperti.
• 21:43
  Metti la gestione delle API in primo piano per limitare la versione e interromperci.
• 21:46
  Le API logiche gestiscono le approvazioni e i flussi di lunga durata.
• 21:49
  Le funzioni fanno da collante e trasformano.
• 21:51
  L'automazione di Azure esegue script con protezioni e controlli successivi.
• 21:54
  Graffa la tua fonte di verità per Intune e entra, conformità e punteggio sicuro.
• 21:58
  La ricerca di Azure AI fornisce conoscenze curate per dominio.
• 22:01
  Nessuna minestra di conoscenze.
• 22:02
  Identità è la cintura di sicurezza.
• 22:04
  Ogni agente ha la propria identità gestita.
• 22:06
  Gli agenti di monitoraggio ottengono ambiti di scrittura ma è amministrazione.
• 22:10
  PM blocca tutto ciò che è distruttivo.
• 22:12
  L'elevazione richiede un essere umano e scade.
• 22:15
  Endpoint privati in cui i limiti dei dati sono importanti.
• 22:17
  Le linee di base dei criteri nei progetti Foundry applicano modelli, aree e quote consentiti.
• 22:22
  App Insights e analisi dei log raccolgono tracce, metriche e audit
• 22:25
  in modo da poter rispondere a chi ha fatto cosa senza archeologia di Slack.
• 22:29
  I modelli si collegano tramite l'endpoint di inferenza di Foundry.
• 22:32
  Usa serverless per ragionamenti premium, gestisci il calcolo per modelli aperti e bloccati.
• 22:36
  Scambia modelli senza riscrivere codice ma valuta comunque pertinenza, fondatezza e fluidità
• 22:40
  in CI prima di promuoverli.
• 22:42
  Le aree corrispondono ai tuoi utenti, le zone dati corrispondono ai tuoi regolatori.
• 22:45
  Insieme è una macchina noiosa affidabile.
• 22:47
  Agenti definiti in fonderia, orchestrati da SK, alimentati da strumenti rigorosi, bloccati
• 22:52
  dall'identità, misurati dall'osservabilità e protetti dalla sicurezza.
• 22:56
  La noia vince.
• 22:57
  La noia scala.
• 22:58
  La noia ti fa dormire.
• 23:00
  Le best practice vengono spedite senza rimpianti.
• 23:03
  Costruisci saggezza temporale in modo da non passare la domenica a disfare solo.
• 23:06
  Assegna ogni agente un lavoro.
• 23:07
  Pianificatore pianifica.
• 23:08
  L'operatore opera.
• 23:09
  Revisore esamina.
• 23:10
  Se un agente inizia a scrivere un romanzo sentito, taglia il suo prompt e affida la prosa a uno strumento.
• 23:15
  Mantieni le istruzioni brevi, circoscritte noiose.
• 23:17
  Avrai meno sorprese.
• 23:19
  Preferisci le chiamate degli strumenti alla prosa room.
• 23:21
  Inserisci i contratti in appia aperte, schemi sugli input e protezioni, sugli output.
• 23:24
  Se uno strumento si aspetta un dispositivo, invia un dispositivo, non forse questo dispositivo in finanza.
• 23:29
  I modelli sono creativi, gli strumenti no.
• 23:31
  Questo è il punto.
• 23:32
  Applica il privilegio minimo come se il tuo lavoro dipendesse da esso, perché così?
• 23:35
  Identità separate.
• 23:37
  Sola lettura per il monitor, sola scrittura per il rimediatore,
• 23:39
  e nessuna identità è eliminabile senza PM.
• 23:41
  L'elevazione è temporanea, giustificata e registrata.
• 23:44
  Se qualcuno chiede un amministratore globale permanente, consegnagli una palla antistress e un documento di policy.
• 23:48
  Inizia in piccolo due agenti, un esecutore o un verificatore.
• 23:50
  Aggiungi un pianificatore una volta che il ciclo è stabile.
• 23:52
  Quindi se devi espanderti, non iniziare con un team scrum digitale di 12 persone.
• 23:55
  È così che ricredito il venigramma, iam e piangi.
• 23:57
  Combina modelli per ridurre i costi.
• 23:59
  SLM per l'estrazione, classe GPT4 solo per il ragionamento dove serve.
• 24:03
  Ripileghi invece durante la notte.
• 24:04
  Non stai pagando tariffe elevate per formattare una stringa di dati.
• 24:07
  Salva il modello pesante per le decisioni, non per la narrazione.
• 24:10
  Aggiungi la memoria per uno.
• 24:11
  Usa lo stato esterno come ricerca AI o un piccolo archivio di stato
• 24:14
  prima di iniziare a riempire le finestre di contesto come un bagaglio a mano.
• 24:17
  Metadati dei thread dovrebbero essere meno.
• 24:19
  Se non sono necessari per il turno successivo non vanno.
• 24:21
  Registra tutti.
• 24:22
  Attiva il tracciamento.
• 24:24
  ID thread, parametri strumento e risultati latenza.
• 24:26
  Invia valutazioni in CI in modo da rilevare cali di pertinenza e fondamento
• 24:29
  prima che lo faccia la produzione.
• 24:30
  Attenzione quando calla la concretezza, non quando lo fa Twitter.
• 24:34
  Perdrai il prima della velocità approvazioni per strumenti distruttivi.
• 24:37
  Modalità di prova senza effetti colaterali.
• 24:39
  Implementazioni graduali per gruppo di dispositivi o regioni.
• 24:41
  Se il tuo piano di implementazione è tutto in una volta,
• 24:43
  spero che il tuo curriculum sia aggiornato.
• 24:44
  Compila per i fallimenti.
• 24:45
  Riprova con GIT.
• 24:46
  Riduci la limitazione del grafico.
• 24:48
  Interruttori automatici nella gestione delle app.
• 24:50
  Rambucchi da impotenti.
• 24:51
  Se un passaggio può essere eseguito di nuova in sicurezza, dormi meglio.
• 24:54
  Infine, documenta le tue policy come dati.
• 24:56
  Regole di esclusività reciproca pacchetti di licenze e linee di base dei dispositivi.
• 24:59
  inserisci in forma strutturata.
• 25:01
  I modelli possono selezionare e non doveri ambientali.
• 25:03
  Ecco sì che mantieni gli agenti utili e il tuo raggio di azione ridotto.
• 25:07
  Se ricordi una cosa, i singoli agenti aiutano,
• 25:09
  ma i team di agenti pianificati basati su strumenti con ambito di autorizzazione
• 25:12
  trasformano silenziosamente il tuo ambiente mentre tu fai finta di dormire.
• 25:16
  Se questo ti ha colpito, iscriviti e guarda il seguito in cui inserisco il repository
• 25:19
  del kernel semantico del modello B-CEP in modo che tu possa rubare senza vergogna.
• 25:22
  Vuoi l'episodio degli agenti di valutazione che mantiene la promessa?
• 25:25
  È in coda la prossima settimana.