Every enterprise putting AI agents to work on infrastructure converges on the same DIY stack: an LLM, an agent framework, custom integrations, a workflow engine, and the governance to hold it together. Itential delivers those layers as one governed platform, so your team ships agents that act on production, not proofs of concept.
Updated July 2026 · Built for network and infrastructure operations, not general-purpose AI.
A DIY stack gives you a reasoning layer with governance bolted on top. Itential gives you governed execution across workflows, scripts, configuration compliance, and stateful lifecycle, with reasoning built in. For a customer service bot, the difference is academic. For an agent changing a routing policy on production infrastructure, it’s the whole decision.
When an agent acts on production infrastructure, six things separate a stack that you maintain from a platform you run.
An agent that can reason and act on production infrastructure can also act wrongly, and the blast radius is real. Governance is what makes autonomous action safe enough to allow at all, so it is the first thing to weigh, not the last.
The criteria that matters:
Does every action, whether a human or an agent initiates it, pass through the same enforced RBAC, approval, and audit path by default? If governance is something you bolt on per tool after the reasoning works, you are carrying that risk yourself.
RBAC and audit are built per tool, per integration, and enforced inconsistently. Only 11% of organizations have a governance framework for AI agents in place. The reasoning layer comes first. Governance is bolted on after. The framework decides tool access at runtime, often letting the model discover tools as it runs, so the attack surface can shift mid-session.
One control plane. The same RBAC, GBAC, approval gates, and immutable audit trail apply to every action, whether a human or a FlowAgent triggered it. SOC 2 Type II by default. Zero data retention. Governance is the foundation, not an add-on. Agent tool sets are locked at design time and enforced by the execution engine, so even a successful prompt injection is bounded by a fixed, known surface.
RBAC and audit are built per tool, per integration, and enforced inconsistently. Only 11% of organizations have a governance framework for AI agents in place. The reasoning layer comes first. Governance is bolted on after. The framework decides tool access at runtime, often letting the model discover tools as it runs, so the attack surface can shift mid-session.
One control plane. The same RBAC, GBAC, approval gates, and immutable audit trail apply to every action, whether a human or a FlowAgent triggered it. SOC 2 Type II by default. Zero data retention. Governance is the foundation, not an add-on. Agent tool sets are locked at design time and enforced by the execution engine, so even a successful prompt injection is bounded by a fixed, known surface.
The gap between a demo and a governed production agent is where most programs stall. Standing up the reasoning is the easy 20%. The other 80% is the execution, integration, and control scaffolding that has to exist before an agent can safely touch a live network.
The criteria that matters:
Count how much of that scaffolding you would build and maintain versus inherit on day one, and be honest about how long that takes with your current team. Time to production is really a question of how much undifferentiated plumbing you are willing to own.
MIT research is blunt: 80% of a DIY agent program is governance scaffolding and integration work before any agent ships. Gartner expects 40%+ of agentic AI projects to be canceled by 2027.
The 80% is pre-built. Governed execution, rollback, approval gates, audit, and 1,000+ integrations are already there. A global Tier 1 telco put 5 FlowAgents into production in 4 days.
MIT research is blunt: 80% of a DIY agent program is governance scaffolding and integration work before any agent ships. Gartner expects 40%+ of agentic AI projects to be canceled by 2027.
The 80% is pre-built. Governed execution, rollback, approval gates, audit, and 1,000+ integrations are already there. A global Tier 1 telco put 5 FlowAgents into production in 4 days.
Agents are only as useful as the systems they can act on, so how you connect to infrastructure decides how far the program scales. The trap is that integration is not a one-time cost. Every system has to be connected, exposed as a governed tool, and then maintained as vendors and APIs change.
The criteria that matters:
Look at your integration count and your rate of change, then decide whether you want to own that curve or consume it. If most of your effort goes into wiring and re-wiring connections, less of it goes into the outcomes agents are supposed to deliver.
The N×M problem. Every new system means writing the integration, defining the agent tool schema, registering it in the framework, adding it to the workflow engine, and instrumenting it for audit. Repeat per vendor, then maintain all of it.
Connect a system once. Every method becomes a workflow task and a scoped, governed FlowAgent tool automatically. 1,000+ production-hardened open-source integrations across multi-vendor infrastructure, maintained by Itential.
The N×M problem. Every new system means writing the integration, defining the agent tool schema, registering it in the framework, adding it to the workflow engine, and instrumenting it for audit. Repeat per vendor, then maintain all of it.
Connect a system once. Every method becomes a workflow task and a scoped, governed FlowAgent tool automatically. 1,000+ production-hardened open-source integrations across multi-vendor infrastructure, maintained by Itential.
Every agent turn costs tokens, and how an architecture spends them determines whether your bill scales with outcomes or with noise. This is the line item that turns into a FinOps conversation the moment agents go into production.
The criteria that matters:
Does the architecture only spend tokens on reasoning, or does it route tool execution through the model too? And does a sub-agent hand back a lean result, or its entire transcript? Those two answers decide whether your token cost is bounded and predictable, or open-ended and something you have to police yourself.
Most agent frameworks route everything, reasoning and tool execution alike, through the model, so token cost per outcome is structurally higher and less bounded. Tool calls return full raw payloads by default, and sub-agents hand back their entire execution history unless you build custom filtering to trim it. Retries from ambiguous tool schemas silently re-pay the full context cost each time.
FlowAI’s execution is deterministic: tools run at zero token cost, and tokens only fund the reasoning steps. Sub-agents return a lean status/reference/summary by default, not their full transcript. Essentials-tier customers get a defined ~65k-token budget per agent run, not an open-ended one, because the architecture bounds what a session actually costs.
Most agent frameworks route everything, reasoning and tool execution alike, through the model, so token cost per outcome is structurally higher and less bounded. Tool calls return full raw payloads by default, and sub-agents hand back their entire execution history unless you build custom filtering to trim it. Retries from ambiguous tool schemas silently re-pay the full context cost each time.
FlowAI’s execution is deterministic: tools run at zero token cost, and tokens only fund the reasoning steps. Sub-agents return a lean status/reference/summary by default, not their full transcript. Essentials-tier customers get a defined ~65k-token budget per agent run, not an open-ended one, because the architecture bounds what a session actually costs.
Every tool an agent can reach is a door into your infrastructure. Whether that door was installed through one audited, approved path or by an individual engineer on their own laptop determines whether you have a security posture or a hope.
The criteria that matters:
Is there one place where MCP servers, Skills, Python, Ansible, or Terraform get vetted and installed before any agent can use them, with RBAC and AAA enforced on every action? Or does every engineer run their own local stack of agents and tools, invisible to security and impossible to audit as a whole?
Distributed by default. Every engineer can spin up their own agent with their own locally installed tools, MCP servers, and scripts, outside any central review. There’s no single inventory of what tools exist, who installed them, or what an agent can actually reach. Security finds out what’s running by asking around, not by checking a control plane.
One approved install path. MCP servers, Skills, Python, Ansible, and Terraform are vetted and registered centrally, with RBAC and AAA enforced before any agent can call them. There’s a single, current inventory of every tool in play and every agent that can reach it, not a patchwork of individual engineers’ local setups.
Distributed by default. Every engineer can spin up their own agent with their own locally installed tools, MCP servers, and scripts, outside any central review. There’s no single inventory of what tools exist, who installed them, or what an agent can actually reach. Security finds out what’s running by asking around, not by checking a control plane.
One approved install path. MCP servers, Skills, Python, Ansible, and Terraform are vetted and registered centrally, with RBAC and AAA enforced before any agent can call them. There’s a single, current inventory of every tool in play and every agent that can reach it, not a patchwork of individual engineers’ local setups.
A tool connected once should work for everyone, not get rebuilt every time someone new needs it. Whether your agents are shared, standardized assets or one-off scripts that only work on the machine that made them decides whether your program scales or just multiplies effort.
The criteria that matters:
When one engineer connects a system or builds an agent, does the rest of the team inherit it automatically, or does the next person start from scratch? “It works on my machine” is fine for a prototype and a liability for a program.
Bespoke by nature. An engineer’s local MCP server or agent works for them, on their setup, and often nowhere else. Sharing it with another team means handing over a script and hoping the environment matches. Every new use case tends to become its own snowflake build rather than a reuse of something that already exists.
One approved MCP server, once connected, exposes its tools to every agent and every team building on the platform. Agents themselves are reusable and shareable across teams under the same governance, so the work compounds instead of resetting. Standardized, repeatable, and controlled, not a collection of one-off scripts that only run where they were written.
Bespoke by nature. An engineer’s local MCP server or agent works for them, on their setup, and often nowhere else. Sharing it with another team means handing over a script and hoping the environment matches. Every new use case tends to become its own snowflake build rather than a reuse of something that already exists.
One approved MCP server, once connected, exposes its tools to every agent and every team building on the platform. Agents themselves are reusable and shareable across teams under the same governance, so the work compounds instead of resetting. Standardized, repeatable, and controlled, not a collection of one-off scripts that only run where they were written.
No tool wins on every axis. Here’s an honest read on where a DIY agentic stack holds up, and where a governed platform pulls ahead, when agents act on production infrastructure.
Building your own stack is a legitimate, often correct choice. Here’s where each approach earns its place.
Your agents are general-purpose: customer service, documents, sales, HR, code generation.
Your use case is network and infrastructure automation across multiple vendors.
You have a dedicated AI engineering team that will own the full stack long-term.
You need config compliance, drift remediation, and service lifecycle tracking.
Maximum framework and model portability is a hard procurement constraint.
Agents act on production, so governance and audit can’t be optional.
You’re in early experimentation, before committing to a platform.
Your team is network and infrastructure engineers, not AI engineers.
Your agents don’t touch production infrastructure, so the risk profile is lower.
You need to reach production-grade agentic operations in months, not years.
Your agents are general-purpose: customer service, documents, sales, HR, code generation.
Your use case is network and infrastructure automation across multiple vendors.
You have a dedicated AI engineering team that will own the full stack long-term.
You need config compliance, drift remediation, and service lifecycle tracking.
Maximum framework and model portability is a hard procurement constraint.
Agents act on production, so governance and audit can’t be optional.
You’re in early experimentation, before committing to a platform.
Your team is network and infrastructure engineers, not AI engineers.
Your agents don’t touch production infrastructure, so the risk profile is lower.
You need to reach production-grade agentic operations in months, not years.
A DIY agent stack is really ten layers you build, integrate, and maintain yourself. Itential ships them as one governed platform. An agent without them is a brain with no hands. The platform is the hands.
LLM routing and fallback: OpenAI, Anthropic, or self-hosted Llama, wired and maintained by you
Model-agnostic: choose the LLM per FlowAgent and swap it without rewriting logic
Agent orchestration: LangGraph, AutoGen, or CrewAI, self-hosted and version-chased
FlowAgent Builder: persona-based, natural-language agent design with scoped, governed tools
Memory and state: Redis, pgvector, and Postgres, each provisioned and operated separately
State managed in-platform, with Lifecycle Manager tracking real service state
Tool and integration: a custom MCP server or wrapper built per system, versioned by hand
Itential MCP, FlowMCP plus 1,000+ pre-built integrations, every method exposed as a governed tool
Script execution: Python, Ansible, and Terraform on ad-hoc Jenkins or cron, no RBAC or audit
Itential Gateway: governed execution for Python, Ansible, and OpenTofu with full audit on every run
Workflow engine: Temporal or Prefect, with rollback, approvals, and pre/post checks all custom
Workflow Studio: low-code orchestration with rollback, approval gates, and pre/post validation built in
Config and compliance: Ansible, Nornir, and RANCID stitched together, evidence built by hand
Configuration Manager: golden config, continuous drift detection, and automated remediation
Service lifecycle: ServiceNow CMDB or spreadsheets, with no link to the automation acting on it
Lifecycle Manager: stateful tracking from provision to decommission, so agents check real state first
Self-service catalog: a custom Backstage or ServiceNow portal to expose automations safely
Operations Manager and ServiceNow App: a governed self-service catalog
Governance, RBAC, and audit: rebuilt per tool, with no unified control plane or audit trail
One control plane: platform-wide RBAC, SSO, and a unified audit trail across every layer
LLM routing and fallback: OpenAI, Anthropic, or self-hosted Llama, wired and maintained by you
Model-agnostic: choose the LLM per FlowAgent and swap it without rewriting logic
Agent orchestration: LangGraph, AutoGen, or CrewAI, self-hosted and version-chased
FlowAgent Builder: persona-based, natural-language agent design with scoped, governed tools
Memory and state: Redis, pgvector, and Postgres, each provisioned and operated separately
State managed in-platform, with Lifecycle Manager tracking real service state
Tool and integration: a custom MCP server or wrapper built per system, versioned by hand
Itential MCP, FlowMCP plus 1,000+ pre-built integrations, every method exposed as a governed tool
Script execution: Python, Ansible, and Terraform on ad-hoc Jenkins or cron, no RBAC or audit
Itential Gateway: governed execution for Python, Ansible, and OpenTofu with full audit on every run
Workflow engine: Temporal or Prefect, with rollback, approvals, and pre/post checks all custom
Workflow Studio: low-code orchestration with rollback, approval gates, and pre/post validation built in
Config and compliance: Ansible, Nornir, and RANCID stitched together, evidence built by hand
Configuration Manager: golden config, continuous drift detection, and automated remediation
Service lifecycle: ServiceNow CMDB or spreadsheets, with no link to the automation acting on it
Lifecycle Manager: stateful tracking from provision to decommission, so agents check real state first
Self-service catalog: a custom Backstage or ServiceNow portal to expose automations safely
Operations Manager and ServiceNow App: a governed self-service catalog
Governance, RBAC, and audit: rebuilt per tool, with no unified control plane or audit trail
One control plane: platform-wide RBAC, SSO, and a unified audit trail across every layer
In a DIY stack, every new system is wired five times over: an integration, an agent tool schema, a workflow step, audit instrumentation, and ongoing upkeep as the API changes. In Itential, you connect it once and it propagates to every layer automatically.
Write the integration or MCP server for each vendor API
Upload an OpenAPI spec or decorate a script once, and the adapter is generated
Define every method as an LLM tool with its own JSON schema
Every API method becomes a drag-and-drop workflow task automatically
Register it in the agent framework, then add it again as a workflow step
The same method is instantly selectable as a scoped, governed FlowAgent tool
Instrument each call for audit, and maintain all of it as the API changes
Every call inherits platform RBAC, approvals, and audit, with no extra wiring
Every new vendor is N methods times four or five engineering tasks each
One connection, and all layers update at once, across 1,000+ integrations
Write the integration or MCP server for each vendor API
Upload an OpenAPI spec or decorate a script once, and the adapter is generated
Define every method as an LLM tool with its own JSON schema
Every API method becomes a drag-and-drop workflow task automatically
Register it in the agent framework, then add it again as a workflow step
The same method is instantly selectable as a scoped, governed FlowAgent tool
Instrument each call for audit, and maintain all of it as the API changes
Every call inherits platform RBAC, approvals, and audit, with no extra wiring
Every new vendor is N methods times four or five engineering tasks each
One connection, and all layers update at once, across 1,000+ integrations
AI brought the reasoning. Itential brings the governed harness it acts through, the execution, integration, and control that make an agent safe to run on a live network. That is the platform, and it is why serious infrastructure teams run agentic operations on Itential.
Reasoning you can trust to act. That is what defines the agentic era of infrastructure, and it is what Itential was built for.
Bring your own environment and your own agents. We’ll show you governed execution, integration, and control on live infrastructure.
It depends on what the agent acts on. For general-purpose AI across business functions, a DIY stack with open-source frameworks gives you flexibility and portability. For agents taking action on production network and infrastructure, the governance, execution, and integration scaffolding you’d build is roughly 80% of the effort, and it’s exactly what Itential provides out-of-the-box.
They’re capable agent orchestration frameworks, and Itential is model and framework friendly. The gap is everything underneath the reasoning layer: governed script execution, a workflow engine with rollback and approval gates, configuration compliance, service lifecycle tracking, a self-service catalog, and pre-built infrastructure integrations. None of that ships with an agent framework. You build and maintain it yourself.
Lock the tool set before the agent runs, keep credentials out of the agent entirely, and trace every run. On Itential, a FlowAgent’s tools are fixed at design time and enforced at runtime by the execution engine, credentials stay on the Integration Instance, Adapter, or Itential Gateway service and are injected at execution only, and FlowAgent Sessions record every reasoning step and tool call. In a DIY stack, each of those protections is something you build and maintain per component.
Not necessarily. A common 2026 pattern is two tracks: DIY stacks for general-purpose AI in functions like customer service and sales, and Itential as the governed execution platform for infrastructure operations. The Itential MCP Server connects the two, so any AI agent in the enterprise can invoke governed infrastructure actions without bypassing the control plane.
There’s a real trade-off, and we’re direct about it. DIY wins on component portability. Itential is model-agnostic and built on open standards like MCP, with 1,000+ open-source integrations, but the execution and governance model is the platform’s. The question is whether you want to own and maintain that model yourself, or run on one that’s already production-hardened.
A first FlowAgent typically reaches production within days, because governance, execution, and connectivity already exist. A global Tier 1 telco put 5 FlowAgents into production in 4 days using Spec-Driven Development.
Itential is purpose-built for network and infrastructure operations: multi-vendor networks, cloud, security policy, SD-WAN, and hybrid orchestration. It is not designed for general-purpose business AI. That focus is the source of its depth, and the reason DIY remains the better choice for non-infrastructure agents.
In a DIY stack, yes, and more than once. Each system means writing the integration, defining the agent tool schema, registering it in the framework, adding it to the workflow engine, and instrumenting it for audit, then maintaining all of it as the API changes. In Itential, you connect a system once and every method becomes both a workflow task and a scoped, governed FlowAgent tool automatically, across 1,000+ pre-built integrations. You consume the integration curve instead of owning it.
Tool execution itself doesn’t cost tokens on Itential — only the LLM’s reasoning does. Sub-agents return a lean result (status, identifier, short summary) rather than their full execution history, and builders can scope tool schemas and payloads to avoid over-specified prompts that inflate every turn. That’s why Essentials-tier customers work within a defined token budget per agent run rather than an open-ended one.
Tools, MCP servers, and scripts get vetted and installed once, centrally, through the same RBAC and governance controls your team already runs on, with AAA enforced on every call. Engineers build agents against that approved, governed set rather than installing their own locally, so there’s one inventory of what’s running and one place to control it, not a separate shadow stack per person.
Yes. Once a tool or MCP server is connected centrally, it’s exposed to every agent and team on the platform, not just the one that built it. Agents themselves are reusable assets under the same governance — the same problem covered in Why Agent Sprawl Is the Next Script Sprawl. In a DIY stack, that reuse usually means handing over a script and hoping it works in someone else’s environment.