...
Itential Platform Pricing Explore flexible plans and options for your team
Itential logo
Blogs

What Excites Me About Infrastructure Agent Skills

Headshot of John Capobianco, Head of AI and Developer Relations at Itential, helping organizations adopt AI safely in network automation with deep experience across enterprise, government, and cloud networking.
John Capobianco
Head of AI & Developer Relations
Last updated November 16, 2026

Key Takeaways

    • MCP tells the agent what it can do. A skill tells it what it should do, in what order, and what the evidence actually proves.
    • Skill sprawl is the new script sprawl. The fix is not fewer skills. It’s better-shaped ones.
    • A skill carries the judgment a tool list cannot.
    • The vendor changes. The operation doesn’t.
    • Skills tell the agent what to do. A platform governs how it happens.
    • Your best runbook is most of a skill. It just hasn’t been written for an agent yet.

Chris Wade already wrote the big-picture post on where agentic infrastructure is headed and why open skills matter for the whole industry. This post is the other half of that story. It’s what infra agent skills look like from the keyboard, written by someone whose agents touch real routers every day.

Here’s my confession. I have not hand-written a line of code since February 2026, and I am shipping more network automation now than I did in 15 years as a network engineer. The model is not the reason. The reason is a folder with a file called SKILL.md in it.

I have written dozens of these skills. I wrote the pyATS skills. I contribute to Itential’s open source infra-agent-skills repository. This post is about why that work excites me, what I’ve learned building it, and why I think every network engineer should write at least one skill this year.

Models got smarter. Skills made them useful.

Tools Gave Agents Hands. Skills Gave Them Judgment.

I came to this the long way. I spent 15 years as a network engineer, first at Empire Life and then as a Senior Architect for the Parliament of Canada. The tool that rewired how I think about networks was pyATS: show commands in, structured data out, snapshots you can diff before and after a change.

When large language models showed up, I followed the same progression a lot of you are on right now:

  • RAG (2023 to 2024) grounded the model in real documentation, so it stopped guessing about RFCs and config guides.
  • Model Context Protocol (MCP) servers (2025) gave the model tools with determinism, control, and scope. My first ones wrapped pyATS, NetBox, and ACI, and they were read-only first.
  • Agent-to-agent delegation and agent harnesses (2025 to 2026) let one agent hand work to another and let me pick the right model for each job.
  • Loops and specs (2026) gave the agent a definition of done, so it could iterate until the work was verifiably finished.

Somewhere around step two, I hit a wall every network automation engineer will recognize.

Why Skills Matter

The Gap Skills Fill

An agent with 40 MCP tools and no method is a junior engineer with enable access and no runbook. It knows every command. It does not know which one to run first, what a healthy answer looks like, or when to stop and ask a human.

That gap is exactly what a skill fills. MCP tells the agent what it can do. A skill tells it what it should do, in what order, and what the evidence actually proves.

I learned the other half of the lesson the hard way. When I built NetClaw, my open source network engineering agent, it had 82 skills and 37 MCP server backends six days after the first commit. By September it had 237 skills, and roughly 194 of them were loading into every single turn. More skills did not make it smarter. They made it slower, more expensive, and easier to confuse.

Skill sprawl is the new script sprawl. The fix is not fewer skills. It’s better-shaped ones.

A Folder. A File. An Open Standard.

A skill is a folder with a SKILL.md file in it that teaches an agent one task, plus any scripts or reference material that task needs. That’s the whole idea, and the simplicity is the point.

Anthropic published Agent Skills as an open standard in December 2025. On October 22, 2026, it donated the standard to the Agentic AI Foundation (AAIF), the Linux Foundation home that already hosts MCP. By then more than 70 agent platforms had integrated it, including ChatGPT, Cursor, GitHub Copilot, and VS Code, with 1 million skills published and nearly 280 million installs.

  • 💡 For a practitioner, neutral governance is not a press-release detail: it means a skill I write today runs on Claude Code, Codex, Copilot, OpenClaw, or whatever harness my team picks next year.

    Write once. Run on any agent.

What the spec actually asks for

The Agent Skills specification is short enough to read over coffee. A SKILL.md opens with YAML frontmatter that has two required fields:

  • name: up to 64 characters, lowercase letters, numbers, and hyphens, matching the folder name.
  • description: up to 1,024 characters, saying what the skill does and when to use it.

Optional scripts/, references/, and assets/ folders hold everything else. The design principle that makes it all work is progressive disclosure, which loads a skill in three tiers:

  • Metadata (about 100 tokens): every skill’s name and description load at startup.
  • Instructions (under 5,000 tokens recommended): the full SKILL.md body loads only when the skill activates.
  • Resources (as needed): reference files and scripts load only when the task calls for them.

Remember my 194 skills loading into every turn? Progressive disclosure is the cure. An agent can carry hundreds of skills and pay for the dozen words that describe each one, until it actually needs one.

The anatomy of a skill

The spec defines the envelope. What goes inside is where the craft lives. In my AutoCon 6 talk, I break a good skill into five parts:

  • Purpose: the one question the skill answers.
  • Tools: which MCP servers or tools it may call, and which it may not.
  • Method: the order of checks an expert would run.
  • Guardrails: read-only by default, with writes behind an approval.
  • Output: what the evidence does and does not establish.

My favorite example is an out-of-band skill for Lantronix gear. It binds two MCP servers with 37 tools each: one for fleet-wide, asynchronous work and one for a single device, synchronously. The tools are not the valuable part. The valuable part is one routing rule: the console server is not the router on its serial port, and if you confuse them, your command lands on the wrong hardware.

No tool schema carries that sentence. A skill does. A skill carries the judgment a tool list cannot.

My pyATS Skill Got Cut From 10 Capabilities to 2. It Got Better.

The pyATS skill is the one I’m proudest of, partly because of how much of it got thrown away.

It started in my own repo, automateyournetwork/pyATS_skills. The goal was simple: teach any coding agent to use pyATS and Genie correctly instead of hallucinating flags from a 2019 blog post. It covers 17 topics, from testbeds and secret strings to learn, parse, AEtest, Blitz, Clean, mock devices, and health checks. Today it ships as one pyats skill whose SKILL.md carries the core concepts and decision logic, then routes to 21 focused reference files that load only when the task needs them.

A few principles held up well:

  • Generic, not wrapped.
    The skill teaches pyATS itself, so it works with any MCP server, script, or CLI.
  • Credentials never hardcoded.
    Every path to a device goes through pyATS secret markup.
  • Destructive means destructive.
    Clean gets the same caution as rm -rf: confirm scope before running.
  • Diffs need exclusions.
    Counters and uptime will fail every comparison unless the skill says how to handle them.

Then I brought it to Itential’s infra-agent-skills repository. On October 9, 2026, my pull request added pyATS coverage across 10 new capabilities and 2 existing ones. I was pretty pleased with myself.

Three days later, Joksan Flores reworked it. He kept two capabilities, network-state-collection and network-health-verification, and removed the rest. His reasons were blunt and correct:

  • A generic “send these commands” skill adds nothing a capable agent lacks.
  • A device-reprovisioning skill that hands the real procedure back to the caller is a wrapper, not a skill.
  • pyATS is a test framework, not a container platform, so it has no business inside a container deployment skill.

That rework also added two new rules to the repo’s AGENTS.md contribution contract. Rule 13 is an applicability screen with a quick test I now apply to everything I write: remove the skill, and ask whether a capable agent with the vendor’s own documentation would do the job worse or less safely. If not, the skill does not belong. Rule 14 defines how a tool, SDK, or MCP server can sit underneath a capability as a “vendor,” as long as the capability still makes sense with the tool removed.

That was the best code review I’ve had in years, and it taught me the difference between a tool manual and a skill.

My pyATS_skills repo is a tool manual, and it’s genuinely useful when an agent is writing pyATS code. Infra-agent-skills teaches an agent an operation, like collecting network state before and after a change, and pyATS is one way to do it.

Here’s the payoff. Once network-state-collection was shaped around the operation instead of the tool, other tools fit underneath it. Ankit Bhansali added IP Fabric and Forward Networks. I added Arista CloudVision, Zabbix, Auvik, and Cisco ACI APIC. The capability now routes to 9 tool references, and its SKILL.md stayed a thin, stable router the whole time.

The judgment survived the refactor, too. The pyATS procedure now stops for operator confirmation before any live connection, because Unicon’s connection setup can run configuration commands even when your intent is read-only. It also treats a parser error or an empty result as incomplete data, never as a healthy network. Those two sentences have saved me more grief than any tool I’ve written.

I shipped 10 capabilities. The architecture kept 2. Both are better than anything I had.

What Actually Excites Me

I get asked some version of “why do you care so much about markdown files?” at every event. Here’s the honest answer, one reason at a time.

Before skills With infra agent skills
Every agent re-derives the procedure from raw API docs The procedure is written once, reviewed, and reused
Expertise lives in one senior engineer’s head Expertise lives in a versioned file anyone can read
Safety depends on the prompt remembering to ask Confirmation gates are written into the step itself
A new vendor means a new agent A new vendor means a new reference file
“It worked on my harness” One open standard, any harness

1 // Capability first, vendor second

The repo is organized by operation, not by vendor. A DNS record is a DNS record whether it lives in Route 53, Infoblox, or Cloudflare, so dns-record-management is one skill with 10 vendors underneath it. Across the repo, that’s 40 capabilities carrying 153 vendor references.

Multi-vendor is the reality of every network I’ve ever run. A skill shaped this way means my method survives the next platform migration. The vendor changes. The operation doesn’t.

2 // Judgment becomes portable

These skills are plain markdown. There’s nothing to compile and nothing to pip install. Drop a capability folder where your harness looks for skills, and if your harness has no skills folder at all, paste the SKILL.md into context and add references as the task needs them.

That portability is what the AAIF standard buys us. I spent years writing automation that only ran on one platform. Now the most valuable thing I write, the method, runs everywhere.

3 // Guardrails live in the skill, not in someone’s memory

Every step that deletes, overwrites, reloads, or touches production carries its own “stop and confirm with the operator” gate, written directly into that step. It is not left for the calling agent to infer. One of my own merged fixes added exactly those gates to ServiceNow approve, reject, and state changes in change-management.

Agents follow what is written. So we write the gate down.

4 // Grounded in vendor documentation, with unknowns labeled as unknown

The contribution rules require every fact to come from the vendor’s own approved documentation, restated in the contributor’s own words, with citations and retrieval dates. If the source is silent on a timeout or a rate limit, the skill says so explicitly instead of inventing a plausible number. Assumptions are marked as assumptions, right next to the detail.

As someone who has debugged plenty of confidently wrong runbooks, I find this the most quietly radical part of the project. A skill that admits what it doesn’t know is a skill I trust in production.

5 // Skills are treated as an attack surface

Here’s the uncomfortable truth: Anyone who can get text into a merged procedure can instruct every agent that later runs it.

The repo says that out loud. Reviewers treat “does every step trace back to the cited vendor source?” as a security check, not just an accuracy check, and the project documents how to report suspected prompt injection in merged content.

Most skill libraries I’ve seen don’t think about this at all. This one was built around it from week one.

6 // Skills tell the agent what to do, a platform governs how it happens

A skill is a method, not an execution engine. In my own work, NetClaw reasons with skills and then drives the Itential Platform through the Itential MCP Server, so the change itself runs as a governed, audited job with RBAC and approval gates. That split matters when an agent is about to touch a production router.

AI adds reasoning. Itential adds the guardrails.

7 // Practitioners finally get to contribute expertise, not code

This is the one that gets me most. You don’t need to be a developer to write a great skill. You need to know the right order to check things, what a healthy result looks like, and when to stop and call a human. Every senior network engineer I know has that in their head already.

Your best runbook is most of a skill. It just hasn’t been written for an agent yet.

  • 💡You don’t need to be a developer to write a great skill.

    You need to know the right order to check things, what a healthy result looks like, and when to stop and call a human. Every senior network engineer I know has that in their head already.

Your best runbook is most of a skill. It just hasn’t been written for an agent yet.

Inside infra-agent-skills

As of today, infra-agent-skills holds 40 capabilities and 153 vendor references, licensed Apache 2.0 and built in the open since September 10, 2026. The architecture is Joksan Flores and Ankit Bhansali’s, and it’s the reason the rest of us can contribute fast without making a mess.

One quick distinction, because people mix them up. Itential Builder Skills teach a coding agent to build on the Itential Platform. Infra-agent-skills is vendor-neutral and framework-agnostic: it teaches any agent how to run an infrastructure operation, on any platform, in any harness.

Every capability has the same shape:

skills//
├── SKILL.md              # thin, stable router
└── references/
    ├── INDEX.md          # vendor -> directory -> scope -> notes
    └── /
        ├── procedure.md  # the step-by-step: sequence, gates, success criteria
        └── endpoints.md  # the wiring: API routes, CLI, or MCP tool names

Three design choices make this work in practice:

  • SKILL.md almost never changes.
    It changes for exactly two reasons: fixing its shared concepts, or adding a pointer to a new vendor. Every vendor-specific fact lives in that vendor’s own reference files. Adding Zabbix did not risk breaking pyATS.
  • Procedures speak in operations, not wire calls.
    A procedure says “update the change request record.” The literal HTTP route, SDK call, or MCP tool name lives in endpoints.md, the binding layer. At runtime the agent follows the procedure and resolves each step to a tool it actually has. If no binding exists, it reports that instead of improvising a call.
  • The spec is enforced, not admired.
    Every pull request is checked automatically against the AAIF limits: a name of 64 characters or fewer matching its folder, and a description of 1,024 characters or fewer. Reviewers then hold each SKILL.md under about 500 lines and 5,000 tokens.

Only the catalog is always in context. Everything below it loads when a task calls for it, and a step with no tool binding gets reported, never guessed.

The 40 capabilities span the whole operations estate, not just the network:

Category Capabilities Examples
Network 13 software-upgrade-lifecycle, routing-troubleshooting, network-state-collection, sdwan-site-onboarding
Security 9 firewall-management, secret-retrieval, certificate-management, vulnerability-lookup
DDI 4 dns-record-management, dns-zone-management, ipam-allocation, dhcp-scope-management
ITSM 4 change-management, incident-management, cmdb-asset-management, dcim-asset-management
Observability 3 alert-monitor-management, metric-query, log-query
Automation 3 automation-job-execution, infrastructure-plan-execution, repository-pull-request-management
Compute 2 compute-instance-provisioning, container-workload-deployment
Collaboration 2 notifications, crm-contact-management

Categories come from the repo’s own CATALOG.yaml, which also feeds a public skills website.

  • 💡 The point is not the count. The point is that an agent can carry all 40 descriptions in its catalog for a few thousand tokens, then load only the one vendor procedure a task needs.

That’s progressive disclosure doing exactly what NetClaw’s monolith couldn’t.

Start With One Skill. Then Write One.

You can have a skill working in your agent in minutes, and you don’t even need the whole repo. A sparse checkout pulls down only the capability you name:

git clone --depth 1 --filter=blob:none --sparse https://github.com/itential/infra-agent-skills.git
cd infra-agent-skills
git sparse-checkout set --no-cone skills/network-state-collection

For Claude Code, copy or symlink that folder into .claude/skills/ for one project, or ~/.claude/skills/ for all of them. No git? Download the ZIP from GitHub and copy the capability folders you want. Other harnesses work the same way: put the folder wherever your agent looks for skills.

Then write your own. Here’s the path I follow now:

  • Pick a runbook you trust.
    Something you’ve run a hundred times and could teach a new hire, like a pre-change state capture or a BGP neighbor check.
  • Apply the anatomy.
    Write down the purpose, the tools it may call, the order an expert checks things, the guardrails, and what the output does and does not prove.
  • Run the applicability test.
    Remove the skill. Would a capable agent with the vendor’s own docs do worse or less safely? If not, you’ve written a tool manual. Keep going until the answer is yes.
  • Find the capability it belongs to.
    Most new work is a new vendor under an existing capability, not a new skill. Fold it in rather than adding a sibling.
  • Point your coding agent at AGENTS.md before it writes a word.
    It’s the contribution contract: sourcing, shape, gates, and the review checklist. Yes, I use an agent to write skills for agents.
  • Validate and open the pull request.
    Run the spec’s skills-ref validator and the repo’s own checks, then sign the CLA and open the PR.

Already publishing infrastructure skills in your own public repo? You don’t have to move them. A catalog-only pull request lists your skill on the skills website, while the skill itself stays in your repository under your license. Check out the full contribution guide here.

And if you want to talk shop, find me in the VibeOps Forum on Slack. Bring your runbooks.

The Models Will Keep Changing. The Method Is Yours.

Chris’s post explains why open skills matter to the industry. From the keyboard, it comes down to this: the best thing I know about running a network can now be written once, reviewed by people who are better at this than I am, and run by any agent on any platform, with the guardrails written into the step itself.

A year ago, at AutoCon 4, I had a pile of MCP servers and an agent that knew every command and no method. Today the method is a folder. It’s open, it’s governed by a neutral foundation, and it gets better every time someone like Joksan tells me my pull request is a tool manual.

So here’s my ask. Pick one runbook this week. Write one skill. Open one pull request against infra-agent-skills. I’ll be watching for it.

Models get smarter every quarter. Your expertise is what makes them safe to use.

Headshot of John Capobianco, Head of AI and Developer Relations at Itential, helping organizations adopt AI safely in network automation with deep experience across enterprise, government, and cloud networking.
John Capobianco is the Head of AI & Developer Relations at Itential, and a technology leader, developer advocate, and builder at the intersection of AI and network automation. With a career spanning enterprise, government, and cloud networking, John has held roles including Head of Developer Relations at Selector AI, where he focused on AI-driven observability, configuration intelligence, and autonomous network operations, as well as Cisco AI Technical Leader and Senior Network Architect for the Parliament of Canada / House of Commons. He brings deep, hands-on experience applying automation and AI in highly regulated, mission-critical environments. His work centers on helping large organizations adopt AI safely while maintaining reliability, security, and operational trust. John is a former professor at St. Lawrence College, an author, speaker, and educator. He is the author of Automate Your Network (self-published, 2019) and the Cisco Press pyATS book (2024). He regularly shares insights through talks, workshops, and the Automate Your Network brand, with a focus on practical, production-ready AI, developer empowerment, and the evolution of network engineering in an AI-first world.
Keep Learning

The Latest in Agentic Operations

Get Started

Agentic infrastructure operations starts here.

See how Itential connects AI reasoning to governed execution across your entire infrastructure.