Part II

Labs

Every lab here ships with something you can test in your lab today. They build on each other, and they all run against the same small Cisco lab: two routers and a switch in Cisco Modeling Labs. Cisco's free version (CML Free) runs it.

No lab needed You don't need the lab to start. Steps 0 and 1 run without one.

Already scripting?

Already scripting with Netmiko and running a lab? Start at Step 6, where the model gets read-only access to your devices through MCP.

starter lab · Cisco Modeling Labs3 devices
Starter lab topology edge-rtr-01 connects to core-rtr-01, which connects to access-sw-01, which connects through the External Connector to your home network. Eth0/0Eth0/1 Eth0/0Eth0/0 Eth1/0 edge-rtr-01 core-rtr-01 access-sw-01 routerrouterswitch to yournetwork
The starter lab every step below runs on. Cisco's free CML runs it.
No lab needed

Step 0: Got told to use AI? Get one safe win in ten minutes

You end with
a handoff doc for a real router, drafted by AI and checked by you.
Needs
a browser and any AI chat tool. No lab, no install.
Time
about ten minutes

Paste my documentation prompt and the core-rtr-01 config into any AI chat tool, then check what it wrote against the config. The config is from my home lab and it's public on GitHub, passwords and all, so it's safe to paste. Your own configs aren't, so those stay in your company's approved tool.

documentation handoff prompt
You are documenting a network device for an engineer handoff. From the
following running configuration, produce:
1) an interface table (name, IP, mask, description, state),
2) a routing summary (protocols, router-id, networks, passive interfaces),
3) a list of configuration risks or oddities worth an engineer's attention.
Config follows:

[PASTE RUNNING-CONFIG HERE]
No lab needed

Step 1: Run the same prompt on your own machine

You end with
a local model that documents a config without anything leaving your laptop.
Needs
Ollama, and enough memory for the model (the runbook helps you size it). Python 3.10 or newer only for the optional test scripts. No lab.
Time
about an hour

This is the one for shops that won't let you paste configs into a cloud tool. The runbook also shows you how to check that nothing leaves the machine, so you don't have to take my word for it.

Step 2: Build the lab

You end with
two routers and a switch in CML Free that answer SSH from Python on your machine.
Needs
CML Free (free Cisco.com account, five running nodes, and my lab fits), VMware or a spare box to run it, WSL2 on Windows or a Mac, Python, and Netmiko.

This is the setup every later step runs against. The lab files match my lab exactly, same hostnames and same lab credentials, so the scripts in the next steps run without editing.

Step 3: Prove the lab works

You end with
a Python script that logs into your lab devices and prints their interfaces.
Needs
the Step 2 lab, Python 3, and Netmiko.

Two short scripts, one device and then several. If these run, everything after this point will too.

Step 4: Turn device output into documentation

You end with
structured docs for your lab, built from live device output, with your secrets redacted before the AI sees anything.
Needs
the Step 2 lab, Python 3.8 or newer, WSL2 or Linux or a Mac.

Five small scripts: collect, redact, build the prompt, restore, and draw a diagram. The redactor is the never-paste rule written as code.

Step 5: One command, SSH to runbook

You end with
one script that goes from SSH to a finished, AI-written runbook with no copy and paste.
Needs
the Step 2 lab, Python 3.8 or newer, and an AI API key.

Same job as Step 4, with the browser chat taken out. The script calls the model through its API.

Step 6: Give the model read-only access with MCP

You end with
Claude running show commands against your lab through a read-only MCP server, and reading the real output.
Needs
the Step 2 lab, Python 3.12 or newer, uv, and Node.js.

This is where the model stops guessing from what you pasted and reads the real network. Read-only, on purpose.

Step 7: A local agent with one write tool

You end with
a local AI agent wired to a router with one write tool, and a clear answer on what decides whether that write runs.
Needs
a machine that runs a tool-calling local model (I measured it on an M3 Max with 64 GB). That's a real hardware wall, so check it first.

Two local agent harnesses, one write tool, and the three guardrails that held. In one app, the approval prompt wasn't where I expected.

Step 8: A bounded agent that can't touch prod without you

You end with
an agent that audits the lab, finds a real CVE, writes the fix with a rollback, and waits for a named human to approve it.
Needs
the Step 2 lab, Python 3.11 or newer, and Claude Code. NetBox is optional.

The capstone. It isn't finished: the approver's name comes through the model, so it enforces the process, not who you are. The write-up says so.