You’ve tried an AI chatbot for troubleshooting, maybe for scripting. It helped—sometimes. But your Monday still starts the same way: manually building lab topologies, writing configurations from memory, and documenting changes that nobody reads until something breaks at 2 a.m.

The problem isn’t that AI doesn’t work. It’s that most network engineers are still on the first two rungs of the capability ladder.

Three levels of AI for network engineering

 

• Level 1: Conversational AI. You ask an LLM to “generate a BGP EVPN configuration for my leaf switches,” and it gives a generic response—it doesn’t know your naming conventions, addressing scheme, or validated design patterns. Useful for brainstorming, but the model has no access to your environment.
• Level 2: AI Assistants. The LLM gains access to external sources—documentation via RAG, APIs, files. Cisco’s AI Assistant in Catalyst Center—powered by the Deep Network Model—is a good example: it queries your network state and gives context-aware answers. But for a multi-step workflow like building a lab topology, you’re still prompting one action at a time.
• Level 3: Agentic Frameworks. A single or multi-agent AI architecture takes your requirements and orchestrates a complete multi-step workflow—using tools, domain knowledge, and your team’s standards—with you reviewing at critical steps. You define the “what.” The agent handles the “how.”

The jump from Level 2 to Level 3 is not about smarter models. It’s about a different architecture.

What makes an agentic framework

Four core components make this work for network engineering:

• The AI agent is the reasoning engine—an LLM that interprets requirements, reads skills, calls tools, and decides the next step. In advanced setups, multiple agents collaborate—a planning agent designs the topology while a validation agent checks the output.
• Skills are markdown files that encode your team’s domain knowledge—naming conventions, design patterns, templates. When a senior engineer leaves, their expertise leaves with them. Skills capture it in a format agents consume directly—runbooks the AI actually follows.
• MCP (Model Context Protocol) servers bridge agents and your infrastructure APIs—Catalyst Center, vManage, CML, ISE—to read state, push configurations, or validate changes. Because MCP is an open standard, the same servers work across any compatible framework.
• Human-in-the-loop gates are mandatory pause points where the agent waits for your approval. Nothing touches your infrastructure without explicit sign-off. This isn’t a limitation—it’s the feature that makes enterprise adoption possible.

 

What this looks like in practice

Consider a common task: building a BGP EVPN fabric lab in Cisco Modeling Labs for a customer proof-of-concept.

• Manual: 2-4 hours. Incomplete documentation. Knowledge stays in one engineer’s head.
• Agentic Framework: 10-15 minutes. Full documentation generated. Standards applied every time.

 

Engineer request to "Build a BGP EVPN fabric — 2 spines, 2 leaves, OSPF underlay, iBGP overlay with VXLAN."

Agent generates a plan — lab name, 6 nodes, 8 links, base configurations, boot order. Presents it for review.

Engineer reviews, adjusts the VXLAN VNI range, approves.

Agent executes via MCP — create_lab → add_node (×6) → add_link (×8) → set_node_config → start_lab.

Agent verifies all nodes are active, BGP EVPN neighbors established, VXLAN tunnels up. Generates documentation.

The agent isn’t generating text — it’s executing a workflow. It reads skill files for your standards, calls MCP tools to interact with the CML API, pauses for your approval, and produces reusable artifacts.

Building your first agentic workflow

You have the framework—agents, skills, MCP servers, human gates. Now you need a workflow: a specific automated process like building a lab or validating a design. Agentic frameworks like Claude Code, OpenCode, Windsurf, and Cursor all support MCP and can orchestrate these workflows. The example repository uses Claude Code to walk through the full pattern:

1. Define skills—Markdown files that capture your team’s domain knowledge. The repo includes ready-to-use skills for EVPN fabric standards, naming conventions, and IOS XE configuration templates. Start with one workflow you repeat weekly and encode the decisions you make every time.
2. Connect MCP servers—each server bridges an agent to a specific platform API. The repo includes a CML MCP server you can point at your lab instance. CML is the ideal starting point: low risk, high repetition.
3. Configure agents—define what each agent does and how they collaborate. The repo includes a planning agent that generates topology designs and a validation agent that checks the output. You review and approve between steps.
4. Create commands—chain the workflow into a single invocation: parse requirements → generate plan → human gate → execute → validate → document.

When standards change, you update one skill file, not retrain a person. Every agent interaction benefits from it.

 

 

Clone the repo, point the MCP server at your CML instance, and run your first agent-assisted EVPN fabric build in under 30 minutes.

The shift that matters

This isn’t about replacing network engineers—it’s about the emergence of the AI-augmented network engineer. AI doesn’t just speed up execution. It reshapes how engineers design, troubleshoot, document, and preserve knowledge. Specialized agents can plan topologies, validate configurations, or troubleshoot issues in parallel—compressing hours of work into minutes. Skill files codify years of tribal knowledge that would otherwise walk out the door when a senior engineer leaves. The engineer’s role shifts from task executor to orchestrator, curator, and decision-maker.

That shift demands guardrails. LLMs hallucinate—they can generate plausible-looking configurations with wrong subnet masks or nonexistent CLI commands. Human-in-the-loop gates aren’t optional—they are a core architectural requirement that keeps the engineer in control as AI takes on more of the workflow.

Cisco is already moving in this direction—Meraki’s Agentic Workflows, AgenticOps, and the Deep Network Model all embed AI across network operations. The approach described here is complementary for engineers who need custom workflows or multi-platform orchestration.

The deeper impact is organizational. Agentic frameworks turn individual expertise into shared capability. Design patterns become skills. Validated designs become templates. Knowledge that takes months of onboarding to transfer becomes available on day one—and improves with every interaction.

Start small. Pick one workflow you repeat every week. Build one skill file. Encode what you already know. Run your first agentic workflow build. The shift from chatting with AI to working with an AI agent is smaller than you think—and the impact is larger than you expect.

 

---