Uploaded October 2026 | Updated November 2026, 3 days ago
There are a lot of new names in the Fabric AI story. Letโs slow down and connect the pieces.
Weโll look at how Copilot, Fabric IQ, Fabric Apps, and your data work together, what each one is for, and where they could fit into the work youโre already doing.
For more information on Data Days and all it has to offer, visit https://aka.ms/DataDays
๐ This event is part of a series. Learn more here: https://aka.ms/AIatWork/UnderstandIt/y
#MicrosoftReactor #LearnConnectBuild #Fabric #AI #DataDays
[eventID:27715]
There are a lot of new names in the Fabric AI story. Letโs slow down and connect the pieces.
Weโll look at how Copilot, Fabric IQ, Fabric Apps, and your data work together, what each one is for, and where they could fit into the work youโre already doing.
For more information on Data Days and all it has to offer, visit https://aka.ms/DataDays
๐ This event is part of a series. Learn more here: https://aka.ms/AIatWork/UnderstandIt/y
#MicrosoftReactor #LearnConnectBuild #Fabric #AI #DataDays
[eventID:27715]
![New Year, New Bot - Bring Your AI Desk Robot to Life
Meet the M5Stack StackChan as a physical AI desk robot. Program its expressions and movements, connect it to a .NET backend and dashboard, and create a first end-to-end interaction.
This hands-on session shows how hardware and .NET services can work together to bring a real desk companion to life.
๐ Learn more by exploring the resources:
https://aka.ms/newyearnewbot
https://aka.ms/M5StackStackChanfirmwaredevelopersetup
https://aka.ms/M5StackStackChanproductinformation
https://aka.ms/dotNETAspiredocumentation
๐ This event is part of a series. Learn more here: https://aka.ms/NewYearNewBotSeries
#MicrosoftReactor #LearnConnectBuild #dotNet #Aspire #Agent #M5Stack #StackChan, #IoT #EdgeComputing
[eventID:27761] New Year, New Bot - Bring Your AI Desk Robot to Life](https://i.ytimg.com/vi/L-zaWiyjDEU/mqdefault.jpg)
![De MCP a agentes A2A en Microsoft Fabric: Fabric MCP en acciรณn
En esta sesiรณn conectaremos un agente o cliente de IA con Microsoft Fabric mediante MCP para entender cรณmo los agentes descubren capacidades, consultan metadatos y trabajan con artefactos de Fabric.
Explicaremos la diferencia entre MCP local y remoto, revisaremos cรณmo se autentican las llamadas, quรฉ permisos intervienen y quรฉ tipo de operaciones puede realizar un agente sobre un workspace.
La sesiรณn tendrรก un enfoque prรกctico para mostrar cรณmo MCP se convierte en la primera capa de conexiรณn entre agentes y Fabric.
๐ Aprende mรกs accediendo a los recursos:
https://aka.ms/FabricMCPservers
https://aka.ms/FabricCoreMCPServertools
https://aka.ms/FabricCoreMCPServer
https://aka.ms/SkillsforMSFTFabric
https://aka.ms/InstallSkillsforFabric
https://aka.ms/A2AandMCPComparison
https://aka.ms/GitHubSpecKit/y
https://aka.ms/Codexbestpractices
https://aka.ms/OpenAIAgentSkills
๐ Este evento es parte de una serie, aprende mรกs aquรญ:
https://aka.ms/MCPaA2AFabric/y
#MicrosoftReactor #LearnConnectBuild #MicrosoftFabric #MCP #Agents #OpenAI #Codex #DeveloperTools
[eventID:27821] De MCP a agentes A2A en Microsoft Fabric: Fabric MCP en acciรณn](https://i.ytimg.com/vi/L4L3LZj5dC4/mqdefault.jpg)
![.NET + Foundry, Better Together: Decision Models in Action
What can you build with .NET and Microsoft Foundry? Letโs find out together! Join us for a series of practical explorations featuring new SDK capabilities, cool projects, and the latest Foundry features and services. With live demos, code, and plenty of curiosity, each episode offers something new for .NET developers looking to learn, experiment, and build with AI.
๐ Learn more by exploring the resources:
https://aka.ms/MSFTFoundryDoc
https://aka.ms/AIappsfordotNETdev
https://aka.ms/netfoundry-bt
๐ This event is part of a series. Learn more here: https://aka.ms/dotNET-Foundry
0:00:00 Introduction and welcome
0:03:09 GitHub Universe keynote recap
0:05:48 Foundry and Agent Collections overview
0:09:14 New Year Bot Project introduction
0:13:32 Decision models in Foundry
0:18:32 Code walkthrough: Decision model console application
0:25:06 Implementing decision models within an agent
0:31:47 Hosted agents in Foundry
0:36:20 Managing agent memory with graph databases
0:41:43 Comparing MCP tools vs. AI context memory
0:52:16 Agent memory project resources
0:55:45 Future topics: Routines, evaluations, and closing remarks
#MicrosoftReactor #LearnConnectBuild #dotNET #MicrosoftFoundry #C# #AI #SDKs
[eventID:27631] .NET + Foundry, Better Together: Decision Models in Action](https://i.ytimg.com/vi/Lq_Syddmhvc/mqdefault.jpg)
![.NET + Foundry, better together
What can you build with .NET and Microsoft Foundry? Letโs find out together! Join us for a series of practical explorations featuring new SDK capabilities, cool projects, and the latest Foundry features and services. With live demos, code, and plenty of curiosity, each episode offers something new for .NET developers looking to learn, experiment, and build with AI.
๐ Learn more by exploring the resources:
https://aka.ms/MSFTFoundryDoc
https://aka.ms/AIappsfordotNETdev
๐ This event is part of a series. Learn more here: https://aka.ms/dotNET-Foundry
#MicrosoftReactor #LearnConnectBuild #dotNET #MicrosoftFoundry #C# #AI #SDKs
[eventID:27634] .NET + Foundry, better together](https://i.ytimg.com/vi/M7umULjrNEY/mqdefault.jpg)
![The Agentic SDLC: Making Application Modernization Continuous
What if applications could continuously identify what needs to be modernized and help developers act on it?
This session explores how agentic workflows can embed application modernization into the SDLC, moving teams from reactive, one-off upgrades toward continuous modernization.
Bruno Borges will examine how AI agents and developer workflows can help keep applications current while maintaining human review and control.
0:00:03 Introduction and housekeeping
0:00:57 Speaker introduction and agenda
0:02:04 Agents in the Software Delivery Life Cycle (SDLC)
0:03:31 Impact of AI on SDLC (metrics and performance)
0:04:13 Example of agent-based workflows in development teams
0:06:47 Post-production loops and self-healing systems
0:08:11 The missing link: keeping the tech stack current
0:09:07 Modernization: the old way (Big Bang approach)
0:11:34 Introduction to GitHub Copilot App Modernization
0:13:26 How the modernization workflow works (Assessment to Deployment)
0:18:13 Live Demo: Automating Java/Spring Boot modernization
0:23:44 Deep dive: Modernized CLI and CI/CD integration
0:31:06 Troubleshooting and fixing modernization failures with agents
0:40:21 Comparison: Big Bang vs. Continuous Modernization
0:42:14 The balance: Agents for volume, humans for judgment
0:43:13 Making modernization a habit in the SDLC
0:44:41 Getting started: Building blocks and 30-day goals
0:48:07 Conclusion and final thoughts
[eventID:27622] The Agentic SDLC: Making Application Modernization Continuous](https://i.ytimg.com/vi/MHWQaoabVkc/mqdefault.jpg)
![Episode 2 | AI ์ํฌํ๋ก ํ์ง ์ธก์ , ๋ฒค์น๋งํน ๋ฐ ๊ฐ์
์ธ์
์๊ฐ
AI ์์ด์ ํธ ๊ตฌ์ถ์ ์์์ ๋ถ๊ณผํฉ๋๋ค. ํ๋ก๋์
ํ๊ฒฝ์์๋ ํ์ง์ ์ง์์ ์ผ๋ก ํ๊ฐํ๊ณ ๋น์ฉ์ ์ต์ ํํ๋ฉฐ, ๋ณ๊ฒฝ ์ฌํญ์ด ์ค์ ์ฑ๋ฅ ๊ฐ์ ์ผ๋ก ์ด์ด์ง๋์ง ๊ฐ๊ด์ ์ผ๋ก ํ์ธํ๋ ๊ณผ์ ์ด ์ค์ํฉ๋๋ค.
์ด ์ธ์
์์๋ Microsoft Foundry, Evaluations, Agent Optimizer๋ฅผ ํ์ฉํด AI ์ํฌํ๋ก์ ํ์ง์ ์ธก์ ํ๊ณ ๋ฒค์น๋งํนํ๋ฉฐ ์ง์์ ์ผ๋ก ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ์์๋ด
๋๋ค. Microsoft IQ๋ฅผ ํ์ฉํ ํจ๊ณผ์ ์ธ ์ปจํ
์คํธ ๊ตฌ์ฑ๋ถํฐ ์ง์์ ์ธ ํ๊ฐ๋ฅผ ํตํ ํ์ง ๊ด๋ฆฌ๊น์ง, ์์ด์ ํธ์ ์ ์ฒด ์๋ช
์ฃผ๊ธฐ์ ๊ฑธ์ณ ์ธก์ ๊ฐ๋ฅํ ์งํ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ด
๋๋ค.
์ฃผ์ ํ์ต ๋ด์ฉ
1. Microsoft Foundry๋ฅผ ํ์ฉํด ๋ชจ๋ธ์ ๋น๊ตํ๊ณ ์ ํํ๋ ๋ฐฉ๋ฒ
2. ์์ด์ ํธ์ ์กฐ์ง์ ์ปจํ
์คํธ๋ฅผ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ
3. ์์ด์ ํธ๋ฅผ ์ํ ์ง์์ ์ธ ํ๊ฐ ํ์ดํ๋ผ์ธ์ ๊ตฌ์ถํ๋ ๋ฐฉ๋ฒ
4. ํ์ง, ์๋, ํ ํฐ ๋น์ฉ ๊ฐ์ ๊ท ํ์ ๋ถ์ํ๋ ๋ฐฉ๋ฒ
5. Agent Optimizer๋ฅผ ํ์ฉํด ์์ด์ ํธ๋ฅผ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ
6. CI/CD ํ์ดํ๋ผ์ธ์์ ์์ด์ ํธ๋ฅผ ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ
ํ์ฉ ๊ธฐ์ค
- Microsoft Foundry
- Microsoft Foundry Extension for Visual Studio Code
- Microsoft Foundry Evaluations ๋ฐ Agent Optimizer
- Foundry ์ฐ๋์ ์ํ GitHub Actions
์ถ์ฒ ๋์
- Microsoft Foundry์์ AI ์์ด์ ํธ๋ฅผ ๊ตฌ์ถํ๊ณ ํ๊ฐ ๋ฐ ์ต์ ํํ๋ ๋ฐ ๊ด์ฌ ์๋ ๊ฐ๋ฐ์
- GitHub ๋ฐ CI/CD ํ๋ก์ธ์ค์ ์์ด์ ํธ๋ฅผ ๋์
ํ๋ ค๋ ํ
*
0:00 - ์ธ์
์๊ฐ ๋ฐ ํ์ต ๋ชฉํ
1:05 - AI ์ํฌํ๋ก ํ์ง ๊ด๋ฆฌ์ 6๋จ๊ณ ํ๋ฆ
1:55 - ๊ตฌ๋งค ์กฐ์ธ ์์ด์ ํธ ์๋๋ฆฌ์ค ์ค๋ช
3:01 - AI ๋ชจ๋ธ ์ ํ ๋ฐ ์ฑ๋ฅ ๋น๊ต ๋ฐฉ๋ฒ
5:46 - ์์ด์ ํธ ๊ทธ๋ผ์ด๋ฉ(Grounding)๊ณผ ๋ฐ์ดํฐ ์ฐ๊ฒฐ
9:59 - ์์ด์ ํธ ์คํ ๊ธฐ๋ก(Trace) ๋ถ์ ๋ฐ ๋๋ฒ๊น
13:21 - ์์ด์ ํธ ํ์ง ํ๊ฐ ๊ธฐ์ค ๋ฐ ์งํ ์ค์
15:52 - ๊ตฌ๋งค ์ฌ๋ก๋ฅผ ํตํ ํ์ง ํ๊ฐ ๋ฐ๋ชจ
19:35 - Agent Optimizer๋ฅผ ํ์ฉํ ์์ด์ ํธ ์ต์ ํ
22:20 - ์ตํฐ๋ง์ด์ ์คํ ๊ฒฐ๊ณผ ๋ฐ ๋ถ์
26:24 - ํ
์คํธ ๋ฐ์ดํฐ ์ธํธ ๊ตฌ์ฑ ์ ๋ต(Develop, Holdout, Drift)
27:53 - ๋ฐฐํฌ ์ ์๋ ๊ฒ์ฌ ๊ท์น ๋ฐ ์์ ์ฅ์น
29:26 - CI/CD ํ์ดํ๋ผ์ธ ์ฐ๋ ๋ฐฐํฌ ๊ฒ์ฌ ๋ฐ๋ชจ
34:18 - ์ํฌํ๋ก ์์ฝ ๋ฐ ์ด์ ์ค ํผ๋๋ฐฑ ๋ฃจํ
37:21 - ํต์ฌ ๋ด์ฉ ์ ๋ฆฌ ๋ฐ Q&A ์๋ด
[eventID:27625] Episode 2 | AI ์ํฌํ๋ก ํ์ง ์ธก์ , ๋ฒค์น๋งํน ๋ฐ ๊ฐ์](https://i.ytimg.com/vi/MxB902GcvoY/mqdefault.jpg)
![Production-Grade Agents: Evaluation, Tracing, Security, and Operations
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] Production-Grade Agents: Evaluation, Tracing, Security, and Operations](https://i.ytimg.com/vi/NI-MgkhNfeU/mqdefault.jpg)
![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)