Across modern industrial environments, one challenge stands out: how to provide actionable, trustworthy intelligence from complex factory telemetry without guessing or hallucinating. Large language models (LLMs) excel at reasoning but lack intrinsic understanding of specific plants or assets. Relying on raw LLMs to answer questions about real-time industrial data risks mistakes with costly consequences.

The Azure Architecture Center’s Agentic AI for the reference solution bridges this gap by embedding AI agents atop a rich, normalized information model of the factory. The solution grounds reasoning in the ISA-95 asset hierarchy, the OPC UA information model, and live telemetry sourced from OPC UA devices—making AI not only intelligent, but trustworthy and auditable.

In this post, we explore how the Plant Copilot—an agent built using the Model Context Protocol (MCP)—enables natural-language querying over real-time plant data, its architecture, deployment, and pathways beyond read-only insights into safe, approval-gated industrial actions.

Architecture Overview

┌─────────────────────────────────────────────┐
│                 User Interface               │
│           (Chat/App: Teams, Outlook)         │
├─────────────────────────────────────────────┤
│          Agent Runtime (Microsoft 365         │
│           Copilot, Foundry, Claude)           │
└─────────────────────────────────────────────┘
                      ↓ (natural language)
┌─────────────────────────────────────────────┐
│                Model Context Protocol (MCP) │
│                Plant Copilot MCP Server      │
│       (Read-only wrapper over I3X API)      │
└─────────────────────────────────────────────┘
                      ↓ (KQL queries)
┌─────────────────────────────────────────────┐
│             I3X4Kusto Query Engine           │
│          (normalizes ISA-95 & OPC UA data)  │
└─────────────────────────────────────────────┘
                      ↓ (query result)
┌─────────────────────────────────────────────┐
│      Azure Data Explorer / Fabric Eventhouse │
│         (curated real-time telemetry & logs)│
└─────────────────────────────────────────────┘

The agent never accesses raw databases directly. Instead, it strictly interacts with the curated, read-only Plant Copilot MCP server. This server enforces authentication, ISA-95 hierarchical shape, and delivers telemetry with timestamps and quality metadata to ground every response.

Architecture visual from Microsoft Learn - Azure Architecture Center

Key Technical Observations

• Information Model Grounding: Leveraging the ISA-95 asset hierarchy combined with OPC UA object and variable types provides semantic context and structure essential for accurate AI reasoning. This prevents hallucinations common in LLMs by enforcing a browsable plant map and precise asset identification.

• Model Context Protocol (MCP) Adoption: MCP’s open-standard protocol acts as an abstraction layer exposing industrial telemetry and metadata as well-defined tools to AI agents. Its broad support by Microsoft Copilot, Foundry, and third parties enables flexible, reusable agent runtimes.

• Read-Only Safety by Design: The Plant Copilot MCP server purposely exposes only query (browse/read) capabilities. Any actuation or write operation requires separate, authenticated, and approval-gated paths. This ensures physical safety on the factory floor while still enabling intelligent insights.

• Cross-Platform Data Access with I3X API: The I3X service not only normalizes data against ISA-95 models but enforces authentication and shape consistency. By exposing telemetry through a standardized API, multiple agent platforms can safely access consistent, reliable data.

• Integration with Microsoft 365 Ecosystem: Publishing the Plant Copilot agent to Microsoft 365 Copilot allows end users to query factory conditions directly from familiar tools like Teams and Outlook—democratizing data access without specialized software.

• Alternative Fabric Data Agent Approach: For customers investing heavily in Microsoft Fabric, a Fabric-native data agent can query Eventhouse/KQL data directly—bypassing MCP but requiring Fabric-specific governance and capacity considerations.

How It Works: Under the Hood of Plant Copilot

Telemetry Normalization and Exposure

At its core, the solution ingests OPC UA telemetry from the factory floor and normalizes it against the ISA-95 asset hierarchy (enterprise > site > area > line > cell > asset). This hierarchy offers a structured map of all assets and their relationships.

The OPC UA information model further defines each asset’s types and measured variables. This combined model ensures agents understand not only what data exists but how the data relates semantically.

The normalized, structured data lands in Azure Data Explorer or Fabric Eventhouse, where it becomes queryable via the I3X API and Kusto Query Language (KQL).

Plant Copilot: The MCP Server

The Plant Copilot MCP server wraps the I3X API with a RESTful interface exposing a set of tools for AI agents:

Tool                | Purpose
--------------------|-------------------------------
get_server_info     | Health and capability checks
list_namespaces     | OPC UA namespaces listing
list_object_types   | Information model type browsing
list_root_objects   | Top-level ISA-95 assets browse
list_objects_of_type| Find assets/variables by type
get_related_objects | Drill into asset children/variables
get_current_values  | Latest telemetry values with quality/timestamp
get_value_history   | Historical value trends over time

The Plant Copilot server runs as a Docker container deployed to Azure Container Apps and communicates via MCP’s Streamable HTTP transport on an HTTPS endpoint.

Agent Runtime and Natural Language Interaction

Users type natural language queries in interfaces like Microsoft Teams. The agent runtime (e.g., Microsoft 365 Copilot) translates these queries into calls to Plant Copilot tools over MCP. Responses are grounded in exact telemetry values, asset IDs, and timestamps.

For example:

Q: "What is the current energy consumption of work cell 3?"

The agent calls list_objects_of_type to identify work cell 3, then get_current_values to retrieve live energy consumption data with validation metadata, and finally returns a fully cited, trustworthy answer.

Deployment and Governance

Deploying Plant Copilot requires careful tenant-level governance:

• Power Platform environments must grant Copilot Studio maker permissions.
• Data loss prevention (DLP) policies must allow the Plant Copilot connector.
• Tenant isolation and outbound OAuth to the server endpoint need administrator approval.
• Entra ID and Microsoft 365 admin approvals safeguard authentication and publishing.

These guardrails ensure that agent access is secure, compliant, and aligned with organizational controls.

Quick Tips & Tricks

1. Register the Plant Copilot as a Dynamic OAuth MCP Tool
   Use MCP’s dynamic client registration to streamline authentication without manually managing client secrets.

2. Always Ground Agent Responses in Tool Results
   Set strict agent instructions to never invent data but cite explicit asset IDs, timestamps, and quality metadata for auditability.

3. Use a Dedicated Power Platform Environment for Development
   Isolate agent creation and testing to a sandbox environment to avoid production disruptions and ease governance reviews.

4. Leverage KQL Queries for Historical Trends
   When using Fabric data agents, steer queries to ISA-95-normalized Eventhouse tables with example queries to improve agent accuracy.

5. Start with Read-Only Agents before Action Agents
   Establish trust by first deploying read-only AI assistants. Introduce approval-gated write/actuation paths later for industrial safety.

6. Log All Agent Interactions for Compliance
   Ensure each tool call and proposed action is logged in your SIEM system to support repudiation and forensic analysis.

Conclusion

Agentic AI combined with a well-structured industrial information model unlocks a new tier of operational intelligence for factories. The Azure Plant Copilot exemplifies how grounding LLMs in standards like ISA-95 and OPC UA, exposing only curated, authenticated data through MCP tools, delivers safe, trustworthy AI assistants. By integrating seamlessly into Microsoft 365 Copilot, it democratizes plant insights to a broad user base.

Moving forward, the ability to transition from read-only AI helpers to approval-gated, action-taking agents promises to transform industrial workflows—enabling predictive maintenance, anomaly triage, and human-in-the-loop optimizations with confidence and safety.

References

1. Agentic AI for the reference solution - Azure Architecture Center — The primary source detailing Plant Copilot and MCP in industrial AI.
2. Model Context Protocol (MCP) — Official protocol documentation for MCP used by Plant Copilot.
3. Tools/PlantCopilot GitHub repository — Source code and deployment details for Plant Copilot.
4. Microsoft Copilot Studio — Platform to build, test, and publish AI agents with registered MCP tools.
5. Connect Microsoft Dynamics 365 Field Service to the reference solution — Extending agentic AI with predictive maintenance scenarios.
6. Import OPC UA Information Models from the UA Cloud Library into Azure services — Leveraging standardized OPC UA models for asset semantics.
7. Microsoft Fabric Data Agent — Building AI agents native to Microsoft Fabric querying Eventhouse telemetry.