The Enterprise Is Getting a New Operating System: Agentic AI as Core Infrastructure

The Enterprise Cognitive Layer

The enterprise is getting a new operating system, and it’s not Windows or Linux. It’s a cognitive layer made up of agentic AI systems that sit between people and systems of record.

Over the last few months, I’ve been looking past demo agents and hype to focus on what’s actually working in production. The pattern is consistent: we’re moving away from brittle “if–then” automation toward agents that can interpret intent, plan steps, use tools, check their own work, and stay within policy and cost guardrails.

For the last decade, we’ve used RPA, BPM, and iPaaS to wire together deterministic workflows. They’re great when the world behaves exactly as expected, but they fall apart the second an exception or a weird edge case shows up. Agentic systems flip the model. They don’t just follow a script; they reason about the goal and figure out how to get there, within boundaries we define.

The Realities of Adoption and Economics

The adoption curve is already here. Recent data suggests well over half of IT organizations now have agents embedded into primary workflows, and a meaningful slice are letting agents run entire processes end to end. In practice, that looks like ticket resolution times dropping from hours to minutes without adding bodies. As a CIO, that’s a signal you can’t ignore.

Economically, this is being driven by a simple ratio. A human-handled transactional interaction might cost $3 to $6. The same class of interaction handled by a well-designed agent can land in the $0.25 to $0.50 range. That 85–90% cost reduction is a big part of why enterprise GenAI spend jumped to about $37B in 2025, and why the agent market is projected to grow significantly by 2030.

Of course, none of this is free. Agents that plan, call tools, query data, and run internal evaluations are compute-hungry. If you do all of that on traditional hyperscalers, your infrastructure line item starts to swell fast. That’s why we’re seeing the rise of "neocloud" providers: GPU-focused platforms that come in 60–70% cheaper than the big three. The pattern I’m seeing is: keep your crown-jewel data and compliance workloads on the hyperscalers, but offload inference-heavy agent workloads to these specialized stacks where the economics make sense.

Architectural Foundations for Production

Architecturally, the deployments that survive contact with reality have one thing in common: a hard separation between cognitive planning and deterministic execution.

• The Planning Layer: The probabilistic "brain" that interprets messy human requests, breaks them into steps, and proposes actions.
• The Execution Layer: The gatekeeper that enforces policy, RBAC, rate limits, and rollback.

Model outputs are treated as proposals, not commands. As someone who has to think about change management and risk, that separation is non-negotiable.

Underneath that, we’re also rethinking data platforms. If you want millions of concurrent agent sessions with usable memory, you can’t afford a patchwork of silos and overnight ETL. Architectures like VAST’s disaggregated shared-everything model are one response: decouple compute from storage, keep structured, unstructured, and streaming data co-located on fast media, and run vector search and retrieval next to live workloads. Storage stops being just “where we keep data” and becomes “the memory layer for the agent fleet.”

Integration is the next brick in the wall. A lot of AI projects have quietly failed because every team and every vendor shipped its own one-off connector. The Model Context Protocol (MCP) is one of the more promising answers I’ve seen. Instead of bespoke adapters everywhere, you get a host, a client, and a set of servers that expose tools, resources, and prompts in a common way. Because it’s a standard layer in the middle, it’s also the natural place to enforce governance: scanning and signing servers, enforcing RBAC, and rate-limiting what agents can actually do.

Things get especially interesting when you combine that integration fabric with live enterprise architecture. Instead of giving an agent a PDF of your app landscape, you let it traverse the graph of capabilities, processes, applications, and risks. Then questions like “What breaks if we retire this system?” can be answered with traceable reasoning instead of gut feel.

Once you allow agents to write and execute code, the sandbox where that code runs becomes part of your security perimeter. At that point, picking runtimes is an architecture decision, not a developer convenience. Container-based isolation gives you huge concurrency and direct GPU access for heavy ML and data workloads. MicroVM-based isolation gives you stronger separation and very low cold-start latency for long-running, low-latency agent services. In a mature environment, those options are spelled out in the reference architecture with clear guidance for when to use which.

Proven Use Cases vs. High-Friction Patterns

The most compelling examples in the wild are not "LLMs in a demo environment," they’re agents wired into real transactional flows.

• Substack uses agents to handle billing and refunds, and log bugs straight into Jira.
• Retail and travel brands use voice and chat agents to absorb the bulk of seasonal volume while maintaining CSAT.
• Cybersecurity teams automate most of incident investigation and push triage below a dollar an event.

On the other side, platforms like Sierra AI show a high-end, high-friction pattern: strong brand-aligned answers and multi-model architectures, but with six-figure contracts, heavy setup, and noticeable latency. Powerful, but not something you casually sprinkle everywhere.

To bridge the gap between “polite chatbot” and “agent that can actually do work in your applications,” we’re seeing platforms that integrate directly at the UI layer and with domain-specific stacks. In e-commerce, agents are now modifying subscriptions, issuing labels, and completing workflows directly in the live interface. In telco and marketing, domain-specific “agentic operating systems” are orchestrating flows on top of legacy stacks without forcing a full data migration.

Across industries, two deployment patterns keep showing up:

• The Autonomous Front-End Agent: Sits directly with the user and has a lot of freedom to explore solutions. This is useful for open-ended customer conversations, but it requires strong guardrails and token budgets.
• The Deterministic Peer-Node Agent: Lives as a step inside a fixed process alongside RPA, APIs, and humans. It only wakes up for qualitative judgment calls and then hands control back to the deterministic flow.

Most serious implementations end up hybrid: a deterministic backbone with agentic judgment handling the 20% of steps that actually require thinking.

The Playbook Moving Forward

There is a hard truth hiding in the market data: a large fraction of early agentic projects are predicted to be cancelled in the next couple of years. Not because the technology doesn’t work, but because the fundamentals are skipped. No process base, just “let’s throw an agent at it.” Integration chaos instead of a shared fabric. No clear boundary between cognitive and deterministic layers, so security and risk eventually hit the brakes. If you treat agents as a feature rather than a new layer of infrastructure, you pay for it later.

From where I sit, the playbook that seems to work looks like this:

• Start with the process base, not the model. Get brutally clear about workflows, definitions of done, and the tacit knowledge your best people actually use.
• Standardize integration. Value frameworks like MCP so agents can reuse a common tool and resource catalog instead of multiplying connectors.
• Enforce strict separation. Maintain boundaries between planning models and execution controls from day one; every agent action should pass through a governed gateway.
• Invest in observability early. Ensure you can answer the basic question “What did the agent actually do, and what was the impact?” without guesswork.

If you do those things, model choice becomes an important but tactical decision, not the center of your strategy.

I'm curious what you're seeing in the field: Are you finding more traction with autonomous agents in front of customers, or with “quiet” agents tucked into internal workflows as deterministic peers?

Sources & References:

• Mirantis, Ivanti, VAST Data, McKinsey, Itential, Kellton, Kore.ai, Grand View Research
• Industry standards & analysis on Model Context Protocol (IBM, Databricks, Red Hat)
• Technical deep dives: Salesforce Atlas / Agentforce and Azure AI Agent Service
• Secure agent sandboxes & runtime execution: Northflank, Modal, Blaxel, Hugging Face
• Product case studies: Decagon, Sierra AI, Kodif, Amdocs aOS, ServiceNow