Uploaded October 2026 | Updated November 2026, 4 days ago
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]
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]

![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)