Uploaded October 2026 | Updated November 2026, 16 hours ago
Learn how to build and deploy AI-powered applications that analyze football match and player data using AKS and ACA.
Using Premier League-inspired scenarios such as identifying team play styles, analyzing counterattacks, or uncovering player performance patterns, we'll walk through a reference architecture for developing, deploying, and operating AI applications and agents on Azure.
Attendees will leave with practical guidance and ideas they can extend into their hackathon projects.
📌 This event is part of a series. Learn more here: https://aka.ms/PremierLeagueHack
0:00 Introduction and housekeeping
1:13 Premier League hackathon details and goals
2:56 Live demo of the football results dashboard
4:49 Exploring 150 years of international football data
8:19 Presentation agenda
9:17 Reference architecture overview (AKS and ACA)
11:29 Application data flow and ingestion process
12:33 Deterministic code vs. Microsoft Foundry logic
14:43 Security and Microsoft Entra ID implementation
18:01 Reviewing the Azure resource group and components
20:41 Data sources and handling in the repository
27:06 Challenges in data reconciliation and naming
31:13 AKS versus ACA infrastructure comparison
38:03 Scaling, revisions, and rolling updates
42:41 Building the app with GitHub Copilot
43:40 Reviewing the generation prompt structure
57:00 Final thoughts, hackathon resources, and Q&A
#MicrosoftReactor #LearnConnectBuild #PremierLeagueHackathon
[eventID:27536]
Learn how to build and deploy AI-powered applications that analyze football match and player data using AKS and ACA.
Using Premier League-inspired scenarios such as identifying team play styles, analyzing counterattacks, or uncovering player performance patterns, we'll walk through a reference architecture for developing, deploying, and operating AI applications and agents on Azure.
Attendees will leave with practical guidance and ideas they can extend into their hackathon projects.
📌 This event is part of a series. Learn more here: https://aka.ms/PremierLeagueHack
0:00 Introduction and housekeeping
1:13 Premier League hackathon details and goals
2:56 Live demo of the football results dashboard
4:49 Exploring 150 years of international football data
8:19 Presentation agenda
9:17 Reference architecture overview (AKS and ACA)
11:29 Application data flow and ingestion process
12:33 Deterministic code vs. Microsoft Foundry logic
14:43 Security and Microsoft Entra ID implementation
18:01 Reviewing the Azure resource group and components
20:41 Data sources and handling in the repository
27:06 Challenges in data reconciliation and naming
31:13 AKS versus ACA infrastructure comparison
38:03 Scaling, revisions, and rolling updates
42:41 Building the app with GitHub Copilot
43:40 Reviewing the generation prompt structure
57:00 Final thoughts, hackathon resources, and Q&A
#MicrosoftReactor #LearnConnectBuild #PremierLeagueHackathon
[eventID:27536]
![From Insight to “What If?”: Planning in Microsoft Fabric (Option 1)
Knowing what happened is just the beginning. With Planning in Microsoft Fabric, turn insights into forecasts, scenarios, and plans that help answer the bigger question: what if? Bring data, analytics, planning, and AI together so teams can look ahead, test possibilities, and make smarter decisions about what comes next.
📌 This event is part of a series. Learn more here:
https://aka.ms/DataDays/FabConRecap/y
https://aka.ms/DataDays/IntoCerts/y
https://aka.ms/AIatWork/UnderstandIt/y
https://aka.ms/AIatWork/BuildIt/y
https://aka.ms/AIatWork/ShowIt/y
[eventID:27708] From Insight to “What If?”: Planning in Microsoft Fabric (Option 1)](https://i.ytimg.com/vi/EoUuhtPgUxA/mqdefault.jpg)
![Beyond Chatbots: Build Your First Production Agent with Microsoft Foundry
AI agents are rapidly moving beyond simple conversational experiences. In this session, we will build the foundation of a production-ready agent using Microsoft Foundry Agent Service, Microsoft Agent Framework, and Azure application services.
Starting from a practical enterprise operations scenario, we will define the agent’s responsibilities, instructions, tools, conversation state, and structured outputs. We will then connect the agent to a Foundry model, add a typed function tool, stream responses to a web application, and examine the architectural differences between a model call, an assistant, an agent, and an agent workflow.
The session will also explore hosting options, including Foundry hosted agents and custom agent applications deployed to Azure Container Apps. Along the way, we will discuss identity, configuration, state management, failure boundaries, and the design decisions that separate a useful prototype from an application that can evolve toward production.
By the end of the session, attendees will understand the core components of a Microsoft Foundry agent application and will have a reusable starting point for building their own agentic solutions. Key topics: Microsoft Foundry Agent Service Microsoft Agent Framework Agent instructions and tool contracts Conversation state and streaming responses Structured outputs Hosted agents and Azure Container Apps Production-oriented agent architecture.
0:00 - Welcome and Introduction
1:30 - Series Overview: Beyond Chatbots to Enterprise Agents
4:27 - Speaker Introduction
6:20 - Enterprise Scenario: Service Ticketing Incident Example
8:30 - Architecture Overview: From Web App to Agentic Workflow
10:45 - Orchestration, Managed Identity, and API Management
12:35 - Foundry Model Integration, Typed Outputs, and Content Safety
13:45 - Parallel Agent Processing: Knowledge and Impact Analysis
14:30 - State Aggregation and Cosmos DB Checkpoints
16:00 - End-to-End Workflow Animation
20:10 - Today’s Session Objectives and Outcomes
21:35 - Live Demo: Model vs. Prompt Agent vs. Hosted Agent
28:30 - Architectural Principles: Agentic Boundaries and Guardrails
31:35 - The Four Implementation Shapes
34:10 - Microsoft Foundry vs. Agent Framework Roles
36:12 - Defining the Agent Contract and Responsibilities
39:27 - Case Study: From Incident Report to Triage
42:00 - Operational Ownership and Hosting Choices
46:25 - Azure Infrastructure and Resource Deep Dive
49:25 - Next Steps, Q&A, and Closing
This session is a part of a series, learn more here! https://aka.ms/BEA-Series
[eventID:27507] Beyond Chatbots: Build Your First Production Agent with Microsoft Foundry](https://i.ytimg.com/vi/ExJXHCkeO4A/mqdefault.jpg)
![Creación de una canalización de Integración Continua para Power Platform
En esta sesión se realizará una demostración paso a paso de cómo crear una canalización de integración continua en Azure DevOps para Power Platform. Los asistentes aprenderán a validar una solución, ejecutar Power Apps Checker, empaquetar soluciones administradas y no administradas, actualizar versiones y publicar artefactos de compilación reutilizables.
🔗 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
#MicrosoftReactor #LearnConnectBuild #Devops, #PowerPlatform, #ALM
[eventID:27573] Creación de una canalización de Integración Continua para Power Platform](https://i.ytimg.com/vi/G4-gmvIBbwE/mqdefault.jpg)
![Episódio 4: Agentes de IA – Da Assistência à Colaboração Autônoma
Explore a próxima evolução da IA por meio de agentes inteligentes capazes de raciocinar, planejar, automatizar e colaborar com os usuários. Os participantes conhecerão casos de uso emergentes e oportunidades para aplicar agentes de IA nos ambientes de trabalho modernos.
🔗 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:00 Introdução e apresentação
2:56 Conceito de Agentes de IA
4:20 Contrato operacional e autonomia
7:47 Demonstração 1 - Criação de plano de capacitação
16:07 Parceria operacional e loop humano
18:04 Demonstração 2 - Revisão de plano e subagentes
28:22 Padrões de agentes no trabalho
32:20 Demonstração 3 - Equipe de agentes e orquestração
44:17 Caminhos práticos de adoção e governança
47:23 Ferramenta AI Skills Navigator
#MicrosoftReactor #LearnConnectBuild #MicrosoftCopilot #Copilot #Agents #AIAgents #GenAI
[eventID:27645] Episódio 4: Agentes de IA – Da Assistência à Colaboração Autônoma](https://i.ytimg.com/vi/Gr6A1100ZwU/mqdefault.jpg)
![De “eso está genial” a “realmente podría usar esto”
Es fácil ver una demo de IA y pensar: “Qué bien.” Convertir eso en algo realmente útil en el trabajo es otra historia.
En esta sesión, partiremos de un problema real y pensaremos juntos cómo convertirlo en un escenario de IA que valga la pena explorar.
[eventID:27751] De “eso está genial” a “realmente podría usar esto”](https://i.ytimg.com/vi/Gru5SIwaXEY/mqdefault.jpg)
![Grounding Agents in Business Context with Fabric IQ
Learn how to connect agents to business data, metrics, and operational context with Fabric IQ. In this session, well explore how agents can use structured business knowledge to better understand entities, relationships, and processes across your organization.
Youll see how grounding agents in business context enables more accurate, relevant, and actionable responses.
0:00:00 - Introduction and Housekeeping
0:00:55 - Speaker Introduction and Business Context for Agents
0:04:05 - Overview of Microsoft IQ Architecture
0:06:04 - Introducing Fabric IQ
0:07:43 - Deep Dive: OneLake Data Unification
0:09:24 - Power BI Semantic Models for AI
0:11:42 - Operational Context with Ontologies
0:18:24 - Modeling the Business: Creating Ontologies
0:25:51 - Sharing and Reusing Operational Context
0:30:46 - Graph Analytics on Ontology
0:32:10 - Ontology in Real-Time Dashboards
0:34:25 - Using Ontology as Context for Data Agents
0:38:13 - Operations Agents and Agentic Experiences
0:43:08 - Governance and Ontology Lifecycle
0:45:56 - Understanding Ontology Health
0:53:15 - Resources and Engaging with the Fabric IQ User Panel
0:54:25 - Live Q&A Session
🔗 Resources: https://aka.ms/iq-series
📌 This event is a part of a series, learn more here: https://aka.ms/microsoftiqlive
#MSFTReactor #learnconnectbuild #foundryiq #serverless #knowledgebases #agentdevelopment #retrieval #datagrounding #azureaifoundry #enterpriseknowledge
[eventID:27455] Grounding Agents in Business Context with Fabric IQ](https://i.ytimg.com/vi/HNIx_Z0U8QA/mqdefault.jpg)
![Build SRE Agent Canvas in GitHub Copilot
Join us to explore Azure SRE Agent Canvas in GitHub Copilot.
See how it brings operational findings and context into GitHub Copilot Apps and Copilot CLI, giving developers and operators a shared place to review evidence, work through issues, and take the next step together.
Learn more at https://aka.ms/sreagent/canvas/blog
[eventID27745] Build SRE Agent Canvas in GitHub Copilot](https://i.ytimg.com/vi/HVLre_D9RDw/mqdefault.jpg)
![Creating Custom Code Execution Engine Sandboxes For Your Loops And Harnesses
The last session showed how agent swarms can run safely on disposable, hardware-isolated compute.
This second session covers building the custom sandboxes that those agents need.
See how to package your own runtimes, dependencies, and tools as a custom container, expose it through Azure Container Apps Sandboxes, and operate it as a fast, isolated execution service.
Watch a custom engine move from container image to a managed session pool that agents can invoke on demand.
Youll learn • When to choose a custom sandbox
• How to package specialized runtimes, libraries, binaries, and tools
• Configuring prewarmed capacity, lifecycle policies, health probes, and automatic cleanup
• Securing execution with isolation, network controls, managed identity, and tenant-aware session identifiers
• Monitoring engine health, capacity, lifecycle events, and application output with Azure Monitor
Explore the Build Cloud Native Apps series
https://developer.microsoft.com/reactor/series/S-1692?wt.mc_id=meetup_27397_webpage_reactor
0:06 - Welcome and Introduction
1:12 - Overview of Custom Code Execution Engine Sandboxes
2:20 - Recap of Previous Research Swarm Session
9:10 - Part 1: Every Loop Needs a Referee (Orchestrator)
13:34 - Live Demo: Running Code Candidates in Sandboxes
22:36 - Part 2: Building the Custom Engine (Package & Warm-up)
28:38 - Anatomy of the Referee Engine
32:06 - Custom Runtime Dockerfile and Configuration
37:52 - Priming and Booting Warm Sandboxes
40:02 - Benchmark: Cold vs. Primed Build
44:46 - Part 3: Running Safely (Isolation, Egress, & Identity)
49:17 - Deny Egress Control Policies
57:06 - Keyless Access and Managed Identity
59:16 - Automatic Cleanup and Lifecycle Policies
1:01:25 - Monitoring Engine Health with Azure Monitor
1:02:44 - Conclusion and Resources
[eventid:27489] Creating Custom Code Execution Engine Sandboxes For Your Loops And Harnesses](https://i.ytimg.com/vi/HWzwqQy8TYE/mqdefault.jpg)
![Scaling the Claw: Skills, Shell, CodeAct and Background Agents
Four additions make the agent genuinely useful. Skills package domain knowledge such as valuation and risk scoring into files it discovers and loads only when a request calls for them, including skills managed centrally in Foundry that update with no redeploy. Shell access lets it reorganise a messy folder of trade confirmations, confined to one working directory.
CodeAct gives it a sandbox where it writes and runs code to work out an answer rather than guessing at the arithmetic. Background agents let it research several tickers at once and pull the results back together.
📌 This event is part of a series. Learn more here: https://aka.ms/FMTA/series
🔗 Learn more by exploring the resource: https://aka.ms/AgentHarness
00:00:00 - Introduction and Welcome
00:02:17 - Defining the Agent and the Harness
00:04:42 - Recap of Session 1 and 2
00:09:51 - Introduction to Skills in the Harness
00:12:13 - Demonstrating Skill Discovery and Loading
00:19:36 - Executing Skills with the Microsoft Agent Framework
00:24:25 - Confined Shell Access and Security Policies
00:28:51 - Implementing Local Shell Executors
00:35:42 - Demo: Tidy up Trade Confirmations via Shell
00:42:25 - CodeAct and Python Scripting for Calculations
00:47:08 - Demo: Running Portfolio Calculations with CodeAct
00:51:51 - Introduction to Background Agents
00:53:25 - Demo: Research Agent Orchestration
#MicrosoftReactor #LearnConnectBuild
[eventID:27519] Scaling the Claw: Skills, Shell, CodeAct and Background Agents](https://i.ytimg.com/vi/H_rO1j6ThX8/mqdefault.jpg)
![Model Mondays - Spotlight on Azure Open AI
Azure OpenAI provides a broad family of models for generation, reasoning, coding, multimodal, and real-time experiences, allowing developers to select the right capability for each part of an application.
Join us as we explore these models in Microsoft Foundry and see how they can be combined with grounding, tools, and evaluation to build effective AI agents.
0:00:00 - Introduction and Housekeeping
0:00:56 - Model Mondays Season 4 Kickoff
0:01:25 - Weekly News Highlights
0:05:41 - Spotlight: Azure OpenAI Models Overview
0:07:49 - Introducing the GPT-5.6 and Astra Model Portfolio
0:09:08 - Deep Dive: GPT-6 Astra Capabilities
0:10:28 - GPT-5.6 Family (Sol, Terra, Luna) Breakdown
0:13:39 - Customer Model Selection Guide
0:15:38 - Microsoft Foundry Platform Tour
0:20:16 - Q&A: Model Providers and Pricing
0:24:31 - GPT-6 Astra Use Cases
0:26:34 - Choosing Between Models (Astra vs. 5.6 Series)
0:29:41 - Hands-on Demos: Building with Copilot and Foundry
0:31:34 - Demo 1: Rebuilding Contoso Outdoors with GPT-5.6 Sol
0:39:45 - Demo 2: Concept Building with GPT-6 Astra and Computer Use
0:48:46 - Resources and Future Look (Ignite, AI Tour)
0:51:25 - Closing and Next Weeks Preview
- 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
[eventID: 27561] Model Mondays - Spotlight on Azure Open AI](https://i.ytimg.com/vi/HnnJ54xJmEM/mqdefault.jpg)
![Lets Learn GitHub Copilot SDK (日本語)
GitHub Copilot SDK を使ったエージェントアプリケーション開発を学ぶ、初心者向けライブ配信です。エージェントループを自分で実装することなく、GitHub Copilot のエージェント機能をアプリケーションやサービスに組み込む方法を紹介します。
モデル API を直接呼び出す場合とは異なり、GitHub Copilot SDK を利用することで、会話管理、タスク計画、ツールオーケストレーション、ストリーミング応答、セッション状態管理など、GitHub Copilot のエージェントランタイムを活用できます。
セッションでは、クライアント、セッション、プロンプト、エージェントランタイムの基本概念を解説します。
また、マルチターン会話の実装、リアルタイム応答のストリーミング、アプリケーションの機能をツールとして公開する方法、MCP サーバーによる外部機能との連携、フックや permission handlers を活用したエージェント動作の制御について学びます。
さらに、GitHub Copilot SDK と GitHub Copilot CLI の使い分けについても説明します。GitHub Copilot CLI はターミナル上での開発作業に適しており、GitHub Copilot SDK は GitHub Copilot のエージェント機能を独自のアプリケーションやサービスへ組み込みたい場合に適しています。
GitHub Copilot SDK の事前知識は必要ありません。
0:00:00 オープニング・自己紹介
0:02:17 GitHub Copilot SDKの概要
0:05:34 GitHub CopilotランタイムのRust移行とパフォーマンス向上
0:08:33 エージェントループの基本概念(設定・組み立て・推論・認可・実行・継続)
0:11:04 エージェントのデプロイ戦略
0:17:01 ワークショップ・デモ開始(コンソールRPGでの活用)
0:21:20 環境準備とアクセシビリティレビューの紹介
0:24:29 Copilotクライアントとセッションの実装
0:29:34 レスポンスのストリーミング実装
0:33:05 ローカルツールの作成と呼び出し
0:41:05 MCPサーバーとPlaywrightによる外部機能連携
0:53:29 開発したエージェント(RPG)の実機デモ確認
1:00:24 エンディング
[eventID:27617] Lets Learn GitHub Copilot SDK (日本語)](https://i.ytimg.com/vi/HtVPq-jpQIs/mqdefault.jpg)