About Infra Agent Skills
Teach agents how infrastructure work gets done.
Open-source skills that teach AI agents how to handle real network and infrastructure work.
Your agent can call a tool. It still needs to know what to check first, which steps to take, and how to prove the change worked. That knowledge is what a skill carries.
01What is an agent skill?
An agent skill is a packaged, reusable playbook for one kind of task. Instead of asking an agent to figure the job out from scratch every time, you hand it a procedure that already knows how the job should be done.
A skill is a folder with a SKILL.md file in it: a short header (a name, and a description of when to use the skill) followed by the instructions the agent should follow. The folder can also holdscripts/, references/, and assets/ such as templates.
A good skill carries the judgment a tool list cannot.
What a SKILL.md carries
Hover or tap a part to see it in the file.
Why it matters
The tool list says the agent can reach both the console server and the router cabled to it. The skill adds the rule between them: the console server is the way in; the router on its serial port is the target.Mix them up and the command lands on the wrong hardware.
02An open standard, not a vendor format
Agent Skills is an open format. Anthropic created it and released it as an open standard, and it is now developed in the open with contributions from across the ecosystem. It is a project of the Agentic AI Foundation (AAIF).
Because the format is shared, a skill is not tied to one product. Dozens of agent tools support it, so the same procedure can travel with your team as your tooling changes. Every skill in this directory follows the standard, with nothing proprietary layered on top.
- Claude
- ChatGPT & Codex
- GitHub Copilot
- Cursor
- Gemini CLI
- VS Code
- Goose
- OpenCode
- Itential FlowAI
- and many more
03Agent, skill, tool: what’s the difference?
| What it is | Infrastructure example | |
|---|---|---|
| Agent | The agent’s identity and standing rules: role, constraints, permissions. | “You are a network operations agent. Never push config to production without approval. Always back up a device before changing it.” |
| Skill | A packaged playbook for doing one kind of task well, loaded when the task matches. | A BGP neighbor troubleshooting skill: check session state, verify ASNs and timers, compare against the golden config, in that order. |
| Tool | A function the agent can call to take an action or fetch data. | get_device_configuration(device), run_command(devices, cmd), backup_device_configuration(device) |
The agent decides when. The skill teaches how. Tools provide access.
04How skills work
Agents load skills in stages, so they only spend context on the skill a task actually needs.
- 1Discovery
At startup the agent reads only each skill’s name and description, just enough to know when one might apply.
- 2Activation
When a task matches a description, the agent loads that skill’s full instructions.
- 3Execution
The agent follows the steps, running bundled scripts or opening reference files as it goes.
That is why an agent can keep many skills installed without slowing down or losing focus.
05Why skills matter for infrastructure
Infrastructure teams keep teaching agents the same lessons: how to reserve an IP without overlap, what to check before a device upgrade, where a firewall change can go wrong, and what proves a change worked. That knowledge is scattered across runbooks, vendor docs, scripts, and the heads of the people who get paged when things break. A tool gives an agent access to a system. It does not teach the agent a repeatable procedure.
- ConsistencyThe task runs the same tested way every time.
- Captured expertiseA senior engineer’s judgment is written down once, not locked in one person’s head.
- ComposableSkills chain together for larger, multi-step jobs.
- ReusableDefine the procedure once and use it across agents and teams.
- Less re-explainingThe skill carries the context and constraints, so prompts stay short.
06What skills can do
A few of the jobs skills can take on for network and infrastructure teams.
Provisioning
Reserve an IP or subnet without overlaps, create DNS records that follow naming conventions, and configure VLANs, BGP peers, or VPN tunnels for the target platform.
Day 2 operations
Compare running config with an approved baseline, catch expiring certificates, investigate a flapping BGP or OSPF session, and find devices nearing end of life.
Pre-change safety
Map dependent services and blast radius, confirm the change window and approvals, snapshot state, make the change, validate it, and roll back when post-checks fail.
Cross-vendor work
Start from an intent like “add this VLAN” and follow the steps for each platform. Normalize telemetry from mixed Cisco, Juniper, and Arista estates.
Cloud and Kubernetes
Build VPCs and subnets with the right security rules, set up load balancers and health checks, and scope ingress and network policy to what a workload needs.
Capacity and access
Check port availability before provisioning, and audit ACL and firewall rules against policy to flag ones that are too broad or unused.
These show the range skills can cover, not a list of what is in the directory today. Browse what’s available.
07Using skills from this directory
Skills here come from many contributors and repositories, and each card shows who made it. Treat a skill like any other code you bring into your environment.
- Read before you run. Skills can include scripts and can change real infrastructure. Check what a skill does and what license it uses, and try it in a lab or non-production environment first.
- Adapt it to your environment. Connect it to your own tools, permissions, approval steps, and naming conventions.
- Keep it current. Skills live in version control. Pin the version you tested and watch the source for fixes.
08Give back
No single team has seen every vendor quirk, change window, or failure mode. The library gets better when the people who run these systems share what they learn.
- Found a fix? Send it upstream. If you hit an edge case, a vendor quirk, or a wrong step, open an issue or pull request on the skill’s own repository instead of keeping a private fork. Skills listed from other repos belong to their authors, so contribute there.
- Keep credit and license. When you adapt a skill, keep the original author and license, and add your name to what you changed.
- Keep it clean. Never commit credentials, customer data, internal hostnames, or real IPs. Use placeholders and example values.
- Small and focused. One skill should do one job well. Write a clear description of when to use it, because that is what the agent matches on.
- Show your work. Note the platforms and versions you tested on, and what proves the change worked.
- Be kind in review. Everyone’s infrastructure is different, and every contribution is someone’s hard-won lesson.
Built by the people who run infrastructure.
Open to everyone building agents for it.
Use a skill. Make it better. Share it back.