From Build to Run to Distribute: Autonomous Agents with Microsoft Foundry Agent Service Part 1/5

At Build 2026, we shared an exciting glimpse into the future of autonomous agents on Microsoft’s platform. Now, those promises have come to fruition. The Microsoft Foundry Agent Service, Microsoft Agent Framework, and GitHub Copilot SDK are now generally available. This means developers can easily create agents in GitHub, operate them in Foundry, and share them seamlessly across Microsoft Teams and Microsoft 365 Copilot.

This blog series will use FibreOps, an autonomous fibre outage response system, as a practical example to guide you through every aspect of the platform. FibreOps was showcased live at Microsoft Build BRK241 and is also available as open source on GitHub.

The story of the agent platform is straightforward: one platform with three main actions.

• Build in GitHub Copilot— Easily integrate the Microsoft Agent Framework with the GitHub Copilot SDK, Foundry Toolkit for VS Code, and support various models (including Claude Code connectors and Magentic-One).
• Run in Foundry — Use Hosted Agents, Agent Optimizer, and Routines with event triggers, alongside Toolboxes, Memory (procedural, user sessions), Tracing and Evaluation, and Voice Live integration.
• Distribute in M365 — Simply publish agents to Microsoft Teams and Microsoft 365 Copilot with a single command and deploy them as Autopilots for complete automation.

FibreOps is designed as an Autonomous Fibre Outage Response System running on the Microsoft Foundry Agent Service. When an optical line terminal (OLT) detects an issue—like a fault, loss of light, high bit-error rate, or degraded signal—FibreOps automatically assesses the problem, generates a ticket, alerts the operations team, and assigns a field engineer.

Its architecture comprises three specialised agents working together in a pipeline:

1. IncidentAnalysisAgent — Assesses severity, pinpoints the root cause, and retrieves the relevant Standard Operating Procedure.
2. NetOpsCoordinatorAgent — Creates a Dynamics 365 Field Service incident and posts an outage notice on Teams using Adaptive Cards.
3. FieldDispatchAgent — Chooses the most suitable engineer, reserves resources, and communicates updates to the team.

The complete workflow looks like this:

OLT telemetry ──▶ Event Hub ──▶ Orchestrator ──┬─▶ IncidentAnalysisAgent
                                                       ├─▶ NetOpsCoordinatorAgent ──▶ D365 + Teams
                                                       └─▶ FieldDispatchAgent     ──▶ D365 booking + Teams update
                                                                                       │
                                                                                       ▼
                                                                        OpenTelemetry → Application Insights
                                                                                       │
                                                                                       ▼
                                                                         Optimiser (rubric → suggestions)

Agents act as hosted Prompt Agents in Microsoft Foundry Agent Service, functioning as containerised services that comply with the OpenAI /responses contract. FibreOps bundles its entire agent pipeline into a single hosted agent, easily deployed using agent.yaml and a Dockerfile — no need for infrastructure management.

Each run is evaluated based on a rubric assessing classification accuracy, suitability of dispatch, SLA compliance, and communication effectiveness. The optimiser then generates practical suggestions for improvement and works with Foundry cloud Evaluators for top-tier evaluation.

The NetOps coordinator can function with two flexible implementations: a chat agent guided by prompts and a Foundry Routine—a step-by-step execution plan that follows a specific order (file_ticket → post_teams_notice → remember_ticket). Routines are now equipped with event triggers to enable reactive automation.

The Incident Analysis agent enhances its reasoning capabilities using Foundry IQ. Web IQ provides information from the public web (like roadworks, weather updates, power outages, and splice guidance), while Work IQ delivers enterprise context (including site surveys, SLA tiers, competency frameworks, and MTTR trends). Each lookup is saved and can be accessed via the NOC console.

Agents retain procedural memory, allowing them to learn from previous incidents through the Foundry Memory store. This supports continuous improvement without the need for retraining.

FibreOps offers a FibreOpsCopilotClient, which mimics the same structure as github/copilot-sdk with functions like create_session() and send_and_wait(). This allows for engaging conversations with the agent system, whether connecting to a local adapter or a hosted endpoint.

To publish your agents, you can simply run a single command (python -m fibreops.demo publish-m365), creating a declarative agent + action plugin package ready for sideloading via the Teams Admin Center. The agent includes publisher details, provides conversation prompts, and routes tool requests to the deployed FastAPI backend.

Status updates are conveyed through Azure AI Voice Live, using SSML utterances tailored to the severity level, ensuring an accessible, hands-free operational experience.

The entire system can operate locally without requiring Azure credentials by using the deterministic local backend:

# Clone and install
git clone https://github.com/leestott/BRK241-frontier
cd BRK241-frontier
python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements.txt
.\.venv\Scripts\python.exe -m pip install -e .

# Run with local backend (no Azure needed)
.\.venv\Scripts\python.exe -m fibreops.demo --signals 3

For deploying in a production environment with real Foundry agents, follow these steps:

# Authenticate and deploy
az login
azd auth login
azd env new fibreops-demo
azd env set AZURE_AI_PROJECT_ENDPOINT "https://.services.ai.azure.com/api/projects/"
azd env set AZURE_AI_MODEL_DEPLOYMENT "gpt-4.1-mini"
azd up

This marks the first part of a five-post series that will delve into the platform from start to finish:

1. This post — An overview of the platform and the Build → Run → Distribute approach
2. Creating Autonomous Agents with the Microsoft Agent Framework and GitHub Copilot SDK — A deep dive into agent building, tool design, and the development workflow
3. Operating Hosted Agents in Microsoft Foundry Agent Service — Exploring hosted agents, optimizers, routines, memory, and toolboxes
4. Sharing Agents to Teams and Microsoft 365 Copilot — How to publish them, and working with declarative agents, action plugins, and autopilots
5. Voice Live and Observability for Production Agent Systems — Insight into Azure AI Voice Live, OpenTelemetry, Application Insights, and achieving operational excellence

• The Microsoft agent platform is now generally available (GA) across all three components: Build, Run, and Distribute.
• Hosted Agents simplify the process—just deploy a container and get a production-ready agent.
• The Agent Optimizer along with Routines introduces reliability and continuous enhancements to autonomous systems.
• Publishing agents to Teams and M365 Copilot requires just a single command, eliminating the need for separate app registration.
• The entire FibreOps reference implementation operates offline without Azure credentials for development and demonstration.