Most of what NetClaw does, it does through APIs — gNMI, REST, NETCONF, GraphQL. That’s the right way to automate a network: structured, auditable, repeatable. But real networks are messy, and not everything worth touching has a clean API behind it. Some of the most useful information lives behind a login screen in a vendor’s web dashboard. Some of it lives in an old desktop application that has never had an API at all. So over two features, I gave NetClaw a way to reach both.

Part 1: Teaching NetClaw to Drive a Browser

SDN controllers, in particular, have a habit of putting real operational data — bridge domain status, tenant health, a specific alarm — behind a GUI-only report that the REST API simply doesn’t expose. You can see it in the dashboard. You can’t query it. That’s the gap Chrome DevTools MCP closes.

I integrated the official chrome-devtools-mcp server (built by the Chrome DevTools team) and wrote a skill, browser-gui-inspect, with one non-negotiable rule: read, confirm, and search only — never submit a configuration change. If a task needs to actually change something, that belongs to NetClaw’s proper API-based skills, with their observe → baseline → modify → verify workflow and ITSM change-request gating. The browser is for reading what the API won’t show you, not for sneaking a config push around the guardrails.

The part I actually wanted, though, was Watch Mode. By default the browser runs headless — no visible window, just NetClaw reading the page. But say the word, and NetClaw spins up a real, visible Chrome window instead — wherever NetClaw happens to be running. Ask it over Slack to log into a demo NetBox instance and create a new site, and you can watch it happen, live, click by click. It’s the difference between trusting a report and watching the work.

Getting there took a real bug fix, too — running this live, NetClaw hit a wall because Chrome wasn’t installed in the path the tool expected. Rather than patch around it once, I built Chrome provisioning directly into the installer, so it self-heals on any machine — Linux, WSL2, or Mac — without anyone needing to know where Chrome “should” live.

Part 2: Teaching NetClaw to Drive an Entire Desktop

Browser control solves the web-GUI gap. But some of the oldest, most stubborn tooling in networking and security has no web GUI and no API — just a native desktop application. A legacy Java-based NMS client. A vendor’s Windows-only configuration utility. A terminal emulator with no scriptable interface at all. Browser automation can’t touch any of that, because there’s no browser involved.

That’s where Computer Use comes in — OpenClaw’s own full-desktop automation capability. Instead of a browser, NetClaw now gets a real virtual desktop: Xvfb and XFCE running headlessly on the NetClaw host, driven by xdotool for real mouse movement, clicks, drags, keyboard input, and screenshots. Seventeen actions in total. It’s the same idea as browser control, one layer down the stack — instead of controlling one application (Chrome), NetClaw controls the whole screen.

I wrapped this in a new skill, desktop-gui-inspect, with the exact same golden rule as its browser sibling: reading and confirming state only, never a side door around the real change-management workflow. And it gets the same Watch Mode, too — a VNC/noVNC live-viewing service so an operator can watch NetClaw operate the virtual desktop in real time, or take over the mouse and keyboard themselves if a step needs a human (an interactive first-run license dialog, say).

Building this one live surfaced two real bugs before they ever shipped. First: the virtual desktop’s live-viewing service, by default, listens on every network interface — not just localhost. That’s full desktop control exposed to anyone who can reach the port. I caught it with a plain ss -tlnp check during testing, and the installer now locks it to loopback-only automatically, verifying the fix on every install rather than just hoping it stuck. Second: the installed skill’s own action scripts weren’t executable out of the box — every single click or keystroke failed with a permission error until that got fixed too. Neither of these is a hypothetical “best practice” — they’re bugs a live desktop, with a real terminal window and a real typed command, exposed in the first ten minutes of testing.

The Pattern

Two features, one shape: give NetClaw a controlled way to see something the APIs can’t reach, make sure it can never use that access to make an unaudited change, and always give the human a window to watch — or take the wheel. Browser control and desktop control aren’t a replacement for API-driven automation; they’re the fallback for when a legitimate answer only exists on a screen, wherever that screen happens to live.

The Achievement

NetClaw — my AI network engineer — just gained a body. Not a metaphorical one. A literal, walkable, three-dimensional one, built inside Unreal Engine 5.8.

Here’s what that actually means: I pointed NetClaw at a real lab running in Cisco Modeling Labs (CML). NetClaw used pyATS to gather live device state from that lab — the routers, the switches, the links between them, their health. Then, using nothing but the Model Context Protocol (MCP) and Unreal Engine 5.8’s own built-in MCP server, NetClaw reconstructed that exact topology as a fully rendered 3D scene — devices as objects in space, links as glowing connections, colors mapped to device type and health, laid out automatically with a force-directed algorithm and centered on the map.

No human touched a single actor in the scene. No one dragged a node, ran a cable, or set a color. NetClaw talked to three separate systems — CML, pyATS, and Unreal Engine — over MCP, and built the world itself.

This is a new composable skill for NetClaw: ue5-network-viz. And it’s not a one-off demo — it’s a reusable pipeline. Any topology NetClaw can see through CML, pyATS, gNMI, SuzieQ, or any of its other network-data MCP servers can now be rendered as a living 3D scene in Unreal Engine.

Why This Matters — The Bigger Picture

Network diagrams have looked the same for 40 years: boxes and lines on a 2D canvas — a whiteboard, a Visio file, a NetBox topology view. They’re static the moment they’re drawn, and they go stale the moment someone racks a new switch or re-patches a link. We’ve been representing something inherently physical and spatial — racks, cables, rooms, buildings, campuses — as flat, lifeless diagrams.

That’s what changes here.

Once a network exists as real objects in 3D space instead of shapes on a page, a whole category of things becomes possible that was never possible with a flat diagram:

• Fly-throughs. Don’t squint at a topology export — fly through your network like a level in a game, camera gliding between core, distribution, and access layers.
• Live traffic flow visualization. Imagine packets rendered as moving light along the links, real interface utilization shown as flow intensity, congestion visibly building on a saturated trunk in real time.
• Color and light as telemetry. Device and interface health rendered as actual color and glow in a 3D scene instead of a row in a spreadsheet or a red dot on a dashboard.
• Rack and elevation views, to scale. Generate an accurate 3D rack elevation automatically from live inventory data — see exactly what’s mounted where, without opening a spreadsheet.
• Walkable wire maps. Every cable, every port, spatially accurate and traceable by literally walking along it.
• First-person exploration. Drop into first-person view and stand inside your own network — walk the server room, walk the campus backbone, walk a topology that doesn’t even physically exist yet because it’s still in a lab.

And critically — this doesn’t stop at lab environments. The exact same pipeline that rebuilt this CML lab as a 3D world can rebuild a real, production network the same way: pull live state from real devices, and render a true 3D digital twin of a real data center, campus, or site. Virtual labs and real infrastructure become the same kind of object once they’re described the same way — as data flowing through MCP into a 3D engine.

We are not far from the point where “monitoring the network” means literally walking through it.

---

For the Technically Curious — Hurdles Faced

I want to be upfront about something before diving into the technical details: this took longer than it should have, and it wasn’t because the integration itself was hard. It was because I was building this on a PC that started showing real instability under the combined load of Unreal Engine 5.8, live rendering, and an AI agent hammering it with MCP tool calls. This is a heavy workload — a full game engine, a live editor session, real-time actor spawning and transform updates, screenshot capture, all while a separate process (NetClaw) is issuing dozens of MCP calls per topology build. My machine crashed, repeatedly, mid-build, more than once wiping out an in-progress scene and forcing a full restart of both Unreal Engine and the session. If you attempt this yourself, budget real headroom on GPU and system stability — this is not a lightweight integration to run on marginal hardware.

Setup, Step by Step

For anyone who wants to reproduce this, here is the exact order that worked:

1. Create an Epic Games account and install the Epic Games Launcher. This is the gate to everything else — Unreal Engine itself is distributed through the launcher, not as a standalone installer.
2. Download and install Unreal Engine 5.8 through the launcher. This is a large install — allow real time and real disk space for it.
3. Install the MCP Plugin — and note, there are two of them. Unreal Engine’s plugin ecosystem currently has more than one MCP-related plugin available; make sure you install the one that exposes the actual ModelContextProtocol server subsystem (the built-in MCP integration), not a third-party alternative with different tool coverage. Enable it from Edit > Plugins inside the editor and restart when prompted.
4. Find “All Tools” in the plugin’s settings and enable it for full Read/Write access. By default, the MCP plugin exposes a curated, limited subset of tools. There is a specific “All Tools” toggle that unlocks the entire tool surface — all 55 tools — with read/write access, instead of a read-only or partial subset. Without flipping this on, most of what NetClaw needed to do (spawning actors, setting transforms, applying materials) simply is not available to call.
5. Start the MCP server from the in-editor console with:

   ModelContextProtocol.StartServer

   Which produces output like:

   LogModelContextProtocol: Starting MCP server on port 8000 (override with -ModelContextProtocolPort=N).
   LogModelContextProtocol: Warning: Data transmitted via this plugin to your connected LLM service is Licensed Technology under the UE EULA. You are responsible for ensuring your LLM provider does not use it as training input. See Section 6(e) of the UE EULA for full terms.
   LogHttpServerModule: Starting all listeners...
   LogHttpServerModule: All listeners started

   That EULA warning is worth actually reading — it’s a real legal note about how data flowing through this plugin to your LLM provider is treated, not boilerplate to skip past.

The Real Bugs — What Actually Broke, and Why

Once the server was up and NetClaw could talk to it, the real work started, and it surfaced a run of genuine bugs that no amount of reading documentation would have caught — they only showed up under live, repeated use against real UE5.8 builds:

• Tool-calling convention was wrong. The obvious assumption — call tools using a fully-qualified toolset.method_name string — silently failed. Some builds only accept the short tool name. Worse, the failure came back looking like a generic “Unknown tool” response that could be misread as a successful no-op rather than a hard failure, so the very first version of this integration was quietly failing every call while reporting green.
• Batch scripting isn’t universal across UE5.8 builds. The fast path for building a topology was supposed to be a single batched execute_tool_script call that spawns every actor at once using Python inside Unreal. On some UE5.8 builds, that path is locked down and forbids import unreal inside the script entirely — the fast path simply cannot run. The fix was to detect that failure mode and fall back automatically to a slower, proven per-actor build path, rather than assuming one code path works everywhere.
• The HTTP transport would hang on a connection that was already done. Some MCP responses come back over a Server-Sent-Events stream that stays open as a keep-alive even after the real answer has already arrived. The original client waited for the entire HTTP body to close before returning — which meant it could sit there for the length of a full timeout even though the actual answer showed up in under half a second. The fix was to read the stream line by line and stop the instant a complete JSON-RPC object is seen, rather than waiting for the connection itself to close.
• Setting a transform could silently wipe fields you didn’t touch. Calling the actor-transform tool with, say, only a new scale value, could reset that actor’s location back to the world origin on some builds — despite the tool’s own documentation claiming untouched fields are left alone. The only safe pattern found was to always pass location, rotation, and scale together, every single call, never partially.
• Nothing re-centered the topology as a whole. The force-directed layout algorithm kept individual nodes from overlapping and kept them within bounds, but nothing corrected the topology’s overall center of mass — so a build could quietly drift off the map origin over successive layout passes. A centroid-correction step after layout fixed this.
• A false-positive success check. A verification step used a pattern like sum(device_counts) or len(expected_specs) — which is a classic Python trap: if the real count comes back as zero (a genuine failure), the “or” silently falls back to the expected count and reports success anyway. Removed the fallback so a real zero stays a real, visible zero.
• Some tool responses come back as strings, not structured data. The tool for finding existing actors in the scene returned a raw JSON string instead of an already-parsed list/dict on certain builds — meaning code that expected to iterate a list would instead iterate the characters of a string. The client now tolerates both shapes.
• The package’s own import chain was broken from day one. Every submodule inside the skill used plain absolute imports, while the package’s own __init__.py used relative imports — meaning the documented entry point, from workspace.skills.ue5_network_viz import ..., had never actually worked, in any prior session, before this pass. Fixed with a dual-mode import shim and verified both the package-style and path-style import actually succeed.

None of these are exotic bugs. They’re the ordinary, unglamorous cost of integrating against a real, evolving third-party plugin surface rather than a stable, versioned API — and every one of them only became visible by actually running the thing against a live editor, over and over, through crashes and restarts, until it worked cleanly end to end.

From Lab to Your Own Setup

If you’re running NetClaw already and want this capability, there are two paths in:

• Existing installs — pull the update and run the UE5 patch installer, which drops the new ue5-network-viz skill and MCP server registration into your existing NetClaw workspace without touching anything else.
• Fresh installs — it’s included by default; just make sure you complete the Unreal Engine 5.8 setup steps above first.

Either way, the remaining steps are the same: fill out the UE5_MCP_URL entry in your .env file (defaults to http://127.0.0.1:8000/mcp, matching the port the editor’s MCP server starts on), make sure Unreal Engine 5.8 is running with the MCP server started, and you’re ready to interface with it directly through NetClaw.

From there, it’s just another composable skill. Ask NetClaw to pull a topology from CML and pyATS and render it in Unreal Engine, and it chains the calls itself — gather state, lay out the graph, spawn the actors, apply the materials, frame the camera, and hand you back a live 3D scene built from real data. The same composability that lets NetClaw chain gNMI, SuzieQ, GitLab, or PagerDuty into a single conversation now extends into a full 3D engine.

What’s Next

This is Day 1 of representing networks in three dimensions instead of two. Traffic-flow visualization, live health-driven color and light, automatically generated rack and elevation views, walkable wire maps, first-person exploration of your own infrastructure — all of it sits on top of the same foundation shipped here. The hard part — proving an AI agent can reliably drive a real 3D engine over MCP, using real network state, with zero human placement — is done.

I’m genuinely proud of this one. Full code and the incident log of every bug above is in the pull request on GitHub.

What how it was made here:

NetClaw + IP Fabric: Network Assurance Meets AI-Powered Automation

I’m thrilled to announce a new integration that brings IP Fabric’s powerful network assurance capabilities directly into NetClaw through the official IP Fabric MCP Server. This integration represents a collaboration nearly a decade in the making.

A Partnership Built on Trust

This integration was developed in collaboration with Daren Fulwell, Field CTO at IP Fabric, and myself. Our professional partnership spans almost a decade, and this feature represents the culmination of countless conversations about how AI can transform network operations.

What is IP Fabric?

IP Fabric is a network assurance platform that automatically discovers, models, and analyzes network infrastructure. It provides:

• Automated Discovery – No agents required, IP Fabric discovers your entire network
• Mathematical Verification – Intent-based validation ensures your network matches your design
• End-to-End Path Analysis – Trace any path through your network with visual diagrams
• Historical Snapshots – Compare network state over time for drift detection

What’s New in NetClaw?

The IP Fabric MCP integration adds 10 new tools to NetClaw’s arsenal:

Health Assessment

• ipf_network_health_assess – Comprehensive network health overview including snapshot freshness, intent verification, device issues, and routing stability

Path Analysis

• ipf_pathlookup_unicast – Trace forwarding path between any two IPs
• ipf_pathlookup_host-to-gateway – Trace host to its default gateway
• ipf_pathlookup_multicast – Trace multicast distribution paths

Visual Diagrams (PNG)

• ipf_png_pathlookup_unicast – Unicast path as visual diagram
• ipf_png_pathlookup_host-to-gateway – Host-to-gateway path diagram
• ipf_png_pathlookup_multicast – Multicast path diagram

API Discovery

• ipf_api_endpoint_search – Find API endpoints using natural language
• ipf_api_endpoint_details – Get endpoint parameters and response schema
• api_invoke – Execute arbitrary API calls

Natural Language Queries

With this integration, you can ask NetClaw questions like:

/ipfabric check network health
/ipfabric show path from 10.0.1.5 to 10.0.2.10 with diagram
/ipfabric show BGP neighbors not in Established state
/ipfabric are there any intent violations
/ipfabric show all Cisco devices in site HQ

NetClaw translates your intent into the appropriate IP Fabric API calls and presents the results in a human-readable format.

Getting Started

For New NetClaw Users

During installation, simply answer "y" when prompted:

./scripts/install.sh
# ...
Enable IP Fabric Integration? [y/N] y

For Existing Users

Run the dedicated enablement script:

./scripts/ipfabric-enable.sh

The script will:

1. Check prerequisites (Node.js, npx)
2. Prompt for your IP Fabric credentials
3. Test connectivity
4. Configure the MCP server automatically

Cross-Platform Composition

One of the most powerful aspects of this integration is how IP Fabric data can be combined with other NetClaw skills:

• IP Fabric + SuzieQ – Compare live state with historical analysis
• IP Fabric + Batfish – Validate live paths against config analysis
• IP Fabric + Check Point – Correlate network paths with security policies
• IP Fabric + CML/GNS3 – Compare production topology with lab environments

Technical Details

The IP Fabric MCP Server is built directly into IP Fabric appliances (v6.0+). NetClaw connects via the mcp-remote proxy over HTTPS, requiring only two environment variables:

• IPFABRIC_HOST – Your IP Fabric appliance URL
• IPFABRIC_API_TOKEN – API token with RBAC permissions

All queries execute against IP Fabric’s snapshot model, defaulting to the most recent completed snapshot ($last).

What’s Next?

This integration is just the beginning. As IP Fabric continues to enhance their MCP Server capabilities, NetClaw will automatically gain access to new features. We’re also exploring deeper integrations for:

• Real-time intent violation alerting
• Automated remediation workflows with ServiceNow
• Comparative analysis across multiple snapshots

Documentation

Full documentation is available:

• IP Fabric Integration Guide
• IP Fabric Skill Reference
• IP Fabric Official Docs

Thank You

A huge thank you to Daren Fulwell and the entire IP Fabric team for their collaboration on this integration. The future of network automation is AI-powered, and partnerships like this make it possible.

---

NetClaw is an open-source AI-powered network automation platform. Learn more at github.com/automateyournetwork/netclaw.

NetClaw Gets Enterprise Security with Cisco DefenseClaw

We’re excited to announce the integration of DefenseClaw from Cisco AI Defense as the enterprise security layer for NetClaw. This represents a major upgrade to our security posture, with a comprehensive, production-ready governance solution.

What is DefenseClaw?

DefenseClaw is an enterprise governance layer for OpenClaw-based AI agents developed by Cisco AI Defense. It provides:

• OpenShell Sandbox: Kernel-level isolation using Landlock, seccomp, and network namespaces
• Component Scanning: Static analysis of skills, MCPs, and plugins before execution
• CodeGuard Analysis: Detects hardcoded credentials, eval(), shell commands, SQL injection
• Runtime Guardrails: LLM prompt/completion inspection across 7 AI providers
• Tool Call Inspection: 6 rule categories (secret, command, sensitive-path, C2, cognitive-file, trust-exploit)
• Audit Logging: SQLite database with SIEM export (Splunk HEC, OTLP)

Why DefenseClaw?

Our original NetShell implementation required manual YAML policy configuration and custom Python scripts. DefenseClaw provides all this functionality out of the box:

Feature	NetClaw(Old)	DefenseClaw (New)
OpenShell Setup	Manual	Automatic
Component Scanning	No	Yes
LLM Inspection	No	Yes (7 providers)
Tool Rules	YAML files	CLI commands
SIEM Integration	No	Splunk HEC, OTLP
Webhook Alerts	No	Slack, PagerDuty, Webex

Getting Started

Fresh Installation

./scripts/install.sh
# When prompted:
# Enable DefenseClaw (recommended)? [y/N]: y

Existing Users

./scripts/defenseclaw-enable.sh

Key Commands

defenseclaw --version              # Check installation
defenseclaw skill scan <name>      # Scan a skill
defenseclaw tool block <tool>      # Block a tool
defenseclaw alerts                 # View security alerts
defenseclaw setup guardrail --mode action  # Enable blocking

Security Modes

DefenseClaw operates in two modes:

1. Observe Mode (default): Logs all security events without blocking. Perfect for onboarding and development.
2. Action Mode: Actively blocks dangerous operations. Use for production deployments.

Start in observe mode to understand your workflow’s security profile, then switch to action mode for production:

# Enable blocking mode
defenseclaw setup guardrail --mode action --restart

Compliance Ready

DefenseClaw’s audit logging supports enterprise compliance requirements:

• SOC2 Type II: Audit trail, access controls, event monitoring
• PCI-DSS v4.0: Anti-malware, audit trails, incident response
• HIPAA: Audit controls, integrity, transmission security

Export audit data for compliance review:

defenseclaw alerts --export json > audit-$(date +%Y%m%d).json

Documentation

We’ve created comprehensive documentation:

• DefenseClaw Enterprise Guide – Full technical documentation
• Security Principles (SOUL-DEFENSE) – Security posture guidance
• Upgrade Guide – Migration for existing users

Thank You, Cisco AI Defense

A huge thank you to the Cisco AI Defense team for creating DefenseClaw. This integration brings enterprise-grade security to NetClaw without requiring users to become security experts.

The combination of OpenClaw, Claude, and DefenseClaw creates a powerful, secure platform for AI-powered network operations.

---

Ready to upgrade? Run ./scripts/defenseclaw-enable.sh and enjoy enterprise security for your NetClaw deployment.

Questions? Open an issue on GitHub.

NetClaw Gets Long-Term Memory: Community Contribution Brings MemPalace Integration

One of the most exciting aspects of open source is when the community steps up and adds capabilities you didn’t even know you needed. Today we’re thrilled to announce that NetClaw now has long-term memory — thanks to a fantastic contribution from community member Satyam Thakur.

The Memory Problem

AI agents are brilliant in the moment, but they forget everything between sessions. Ask NetClaw to troubleshoot a network issue today, and tomorrow it has no memory of what you discussed, what you tried, or what worked.

OpenClaw already had short-term memory through daily log files (memory/YYYY-MM-DD.md), but these are ephemeral — yesterday’s context fades as today’s work takes over.

Enter MemPalace: A Two-Layer Memory Architecture

The new integration creates a two-layer memory system:

Layer	Purpose	Technology
Short-Term	Daily session logs	OpenClaw’s existing memory/YYYY-MM-DD.md files
Long-Term	Persistent knowledge across sessions	MemPalace MCP with temporal knowledge graphs

What is a Memory Palace?

MemPalace uses a spatial metaphor inspired by ancient rhetoric techniques. Instead of a flat search index, memories are organized into a navigable structure:

• Wings — People or projects (e.g., "datacenter-migration", "customer-acme")
• Rooms — Specific topics within a wing
• Halls — Memory types (facts, events, relationships)
• Closets — Summaries for quick retrieval
• Drawers — Original verbatim content

This architecture means NetClaw can now remember that "the BGP peer with AS65000 was flapping last month due to MTU issues" and recall that context when similar symptoms appear again.

19 Tools for Memory Management

The MemPalace MCP server provides 19 tools across five categories:

Palace Operations

• Check memory status
• List wings and rooms
• Semantic search with filtering
• Duplicate detection

Temporal Knowledge Graphs

• Store facts with validity windows ("this was true from January to March")
• Query what was true at a specific point in time
• Track entity relationships over time
• Generate timelines

Navigation

• Traverse the knowledge graph across wings
• Discover tunnels between related topics
• Analyze connectivity patterns

Content Management

• Add and organize memories
• Delete outdated information

Agent Diaries

• Per-agent continuous diaries using AAAK compression
• Enables specialized expertise development over time

Why This Matters for Network Operations

Imagine these scenarios:

Recurring Issues: "This interface keeps flapping. Have we seen this before?"
NetClaw can now search its long-term memory and find that yes, this same interface had issues 6 months ago, and the root cause was a bad SFP.

Tribal Knowledge: "What’s the story with VLAN 100?"
NetClaw remembers that VLAN 100 was originally created for guest WiFi, was repurposed for IoT devices in Q2, and has special QoS policies because of that legacy camera system nobody wants to touch.

Change Context: "Why did we set the OSPF cost to 1000 on this link?"
NetClaw recalls the change request from 8 months ago where the link was deprioritized during a circuit migration that never got cleaned up.

Semantic Search Without API Calls

MemPalace uses ChromaDB for semantic search — meaning NetClaw can find relevant memories even when the exact keywords don’t match. Searching for "BGP problems" will find memories about "peering session failures" or "route convergence issues."

And it’s all local. No API calls to external services. Your network’s institutional memory stays on your infrastructure.

Community-Driven Innovation

This integration exists because Satyam Thakur saw an opportunity and contributed PR #55. The changes include:

• MCP server registration in config/openclaw.json
• Installation automation in scripts/install.sh
• A comprehensive skill definition at workspace/skills/mempalace/SKILL.md
• Documentation updates across README, TOOLS, SOUL, and AGENTS files

This is what open source is all about — the community identifying gaps and filling them with elegant solutions.

Getting Started

After updating NetClaw, the MemPalace MCP server is available immediately. NetClaw will automatically learn the memory protocol and AAAK dialect from status responses — no manual configuration needed.

Start building institutional memory by simply working with NetClaw. Over time, your AI network assistant will develop deep contextual knowledge about your specific environment, your historical decisions, and your operational patterns.

---

Thank you to Satyam Thakur for this contribution. NetClaw continues to grow through community involvement — now with long-term memory capabilities that transform ephemeral AI assistance into persistent institutional knowledge.

NetClaw Now Has Direct Access to Cisco’s Official Meraki and Catalyst Center API Documentation

Network automation with AI is powerful, but only when the AI has access to accurate, authoritative information. Today we’re excited to announce that NetClaw now integrates with Cisco’s official DevNet Content Search MCP server — giving our AI agent direct access to the source of truth for Meraki and Catalyst Center APIs.

The Problem with Guessing API Endpoints

When you ask an AI to help with Meraki or Catalyst Center automation, it typically relies on training data that may be outdated, incomplete, or simply wrong. API endpoints change. New features get added. Parameters get deprecated. The result? Code that doesn’t work, frustrating debugging sessions, and wasted time.

The Solution: Cisco-Approved MCP Integration

NetClaw now connects directly to Cisco DevNet’s official MCP server at https://devnet.cisco.com/v1/foundation-search-mcp/mcp. This means:

• Always accurate — API documentation comes straight from Cisco, not from cached training data
• Always current — As Cisco updates their APIs, NetClaw sees the changes immediately
• Always complete — Full OpenAPI specifications including parameters, response schemas, and examples

What This Enables

Meraki API Search

Ask NetClaw about any Meraki capability and it will search Cisco’s official documentation:

• "How do I configure L3 firewall rules?"
• "What’s the API for VLAN management?"
• "Show me the wireless SSID endpoints"
• "How do I set up OAuth for Meraki?"

NetClaw returns the exact API endpoints, HTTP methods, required parameters, and example payloads — all from Cisco’s official documentation.

Catalyst Center API Search

The same applies to Catalyst Center (DNA Center):

• "Find device inventory APIs"
• "How do I automate policy deployment?"
• "Show me assurance and health monitoring endpoints"
• "What APIs handle site provisioning?"

Operation ID Lookup

For developers who know exactly what they need, NetClaw can lookup specific Meraki operations by ID and return the complete OpenAPI specification:

Lookup: updateNetworkApplianceFirewallL3FirewallRules

Returns: Full spec including path, method, all parameters, 
request body schema, response codes, and examples

Two New Skills

This integration adds two new skills to NetClaw’s arsenal:

Skill	Purpose
devnet-meraki-search	Search Meraki Dashboard API documentation
devnet-catalyst-search	Search Catalyst Center API documentation

No Authentication Required

The DevNet Content Search MCP is a public service — no API keys, no tokens, no setup. It just works.

Why This Matters

This isn’t just another integration. This is NetClaw getting authoritative access to Cisco’s own documentation. When you ask NetClaw about Meraki or Catalyst Center APIs, you’re not getting guesses based on training data — you’re getting answers sourced directly from Cisco DevNet.

The result: more reliable automation, fewer errors, and faster development cycles.

Get Started

NetClaw 71 MCP integrations now include DevNet Content Search. Just ask:

"Search Meraki API for firewall rules"

"Find Catalyst Center device inventory endpoints"

"Lookup the Meraki operation createNetworkMerakiAuthUser"

NetClaw will search Cisco’s official documentation and return exactly what you need.

---

NetClaw continues to grow — now with 162 skills backed by 71 MCP integrations, bringing authoritative network automation to your fingertips.

The Future of Network Visualization Has Arrived

Hold onto your console cables, network engineers — NetClaw just shattered the boundaries of what’s possible with network visualization!

We’re thrilled to announce the most visually stunning integration in NetClaw’s history: full Blender 3D visualization support. That’s right — the same Blender used by Hollywood studios, game developers, and 3D artists worldwide is now your network visualization engine.

One Command. Infinite Possibilities.

Imagine saying this to your AI network coworker:

"Draw the network topology in Blender using CDP data"

And then watching — in real-time — as your network materializes in full 3D right before your eyes. Routers rising as blue cubes. Switches glowing green. Firewalls blazing red. All connected by sleek cylindrical links showing your actual network topology.

This isn’t science fiction. This is NetClaw + Blender. And it’s available NOW.

156 Skills. One Stunning Visualization Platform.

Here’s what makes this truly revolutionary: NetClaw doesn’t just visualize static data. It pulls live network intelligence from across your entire infrastructure:

• pyATS grabs interface states, CDP/LLDP neighbors, routing tables
• Grafana & Prometheus feed real-time metrics
• SuzieQ provides network-wide observability data
• Cisco Meraki, Catalyst Center, ACI — all feeding the visualization
• AWS, Azure, GCP cloud infrastructure — rendered in 3D
• PagerDuty incidents — see which devices are on fire (literally, in red!)

156 skills worth of network data — now rendered in breathtaking 3D.

What Can You Actually DO?

Draw Your Entire Network Topology

"Visualize the CDP neighbors for all core routers in 3D"

Watch as NetClaw queries your devices, extracts neighbor relationships, and builds a complete 3D model of your network. Devices are automatically color-coded:

Device Type	Color	Because…
Routers	Blue	Cool, calm, directing traffic
Switches	Green	The workhorses, always on
Firewalls	Red	Security = high alert
Access Points	Yellow	Wireless, bright, everywhere

Export for Documentation & Presentations

"Export the Blender scene as network-topology.png"

Need to show the board what your network looks like? Export stunning 3D renders. Create rotating videos. Build presentations that make your infrastructure team look like absolute wizards.

Customize Everything

"Color the core routers dark blue and highlight router-1"
"Add hostname labels to all devices"
"Make the firewalls larger and more prominent"

Full creative control. Your network, your way.

The Technical Magic Behind the Scenes

NetClaw leverages the community blender-mcp server to bridge the gap between AI-powered network intelligence and professional 3D visualization:

NetClaw (WSL) → blender-mcp (MCP Server) → Blender (Windows)
     ↓                    ↓                      ↓
  AI Brain          Translation Layer      3D Rendering Engine

• Zero code required — just natural language
• Real-time updates — change something, see it instantly
• Cross-platform — WSL intelligence, Windows visualization
• Professional quality — Blender’s industry-leading renderer

Why This Changes Everything

For Network Engineers

Stop staring at CLI output. Stop squinting at 2D diagrams. See your network in three dimensions. Understand spatial relationships. Spot issues visually.

For Network Architects

Design reviews just got a massive upgrade. Walk stakeholders through your topology in 3D. Export renders for documentation. Create videos for training.

For Incident Response

When things go wrong, visualize the blast radius. See which devices are affected. Understand the topology context instantly.

For Executive Communication

Try explaining BGP peering to a CFO with CLI output. Now try showing them a 3D visualization where they can see the connections. Night and day.

Getting Started in 5 Minutes

1. Install Blender on Windows: winget install BlenderFoundation.Blender
2. Install the BlenderMCP addon from GitHub
3. Connect the addon (Press N → BlenderMCP tab → Connect)
4. Ask NetClaw: "Create a blue cube in Blender"
5. Mind = Blown 🤯

That’s it. You’re now running the most advanced network visualization system on the planet.

The Numbers Don’t Lie

• 156 skills feeding data into visualizations
• 69 MCP integrations providing network intelligence
• 5 Blender tools for complete 3D control
• 25 devices rendered per topology (optimized for clarity)
• 30 seconds from request to rendered topology
• Infinite possibilities for network visualization

What’s Next?

This is just the beginning. We’re already dreaming about:

• Traffic animation — watch packets flow between devices
• Health overlays — devices glow based on CPU/memory
• Timeline scrubbing — see your network evolve over time
• VR integration — literally walk through your data center
• Digital twin sync — real-time 3D mirror of production

Join the Revolution

NetClaw with Blender integration represents a fundamental shift in how we interact with network infrastructure. We’re not just monitoring networks anymore. We’re not just configuring them. We’re experiencing them.

Your network has never looked this good.

---

Ready to see your network in 3D?

Update to the latest NetClaw, install Blender, and prepare to have your mind blown. The future of network visualization is here, and it’s absolutely gorgeous.

@NetClaw draw my network topology in Blender

Welcome to the future. 🚀

---

NetClaw is the AI-powered CCIE-level network engineer with 156 skills across 69 MCP integrations. From CLI commands to 3D visualization, from incident response to infrastructure automation — NetClaw transforms how network teams operate.

Today’s milestone: NetClaw + Blender = Network visualization will never be the same.

Visualize Your Network in 3D with Blender

NetClaw now integrates with Blender via the community blender-mcp server, enabling 3D network topology visualization. Network engineers can now say "draw the network topology using CDP data" and watch their network come to life in stunning 3D.

What’s New

This integration brings NetClaw’s total to 156 skills backed by 69 MCP servers, adding a powerful visualization capability that transforms how you understand and document your network infrastructure.

Natural Language to 3D Visualization

Simply ask NetClaw to draw your network:

"Draw the network topology in Blender using CDP data"
"Visualize the CDP neighbors for core-rtr-01 in 3D"
"Create a 3D network diagram from the LLDP data"

NetClaw automatically:

1. Queries CDP/LLDP neighbor data from your devices
2. Identifies device types from hostnames
3. Calculates optimal 3D layout positions
4. Creates cubes for each device with appropriate colors
5. Connects devices with visual links

Device Type Color Coding

Devices are automatically colored by type:

Device Type	Color	Visual
Router	Blue	Easy to identify core infrastructure
Switch	Green	Clear distinction from routers
Firewall	Red	Security devices stand out
Access Point	Yellow	Wireless infrastructure highlighted
Unknown	Gray	Catch-all for unidentified devices

Export and Customize

Beyond basic visualization, you can:

Export your diagrams:

"Export the Blender scene as topology.png"
"Save the network diagram as a PNG file"

Customize appearance:

"Color router-1 red"
"Add labels to all devices"
"Highlight the core switches"

Technical Architecture

The integration uses a clever cross-platform architecture:

NetClaw (WSL) → blender-mcp (MCP Server) → Blender (Windows)
                     ↓
              Socket:9876

• NetClaw runs in WSL2, processing natural language requests
• blender-mcp translates commands to Blender Python API calls
• Blender runs on Windows with the BlenderMCP addon

This architecture supports the WSL-to-Windows connectivity pattern common in enterprise development environments.

Getting Started

Prerequisites

1. Blender installed on Windows (winget install BlenderFoundation.Blender)
2. BlenderMCP addon from GitHub
3. NetClaw with the latest configuration

Quick Setup

1. Install the BlenderMCP addon in Blender (Edit → Preferences → Add-ons → Install)
2. Press ‘N’ in Blender to show the sidebar, find "BlenderMCP" tab
3. Click "Connect to Claude" — should show "Server running on port 9876"
4. Get your Windows IP from WSL: cat /etc/resolv.conf | grep nameserver
5. Set BLENDER_HOST in your .env file

Test It

"Create a blue cube in Blender"

If a blue cube appears in Blender, you’re ready to visualize your network!

Design Decisions

Several thoughtful design decisions make this integration practical:

• 25-device limit: Keeps visualizations readable and Blender responsive
• Force-directed layout: Automatically positions devices for clarity
• Hostname-based type inference: No manual device classification needed
• Graceful error handling: Clear messages when Blender isn’t connected

What’s Next

This is just the beginning of 3D network visualization in NetClaw. Future possibilities include:

• Traffic animation: Show packet flows between devices
• Health overlays: Color devices by CPU/memory utilization
• Timeline scrubbing: Visualize network changes over time
• VR integration: Walk through your network in virtual reality

Conclusion

The Blender integration exemplifies NetClaw’s philosophy: powerful capabilities accessible through natural language. Whether you’re documenting your network, presenting to stakeholders, or troubleshooting connectivity issues, 3D visualization provides a new perspective on your infrastructure.

Try it today: "Draw the network topology in Blender"

---

NetClaw is the AI-powered network engineer that speaks fluent CLI. With 156 skills across 69 MCP integrations, it transforms how network teams operate, automate, and innovate.

NetClaw Adds Zscaler and Cloudflare: Zero Trust Security Through Natural Language

Zero trust, conversational access. NetClaw now integrates with Zscaler and Cloudflare, bringing 10 new skills for managing zero trust security, DNS, edge networking, and web security. Query policies, inspect tunnels, analyze traffic, and investigate threats—all through natural language.

---

The Security Perimeter is Everywhere

Modern networks don’t have walls. Users work from anywhere, applications live in multiple clouds, and the "perimeter" is wherever a connection happens. Zscaler and Cloudflare are leaders in this zero trust world:

• Zscaler: Secure access to applications and internet, wherever users are
• Cloudflare: Edge security, DNS, and performance at global scale

Now NetClaw speaks both.

---

Zscaler Integration: 5 Skills

zscaler-zia

Zscaler Internet Access—secure web gateway:

List URL filtering policies in ZIA

Show web security rules for the engineering group

What categories are blocked for guest users?

Get details on the DLP policy for sensitive data

Tools included: list_url_policies, get_url_policy, list_firewall_rules, get_firewall_rule, list_dlp_policies, get_dlp_policy, list_url_categories, get_url_category

zscaler-zpa

Zscaler Private Access—zero trust application access:

List all application segments in ZPA

Show access policies for the internal-apps segment

What connectors are online for the datacenter group?

Get details on the SAP application segment

Tools included: list_application_segments, get_application_segment, list_access_policies, get_access_policy, list_connectors, get_connector, list_connector_groups

zscaler-zdx

Zscaler Digital Experience—endpoint and application performance:

Show ZDX scores for all devices

What's the application performance for Office 365?

List devices with poor network quality scores

Get the digital experience trend for the sales team

Tools included: get_zdx_scores, list_applications, get_application_metrics, list_devices, get_device_details, get_network_metrics

zscaler-identity

User and group management across Zscaler:

List all user groups in Zscaler

Show users in the engineering department

What groups does user john.doe belong to?

Get identity provider configuration

Tools included: list_users, get_user, list_groups, get_group, list_departments, get_idp_config

zscaler-insights

Analytics and reporting:

Show web traffic analytics for the last 24 hours

What are the top blocked categories today?

Get bandwidth usage by department

List security events for the network team

Tools included: get_traffic_analytics, get_security_analytics, get_bandwidth_report, list_audit_logs, get_threat_report

---

Cloudflare Integration: 5 Skills

cloudflare-dns

DNS management at the edge:

List all DNS zones in Cloudflare

Show DNS records for example.com

What's the TTL for the www A record?

List zones with DNSSEC enabled

Tools included: list_zones, get_zone, list_dns_records, get_dns_record, get_zone_settings, get_dnssec_status

cloudflare-security

Web application security:

List WAF rules for example.com

Show firewall events from the last hour

What custom rules are blocking traffic?

Get the security level for the API zone

Tools included: list_waf_rules, get_waf_rule, list_firewall_events, list_custom_rules, get_custom_rule, get_security_settings, list_rate_limits

cloudflare-zerotrust

Cloudflare Access and Tunnels:

List all Access applications

Show policies for the internal-dashboard app

What Cloudflare Tunnels are configured?

Get connection status for the datacenter tunnel

Tools included: list_access_applications, get_access_application, list_access_policies, get_access_policy, list_tunnels, get_tunnel, list_casb_findings, get_casb_finding

cloudflare-analytics

Traffic insights and Radar data:

Show traffic analytics for example.com today

What are the global Internet traffic trends?

Scan https://suspicious-site.com for threats

Get threat intelligence for IP 1.2.3.4

Tools included: get_zone_analytics, search_logs, get_traffic_insights, scan_url, get_threat_intel, get_internet_trends

cloudflare-workers

Edge compute monitoring:

List all deployed Workers

Show details for the api-gateway Worker

What bindings does my edge-proxy Worker have?

Get build history for auth-worker

Tools included: list_workers, get_worker, get_worker_bindings, list_builds, get_build, get_worker_analytics

---

Quick Setup

Zscaler

# ZIA (Internet Access)
export ZSCALER_ZIA_API_KEY="your-zia-api-key"
export ZSCALER_ZIA_CLOUD="zscaler.net"
export ZSCALER_ZIA_USERNAME="admin@example.com"
export ZSCALER_ZIA_PASSWORD="your-password"

# ZPA (Private Access)
export ZSCALER_ZPA_CLIENT_ID="your-client-id"
export ZSCALER_ZPA_CLIENT_SECRET="your-client-secret"
export ZSCALER_ZPA_CUSTOMER_ID="your-customer-id"

Cloudflare

export CLOUDFLARE_API_TOKEN="your-api-token"
export CLOUDFLARE_ACCOUNT_ID="your-account-id"

Generate tokens at dash.cloudflare.com → My Profile → API Tokens.

---

Real-World Security Investigation

Here’s how a security engineer investigates a potential threat:

1. Check Cloudflare for Anomalies

netclaw: Show firewall events for the api zone in the last hour

2. Analyze Traffic Patterns

netclaw: Get traffic analytics for api.example.com today

3. Investigate Suspicious Source

netclaw: Get threat intelligence for IP 203.0.113.42 from Cloudflare Radar

4. Check Zscaler for Internal Activity

netclaw: List security events in Zscaler for users accessing external APIs

5. Verify Access Policies

netclaw: Show ZPA access policies for the internal-api application segment

6. Check User Context

netclaw: What groups does user john.doe belong to in Zscaler?

Complete visibility across edge and access security—through conversation.

---

Integration Architecture

Both platforms connect through their official MCP interfaces:

{
  "zscaler-mcp": {
    "url": "mcp://zscaler.com/mcp",
    "env": {
      "ZSCALER_ZIA_API_KEY": "${ZSCALER_ZIA_API_KEY}",
      "ZSCALER_ZPA_CLIENT_ID": "${ZSCALER_ZPA_CLIENT_ID}",
      "ZSCALER_ZPA_CLIENT_SECRET": "${ZSCALER_ZPA_CLIENT_SECRET}"
    }
  },
  "cloudflare-observability": {
    "url": "mcp://observability.mcp.cloudflare.com",
    "env": {
      "CLOUDFLARE_API_TOKEN": "${CLOUDFLARE_API_TOKEN}",
      "CLOUDFLARE_ACCOUNT_ID": "${CLOUDFLARE_ACCOUNT_ID}"
    }
  }
}

Cloudflare uses multiple specialized MCP endpoints for different capabilities (DNS analytics, Radar, CASB, Workers builds).

---

The Complete Security Stack

With Zscaler and Cloudflare joining Palo Alto and Cisco FMC, NetClaw covers the major security platforms:

Platform	Domain	NetClaw Skills
Palo Alto	Next-gen firewall	Existing
Cisco FMC	Firewall management	Existing
Zscaler	Zero trust access	5 skills
Cloudflare	Edge security	5 skills

Network security engineers can now query across all platforms:

netclaw: Show blocked connections on the Palo Alto firewall,
         check if the source IP is in Zscaler block lists,
         and get threat intel from Cloudflare Radar

---

Zero Trust Through Conversation

Zero trust means verifying everything, everywhere. That’s a lot of queries across a lot of systems. NetClaw makes this manageable:

Before:

• Log into Zscaler admin portal
• Navigate to correct policy section
• Log into Cloudflare dashboard
• Check multiple tabs and filters
• Cross-reference manually

After:

netclaw: Verify that user john.doe can access the SAP application 
         through ZPA and show any recent security events

The security perimeter might be everywhere, but your interface to it doesn’t have to be.

---

NetClaw now supports 68 MCP servers with 124 skills. Zero trust security just became conversational.

---

Get started at github.com/automateyournetwork/netclaw

NetClaw Adds HashiCorp Terraform and Vault: Infrastructure as Code Meets Natural Language

Infrastructure automation through conversation. NetClaw now integrates with HashiCorp Terraform Cloud and Vault, bringing 6 new skills for managing infrastructure as code and secrets. Query workspace state, explore the Terraform Registry, retrieve certificates, and manage secrets—all through natural language.

---

The HashiCorp Stack

HashiCorp tools are foundational to modern infrastructure:

• Terraform defines infrastructure as code, managing everything from cloud resources to network devices
• Vault secures secrets, manages certificates, and provides encryption as a service

Network engineers increasingly rely on both. Now NetClaw speaks their language.

---

Terraform Cloud Integration: 3 Skills

terraform-registry

Explore the Terraform ecosystem:

Search the Terraform Registry for Cisco ACI providers

Show details for the hashicorp/aws provider

What modules exist for network automation?

List versions of the PAN-OS provider

Tools included: search_providers, get_provider, get_provider_versions, search_modules, get_module, get_module_versions

terraform-workspaces

Understand your infrastructure state:

List all Terraform workspaces in my organization

Show the current state of the production-network workspace

What resources are managed in the dmz-firewalls workspace?

Compare state between staging and production workspaces

Tools included: list_workspaces, get_workspace, get_workspace_state, list_state_versions, get_state_version, list_workspace_resources

terraform-operations

Monitor infrastructure changes:

Show recent runs for the network-core workspace

What's the status of the latest plan?

List runs that failed in the last 24 hours

Show the plan output for run-abc123

Tools included: list_runs, get_run, get_plan, list_applies, get_apply, get_run_logs

---

HashiCorp Vault Integration: 3 Skills

vault-secrets

Secure secrets management:

List secrets in the network-credentials path

Get the SNMP community strings from Vault

What secrets are stored under infrastructure/routers?

Show metadata for the admin-credentials secret

Tools included: list_secrets, get_secret, get_secret_metadata, list_secret_versions

vault-pki

Certificate lifecycle management:

List PKI roles in the network-ca mount

Generate a certificate for core-rtr-01.example.com

Show the CA certificate chain

What certificates are about to expire?

Tools included: list_pki_roles, get_pki_role, issue_certificate, get_ca_chain, list_certificates, get_certificate, revoke_certificate

vault-mounts

Understand your secrets architecture:

List all secrets engines in Vault

Show configuration for the network-kv mount

What auth methods are enabled?

Get details on the PKI secrets engine

Tools included: list_mounts, get_mount, list_auth_methods, get_auth_method

---

Quick Setup

Terraform Cloud

export TF_CLOUD_TOKEN="your-terraform-cloud-token"
export TF_CLOUD_ORGANIZATION="your-org-name"

Generate a token at app.terraform.io → User Settings → Tokens.

HashiCorp Vault

export VAULT_ADDR="https://vault.example.com:8200"
export VAULT_TOKEN="your-vault-token"
# Or use other auth methods:
export VAULT_ROLE_ID="your-role-id"
export VAULT_SECRET_ID="your-secret-id"

---

Real-World Workflow: Network Device Provisioning

Here’s how these integrations work together:

1. Find the Right Provider

netclaw: Search Terraform Registry for Juniper Junos providers

2. Check Workspace State

netclaw: Show resources in the juniper-spine-switches workspace

3. Get Credentials Securely

netclaw: Get the Juniper admin credentials from Vault

4. Generate Device Certificates

netclaw: Issue a certificate for spine-sw-01.dc1.example.com from the network-ca

5. Monitor the Deployment

netclaw: Show the status of the latest Terraform run for juniper-spine-switches

6. Verify State

netclaw: List all resources managed in the workspace after the apply

All secure. All audited. All conversational.

---

Integration Architecture

{
  "terraform-cloud-mcp": {
    "command": "npx",
    "args": ["-y", "@hashicorp/terraform-mcp-server"],
    "env": {
      "TF_CLOUD_TOKEN": "${TF_CLOUD_TOKEN}",
      "TF_CLOUD_ORGANIZATION": "${TF_CLOUD_ORGANIZATION}"
    }
  },
  "vault-mcp": {
    "command": "uvx",
    "args": ["mcp-vault"],
    "env": {
      "VAULT_ADDR": "${VAULT_ADDR}",
      "VAULT_TOKEN": "${VAULT_TOKEN}"
    }
  }
}

---

Why This Matters for Network Engineers

Modern network infrastructure is increasingly defined in code:

• Cisco ACI fabrics managed through Terraform
• Palo Alto firewalls configured via providers
• Cloud networking (VPCs, subnets, security groups) in HCL
• Device credentials secured in Vault
• Certificates for mutual TLS between network devices

By integrating Terraform and Vault, NetClaw bridges the gap between network operations and infrastructure as code practices.

Before:

# Check workspace state
terraform login
cd workspace
terraform state list
terraform state show resource.name

# Get credentials
vault login
vault kv get secret/network/credentials

After:

netclaw: List resources in the aci-production workspace 
         and get the APIC credentials from Vault

---

Security First

These integrations respect the security models of both platforms:

• Terraform Cloud: Token-based auth with organization scoping
• Vault: Full support for token, AppRole, and other auth methods
• Audit: All operations logged through Vault’s audit backend
• RBAC: Permissions enforced by the respective platforms

NetClaw never bypasses security—it just makes it more accessible.

---

The Infrastructure Stack

With Terraform and Vault joining Ansible, NetClaw now covers the major infrastructure automation tools:

Platform	Use Case	NetClaw Skills
Ansible	Configuration management	Existing
Terraform	Infrastructure as code	3 skills
Vault	Secrets management	3 skills

Network engineers have a complete automation toolkit through natural language.

---

NetClaw now supports 68 MCP servers with 124 skills. Your infrastructure as code just became conversational.

---

Get started at github.com/automateyournetwork/netclaw