Enterprise Autonomy
Menu
ENTERPRISE AUTONOMY · ARCHITECTURE · November 16, 2026

How Agents Fit Into the Enterprise Stack

Agents are a new tier between the people who supervise work and the integration layer that fronts the systems of record, and fitting them in is mostly a matter of identity, integration and records rather than models.

Trevor Solis · 6 min read
Contributing writer

Layered diagram of an enterprise stack. At the top, people who supervise and approve. Below them, a highlighted agent tier containing agents, policy and approvals, and a trace. Below that, the integration layer of APIs, an integration platform and connectors. At the bottom, the systems of record: ERP, CRM, MES, ITSM and the data warehouse. A vertical identity provider column runs beside every layer.

Agents belong in the enterprise stack as a new tier between the people who supervise work and the integration layer that already fronts the systems of record. They do not replace the ERP, the CRM or the MES, and they should not reach around the integration platform to touch those systems directly. Placed that way, most of the work of adopting agents turns out to be familiar architecture: identity, integration, network zones and records. The model is the smallest part of the decision.

That is not how the question usually arrives. It arrives as "which model should we use," and the stack beneath the model is treated as a detail. The stack is where the risk sits, so it is worth drawing first.

The layers that already exist

Most large enterprises run some version of the same five layers. Systems of record hold the authoritative state of the business: the ERP for orders and inventory, the CRM for customers, the MES for production, the ITSM platform for incidents and changes, the HR system for people. A data warehouse or lakehouse holds copies of that state, reshaped for analysis. An integration layer, often an integration platform plus an API gateway and a message bus, moves data and requests between them. An identity provider decides who may do what across all of it. People sit at the top, working through screens, queues and reports.

Each layer exists because a previous era of computing needed it. The integration layer exists because point-to-point connections between systems became unmanageable. The identity provider exists because each application keeping its own user list became unauditable. Those reasons have not gone away, and an agent that ignores them recreates the problems they solved.

The question is which of these layers the agent belongs to.

Where the agent tier sits

An agent is software that uses a model to interpret a situation and choose an action, as the glossary defines it. That puts it in a position no existing layer occupies. It reads like an analyst, decides like a clerk following policy, and writes like an application. It is not a system of record, because it holds no authoritative state of its own. It is not part of the integration layer, because it makes decisions rather than moving messages. It is not a person, though it does work people used to do.

The useful placement is a tier of its own, directly below the people who supervise and directly above the integration layer. Three things live in that tier: the agents themselves, the policy and approval rules that bound what they may do, and the trace that records what they read, decided and did. The agents reach downward only through the integration layer. People reach into the tier to set policy, approve what needs approval and handle what the agents escalate.

Consider a hypothetical maintenance case. An alert arrives from the MES that a pump is running hot. A maintenance agent reads the asset's service history from the maintenance system, asks an inventory agent whether a replacement seal is in stock in the ERP, drafts a work order and holds it for a supervisor's approval. Every read and every write passes through the integration layer the enterprise already governs. The agent tier adds judgment and sequencing; it adds no new path into the ERP. This is the workflow the publication's Governed AI Workflows benchmark uses, because it exercises exactly these boundaries: a handoff between agents, an approval that must be respected, and a record that must reconcile with the systems touched.

Placing the tier is the easy part. Each layer around it has to change slightly to accommodate it.

What the agent tier needs from the layers around it

The identity provider needs to know each agent as a principal. An agent that can write to the ERP is a new class of user, and the identity provider should know it as one. It is acting with some authority, and that authority has to belong to something the enterprise can name, scope and revoke. Running agents under a shared service account, or under the credentials of whichever person set them up, makes every downstream audit log ambiguous. A log entry that says the integration user changed a purchase order tells an auditor nothing about which agent did it, under which policy, in response to what.

The integration layer needs to expose the right operations at the right grain. Integration platforms were built for system-to-system flows with fixed mappings. Agents need to discover what operations exist, what they mean and what they require, and then call them with narrow permissions. Tool protocols such as the Model Context Protocol address the discovery part. They do not decide which operations an agent should be allowed to call; the integration and identity teams still decide that, the way they already do for applications.

An agent that can write to the ERP is a new class of user, and the identity provider should know it as one.

The data warehouse needs a clear role. Agents that read from the warehouse are reading copies, sometimes hours old. That is acceptable for analysis and risky for action. A reasonable rule is that agents may consult the warehouse for context but must read from the system of record, through the integration layer, before they write anything back.

The records need an owner. The trace an agent tier produces is a new kind of business record: it explains why a work order exists, why a refund was issued, why a ticket was closed. If it lives only inside the agent platform, it disappears when the platform is replaced. It belongs wherever the enterprise keeps records it must retain, with the same retention and access rules.

These are changes to layers the enterprise already runs. The one decision that is genuinely new concerns the network.

Network zones decide more than the model does

Enterprises divide their networks into zones: a corporate zone for office systems, a production or plant zone for operational technology, a restricted zone for regulated data, and an external zone for the internet. Traffic between zones passes through firewalls with explicit rules. Where the agent tier runs, and which zones it may reach, sets the outer limit of what any agent can do, regardless of what its instructions say.

An agent tier in the corporate zone that calls a hosted model on the internet sends every prompt, and every piece of business data placed in a prompt, across that boundary. An agent tier that must act on the MES needs a path into the plant zone, which many manufacturers keep separate from the corporate zone. An agent tier that serves the restricted zone may need its models inside that zone, which changes how they are obtained and updated. Each of these is an architecture decision with a clear owner in the network and security teams, and each is easier to make before agents are deployed than after.

Where the agent tier runs, and which zones it may reach, sets the outer limit of what any agent can do, regardless of what its instructions say.

Drawn this way, the agent tier is not a special case. It is a tier with a defined position, defined neighbours and defined paths between them, like every tier before it. The enterprises that find agents hard to govern are usually the ones that let agents arrive as features inside individual applications, each with its own credentials, its own connections and its own logs. The same agents, placed in a tier the architecture recognises, can be governed with tools the enterprise already owns.

The stack diagram does not settle how agents should talk to the tools beneath them or to each other; that is the subject of When Do You Need MCP, A2A, or Both?. Nor does it settle what changes when the network around the tier is closed entirely, which What Changes When Agents Run Inside an Air Gap? takes up. The scenario report considers where these architectures may stand by 2028.

THE NEWSLETTER

New research, benchmark results and reporting, by email.

No more than one email a week. Unsubscribe from any email. See the privacy notice.