How to Evaluate Network & Infrastructure Platforms in the AI Era

The 3 Stages

The Evolution of Network & Infrastructure Automation

Network and infrastructure automation has moved through three stages. Each one added a new layer without throwing away the last, and each changed how much the human has to specify.

It started with traditional automation. Engineers wrote scripts by hand, and the script did exactly what it was told. Fast when conditions held, brittle when they changed. You told it every step.

Then came workflow orchestration. Instead of scripting each task, teams defined a process once: a reusable workflow that coordinated steps across systems, with order, dependencies, validation, and rollback. This is the deterministic execution layer, and it’s where repeatable, high-volume, mission-critical work still runs today. You defined the process, and the platform ran it the same way, every time.

Now comes agentic operations. AI agents reason, decide, and act within boundaries you set, adapting to context and handling the cases no one pre-programmed. For novel, ambiguous, intent-driven work, you no longer have to define every step. You define the outcome, and the agent works out how to get there.

Follow the line through all three: you tell it every step, then you define the process, then you define the outcome. Each step up handed the system more of the decision and gave the same team far more reach, while everything below it kept running. Agentic operations doesn’t change what your team is responsible for. It changes how much they can accomplish.

Agentic Operations: Common Misconceptions

Here’s the part most stories about AI get wrong: the new layer doesn’t replace the ones beneath it. It depends on them. An agent’s decision only becomes a safe action because there’s a deterministic execution engine to carry it out, with the same validation, approval, and rollback that orchestration always provided. Deterministic execution didn’t go away. It became the foundation agentic reasoning runs on. Different tools for different jobs: agents for the novel and ambiguous, deterministic workflows and scripts for the repeatable and mission-critical, on one governed platform.

That leverage is also the catch. The more a system decides on its own, the more it matters what governs those decisions. An agent with reach into production is the largest source of leverage in your stack, or the largest source of risk, depending entirely on the guardrails around it. Agent sprawl is becoming the new script sprawl.

So the question to ask a platform is no longer whether it can orchestrate, or whether it can bolt an agent onto the side. It’s whether AI can safely operate your network and infrastructure: decide, act, and stay governed on production systems, on top of an execution foundation you can already trust. Reasoning is the easy half. Governed, deterministic execution is the half that decides whether your AI program reaches production or stalls in pilot.

This isn’t only Itential’s view. Analysts now track agentic operations as an emerging software category, and infrastructure automation is consolidating from point tools into platforms. Itential has been recognized across that landscape, including the 2026 Gartner Market Guide for Network Automation Platforms, the Gartner Market Guide for Agentic NetOps Software, and Forrester’s Infrastructure Automation Platforms Landscape, along with 451 Research’s coverage of autonomous, governed AI for enterprise infrastructure operations.

This guide evaluates for that shift. It keeps everything that made orchestration worth buying, cross-domain reach, lifecycle control, and governance at scale, and reframes each around a harder question: not whether a platform can automate, but what makes an action safe, reversible, and provable when AI is the one taking it. Each criterion follows the same shape: the question to ask, why it matters, what to look for in any platform, and how Itential approaches it.

The 5 Criteria

The Surface Area of an Agentic Infrastructure Operations Platform

A platform for this era has to cover five things, the same five whether a human or an agent initiates the work:

• How automation gets built
• How systems get integrated
• How work gets executed
• How every action is secured and governed
• How the organization operates and consumes it across network, cloud, and security.

Build, integrate, execute, secure and govern, operate. The criteria that follow explore that surface area through one lens: what changes when AI is the one acting.

Support for Every Stage

The Lifecycle an Agentic Platform Has to Govern

Agentic or not, network and infrastructure work moves through a lifecycle. A platform built for this era supports every stage in one integrated flow, and lets AI initiate or assist at any stage under the same controls.

01  Request / Intake

Triggered via UI, API, tickets, telemetry, or AI agents. Validate inputs and enrich with context.

02  Approval / Policy / Impact

Apply security, capacity, dependency, and change-window checks. Route for human or automated approval.

03  Provisioning / Activation

Create network, compute, storage, and connectivity. Tie dependencies and update inventories.

04  Change / Update

Execute patches, scaling, and config changes. Join multiple domain changes with pre and post validation and rollback paths.

05  Validation & Drift Detection

Verify actual versus intended state. Detect and remediate out-of-band changes.

06  Day-N Operations

Monitor health, usage, and capacity. Trigger remediation or adjustment.

07  Decommission / Teardown

Safely disable or remove resources. Clean up dependencies and revert policies.

08  Audit, History & Traceability

Log every change with identity, version, and timestamp. Maintain historical state per instance for rollback and review.

The 12 Criteria to Evaluate

The Criteria That Matter in the Agentic Era

Twelve criteria, sequenced for how teams evaluate today. The first four decide whether AI can act at all, act safely, and stay under your control. The next three decide how the work is built, composed, and powered. The next two decide how it connects and stays grounded in reality. The last three decide whether it holds up across your environment and at production scale.

1. The decision-to-action boundary
2. Execution modes: deterministic, agentic, and hybrid
3. Governance and trust across humans and AI
4. Triggers, closed-loop operations, and human control
5. Building automations and agents
6. Agent orchestration: agents that call agents and deterministic work
7. Model choice and flexibility
8. Integration and agent reach
9. State and drift awareness
10. Cross-domain and distributed execution
11. Consumption and self-service
12. Production readiness

1. The Decision-to-Action Boundary

The question to ask. Does the platform put a boundary between an agent’s decision and a change in production, or can the agent act directly?

Why it matters. You are not worried about an AI that suggests a fix. You are worried about one that makes the change itself, on a production device, while no one is watching, and that you signed off on letting it. That instinct is right, and it is the first thing to evaluate: does the agent propose and something governed execute, or is the agent’s decision the action? Without that boundary, you haven’t deployed agentic operations. You have given an AI production credentials and hoped.

What to look for.

• A clear separation between where AI reasons and where execution happens, rather than the agent acting on infrastructure directly.
• AI-initiated changes held to the same validation, approval, and rollback as human-initiated ones.
• AI-generated automations landing in the same governed path as human-built work, not a separate fast lane.
• A gradual path from manual to automated to agentic, so you widen the agent’s latitude as you build trust.

How Itential delivers. In Itential, FlowAgents reason and propose, but act only by calling scoped tools, never touching infrastructure or credentials directly. Whatever an agent initiates runs through the same governed execution engine as every workflow, under the same RBAC, approval gates, validation, rollback, and audit. The agent proposes; the engine executes. That boundary is architectural, not a setting you can forget to switch on.

2. Execution Modes: Deterministic, Agentic & Hybrid

The question to ask. Can the platform reason when work is ambiguous and execute deterministically when it must be exact, and let you move between the two?

Why it matters. Some of your work is novel and benefits from an agent thinking it through. Most of it is repeatable and just needs to run the same way every time. You don’t want to pay an LLM to re-reason a change you have run a thousand times, and you don’t want a rigid script for the messy diagnostic work. The platform should do both, and let you move a proven reasoning pattern down into fixed, deterministic execution, so you stop paying to think through what you already know.

What to look for.

• Deterministic execution that includes both workflows and direct scripts or playbooks, not workflows alone.
• Agentic and deterministic execution running through one engine, under one set of controls.
• An agent able to hand off to deterministic execution mid-flow for the steps that must be exact.
• A supported path to convert a proven agent behavior into a deterministic automation, so repeat work stops incurring reasoning cost.

How Itential delivers. Itential runs deterministic, agentic, and hybrid execution through one governed engine. Deterministic execution isn’t limited to workflows: a script or playbook runs directly through Itential Gateway, the same way every time. Reason through a problem once with an agent, then capture the proven path as a deterministic workflow, so you are not paying to re-reason it on every run. Same governance, whichever mode executes.

3. Governance & Trust Across Humans & AI

The question to ask. Does the platform govern what an AI agent does exactly as it governs what a person does?

Why it matters. The thing that keeps you up isn’t whether the agent can act. It’s whether you can prove what it did when an auditor, or your boss, asks at 9am. Governance you bolt on after the agent ships can’t answer that. It has to apply to the agent the same way it applies to a person: same access control, same approvals, same record, or it won’t hold when it matters.

What to look for.

• Every action, human, workflow, or agent, logged with identity, timestamp, and attribution.
• RBAC, SSO, and MFA enforced on AI actions, not only human ones.
• An agent’s tools and scope locked at design time and validated at runtime.
• Clear control over where infrastructure data goes when AI acts, including whether copies are retained.
• Compliance evidence produced as a native output, not reconstructed after the fact.

How Itential delivers. Itential applies RBAC and GBAC equally to humans, workflows, and FlowAgents. A FlowAgent is constrained at design time to only the tools you authorize, and FlowAgent Projects enforce role-based access control (Owner, Editor, Viewer) as the security boundary for that tool access. Every action lands in an immutable audit trail with AI attribution. Zero data retention means no copies of your infrastructure data are kept, so your systems of record stay the source of truth. SOC 2 Type II by default.

4. Triggers, Closed-Loop Operations & Human Control

The question to ask. Can the platform trigger automation from real events and alerts, and let you choose where a human sits in the loop?

Why it matters. The value shows up when an alert can kick off a response on its own. The fear shows up in the same sentence. What you need is the choice: for a risky change, a human approves before anything runs; for a routine fix, it runs and you keep oversight and can step in. Your job isn’t to approve every action or none of them. It’s to decide, per action, where the human sits, and to be able to pause or stop it the moment something looks wrong.

What to look for.

• Automation and agents triggerable by events, alerts, telemetry, and AIOps signals, not just manual or scheduled runs.
• A per-action choice between human-in-the-loop approval and human-on-the-loop oversight.
• The ability to pause, resume, or cancel an in-flight agent run, with full visibility into what it is doing.
• Clean integration with the observability and AIOps tools that detect the conditions worth acting on.

How Itential delivers. Itential triggers automations and agents from manual, scheduled, API, and event sources through Operations Manager, so an alert or AIOps signal can initiate a governed response. You choose where the human sits: approval gates hold a change for a person in the loop, or it runs with a person on the loop, watching. In FlowAgent Sessions you can follow an agent’s reasoning and tool calls in real time and pause, resume, or cancel a run. AIOps and observability platforms connect in through FlowMCP Gateway, so the systems that detect a problem can hand it to the platform that safely fixes it. They find it; Itential acts on it.

5. Building Automations & Agents

The question to ask. Can the platform build both deterministic automations and agents, and let you scope an agent at build time?

Why it matters. You are accountable for what the agent can do and what it costs to run, and both are decided when it is built, not at runtime. An agent with open-ended latitude is a governance risk and a cost risk at once: it can reach further than you intended and reason more, and bill more, than you expected. Scoping the agent at build time, its tools, its boundaries, how much latitude it has, is how you set the risk and cost envelope before it ever runs.

What to look for.

• Building deterministic automations (workflows, and direct scripts or playbooks) and agents in the same platform, with shared building blocks.
• An agent’s tools and permissions scoped and locked at build time, not assembled at runtime.
• The agent’s latitude defined at build time, so its risk and its reasoning cost are bounded by design.
• A path to move between modes: promote an agent behavior into a deterministic automation, or call a governed automation as a tool from an agent.

How Itential delivers. Itential does both with one set of building blocks. Build workflows on a low-code canvas, write code, or bring your own scripts, Ansible, OpenTofu, and Python and run them directly through Itential Gateway. FlowAgent Builder and FlowAgent Projects compose an agent and authorize its tools at build time, scoped and locked before it runs, with project-level RBAC (Owner, Editor, Viewer) as the security boundary and a readiness gate the agent must pass before it can accept sessions. Scoping at build time sets both the risk and the cost envelope up front. Use Spec-Driven Development (SDD) to turn plain-language intent into a qualified deterministic workflow, or expose a governed workflow as a tool an agent calls.

6. Agent Orchestration: Agents That Call Agents and Deterministic Work

The question to ask. Can the platform let one agent coordinate other agents and deterministic automations as one governed flow?

Why it matters. The work you own doesn’t fit in one agent. A real operation is diagnose, decide, change, verify, and you want the right tool on each step: an agent where judgment is needed, a deterministic workflow where it isn’t. The platform should let agents call other agents and call deterministic automations, and let a workflow call an agent for just the step that needs reasoning, all coordinated and logged as one flow you can follow.

What to look for.

• An agent able to invoke other agents and deterministic automations (workflows, scripts) as steps.
• Workflows able to call an agent for a single reasoning step, then resume deterministic execution.
• Coordination across multiple specialized agents, with handoff and shared context, under one governance model.
• A single execution trace and audit across the whole multi-agent flow, including child runs.

How Itential delivers. Itential orchestrates agents the same way it orchestrates everything else. A FlowAgent draws from a runtime tool catalog that includes workflows, adapter and integration APIs, Gateway services, Lifecycle Manager actions, Compliance Plans, and other FlowAgents, so a diagnostic agent can hand off to a remediation agent that invokes the right workflow to execute the fix. Workflows can call an agent through a Run Agent task in Studio for the one step that needs reasoning, then resume deterministic follow-through. FlowAgent Sessions gives a single chronological trace across the whole run, including any child sessions or jobs the agent invoked, all under one governance model.

7. Model Choice & Flexibility

The question to ask. Can the platform let you choose the model behind your agents, bring your own, and match the model to the task?

Why it matters. The model is the most volatile and most expensive variable you own. The best model for deep diagnosis is overkill, and overpriced, for a routine classification, and the right model today may not be the right or cheapest one in six months. Locked to a single provider’s model, you can’t tune cost to the task or move when the market does, and it decides for you which model sees your infrastructure data.

What to look for.

• Support for multiple LLM providers and models, not a single hardwired one.
• The ability to bring your own model or provider credentials, for data-governance or cost control.
• Model selection per agent or task, so you can match a cheaper model to simpler work, and change models without rebuilding agents.
• Visibility into agent runs so you can see what is consuming reasoning, plus admin control over which models are available and to whom.

How Itential delivers. Itential is model-agnostic. LLM Admins configure one or more FlowModel Provider Profiles per environment, choosing the provider, enabling specific models, and controlling which builder groups can use them. On-prem deployments use your own provider credentials, so you bring your own model and control which one reasons over your data; cloud deployments select from a managed provider catalog. Each FlowAgent’s model is set in FlowAgent Builder and can change without rebuilding the agent, so you can match a lighter model to lighter work. FlowAgent Sessions gives a per-run trace of an agent’s reasoning steps and tool calls, so you can see where reasoning is being spent. [Confirm: whether token usage or counts are surfaced natively.]

8. Integration & Agent Reach

The question to ask. When you connect a system once, can both workflows and agents reach it, by API, MCP, or CLI, through the same governed path?

Why it matters. Your estate isn’t all modern APIs. A lot of it is CLI-driven gear that an API-only agent simply can’t touch, and the moment you bolt a separate MCP server onto each tool, you’ve created a second way into production that your change process never sees. You connect a system once; it should be usable by your workflows and your agents the same governed way, whether it speaks API, MCP, or CLI.

What to look for.

• Connecting a system once makes it usable by both workflows and agents, not wired separately for each.
• Reach that includes CLI, NETCONF, RESTCONF, and SSH devices, not just REST APIs.
• Capabilities reachable by standard API and by MCP, with no requirement to turn everything into an MCP tool.
• A clear split of prebuilt versus custom, and how custom integrations are maintained as APIs change.

How Itential delivers. Itential exposes any connected system as both a workflow task and an agent-callable capability through one governed path, reachable by standard API or by MCP, with no requirement to turn everything into an MCP tool. Itential Gateway reaches network and infrastructure devices over CLI, NETCONF, RESTCONF, and SSH, so agents and workflows can operate the CLI-driven gear that API-only tooling can’t. 1,000+ open source integrations, plus FlowMCP Gateway to bring external MCP tools under governance. When you want to expose capabilities to external AI, the Itential MCP Server does that northbound, as an option, not a toll booth.

9. State & Drift Awareness

The question to ask. Can the platform give an agent the real, current state of infrastructure before it acts?

Why it matters. An agent acting on stale assumptions is your nightmare scenario: confident, fast, and wrong. Infrastructure drifts constantly, and if the agent can’t check what is actually true right now before it acts, you are trusting a decision made on yesterday’s picture. You want it grounded in live state, and you want drift caught before it becomes an incident.

What to look for.

• A state model, with metadata and dependencies, maintained per service or resource.
• The ability for an agent to query current and intended state before proposing an action.
• Drift detected and reconciled, with snapshots, rollback, and full change history.

How Itential delivers. Itential’s Lifecycle Manager provides stateful orchestration: resources defined via JSON Schema, instance state tracked over time, and create, update, and delete actions tied to governed workflows. Agents query it as the source of truth before acting, so decisions are grounded in live state. Property change history shows what changed, when, and by which action.

10. Cross-Domain & Distributed Execution

The question to ask. Can the platform let one workflow or agent act across network, cloud, and security, including at the edge, without custom integration per domain?

Why it matters. The changes you are accountable for rarely stay in one domain, and your infrastructure doesn’t sit in one place. A real request touches network, cloud, and security at once, and reaches data centers, clouds, and edge sites. An agent or workflow boxed into a single domain just creates new handoffs, which is the toil you were trying to remove.

What to look for.

• One workflow or agent acting across network, cloud, and security without per-domain custom integration.
• Cross-domain dependencies, sequencing, locking, and rollback handled natively.
• Reliable reach to edge and remote sites, including under degraded or intermittent connectivity.

How Itential delivers. Itential treats network, cloud, compute, and security as first-class domains under unified control, and supports federated orchestration to run workflows at edge and remote sites, reconciling state when connectivity returns. New domains onboard through the adapter framework without rewriting orchestration logic.

11. Consumption & Self-Service

The question to ask. Can the platform let the whole organization safely consume approved automations and agents, with visibility into what ran?

Why it matters. If only your team can run any of this, you haven’t removed the bottleneck, you’ve moved it onto yourself. The win is letting other teams safely consume what you’ve approved, in plain language, without handing them the ability to do damage, and without you fielding every request.

What to look for.

• Approved workflows and agents published as catalog items or APIs, with RBAC, quotas, and approvals.
• Non-experts able to invoke services safely, in plain language, without deep platform expertise.
• Real-time visibility into what ran, what changed, and what an agent did.

How Itential delivers. Itential publishes orchestrated services to a governed self-service catalog with policy, approval gating, quotas, and audit, and is ServiceNow certified for native consumption. Itential Insights provides real-time operational visibility, including AI-native natural-language queries, so teams can ask what’s happening across their infrastructure and get governed answers.

12. Production Readiness

The question to ask. Will the platform hold up under real concurrency, failure, and the pipelines you already run?

Why it matters. Everything looks good in a demo. You are the one who finds out it doesn’t scale, in production, at 2am, when an agent is mid-change and a node fails. Once AI is acting at scale, the platform has to survive concurrency and failure, fit the CI/CD and change processes you already run, and let you trace exactly what happened when something breaks.

What to look for.

• Integration with CI/CD pipelines, both triggering them and being triggered by them, with versioning and rollback.
• Predictable behavior under node failure, high concurrency, and network partition.
• Failures traceable to the exact step and version, with execution metrics exposed.

How Itential delivers. Itential’s distributed architecture supports high availability, horizontal scale, and partition tolerance, with retries and failover. Workflows and policies are versioned and integrate with CI/CD systems, with staging, promotion, and rollback gating. Execution logs and metrics, correlated to infrastructure state through Lifecycle Manager, keep every change traceable.

How Agentic Operations Earns Its Place

Final Takeaways

The right platform for the agentic era isn’t the one with the most features. It’s the one that lets AI act on your infrastructure without taking control away from you. Orchestration earned its place by making complex change reliable. Agentic operations raises the stakes, because now something can decide to make that change on its own. A platform that can’t put a boundary between an agent’s decision and a production change, can’t govern AI the way it governs your people, can’t show you what it did and let you stop it, and can’t tell you what it costs to run will lose this era no matter how good the demo looked.

What to Prioritize

• A structural boundary between AI reasoning and execution.
• Deterministic, agentic, and hybrid execution through one governed engine.
• Governance that applies identically to humans, workflows, and agents.
• Triggers from real events and alerts, with a per-action choice of where the human sits.
• The ability to build both agents and deterministic automations, scope agents at build time, and move between the two.
• One governed integration path that serves workflows and agents, by API, MCP, or CLI, not an MCP server per tool.
• Model choice, so you can match cost to the task and keep your data under your governance.
• State intelligence, so AI acts on reality instead of assumptions.
• Governed self-service and real-time visibility for the whole organization.
• Production-grade scale, audit, and rollback by default.