Network engineers can stop studying the guts of protocols, Ansible, and Python. I worry about them exactly as much as I worry about assembly and RIPv2. Not at all.
None of it is obsolete. It all still runs, the same way assembly runs underneath engineers who have never written a line of it. It’s just not where the job is anymore.
I get challenged on this a lot. Sometimes kindly, sometimes not. The best challenge is a fair one: a compiler is deterministic and an agent is not, so how will you know when the agent is wrong?
That question is why this guide exists. You still need to know what good looks like on your network. What changed is everything between your intent and the device.
The model. The context you feed it. The protocols it speaks. The loops it runs in. The tests that prove it right.
I’m done writing books, unless a serious publisher convinces me to spend my meat tokens on one or accepts a vibe-published manuscript. So this is the book I’m not writing. It has 19 chapters in 7 parts, and each chapter says what the thing is, why it earned a place, and where to start.
The fundamentals didn’t die. They moved.
Two documents come before any tool. One tells you how to work, and the other tells you what you’re working with.
Agile comes first because working with agents is iteration, and network engineering never learned to iterate. We grew up on design documents, MOPs, change advisory boards, and 2 a.m. windows.
The Agile Manifesto was written in 2001 by 17 software developers. It states four values: people and conversation over process and tools, working software over heavy documentation, customer collaboration over contract negotiation, and responding to change over following a plan. Twelve principles sit behind them.
An agent can hand you a working first version in minutes. That makes planning everything up front the slowest part of the job. Build a small piece, see it work, take the feedback, and go again.
Read the fine print too. The authors say the right-hand items still have value. They just rank the left-hand ones higher. Process and documentation don’t disappear. They come back in Part 6 as specs, in service of working results.
Start here: The manifesto, then its twelve principles. The whole thing fits on one page.
This is the paper every large language model you use descends from. Eight researchers working at Google posted Attention Is All You Need in June 2017. It introduced the Transformer, an architecture built only on attention, with no recurrence and no convolutions.
The original job was machine translation. The idea that mattered was self-attention: every position in a sequence weighs every other position at once. That made training parallel and long-range relationships cheap.
You don’t need the math. You need four consequences, because you’ll meet them every day:
Start here: The abstract, section 3, and the figures. Skip the BLEU tables.
You don’t need to derive attention. You need to stop being surprised by it.
Three skills decide what the model knows when it answers: the instruction, the context around it, and what it can look up.
Prompt engineering is writing the instruction for one model call. It’s still the first skill, even though it’s no longer the whole job.
You already know the difference between a ticket that says “the internet is slow” and one with source, destination, time, and a traceroute. Write the second kind. Name the goal, the constraints, what done looks like, and the format you want back.
Show one example of good output when you have it. Say what the model must not do, like change config on a read-only task. Models differ, so read the guide for the one you use.
Start here: Your model vendor’s own guide. Anthropic’s prompt engineering overview is a good one.
A prompt shapes one call. An agent makes hundreds. That’s where the next chapter starts.
Context engineering decides everything the model sees on a call. The prompt is only one part of that.
The rest is tool definitions, retrieved documents, message history, and memory. Anthropic’s 2025 post Effective context engineering for AI agents treats it as the next step after prompt engineering. Its rule is to give the model the fewest tokens that still carry the signal it needs.
That rule exists because attention is a budget. So don’t paste the whole show tech. Give the agent a tool that runs the one show command it needs, when it needs it.
Long tasks need three more habits from the same post. Compact the history when it grows. Keep notes outside the window. Hand side quests to sub-agents with clean contexts.
You don’t give a new hire every config in the estate on day one. You tell them where the configs live.
Start here: The Anthropic post above, then audit one of your own agent sessions for what was in context and didn’t need to be.
Retrieval is how the model answers from your documents instead of its training data. The four names are four answers to one question: what should I retrieve?
| Approach | What it does | Reach for it when |
|---|---|---|
| RAG (2020) | Finds the chunks closest to the question and puts them in context | The answer lives in one place, like a standard or a runbook step |
| RAPTOR (2024) | Clusters and summarizes chunks into a tree, then retrieves at the right level of detail | The answer is spread across a long document |
| GraphRAG (2024) | Builds a knowledge graph of entities and relationships, with a summary for each cluster | The question is about the whole corpus, like themes across a year of incidents |
| Agentic RAG | Makes retrieval a tool the agent calls, checks, and calls again | One lookup isn’t enough and the agent must decide what to fetch next |
This earned a place because no model was trained on your network. Retrieval is how your standards, configs, and incident history get into the answer.
Two cautions. Retrieval is only as good as the documents, so a stale runbook in means a stale answer out. And the GraphRAG authors themselves note that plain vector RAG works well for direct, local facts.
Network engineers have a head start on the graph one. A topology is already a graph of devices, links, and adjacencies.
Start here: Build plain RAG over one folder of your own runbooks. Earn the other three.
Three open standards now do for agents what SNMP, NETCONF, and BGP did for networks. They let things built by different vendors work together, and all three sit under the Linux Foundation’s Agentic AI Foundation.
| Standard | Connects | What you write | Status, November 2026 |
|---|---|---|---|
| Model Context Protocol (MCP) | An agent to tools and data | A server that exposes tools, resources, and prompts | Spec revision 2026-07-28 |
| Agent2Agent (A2A) | An agent to another agent | An Agent Card that advertises skills and endpoints | v1.0 since March 2026 |
| Agent Skills | An agent to your procedures | A folder with a SKILL.md file | Open standard since December 2025 |
MCP is the standard way an AI application discovers and calls what a system can do. If you know SNMP or NETCONF, you already know the shape.
Anthropic released it in November 2024 and donated it to the foundation in December 2025. A server describes its tools, a client inside the AI application reads that description, and the model decides when to call one. The model never talks to the server directly.
Local servers run over stdio. Remote ones run over HTTP. The July 2026 revision made the protocol stateless, so a remote server now scales behind a plain load balancer.
It earned a place because this is how an agent touches your network. Wrap your source of truth, your monitoring, or a device API in one MCP server, and every MCP-capable agent can use it.
Start here: The specification, then build a read-only server that wraps one show command.
MCP connects an agent to tools. A2A connects an agent to another agent. If MCP is the management interface, A2A is the peering session.
Google announced it in April 2025 and the Linux Foundation took it over that June. Each agent publishes an Agent Card at a well-known URL. The card lists its skills, its endpoints, and how to authenticate, and since v1.0 it can be cryptographically signed.
The two agents then exchange tasks without exposing their prompts, memory, or tools to each other. That’s the BGP instinct. Advertise what you can do, keep your internals private, and agree on the session.
It earned a place because your network agent won’t work alone. It will hand work to the security team’s agent, the ITSM agent, and the cloud team’s agent, each built on a different framework.
Start here: The specification, then read one real Agent Card top to bottom.
A skill is a folder of instructions an agent loads when the task calls for it. It’s a MOP the agent can read.
The folder holds a SKILL.md file with a name and a description, plus optional scripts and reference files. The agent sees only the name and description at startup. It opens the rest when it needs it, which keeps the context window clean.
Anthropic introduced skills in October 2025 and published the format as an open standard that December. Around thirty tools were reading it by early 2026.
MCP gives an agent hands. Skills give it procedure. This is where tribal knowledge goes: how your team runs a change, your naming standard, your pre-check list.
One caution. A skill can carry scripts, so treat a community skill like a script from the internet. Read it before you run it.
Start here: Write one skill for a task you do every week.
An agent is a model using tools in a loop. These four chapters work outward from that loop: the pattern, the runtime around it, the system that reruns it, and the system that connects many of them.
Each engineering layer wraps the one inside it
The two inner layers shape a single call. The middle two make one agent that keeps working. The outer one turns many agents into a system.
ReAct is the reason-then-act loop every agent runs. You’ve been running it by hand your whole career.
The pattern comes from a 2022 paper by Princeton and Google researchers, ReAct: Synergizing Reasoning and Acting in Language Models. The model writes a thought, takes an action, reads the observation, and thinks again.
That’s troubleshooting. Think about the symptom, run a show command, read the output, think again.
The paper’s finding was that the two together beat either alone. Reasoning alone drifts into hallucination. Acting alone can’t plan. The written-out reasoning also leaves a trace you can audit.
Start here: The paper’s first figure. Then watch one agent session and label every step as thought, action, or observation.
The harness is everything around the model that turns it into an agent. The shorthand that stuck in 2026 is agent = model + harness.
A switch ASIC forwards packets, but nobody racks a bare ASIC. The NOS makes it a switch. The harness is the NOS.
It holds the tool definitions, the system prompt, the permissions, the context management, the memory, and the hooks that run checks. Claude Code, Codex CLI, and Gemini CLI are all harnesses.
When an agent fails, look at the harness before you blame the model. A missing tool, a loose permission, or a skipped verification step is a harness bug. Your guardrails live here too: which commands run freely, which need approval, and which never run.
Start here: OpenAI’s February 2026 post, Harness engineering. Then read the permissions and tool list of the harness you already use.
Loop engineering is designing the system that prompts the agent, so you’re no longer the one pressing enter.
Addy Osmani named it in a June 2026 essay. A loop is a goal the agent iterates on until it’s done. His parts list is automations that trigger runs, worktrees for parallel work, skills, connectors, sub-agents, and one place to keep state.
You’ve built this before. Closed-loop remediation is detect, decide, act, and verify. The difference is that the decide step now reasons.
Three things are hard: when to stop, who checks the work, and what it costs. Split the maker from the checker, because a model grades its own work too kindly. Put an iteration cap and a token budget on every loop.
Osmani says himself that it’s early and that the token costs need watching. Believe him.
Start here: His essay, then one scheduled, read-only loop. A morning pass over yesterday’s syslog that files a summary is enough.
Graph engineering is designing how many agents, scripts, checks, and people work as one system. It’s topology design for work.
The name arrived in mid-2026. An August survey, Graph Engineering in the Era of LLM Agents, frames it as three problems: organizing tasks, coordinating agents, and managing state at runtime.
Nodes are agents, deterministic code, validators, and human checkpoints. Edges are the handoffs you allow. An agent still reasons freely inside its node, but the graph decides where the work can go next.
You already know where a firewall belongs. A validation gate belongs in the same kind of place, on the edge where trust changes. Keep deterministic steps deterministic too. If a script does it reliably, make it a node of code, not a prompt.
Loops and graphs aren’t rivals. A loop is what one node does. The graph is how the nodes connect.
Start here: Draw your change process as a graph. Mark who or what does each step and which handoffs need approval.
These two chapters answer the question from the top of this guide. You’ll know the agent is wrong because you test it. And it can’t do much damage because you fenced it in.
An eval is a test for an AI system: give it a task, grade the result, and repeat. It’s the pre-check and post-check for a system that can answer differently each time.
That last part changes the method. One passing run proves little. You run several trials per task and watch the pass rate.
Anthropic’s guide, Demystifying evals for AI agents, names three kinds of grader: code, model, and human. Use code wherever you can. Did the session come up? Does the parsed state match intent? Did the diff stay inside the change scope?
Save model graders for fuzzy output like an incident summary, and check them against a human now and then. Read the transcripts too. A pass can hide a lucky guess, and a fail can be a bad grader.
You need two suites. A capability suite asks whether the agent can do the task at all. A regression suite asks whether it still can, and that one is your change control for prompts, models, and tools.
Start here: The Anthropic guide, then a handful of tasks pulled from real tickets where you already know the right answer.
Agent security starts from one uncomfortable fact. A model has no separation between control plane and data plane, so anything it reads can try to steer it.
That’s prompt injection. The indirect kind is the one to fear, where the instruction arrives inside data the agent was only supposed to read. Now think about what a network agent reads: interface descriptions, LLDP neighbor names, syslog messages, and ticket text. Every one is a string someone else can write.
Filters help, but they don’t close the hole. So design for the day the agent gets hijacked:
OWASP published its Top 10 for Agentic Applications in December 2025. Goal hijack, tool misuse, and identity abuse are the first three entries.
Start here: The list at OWASP’s GenAI Security Project. Then ask one question of every agent you run: what’s the worst it could do with the access it has right now?
Specs are back. The documentation Agile pushed aside returns here with a different job: it’s the input, and working software is still the output.
Spec-Driven Development (SDD) means you write what you want before anything gets built, and the agent builds from that. The spec is the source of truth, and the code is generated from it.
Network engineers have always been spec people. The design document, the MOP, and the intent were all specs. The difference is that this one is executable.
A good spec is short. It says what, why, what must not change, and how you’ll prove it worked. For a VLAN rollout, that’s the sites, the VLAN, the SVI standard, the things nobody may touch, and the checks that confirm it.
That last line matters most. A spec that states what done looks like has already written half your evals.
Review changes too. You stop reading diffs line by line and start approving intent at each stage. When the result drifts, you fix the spec and regenerate, not the output.
Start here: Write a one-page spec for your next change before you open a terminal.
Spec Kit is the fastest way to feel SDD instead of reading about it. It’s GitHub’s open-source toolkit, and its specify CLI adds a set of commands to the coding agent you already use.
Each command writes a Markdown file you review before the next one runs:
The constitution is the part network engineers will like most. It’s where you write “never touch the management VRF” and “every change has a rollback.” Every plan gets checked against it.
It was built for software projects, and your automation repo is one. It also moves fast. Guides from early 2026 are already stale, so trust the README over last year’s blog post.
Start here: The Spec Kit repository. Run it once on a small feature in an automation repo you own.
The last three chapters cover what this costs and who holds the model. They decide whether your agent survives contact with the budget and the security team.
Tokens are the new bandwidth. You’ll capacity-plan them, meter them, and get the bill.
A token is the unit of three budgets at once. Money, because input and output tokens are priced separately. Context, because the window is measured in tokens. Time, because speed is tokens per second.
Agents multiply all three. Every turn of a loop sends the context again, and a loop can run for hours. Configs and IP addresses also cost more tokens than prose of the same length.
The controls are familiar ones. Cache what repeats. Trim what the model doesn’t need. Send easy steps to a smaller model. Put a cap on every loop.
The number to track is cost per successful task, not cost per call. A cheap model that fails half the time isn’t cheap.
Start here: Turn on usage reporting in the agent you use and read one session’s token count. Then set a budget.
Open-weight models are the ones you can download and run yourself, and Hugging Face is where they live. Think of it as the GitHub of models.
The families worth knowing include Llama, Qwen, Gemma, Mistral, Phi, and DeepSeek. A model’s card should tell you what it’s for, how it was evaluated, and how it’s licensed.
Read the license. Open-weight isn’t the same as open source. You get the weights, and the license decides what you may do with them.
This earned a place because your running configs are a map of your network. Some of you can’t send that map to anyone’s cloud. With open weights, the model comes to the data.
Start here: Pick one model family, read its card end-to-end, and note the license and the hardware it needs.
These are the tools that run a model on hardware you own. This is the home lab.
| Tool | What it is | Pick it when |
|---|---|---|
| Ollama | A command-line tool and background service that serves models on a local API | You want a local endpoint for scripts and agents |
| LM Studio | A desktop app for finding, downloading, and chatting with models, with a local server built in | You want to browse and compare models first |
| Foundry Local | Microsoft’s on-device runtime, with Microsoft Foundry as the cloud side | You’re a Microsoft shop and want one path from laptop to cloud |
All three speak the OpenAI API format. Most agent tooling can point at localhost and keep working.
GNS3, EVE-NG, and CML taught a generation of us by letting us break things for free. A local model does the same for agents. Nothing leaves the laptop, and nothing shows up on a bill.
Be honest about the trade. A model that fits on your laptop is smaller than a frontier model and does worse on hard reasoning. Your evals will tell you where that line sits for your tasks.
Start here: Install one, pull a small model, and point your read-only MCP server from chapter 6 at it.
Don’t read all 19 chapters first. Build one small, read-only agent in a lab and let it pull you through them.
If you read three chapters before you start, read 2, 6, and 13. They cover what the model is, how it touches your network, and how you know it’s right.
None of this asks you to forget what you know. It asks you to stop making it the job.
Tell me what I missed. The second edition will be vibe published too.
Primary papers and specifications are linked in the chapters. The status claims were checked against these pages in November 2026.
See how Itential connects AI reasoning to governed execution across your entire infrastructure.