What Are Enterprise AI Agents?

Enterprise AI agents are AI systems that use organizational data and tools to carry out multistep tasks within defined access, governance, and oversight controls. Agentic frameworks are being used everywhere right now to build these agents; Goose, Claude Code, Cursor’s agent mode, and a half dozen more. Your developers are running them against your environment whether you approved them or not. The first time you watch one of these tools work, it’s impressive. They can plan a multi-step task, file a ticket, query monitoring, and run a script. Is any of that an enterprise deployment? Not even close. It’s a demo; one person, one laptop, against production systems that never asked for it.

Here is an excellent case study of what happens without proper planning; the Replit incident from July 2025. An AI coding agent, working in an environment that had been put under an explicit code and action freeze, deleted a production database holding roughly 1,200 executive records and nearly 1,200 company profiles, then told its operator the data could not be recovered which proved false. No malicious actor. No external breach. Just an agent acting confidently inside the boundaries it had access to, in direct violation of the instructions from its operator. Replit’s CEO responded by shipping new safeguards including a planning-only mode and automatic separation between development and production databases. Those were the right fixes. They were also fixes that should have been there before the agent ever had write access to production.

The gap between “this works on my laptop” and “this is safe to run against production” is the same gap that exists for any technology, except wider, because the technology in question is non-deterministic, occasionally confidently wrong, reasoning over data it did not have when you defined the requirements, and will try to fill in its own gaps when it should have asked and confirmed with a human what is accurate in the environment.

If you are a CIO, CISO, or enterprise architect being asked to approve agent deployments, the question isn’t whether agents work. They do. The question is whether your identity, authorization, audit, and observability stack can contain what happens when one of them goes ‘rogue’. For most organizations right now, the honest answer is no.

A Desktop Agent Is Not An Enterprise Platform

Let me be crystal clear about what a desktop agent actually is from a controls perspective.

It runs on a user’s machine, as the user, with the user’s identity and full privileges. Its credentials sit in a local config file or keychain. Its logs, such as they are, live on the laptop. There is no central policy enforcement, no separation of duties, no approval workflow, no sandbox boundary, and no audit trail you can hand to an external auditor. Data egress to the model provider is whatever the terms of service say it is.

That setup is fine for a one-off experiment to prove out the concept. It is also fit to give your security and compliance team a heart attack.

What an enterprise deployment requires is the proper framework, a framework that already follows the same rules you have in place today for the enterprise environment. The following are must-haves:

– Each agent has its own workload identity, distinct from any human operator

– Credentials are short-lived, vault-issued, and scoped to specific operations

– Every plan, tool call, decision, and outcome is captured in an immutable, tamper-evident audit trail

– Human-in-the-loop approvals gate any state-changing action above a defined risk tier

– Execution happens in ephemeral, network-controlled sandboxes

– Compliance evidence for SOC 2, HIPAA, PCI, or GDPR is generated by the runtime, not bolted on later

The move from desktop to enterprise isn’t merely a config change, it’s applying the architectural discipline we’ve done for decades for proper control and security.

Nine Pillars for Deploying Enterprise AI Agents

We have been working through a reference framework that organizes enterprise agent deployment into nine pillars.

To summarize, the nine pillars are:

1. Identity and authentication:

Workload identity, short-lived credentials, on-behalf-of flows for user attribution

2. Least privilege authorization:

Per-task, time-bound, resource-scoped entitlements, with explicit tool allow-listing

3. End-to-end audit:

Prompt, plan, tool call, result, decision, and outcome, all captured and immutable

4. Human-in-the-loop approvals:

Tiered by blast radius, reversibility, and data sensitivity

5. Compliance posture:

Runtime-generated evidence for whichever regimes apply to you

6. Sandboxing and blast radius control:

Ephemeral compute, egress controls, and layered defense

7. LLM containment:

Token limits, endless loop protection, context engineering, memory boundaries, and output validation

8. Observability:

The agent is understandable to you, and the environment is understandable to the agent

9. Lifecycle and change management:

Versioning, rollback, drift detection, and evaluation gates

None of these are optional; skip any one of them and you might not find a problem, but a problem will likely find you.

AI Agent Risks Traditional Change Management Doesn’t Address

Agents introduce problems that change management didn’t anticipate. Traditional change management assumes deterministic systems where a script either does what it says or it errors, and agents do neither reliably. The teams running these systems already see it every day. The gap, when it exists, is in translating that operational reality into a conversation the steering committee can act on. A few of the problems that don’t have a clean comparison in anything we’ve managed before:

– Prompt injection from retrieved content. An agent reading a ticket, an email, or a knowledge-base article is also reading instructions, and it treats them as legitimate even if they were planted by an attacker. There is no perfect mitigation. Sandboxing assumes the agent will eventually be subverted.

– Hallucinated tool arguments. The model is confident, the syntax is valid, and the arguments are wrong. Schema validation catches some, and grounded context from a system of record catches more, but neither catches everything.

– Silent model upgrades. The provider rolls a minor model revision. Your agent’s behavior changes. Without model pinning and regression evals, you find out in production.

– Runaway loops. The agent decides to try, try, and try again. Without step caps and circuit breakers, the bill at the end of the month is the only indicator something went wrong… at your expense.

– Stale state. The agent checks the environment, then acts on what it saw. Between the check and the action, something changes (a service restarts, a resource fills up, another team makes a change) and the agent is now operating from the past, not the ‘now’. Without a refresh from the system of record right before the state-changing action, that gap is where the incident starts, and your co-workers are wondering if you have a ghost in the system.

Most of these are containable, but not by accident; they require deliberate architecture.

Why Enterprise AI Agents Need Grounded Observability

This is clearly where Virtana fits within your environment.

For an agent to act safely on the enterprise, it needs an authoritative model of the environment: topology, dependencies, performance, capacity, and anomalies. Without that grounded context, the LLM has no information specific to your environment and will confidently fill in the gaps with whatever sounds plausible. That is the failure mode I am least willing to accept in production.

Getting that context to the agent is what Model Context Protocol (MCP) was designed for. MCP is the open standard Anthropic introduced in late 2024, now adopted across most major model providers, that gives agents a uniform way to query tools and data sources. Without it, every connection between an agent and an enterprise system is a custom integration. Instead, MCP turns observability platforms, ticketing systems, CMDBs, and operational tooling into structured context any compliant agent can consume.

The Virtana Agentic Observability Platform is exactly that observability piece in the whole agentic pie. The Virtana Platform provides topology and dependency truth across the hybrid estate. Infrastructure Observability provides the real-time signal. Exposed to agents through MCP, both become queryable context the agent can use to bound its reasoning and validate its proposed actions before they execute.

It also closes the loop the other direction. When an agent acts, the resulting change shows up as a measurable signal in Virtana, which is what enables closed-loop verification… and not just a hope and a dream that the problem is actually resolved.

There isn’t just one way to solve this, but you do need something playing this role, and you need it before you let agents touch production. The alternative is agents making confident-sounding decisions against stale or imagined infrastructure state, and you finding out about it through a call from the NOC that production is down.

Controlled Autonomy: Defining Agent Permissions and Approvals

“Autonomous Is Nice, But Not In Our House.” This is the pushback I hear the most often, and someone who has spent time in war rooms, post-mortems, or 3am incident calls is right to feel that way. Handing anyone the keys to the kingdom can be risky, even when it’s to the most seasoned IT veteran. So asking someone with real ownership of the environment to allow an autonomous agent to make production changes has the discomfort for a reason.

The healthy level of skepticism in our role is also not new, and it isn’t wrong. ‘Not in our house’ for autonomous agents is the same instinct that pushed back on hypervisors twenty years ago and cloud ten years ago. Both transitions moved forward anyway, and the concerns the skeptics raised are exactly what shaped the controls that ultimately made each transition safer. The skeptics weren’t wrong; they were upstream of the controls that ended up mattering.

But the problem is the pushback lumps every kind of autonomy into one bucket and rejects the whole thing. There’s a world of difference between an agent running a read-only inventory query and one making a production firewall change during business hours, even though both are technically autonomous. There is a new term coined for this distinction now; ‘controlled autonomy.’ Enterprises were never going to adopt ‘autonomous AI‘ as a category. ‘Controlled autonomy’ isn’t something we want, exactly, but it provides a workable framework that allows us to move forward. It names the controls, scope, and oversight that make the risk manageable, delivering what the C-Suite wants while hopefully calming the nerves of the front-end administrators who have to live with it.

That distinction, translated into practice, is what the nine pillars actually deliver. We named those pillars earlier, and they ensure the process is ‘governed,’ not ‘free.’ Human-in-the-loop approvals (pillar 4) gate every state-changing action above the lowest risk tier. Least privilege (pillar 2) bounds what an agent can touch in the first place. Sandboxing (pillar 6) bounds the blast radius when something goes wrong. The risk-tier model puts destructive and regulated-data actions out of scope by default. Autonomy works like privilege: you grant it by scope, not by category. It’s under this finite control mechanism that the humans control how much autonomy the AI has, for which operations, and under what guardrails you choose to implement. As the environment and the technology evolve over time, so can those guardrails.

The choice isn’t whether agents operate in your enterprise, it’s whether you put governance in place today; otherwise it’s just a matter of time until you figure out someone had their own plans without the proper controls.

Building vs. Buying an Enterprise AI Agent Platform

Build versus buy is a real decision, and it deserves an honest answer. The open-source ecosystem is robust (agent frameworks like LangGraph or CrewAI, OPA for policy, vault tooling for secrets, microVMs for sandboxing, and eval harnesses like Promptfoo or Inspect), but assembling components into a production-grade platform with the integration discipline, ongoing maintenance, and governance to operate an enterprise agent capability is a multi-year commitment few organizations should take on. Most teams don’t have the capacity for it, and even those that do have better places to spend their engineering capital.

Either way, the leverage point is observability: agents need to see and be seen. That’s where the Virtana Platform fits, providing the single operational data layer that serves both humans and agents. If Virtana is already deployed, agent observability isn’t a new line item, you’re extending what you already own. If not, adding it now avoids stacking agent-specific point solutions on top of your general observability spend later. This is the ground truth the framework relies on, and it’s a place where the buy calculation is nearly always the right answer.

There’s doing something, and then there’s doing something right. You can skip the audits, skim the evals, and treat observability as optional. You’ll save a buck… until you don’t. The incident hits, and you waste hours of people’s lives fixing what would have been ‘easy’ if you had done it right the first time. Pay me now, or pay me later.

 Next Steps for Deploying Enterprise AI Agents

  • Workload selection
  • Risk assessment
  • Permissions
  • Approvals
  • Observability

If you’re deploying agents in production right now without addressing the nine pillars above, you have a control gap. You may or may not have noticed it yet. If you’re deploying them without grounded observability backing, you have a bigger control gap.

In this post we’re applying principles that we’ve been applying for decades around a system we already know. That already gets us more than half of the way there on day one. The rest is applying a new thought process to failure modes we hadn’t had to deal with in the past.

We know this because the industry has been through this cycle repeatedly since the 1960s: mainframes, minicomputers, client-server, the web, and more. Two recent examples make the point clearly enough without a full history lesson. With virtualization, server huggers said critical workloads needed bare metal forever. Vendors said you could virtualize anything by Tuesday. Neither was right; some workloads did stay physical and still do, but most did not. The capex math was real, and the operational payoff was larger than anyone sold up front: VDI lifting whole desktop estates off costlier hardware, live migration making upgrades during the business day routine, and snapshots making rollback a trivial operation instead of a four-hour war room. Those were the wins the architects found while building the platform, not the ones anyone promised at the start.

With cloud, marketing sold the vision. Architects translated it into a deployable path: identify the workloads, define the controls, build the landing zones, migrate in waves, and mature the platform. The skeptics who insisted cloud was unworkable were wrong. The optimists who claimed you could lift-and-shift everything in a weekend were also wrong. The architects who said “here is the path, and the devil is in the details” delivered the actual outcome. The enterprises we operate in today are built on what they shipped.

Agents are the same shape of problem at the same point in the curve. The vision is real, and the framework above is the path. What separates the two, as always, is the unglamorous work that wasn’t in the PowerPoint at the beginning: identity, audit, sandboxing, observability, and lifecycle. And if virtualization and cloud are any guide, the wins that ultimately matter most will be the ones nobody promised at the start.

Agents are going to run material parts of the enterprise within the next few years. That is not a prediction that requires courage. The choice in front of you is whether they run it under your governance, with your audit trail, with your blast-radius controls, or whether they run it as a shadow capability your security team discovers after the fact.

Call to Action

– Read the companion post: Why the MCP Server Underneath Matters More Than the AI On Top It makes the case for why the observability stack beneath MCP determines what AI agents can actually do across hybrid infrastructure.

– Request a Demo: Virtana delivers the deepest and broadest agentic observability platform for hybrid infrastructure. The Virtana MCP Server exposes that platform as grounded operational context for AI agents and the LLMs behind them. If you are building agent capability into your enterprise and need the observability stack to make it safe, schedule a demo with us.

References

– Fortune. (2025, July 23). AI coding tool Replit wiped database, called it a “catastrophic failure“.

– Anthropic. Model Context Protocol Specification.

– NIST AI Risk Management Framework (AI RMF 1.0)

– OWASP Top 10 for Large Language Model Application

Devon Brent
Devon Brent

Devon Brent is a Senior Principal Architect at Virtana, working across the Virtana Platform, and Infrastructure Observability. His background spans storage, SAN and Fibre Channel infrastructure, virtualization, and operating systems from Windows NT 4 through current cloud-native environments. He works at the intersection of product, engineering, and customer-facing technical architecture.

Agentic AI
November 04 2026Virtana Insight
Close the Observability Gap with Agentic Observability
As enterprises expand AI, hybrid infrastructure, and sovereign cloud environments, the gap ...
Read More
Agentic AI
October 29 2026Virtana Insight
What Is Agentic AI Observability? Definition, Examples, and Use Cases
Contents Agentic AI Observability vs. AI Agent Observability How Agentic AI Observa...
Read More
Agentic AI
October 29 2026Sankar Nagarajan
From Investigation to Action: How to Adopt Agentic AI in IT Operations
Key Takeaways Agentic AI adoption should begin with autonomous investigation and evide...
Read More
WordPress Cookie Notice by Real Cookie Banner