Uploaded October 2026 | Updated November 2026, 6 hours ago
A successful demonstration does not prove that an agent is ready for production. Production readiness requires measurable quality, end-to-end observability, repeatable testing, controlled releases, and a clear operational model.
In the final session, we will evaluate and operate the agent solution built throughout the series. We will create a representative evaluation dataset covering normal requests, ambiguous cases, tool failures, unauthorized actions, outdated knowledge, and prompt-injection attempts.
Using Microsoft Foundry evaluation and observability capabilities, we will measure task completion, tool-call accuracy, groundedness, relevance, latency, safety, and operational reliability. We will trace requests across the agent, API Management, Logic Apps, Azure Functions, Service Bus, and the worker application using distributed tracing and Application Insights.
During the live demonstration, we will deliberately introduce a faulty tool definition, observe the resulting regression, identify the cause through traces and evaluation results, correct the implementation, and apply a quality gate before releasing the updated version.
The session will conclude with production monitoring, alerting, versioning, rollout and rollback strategies, and agent governance across multiple teams and environments. By the end of the session, attendees will know how to move from “the agent appears to work” to evidence that it is reliable, explainable, supportable, and safe to operate.
Key topics: Microsoft Foundry evaluation Agent and tool-call quality metrics Distributed tracing Application Insights Regression testing safety and adversarial testing CI/CD quality gates Monitoring, incident response, and governance.
0:00 - Introduction and Overview
3:20 - Understanding the Agentic Solution
6:23 - Resource Inventory & Infrastructure
9:02 - Recap of Episodes 1-3
12:12 - Production-Grade Agentic Principles
16:14 - Integration Architecture (API Management & Logic Apps)
23:12 - Live Demonstration - Incident Triage
35:10 - Governance, Security, & Recovery Paths
42:08 - Evaluation, Observability, & Quality Gates
57:54 - Rollout, Rollback, & Incident Response
[eventID:27510]
A successful demonstration does not prove that an agent is ready for production. Production readiness requires measurable quality, end-to-end observability, repeatable testing, controlled releases, and a clear operational model.
In the final session, we will evaluate and operate the agent solution built throughout the series. We will create a representative evaluation dataset covering normal requests, ambiguous cases, tool failures, unauthorized actions, outdated knowledge, and prompt-injection attempts.
Using Microsoft Foundry evaluation and observability capabilities, we will measure task completion, tool-call accuracy, groundedness, relevance, latency, safety, and operational reliability. We will trace requests across the agent, API Management, Logic Apps, Azure Functions, Service Bus, and the worker application using distributed tracing and Application Insights.
During the live demonstration, we will deliberately introduce a faulty tool definition, observe the resulting regression, identify the cause through traces and evaluation results, correct the implementation, and apply a quality gate before releasing the updated version.
The session will conclude with production monitoring, alerting, versioning, rollout and rollback strategies, and agent governance across multiple teams and environments. By the end of the session, attendees will know how to move from “the agent appears to work” to evidence that it is reliable, explainable, supportable, and safe to operate.
Key topics: Microsoft Foundry evaluation Agent and tool-call quality metrics Distributed tracing Application Insights Regression testing safety and adversarial testing CI/CD quality gates Monitoring, incident response, and governance.
0:00 - Introduction and Overview
3:20 - Understanding the Agentic Solution
6:23 - Resource Inventory & Infrastructure
9:02 - Recap of Episodes 1-3
12:12 - Production-Grade Agentic Principles
16:14 - Integration Architecture (API Management & Logic Apps)
23:12 - Live Demonstration - Incident Triage
35:10 - Governance, Security, & Recovery Paths
42:08 - Evaluation, Observability, & Quality Gates
57:54 - Rollout, Rollback, & Incident Response
[eventID:27510]
![GitHub Copilot App Hands-On: From Sessions to Pull Requests
Explore the GitHub Copilot app, session modes, worktrees, and context management. Using the courses Book App, youll create an isolated session, plan and implement a bug fix, and validate changes with tests, builds, and browser previews.
Youll then create a pull request, review feedback, and investigate failing checks while learning how to supervise agent-driven development. This session covers chapters 01, 02, 03 from the GitHub Copilot app for Beginners course.
[eventID:27812] GitHub Copilot App Hands-On: From Sessions to Pull Requests](https://i.ytimg.com/vi/NPPszpJ4BbQ/mqdefault.jpg)
![AI Genius | Architect the Flow: GitHub Canvas, Token Economics & Extensible Workspace
As AI agents tackle increasingly complex development tasks, developers need more than chat-based interactions.
In this session, youll learn how to orchestrate multi-agent workflows with GitHub Canvas, optimize token consumption through effective context engineering, and extend Copilot with MCP integrations and custom plugins.
Discover how leading teams are improving developer productivity while reducing cost, latency, and operational friction.
📌 This session is part of a series. Explore the full series here: https://aka.ms/AIGenius6/y
0:00 Intro and Session Overview
4:02 Section 1: Token Optimization Strategies
14:04 Demo: Managing Agent Sessions
25:25 Section 2: Plugins and MCP (Model Context Protocol) Servers
31:51 Demo: Installing Plugins and Pointing at Copilot
41:00 Section 3: Leveraging GitHub Canvas for Workflows
42:34 Demo: Building and Using Canvases
54:46 Closing Summary and Best Practices
57:00 Q&A Session
[eventID:27639] AI Genius | Architect the Flow: GitHub Canvas, Token Economics & Extensible Workspace](https://i.ytimg.com/vi/NWW67xTIunM/mqdefault.jpg)
![When One Agent Isnt Enough: Orchestrating Secure Parallel Agent Swarms
AI agents need to run code, call APIs, and fan out in parallel - but doing that safely at scale is hard.
This session shows how to build agentic workloads on hardware-isolated, sub-second, disposable compute that agents can provision themselves. Watch a live research-agent swarm spin up a fleet of secure sandboxes in parallel, run real work in true isolation, and tear it down automatically - with keyless auth throughout.
Powered by Azure Container Apps Sandboxes. Youll learn
• Why untrusted agent code and multi-agent fan-out break traditional container/VM approaches
• The pattern for safe, ephemeral, per-agent compute: isolation, instant start, scale-to-zero, snapshot/resume
• How agents can self-provision compute as a tool to extend their own capabilities
• Controlling blast radius with hardware isolation, egress policies, and keyless managed identity
• A working orchestration pattern for parallel agent swarms you can adapt to your own workloads
🔗 https://aka.ms/AzureContainerAppsSandbox
📌 This event is a part of a series, learn more here: https://aka.ms/BCNA
0:00 - Introduction and housekeeping
0:50 - Introduction to multi-agent swarms and research demonstration
6:22 - Architecture overview: Orchestrating parallel agent swarms
7:13 - What are sandboxes and how they work
9:17 - Introduction to Azure Container Apps Sandboxes
11:34 - Anatomy of a sandbox and sandbox groups
12:44 - Creating a sandbox group and using the portal
15:31 - Programmatic sandbox creation options
16:29 - Deep dive into sandbox mechanics and microVMs
18:35 - Bringing your agent image and disk image creation
20:07 - Sandbox configuration: lifecycle, idle times, and policies
21:50 - Auto-suspend modes: Memory vs. Disk
24:00 - Snapshots and persisting state
25:08 - Using volumes for external storage
27:27 - Configuring network egress and outbound calls
29:28 - Outbound calls with credential injection
32:46 - Network ingress and exposing ports
34:20 - IP access control and allowed users
35:24 - Re-examining the swarm architecture with sandboxes
36:35 - Using the Microsoft Agent Framework
38:09 - Building the swarm workflow graph
42:00 - Observability with OpenTelemetry
44:20 - Carrying traces across the sandbox boundary
47:06 - Key takeaways and scenarios for sandboxes
49:27 - Connecting sandbox systems with triggers and connectors
51:10 - Comparison of container apps execution surfaces
52:12 - Resources and learning links
[eventID:27394] When One Agent Isnt Enough: Orchestrating Secure Parallel Agent Swarms](https://i.ytimg.com/vi/Nd3036clOCY/mqdefault.jpg)
![Lets Learn GitHub Copilot SDK (Java)
Join this beginner-friendly livestream to learn how to build agentic applications with the GitHub Copilot SDK for Java, without implementing the agent loop yourself. Unlike calling a model API directly, the SDK gives your application programmatic access to Copilot’s agent runtime, including conversation management, planning, tool orchestration, streaming events, and session state. During the session, we’ll explore clients, sessions, prompts, and the agent runtime. You’ll learn how to create multi-turn conversations, stream responses in real time, expose application functions as tools, connect external capabilities through MCP servers, and control agent behavior with hooks and permission handlers. We’ll also help you understand when to use the Copilot SDK instead of the interactive Copilot CLI: use the CLI for developer tasks in the terminal and use the SDK when you want to embed Copilot’s agentic capabilities in your own application or service. No prior experience with the GitHub Copilot SDK is required.
📌 This event is part of a series. Learn more here: https://aka.ms/letslearnghsdk/series
🔗 Learn more by exploring the resources: https://gh.io/letslearn-sdk
00:00 Introduction and Housekeeping
00:43 Welcome and Overview of the Copilot SDK
01:56 GitHub Copilot SDK Architectural Overview
08:57 Future of Copilot SDK 2.0
09:45 SDK Workshop Introduction
12:47 Exploring the Museum Exhibit Studio (Java)
16:47 Codebase Overview: Understanding the Project Classes
23:12 Step 1: Creating the Client and Session
31:12 Step 2: Enabling Streaming for the Curator
35:12 Step 3: Setting the Curators Voice (System Message)
40:32 Step 4: Enabling Approved Fact Lookup Tools
49:37 Step 5: Implementing Guardrails
57:05 Step 6: Adding Structural Validation
1:02:17 Step 7: Configuring Wikipedia MCP Servers for Research
1:09:02 Step 8: Generating the Interactive HTML Exhibit
1:17:10 Using the Copilot SDK Visualizer
1:22:36 Resources and Learning Path
#MicrosoftReactor #LearnConnectBuild #GitHubCopilot #GitHubCopilotSDK
[eventID:27550] Lets Learn GitHub Copilot SDK (Java)](https://i.ytimg.com/vi/O7bJ4EAAFck/mqdefault.jpg)
![Control de versiones de soluciones de Power Platform con Azure Repos
En esta sesión aprenderemos a exportar, desempaquetar y almacenar soluciones de Power Platform en Azure Repos. También revisaremos estrategias de ramas, versionamiento y colaboración entre varios desarrolladores.
🔗 Aprende más accediendo a los recursos: https://aka.ms/PowerPlatformParaAzureDevOps
📌 Este evento es parte de una serie, aprende más aquí: https://aka.ms/PowerPlatformALM/y
0:07 Introducción y objetivos
3:00 Capas de acceso en Azure DevOps (Organización, Proyecto, Recursos)
6:04 Grupos de seguridad y niveles de permiso
11:07 Configuración de usuarios en Azure DevOps
14:14 Creación y gestión de grupos de desarrollo
17:00 Seguridad en repositorios y pipelines
28:31 Gestión de seguridad en Power Platform (Admin Center)
36:14 Resumen comparativo (DevOps vs. Power Platform)
38:53 Flujo de despliegue (Exportar/Importar con YAML)
42:47 Ejecución y configuración del pipeline
50:24 Demostración: Despliegue de soluciones
56:45 Conclusiones y cierre
#MicrosoftReactor #LearnConnectBuild #Devops, #PowerPlatform, #ALM
[eventID:27569] Control de versiones de soluciones de Power Platform con Azure Repos](https://i.ytimg.com/vi/OAwAfZ47-zI/mqdefault.jpg)
![Model Mondays - Mistral OCR-4 and Building AI Agents in Microsoft Foundry
Mistral models offer developers a versatile family of models for reasoning, coding, multilingual, and multimodal workloads, with options suited to different requirements for capability, speed, and efficiency.
Join us as we explore the Mistral family in Microsoft Foundry and see how these models can support practical agent workflows.
0:00:00 Introduction and Welcome
0:03:08 Foundry Updates: Models, Agents, and Tool Discovery
0:04:43 Model Launch Highlights
0:06:50 Deepseek V4.1 Flash Features
0:08:06 Deep Dive into Model Routers
0:11:03 Meet the Mistral Team
0:12:44 Mistral: Strategy and Sovereignty
- Explore the Resources https://github.com/microsoft/model-mondays
- Read the Newsletter https://aka.ms/model-mondays/newsletter
- Continue the conversation on the Discord https://aka.ms/model-mondays/discord
- Register: https://aka.ms/model-mondays/RSVP
- Schedule & recaps: https://aka.ms/model-mondays
- Playlist: https://aka.ms/model-mondays/playlist
- Mistral cookbook: https://github.com/mistralai/cookbook
[eventID:27546] Model Mondays - Mistral OCR-4 and Building AI Agents in Microsoft Foundry](https://i.ytimg.com/vi/OX1RWeQGhfg/mqdefault.jpg)
![CI/CD integral para Microsoft Fabric: de Git a plataformas de datos en producción
Las organizaciones que adoptan Microsoft Fabric a menudo enfrentan dificultades para implementar estrategias de despliegue automatizadas y coherentes en los distintos espacios de trabajo, lo que deriva en despliegues manuales, divergencia entre entornos y una gobernanza limitada.
En esta sesión veremos cómo diseñar e implementar una canalización de CI/CD integral mediante Azure DevOps y Git para gestionar artefactos de Microsoft Fabric, tales como Lakehouses, Data Warehouses y canalizaciones en Fabric.
0:00 Introducción y bienvenida
3:54 Presentación del ponente
4:59 Agenda de la sesión
6:44 La problemática de Git y el despliegue
8:04 Contexto y puntos de partida de la demo
9:51 ¿Qué es Microsoft Fabric?
12:42 Componentes y experiencias de Fabric
16:32 OneLake y unificación de servicios
19:34 Mirroring: Operaciones sin ETL
22:17 Lakehouse vs. Warehouse: ¿Cuál usar?
27:00 Transformación, orquestación y modelos semánticos
29:34 Real Time Intelligence y Data Agents
30:42 Enfoque de despliegue: De Dev a Producción
34:07 ¿Qué viaja a Git y qué no?
36:25 Azure DevOps y piezas clave de integración
38:34 Arquitectura de referencia y despliegue
41:25 Identidad, seguridad y SPN
43:34 Demo en vivo: Data Agents y Copilot
46:13 Demo en vivo: Workspace y Source Control
52:19 Configuración de seguridad y entornos
56:17 Escalabilidad a nivel empresarial
58:34 Recursos adicionales y cierre
[eventID:27663] CI/CD integral para Microsoft Fabric: de Git a plataformas de datos en producción](https://i.ytimg.com/vi/Oryojln64Sg/mqdefault.jpg)
![Beyond Vibe Coding: Formal Verification for AI-Generated Software
AI coding agents can now write substantial amounts of open-source software, but generated code still needs more than a plausible implementation and a passing test suite.
In this session, Carl will demonstrate a workflow in which AI writes code, creates a formal specification, and produces a machine-checked proof of correctness. He is applying this approach to RangeSetBlaze, an open-source Rust library, using Lean to state and prove key correctness properties.
The broader idea is language-independent: AI may make formal verification practical for ordinary software development by taking on much of the proof engineering itself. The session will explore what this workflow looks like in practice, where it works, where it breaks down, and how formal proofs can complement testing and code review as AI takes on more of the coding.
Introduction and Motivation (0:03:04)
Data Structure: IntRangeSet (0:05:34)
Why Not Just Use Tests? (0:15:05)
Rule 1: Dont Prompt, Metaprompt (0:17:52)
Rule 2: Vibe Specify, Human Review, Vibe Validate (0:20:54)
Rule 3: Preserve Algorithm Abstraction (0:24:08)
Rule 4: Set Up the Theorem (0:26:24)
Rule 5: Enforce Correctness Guardrails (0:29:51)
Historical Interlude (0:31:51)
Rule 6: Review Adversarially (0:35:40)
Rules 7 & 8: Reduce Proof Slop and Dashboard Metrics (0:38:24)
Rule 9: Prove in a Sequence (Shared Libraries) (0:40:54)
Practicality and Limitations (0:44:59)
The State of Formal Verification (0:48:58)
Summary and Conclusion (0:52:42)
Q&A Session (0:54:22)
[eventID:27635] Beyond Vibe Coding: Formal Verification for AI-Generated Software](https://i.ytimg.com/vi/P9xCUmjkPUM/mqdefault.jpg)
![Episódio 1: Fundamentos de IA – Entendendo o Futuro do Trabalho
Descubra os fundamentos da Inteligência Artificial e explore como a IA está transformando setores, carreiras e a vida cotidiana. Esta sessão introdutória desmistifica os principais conceitos de IA, apresenta aplicações no mundo real e ajuda os participantes a construir uma base sólida para sua jornada no universo da IA.
🔗 Aprenda mais acessando os recursos: https://aka.ms/conceitosdeIAdevs
📌 Este evento faz parte de uma série. Saiba mais aqui: https://aka.ms/aiskillsfortomorrow/pt-br/y
0:05 Introdução e apresentação
2:17 Cronograma e objetivos da série
3:13 O que é Inteligência Artificial
5:36 Software tradicional vs. Machine Learning
7:58 Deep Learning e IA Generativa
10:28 Tipos de IA e Agentes
17:37 Demo 1: Contexto e Prompts no Copilot
23:47 Como os modelos de IA aprendem (Tokens e Probabilidades)
28:49 Demo 2: Análise de sentimento com IA
33:27 Diretrizes para o dia a dia e produtividade
36:21 Demo 3: Uso de fontes e imagens no Copilot
39:08 Ética e uso responsável de IA
41:46 Próximos passos e aprendizado
44:22 Sessão de Perguntas e Respostas (RAG e Chunks)
54:46 Encerramento
#MicrosoftReactor #LearnConnectBuild #MicrosoftCopilot #Copilot #Agents #AIAgents #GenAI
[eventID:27642] Episódio 1: Fundamentos de IA – Entendendo o Futuro do Trabalho](https://i.ytimg.com/vi/PAWY6z43I1A/mqdefault.jpg)
![Las habilidades humanas que siguen importando en un mundo AI-first
La IA puede escribir código, sugerir visuales y ayudarnos a trabajar más rápido. Pero no reemplaza el criterio, la curiosidad, el contexto ni la capacidad de saber qué problema vale la pena resolver.
Hablemos de las habilidades que los profesionales de datos todavía necesitan y de las que podrían ser aún más importantes ahora.
0:00:00 - Introducción y bienvenida
0:01:26 - Información logística y código de conducta
0:02:24 - Presentación de los ponentes y moderadores
0:04:42 - Resumen de los Data Days y la agenda
0:05:31 - Certificaciones y recursos de la comunidad
0:07:58 - Introducción al tema: Habilidades humanas en un mundo AI-first
0:08:34 - Discusión: ¿Qué te hace valioso como profesional?
0:14:07 - Habilidades humanas clave para la era de la IA (pensamiento analítico, flexibilidad, curiosidad)
0:26:58 - Ejercicio práctico: Haciendo las preguntas correctas
0:31:34 - Consejos para un prompting efectivo
0:34:25 - Caso de estudio: Validando resultados SQL generados por IA
0:37:46 - Mejores prácticas para arquitecturas AI-first
0:41:00 - Simplificando tareas complejas con IA
0:45:25 - Conceptos fundamentales: LLMs, RAG y Human-in-the-Loop
0:54:49 - Perspectivas en ingeniería de datos y analítica
0:57:44 - Síntesis de habilidades humanas y práctica continua
1:01:18 - Cierre y beneficios de la certificación
[eventID:27748] Las habilidades humanas que siguen importando en un mundo AI-first](https://i.ytimg.com/vi/PDIEEmH1h5w/mqdefault.jpg)
![AI Genius | エピソード1 よりスマートなAIワークフローを設計する
セッションの紹介
AIエージェントの活用が大規模化・高度化する中、効率的なコンテキスト管理とビジュアルオーケストレーションは、次世代のAI開発を支える重要な要素となっています。
本セッションでは、GitHub CopilotのCanvases、コンテキストエンジニアリング、拡張可能なエージェント機能を活用し、よりスマートで効率的なAIワークフローを構築する方法をご紹介します。
実践的なデモを通じて、複数のAIエージェントを連携する方法や、コンテキスト管理を最適化するアプローチ、さらにはチャット中心の操作からビジュアルオーケストレーションへと進化する新たな開発体験をご覧いただけます。
学習内容
• GitHub Copilot の Canvases を活用し、複数のAIエージェントが連携する複雑な開発を効率的に進めるための、ビジュアルワークスペースの活用方法
• トークンの予算管理、プロンプト キャッシュ、コンテキスト最適化を活用し、AIワークフローの効率とパフォーマンスを向上させる方法
• エージェントプラグインや Model Context Protocol (MCP) を活用し、エージェントワークフローを拡張する方法
• 単発のプロンプト実行から、複数のAIエージェントが連携して業務を遂行するエージェントオーケストレーションへ移行するためのベストプラクティス
使用技術
• GitHub Copilot の CLI、app、Visual Studio Codeなどの各種ハーネス
• エージェントプラグインと Model Context Protocol (MCP)
• トークン最適化とコンテキスト エンジニアリング
こんな方におすすめ
• 大規模かつ複雑なコードベースでAIエージェントを活用したワークフローを構築・運用している開発者
• AI ワークフローの 効率向上やコンテキスト管理の最適化に取り組むエンジニア
• 再利用可能なエージェント機能を活用してGitHub Copilotを拡張したいチーム
• マルチエージェントによる新しい開発体験やビジュアルオーケストレーションに関心のある方
講演者
Ayana Yokota
0:00:00 オープニング
0:06:35 セッション1:トークンの最適化
0:09:08 モデルの自動選択(フュージョン)について
0:14:57 作業フェーズの分割(調査・計画・実装)
0:22:13 サブエージェントによる作業の並列化
0:26:44 GitHub Copilotアプリのデモ(設定とモデル選択)
0:38:11 プラグインとMCP(Model Context Protocol)
0:46:51 キャンバス機能の活用
0:51:30 キャンバスのユースケース(Azure SREエージェントなど)
0:55:11 今日のまとめと振り返り
[eventID:27636] AI Genius | エピソード1 よりスマートなAIワークフローを設計する](https://i.ytimg.com/vi/PICDrOU2-ns/mqdefault.jpg)