Back to Blog
AI Agents17 min read

How AI Agents Interact with Corporate Systems: Integration Principles

Integration approaches for connecting AI agents with ERP, MES, and SCADA systems — from direct database access to standardized protocols like MCP.

S

Serhiy Andrejev

Lead Machine Learning Developer

An AI agent is only as capable as the data it can access and the systems it can reach. While much of the industry discourse focuses on model capabilities — reasoning, planning, tool use — the decisive factor in enterprise deployments is integration: how the agent connects to ERP, MES, SCADA, and other corporate systems that hold the operational truth of an organization. This article examines integration approaches, the emerging role of standardized protocols, and why the path from pilot to production runs through the integration layer, not through the model layer.

Introduction

The AI industry has entered a phase where model capability is no longer the primary bottleneck for enterprise adoption. Large language models can reason, plan multi-step actions, and use external tools with increasing reliability. The constraint has shifted downstream — to the integration layer that connects these capable models with the corporate systems where enterprise data actually resides.

According to Gartner, more than 30% of the increase in demand for APIs by 2026 will come from AI agents and tools using large language models [6]. Yet 48% of industrial professionals cite legacy system integration and data silos as the top barrier to AI adoption — not model performance, not cost, not talent. The integration problem is structural: enterprise systems were designed for human operators navigating purpose-built interfaces, not for autonomous software agents requesting data through programmatic protocols.

In our practice of integrating AI into manufacturing and process industries across Ukraine and the EU, we observe a consistent pattern. Organizations invest in selecting the right model, designing the right prompts, and building the right user interface — then discover that 60–70% of the actual project effort goes into connecting the agent with the systems it needs to query. The ERP holds production orders, the MES holds execution data, the SCADA holds real-time process variables, the quality management system holds deviation records — and none of these systems were designed to speak to an AI agent.

The Integration Problem: Why Every Enterprise Is Unique

The fundamental challenge of AI agent integration is heterogeneity. No two enterprise environments are alike, even within the same industry.

Consider a typical manufacturing enterprise. Its technology landscape might include an ERP system from SAP or Oracle, a MES from Siemens or Rockwell, SCADA from Wonderware or Ignition, a laboratory information management system from a specialized vendor, and a maintenance management system that may be anything from a commercial CMMS to a collection of spreadsheets. Each of these systems has its own data model, its own access mechanisms, its own security paradigm, and its own versioning history.

The international standard IEC 62264 (based on ISA-95) defines a hierarchical model for enterprise-control system integration, organizing systems into five levels [4]:

  • Level 0–1: Physical processes and sensors — the shop floor
  • Level 2: Control systems — PLCs, DCS, SCADA
  • Level 3: Manufacturing operations — MES, quality management, maintenance
  • Level 4: Business planning and logistics — ERP, supply chain, finance

The standard was designed to structure communication between Level 3 (manufacturing operations) and Level 4 (business systems). It provides a common vocabulary and object models for exchanging production schedules, performance data, and quality information. However, IEC 62264 predates the AI agent paradigm entirely. It defines what information should be exchanged, but not how an autonomous software agent should access it.

The result is a landscape where every integration is, to a significant degree, a custom engineering project. The protocols differ — Modbus and OPC UA at the control level, SQL and proprietary APIs at the operations level, REST and SOAP at the business level. The data models differ — timestamps may be in different formats, units may be inconsistent, naming conventions vary between plants within the same company. The access mechanisms differ — some systems offer modern APIs, others require direct database queries, and some provide no programmatic access at all.

This heterogeneity is the reason why AI integration projects so frequently stall between pilot and production. A pilot can be built against a single system with custom integration code. Scaling to production — across systems, across plants, across geographies — requires an integration approach that does not multiply engineering effort linearly with each new connection.

Integration Approaches: From Direct Access to Standardized Protocols

Before examining each approach, it is useful to visualize the integration architecture as a stack of layers. Regardless of the specific method chosen, every AI agent integration follows the same logical structure:

graph TB
    L5["User Interface — natural language queries, dashboards, reports"]
    L4["AI Agent — reasoning, planning, tool orchestration"]
    L3["Protocol / Interface Layer — MCP, REST API, or direct DB connection"]
    L2["Data Layer — normalization, mapping, access control, audit"]
    L1["Corporate Systems — ERP, MES, SCADA, QMS, CMMS, LIMS"]

    L5 --> L4
    L4 --> L3
    L3 --> L2
    L2 --> L1

Figure 1. Layered architecture of AI agent integration with corporate systems. The protocol/interface layer (L3) is where the three approaches diverge. Source: author's generalization based on implementation experience.

The three integration approaches differ primarily in how they implement Layer 3 — the protocol and interface layer. Each choice cascades through the stack, affecting security, auditability, and scalability at every level.

In our experience, AI agent integration with enterprise systems follows one of three fundamental approaches, each with distinct trade-offs.

Direct Database Access

The simplest and most immediate approach is to connect the AI agent directly to the underlying databases of enterprise systems. The agent issues SQL queries against the ERP database, reads process historian tables from the SCADA system, or accesses MES data stores directly.

This approach has obvious appeal: it requires no middleware, no API development, and minimal coordination with the vendor of the target system. For a proof-of-concept or internal pilot, it can deliver results in days rather than months.

However, direct database access carries substantial risks that make it unsuitable for production deployments. First, it bypasses the business logic layer — an ERP database contains raw tables whose relationships and constraints are enforced by the application, and querying them directly can return misleading results. Second, write access at the database level can corrupt data or violate integrity constraints. Third, direct database access provides no audit trail at the application level — the ERP system has no record that an AI agent queried or modified its data. Fourth, database schemas change between software versions, making integrations fragile.

API-Based Integration

The more disciplined approach is to integrate through the APIs that enterprise systems expose — whether REST, SOAP, GraphQL, or vendor-specific protocols. APIs provide a defined contract: the agent calls a specific endpoint with specific parameters and receives a structured response. The business logic remains on the application side. Access control is enforced by the API layer. Audit trails are maintained by the target system.

API-based integration is the current industry standard for system-to-system communication, and it works well for AI agent integration when APIs are available. Gartner predicts that by 2026, more than 80% of independent software vendors will have embedded generative AI capabilities in their enterprise applications [6], which implies an expanding ecosystem of AI-relevant API endpoints.

The limitation is that API integration remains a one-to-one engineering effort. Each vendor's API has its own authentication mechanism, data format, rate limits, and error handling conventions. Integrating an AI agent with SAP requires understanding SAP's API landscape; integrating the same agent with Oracle requires understanding Oracle's. The knowledge does not transfer, and the maintenance burden grows linearly with the number of integrated systems.

For organizations with a heterogeneous landscape of dozens of systems — which is the norm in manufacturing — the cumulative engineering effort becomes a significant constraint.

Standardized Protocols: MCP and the Emerging Paradigm

The third approach — and the one we consider most significant for the medium-term trajectory of enterprise AI — is integration through standardized, open protocols designed specifically for AI agent interaction with external systems.

The most prominent example is the Model Context Protocol (MCP), introduced by Anthropic in November 2024 as an open standard [1]. MCP defines a universal protocol through which AI agents can discover, access, and interact with external data sources and tools. Rather than writing custom integration code for each target system, the agent communicates through a standardized client-server architecture. The target system (or a middleware layer in front of it) exposes its capabilities through MCP servers that describe available tools, resources, and data in a format any MCP-compatible agent can understand [2].

The adoption trajectory has been striking. MCP SDK downloads grew from approximately 100,000 in November 2024 to 97 million monthly downloads by early 2026. According to the Zuplo State of MCP Report, 72% of developers expect their MCP usage to increase over the next twelve months, and 54% are confident that MCP will persist or become an industry standard [8].

MCP is not the only protocol addressing this space. OpenAI's Function Calling mechanism provides a parallel approach, allowing models to invoke structured functions with defined parameter schemas [3]. While Function Calling is model-specific rather than protocol-level, it addresses the same fundamental need: giving AI agents a structured, auditable way to interact with external systems.

In the industrial domain, the OPC Foundation has taken a significant step by announcing plans to convert all 430+ OPC UA Companion Specifications into AI-optimized formats — including Markdown descriptions, token-optimized RAG chunks, vector embeddings, and MCP interfaces [5]. This initiative bridges the gap between the established industrial communication standard (OPC UA) and the emerging AI agent integration paradigm. It signals a future where an AI agent can discover and interact with industrial equipment and control systems through the same standardized protocol it uses to access business systems.

The following table summarizes the trade-offs across these three approaches:

CriterionDirect Database AccessAPI IntegrationStandardized Protocol (MCP)
Implementation complexityLow (initial)MediumMedium (initial), Low (incremental)
SecurityPoor — bypasses application layerGood — enforced by APIGood — built-in access controls
ScalabilityPoor — each DB is uniqueLimited — linear effort growthHigh — one protocol, many systems
Maintenance costHigh — schema changes break integrationMedium — API versioning requiredLow — protocol handles versioning
Audit capabilityNone at application levelYes — API loggingYes — protocol-level audit trail
Business logic preservationNo — raw data accessYes — API enforces logicYes — server implements logic
Vendor independenceTied to DB schemaTied to vendor APIProtocol-agnostic

Table 1. Comparison of AI agent integration approaches for enterprise systems.

Figure 2. Radar chart comparing three integration approaches across six enterprise criteria. Direct database access (dotted line) scores minimally across all dimensions. API integration (dashed line) provides moderate security and business logic preservation but limited scalability and vendor independence. Standardized protocols (solid line) achieve the strongest profile across all criteria except initial implementation complexity. Data derived from Table 1.

The pattern is clear: standardized protocols reduce the marginal cost of each additional integration while improving security and auditability. The initial investment in supporting a protocol like MCP is comparable to API integration, but the incremental cost of connecting each subsequent system decreases significantly because the agent-side integration code does not change.

The Role of Standardization: Lessons from Industrial History

The significance of standardization in AI agent integration becomes clearer when viewed through the lens of industrial history.

Before OPC (OLE for Process Control) was introduced in the mid-1990s, connecting a supervisory application to a PLC required vendor-specific drivers. Each combination of supervisory software and PLC hardware required a dedicated integration effort. The industry termed this the "driver problem" — an N×M matrix of required integrations that grew quadratically with the number of products in the market.

OPC — and later OPC UA, its platform-independent successor — solved this by defining a standard interface. Any OPC UA client can communicate with any OPC UA server, regardless of the underlying hardware or software vendor. The N×M matrix collapsed to N+M: each product needed only one implementation of the standard. This transformation did not happen overnight. It took more than a decade for OPC UA to achieve widespread adoption in industrial automation. But the economic logic was irresistible, and today OPC UA is a de facto requirement for industrial equipment.

We observe the AI agent integration landscape at a similar inflection point. Today, connecting an AI agent to an enterprise system requires custom integration for each system — the modern equivalent of the driver problem. MCP and similar protocols represent the same architectural solution: a standard interface that reduces the integration matrix from N×M to N+M.

The IEEE Standards Association has recognized this trajectory. The recently approved project P3945.2 specifically addresses "Agent-to-Tool and Data Access Interfaces in Industrial Intelligent Agent Systems," defining reference interface models for secure and interoperable interaction between agents and external resources in industrial settings [7]. While still in development, this standard signals institutional recognition that AI agent integration requires the same standardization rigor that industrial communication received two decades ago.

The OPC Foundation's decision to convert its Companion Specifications into AI-optimized formats, including MCP interfaces [5], represents a convergence of these two standardization traditions. Industrial communication standards (OPC UA) and AI agent communication protocols (MCP) are beginning to merge into a unified integration layer. In our assessment, this convergence will be one of the defining technical developments for industrial AI over the next three to five years.

Integration Security: The Non-Negotiable Foundation

No discussion of AI agent integration is complete without addressing security — and based on our implementation experience, we consider it important to note that security is the area where the gap between current practice and necessary rigor is widest.

The Zuplo State of MCP Report confirms this assessment: 50% of developers building MCP integrations cite security and access control as their primary concern, and 38% report that security concerns actively block increased adoption [8].

The security requirements for AI agent integration differ qualitatively from traditional system-to-system integration. A conventional API integration typically operates under a fixed service account with predetermined permissions. An AI agent, by contrast, may dynamically select which tools to use, which data to query, and which actions to take — all based on reasoning that is not fully deterministic. This dynamic behavior demands a more granular and more strictly enforced security model.

Several principles, drawn from our implementation practice, should guide integration security design:

Principle of least privilege. An AI agent should have access to exactly the data and operations it needs for its defined tasks, and no more. If the agent's function is to generate production reports, it needs read access to production data — not write access to production parameters. This seems obvious, but in practice we observe that many early integrations grant overly broad permissions for convenience during development and never restrict them for production.

Read-write separation. Integration endpoints should explicitly distinguish between read operations (querying data) and write operations (modifying system state). Read operations can be authorized more liberally; write operations should require additional validation, including human approval for safety-critical or financially significant actions. The MCP specification supports this distinction at the protocol level, allowing servers to declare which operations are read-only and which are state-modifying [2].

Comprehensive audit logging. Every interaction between an AI agent and a corporate system must be logged with sufficient detail to reconstruct the agent's reasoning and actions after the fact. This includes: what data the agent requested, what it received, what action it proposed, what authorization it operated under, and what the outcome was. In regulated industries — food production, pharmaceuticals, energy — this audit trail is not merely a best practice but a compliance requirement.

Authentication and authorization at the protocol level. The integration protocol itself must enforce identity verification and permission checking, not delegate these to the application layer. MCP's specification includes provisions for authentication and access control at the protocol level [2], ensuring that security cannot be circumvented by a misconfigured application.

Isolation of agent actions. Where possible, agent actions should be executed in a sandboxed or transactional context that allows rollback in case of error. An agent that generates an incorrect purchase order should not be able to submit it directly to the ERP's procurement module without an approval step that a human — or a separate, independently authorized system — can review and reverse.

Market Maturity: A Practitioner's Assessment

Based on our observations across dozens of integration projects in manufacturing and process industries, we offer the following assessment of where the market stands today.

The technology is ahead of adoption. The tools for standardized AI agent integration — MCP, Function Calling, OPC UA for AI — are maturing rapidly. The 97 million monthly MCP SDK downloads and 28% Fortune 500 adoption rate demonstrate real traction, not merely aspirational interest. The IEEE and OPC Foundation are investing in formal standardization.

However, enterprise readiness lags significantly. Only 16% of organizations report using AI beyond limited applications. Scaling from pilot to production typically increases investment by 250–400%, and this cost escalation is driven primarily by integration complexity — not by model licensing or compute costs. The SAPinsider Benchmark for 2026 found that 70% of technology leaders prioritize operational efficiency and cost reduction, suggesting that integration cost remains a gating concern.

The security gap is real and consequential. While the protocols support robust security, implementation practice has not caught up. Many early integrations operate with overly permissive access, insufficient audit logging, and no formal authorization framework for agent actions. This gap represents the single largest risk factor for production deployments today.

Standardization will accelerate but not overnight. The historical precedent of OPC UA — a decade from introduction to widespread adoption — suggests that MCP will follow a similar but compressed trajectory. What we expect is a gradual transition where new integrations are built on standardized protocols while existing API integrations continue to operate in parallel.

Author's Assessment and Conclusions

The central argument of this article is straightforward: the integration layer — not the AI model — is the decisive factor in enterprise AI agent deployments. An agent with the most advanced reasoning capabilities is operationally useless if it cannot access the ERP data it needs to answer a production question, or the MES data it needs to analyze a quality deviation.

Based on our experience, we offer three conclusions:

First, enterprises should evaluate integration approaches with the same rigor they apply to model selection. The choice between direct database access, API integration, and standardized protocols has long-term implications for security, scalability, and maintenance cost. For new projects, we consider standardized protocols — particularly MCP — to be the preferred approach wherever the target systems support them or can be adapted to support them through middleware.

Second, standardization is not a future promise but a present requirement. The convergence of OPC UA and MCP, the IEEE's work on agent-to-tool interface standards, and the rapid adoption of protocol-level integration tools all point to a landscape where standardized interfaces become the expected — and eventually the required — method of AI agent integration. Organizations that build custom, proprietary integration layers today will face migration costs tomorrow.

Third, security must be designed into the integration architecture from the outset, not retrofitted after deployment. The principle of least privilege, read-write separation, comprehensive audit logging, and human-in-the-loop approval for write operations are not optional enhancements — they are structural requirements for any AI agent that interacts with systems of record in an industrial environment.

The enterprise that gets integration right — secure, standardized, auditable, and scalable — will find that the AI agent capabilities follow naturally. The enterprise that focuses on model capabilities while treating integration as an afterthought will join the 40% of agentic AI projects that Gartner estimates will be cancelled before delivering value.

Integration is not a technical detail. It is the strategy.

References

  1. Anthropic. "Introducing the Model Context Protocol." 2024. https://www.anthropic.com/research/model-context-protocol
  2. Model Context Protocol. "Specification (Latest Stable)." 2025. https://modelcontextprotocol.io/specification/latest
  3. OpenAI. "Function Calling." 2025. https://platform.openai.com/docs/guides/function-calling
  4. IEC/ISO. "IEC 62264-1:2013 — Enterprise-Control System Integration — Part 1: Models and Terminology." https://www.iso.org/standard/57308.html
  5. OPC Foundation. "OPC Foundation Advances OPC UA for the AI Era with Companion Specifications Optimized for Agentic AI." April 2026. https://opcfoundation.org/news/press-releases/opc-foundation-advances-opc-ua-for-the-ai-era-with-companion-specifications-optimized-for-agentic-ai/
  6. Gartner. "Predicts More Than 30% of the Increase in Demand for APIs Will Come From AI and Tools Using Large Language Models by 2026." 2024. https://www.gartner.com/en/newsroom/press-releases/2024-03-20-gartner-predicts-more-than-30-percent-of-the-increase-in-demand-for-apis-will-come-from-ai-and-tools-using-llms-by-2026
  7. IEEE Standards Association. "P3945.2 — Agent-to-Tool and Data Access Interfaces in Industrial Intelligent Agent Systems." 2026. https://standards.ieee.org/ieee/3945.2/12438
  8. Zuplo. "The State of MCP Report." 2026. https://book.zuplo.com/blog/mcp-survey
ai agent integrationerp integrationmesscadamcpmodel context protocolopc uaenterprise aiindustrial automationapi integration

AQTeck solutions on this topic

We design and implement these systems at industrial enterprises in Ukraine and the EU.

Related Articles

Need a consultation?

Contact us for a free consultation.