NetClaw

A CCIE-level AI network engineering coworker that runs on OpenClaw or Hermes, with 237 skills and 176 MCP integrations in its catalog. Investigate live networks, learn from your own documentation, coordinate specialist agents, and carry out approved changes with baselines, verification and an immutable audit trail. Available tools and HUD controls depend on the selected runtime and installed components.

Work from chat, the visual HUD, your phone, or a Zoom meeting. Start with one NetClaw, or build a risk of specialist NetClaws behind a single Border.

Start here: Choose a runtime · Install · Capabilities · RAG · GCF · Mobile · Zoom · VS Code · HUD · Jev

Project: Source version 1.12.0 · Release notes · Contributing — numbered specs + Spec Kit · Changelog

VS Code: Install NetClaw or explore the VS Code Extension: set up a separate NetClaw or mixed Risk from empty homes, or connect your existing installation for Chat, Canvas, RAG, Testbed management, per-MCP configuration and reviewed security controls.

Reference: Architecture · MCP servers · Skills · Workflows · Safety

Hermes or OpenClaw?

Choose the agent runtime during installation. Both can use the shared NetClaw HUD for Chat, branching Canvas investigations, local Avatar and browser-owned conversation history. Your choice persists across launches; an existing OpenClaw installation keeps its default.

| Choose | Why use it? | Current shared HUD behavior | |---|---|---| | OpenClaw (default) | You want NetClaw's established gateway workflows and its broader existing HUD controls, or already run OpenClaw. | Uses your configured gateway, with model/effort controls and installed tools subject to existing permissions and change control. | | Hermes | You prefer the Hermes agent, CLI and skill ecosystem, or already deploy Hermes and want the same NetClaw workspace. | Uses your selected Hermes home and configured provider/model through a dedicated protected companion. The first qualified HUD tool is the read-only subnet calculator and its installed skill. |

Hermes runtime installation includes the selected NetClaw MCP servers and skills. The protected HUD companion admits only reviewed tools: installing another MCP does not automatically enable it in HUD conversations. Attachments, configuration APPLY, per-conversation model/effort overrides and hosted Avatar are unavailable in this first Hermes HUD release. Local Avatar is supported. See the Hermes setup and capability guide.

Connection: the browser on :3000 talks to the HUD API on :3001. For Hermes, the API uses a private MCP bridge and an authenticated companion on loopback :8643; it does not connect directly to or restart your ordinary Hermes gateway. Hermes HUD acceptance passed on Mac and Ubuntu under Windows WSL2; native Windows uses WSL.

Spec 148 delivers the shared HUD connection. **NetClaw 1.8.0 / spec149 adds Hermes iN2N/eN2N and Mobile Ask Border** through protected execution. The initial qualified profile is subnet calculation; media attachments and production Hermes confinement remain unavailable. See setup, mobile versions and tested scope. Runtime installation details · Acceptance and exact tested platforms

The function-first HUD opens on standard Chat, with a Chat / Canvas interface switch, selected-runtime operations panels, Basic/Advanced presentation and detailed Jev views. OpenClaw also offers its native interface in a separate tab. Saved conversations survive refresh; runtime and usage indicators show available evidence rather than assumed values. See the HUD guide for the broader workspace.

RAG — answers grounded in your documents

Teach NetClaw your vendor guides, standards, customer designs and runbooks. Upload through Slack or the HUD RAG panel, ingest a local file, or preview a URL crawl before importing it. PDF, Markdown, HTML, text and modern Office formats are supported; legacy Office conversion uses optional LibreOffice.

Hybrid semantic and keyword search, local reranking and structure-aware chunks return cited passages with document, section and page context. Retrieval runs locally after the models are installed. NetClaw can refine a search within a bounded budget and report when the corpus cannot answer. Uploaded knowledge stays separate from the agent's experiential memory; captured network snapshots are opt-in and carry their age.

Try: “Using our uploaded design guide, explain the intended BGP policy and cite the relevant sections.” Then ask for a live device check to compare intent with current state.

Setup, formats and retrieval pipeline · Consented knowledge sharing between peers

GCF — compact network evidence

GCF gives participating MCP integrations a compact representation of structured tool results: tabular encoding for repeated records, graph encoding for topology, and optional session references and deltas for repeated queries. This reduces repetitive payload text so more useful network evidence can fit into a model's context. The serializer retains source data and falls back to JSON when encoding fails.

Choose NETCLAW_GCF_MODE=full, graph, generic or off; session/delta behavior also requires the caller to enable it. Savings depend on the payload and model. The recorded 1,000-node fixture used 98,859 graph-output characters versus 139,881 compact-JSON characters (about 29% less); serializer token counts use a characters/4 estimate, not a model tokenizer or a guaranteed billing reduction.

Optional: NETCLAW_TABULAR_FORMAT=bpp encodes flat, non-graph results (the payloads that would otherwise use the GCF generic profile) with bpp instead. It requires pip install bpp-format, is off by default, never affects graph, session or delta encoding, and falls back to GCF generic if bpp is missing or its round trip is not lossless.

Serializer and mode reference · Recorded benchmark · Reproduce the benchmark

NetClaw Mobile — your network in your pocket

The Flutter client brings the Border to iOS and Android. Enroll with a single-use QR token, ask by text or voice, scan a device QR/deep link, and receive answers with the responding claw identified. A dashboard, conversation history, feed and approvals view keep the operator connected away from the desk.

Resolve approval requests with device biometrics and attach camera/microphone captures to an investigation. The phone is an NCFED edge member with device-native capabilities; the Border handles agent reasoning. Explicit notifications can reach a connected phone, with platform push fallback when configured. Existing authorization and audit rules still apply.

Build, enroll and use Mobile · iOS release checklist · Android release checklist

Zoom — network investigations in the meeting

Bring NetClaw into an incident call through Zoom Realtime Media Streams. With listening enabled, transcript and chat context can trigger network investigations through the existing Border and specialist routing. The Zoom App side panel shows status and returned evidence, with an optional camera overlay.

Live meeting context and historical meeting search serve different purposes: RTMS supplies the current conversation; the official Zoom Meetings MCP can supply prior meeting context where configured. Historical connectivity is environment-dependent. Meeting requests retain the same device-write approval gates as other channels.

RTMS setup, tools and deployment boundaries · Meeting intelligence specification

Function-first HUD

Start with standard Chat, switch to Canvas for branching investigations, or open the native OpenClaw interface in a separate tab. The local operations workspace also provides Claw/MCP drill-downs, reported LLMs, Jev assessments, RAG uploads and retrieval, Tokenomics, service Logs, masked Configuration, Security mode/enforcement panels, and Documentation. Basic/Advanced presentation and optional Three.js views keep evidence accessible. See the HUD guide. The service remains local to the host; the new UI does not change its access controls.

VS Code Extension

Bring your existing NetClaw into Visual Studio Code. The NetClaw extension gives you a themed operations workbench alongside your code, configuration and documentation. It connects to the NetClaw you already run on OpenClaw or Hermes; available actions follow that runtime's capabilities.

Install: search Extensions for NetClaw by publisher NetClaw, or use:

code --install-extension NetClaw.netclaw

Use VS Code 1.102 or later on macOS or Linux. On Windows, open your intended WSL distribution and install the extension in WSL. Existing Remote SSH workspaces are supported; loopback addresses refer to the extension host. Browser VS Code and native Windows runtime hosting are not supported.

Start your NetClaw HUD, open the NetClaw Activity Bar, and choose Add existing NetClaw. Give the connection a friendly nickname such as My Mac lab, enter its HUD API address—normally http://127.0.0.1:3001—and review the returned installation identity. Start the updated HUD to enable full Testbed and scoped MCP editing; updating the extension alone cannot add those API routes.

| Work in the editor | What you can do | | --- | --- | | Chat, Canvas and Avatar | Talk to the selected runtime, branch investigations and use bundled local characters beside the same Chat. Select file/context content explicitly. | | RAG knowledge | Browse collections, upload selected documents and search cited passages with source and staleness context. | | Testbed inventory | Add, edit and remove devices through cards or advanced YAML. Import YAML, JSON or basic CSV, preview changes, review saves, export and inspect recovery copies. | | MCP configuration | Open integration-specific fields, keep/replace/clear values, inspect shared settings and review supported setup actions. Existing secret values stay private. | | DefenseClaw and OpenShell | Inspect status, permissions, redacted policy YAML and logs. Review supported connector tool rules or sandbox network-policy changes, with explicit acknowledgment when protection may weaken. | | Operations and federation | Inspect reported Risk/peer state, BGP relationships, tokenomics, logs, audit evidence, mobile/edge and Science Officer observations. | | Copilot, Claude Code and Codex | Opt into the scoped assistant interface for inspection/proposals and separately enable delegated NetClaw requests. Existing runtime authorization still applies. |

Cards, labeled forms, search and filters follow light, dark and high-contrast editor themes. The interactive 3D BGP view uses reported sessions and includes an accessible list. It does not infer physical cabling or health.

Changes retain their review boundaries: Testbed saves do not connect devices, saved MCP configuration does not prove endpoint access, and stored security policy does not prove traffic enforcement. Supported actions depend on the installed runtime and native CLI capabilities.

VS Code 1.1.0 (Spec152): the upper Connections panel now opens the six runtime workspace Markdown files for reading, reviewed edits and upload/overwrite, with no delete. It also provides reviewed Start/Stop/Restart for the selected installation’s verified owned services, offline Start and Save & Restart. This is not in Marketplace 1.0.1. See workspace controls and prerequisites and verification. Source 1.11.0 supplies the required HUD discovery and native helper. See release verification and platform limits, including WSL regular-file acceptance and intentional symlink refusal.

Extension guide and setup · Privacy · Exact 0.1.1 qualification and platform scope

Resources

• NetClaw Overview — community guide

Quick Install

New in source 1.12.0 / extension 1.2.0 (Spec153): VS Code wizard, CLI Claw Plans and assistant guidance now share a separate-home setup engine. A deployment Spec Kit preset stages the same native review. Existing claws are detected and preserved; each new claw has independent identity, credentials, services and connection. Extension 1.2.0 requires VS Code 1.109+. See verification and open acceptance work before real installation; the historical installer below retains its existing behavior.

git clone https://github.com/automateyournetwork/netclaw.git
cd netclaw
./scripts/install.sh          # interactive installer — pick exactly what you want

Run it as your normal user — not with sudo. Under sudo, OpenClaw's config, your API keys, and all skills land in /root/.openclaw where your own openclaw can't see them. The installer refuses to run under sudo and instead asks before each specific command that needs root.

The installer opens an interactive TUI (pure bash — no dialog/whiptail needed): pick an install profile, then optionally fine-tune the exact MCP server list in an arrow-key checklist (Space to toggle, a all, n none). Only what you select gets installed.

Install profiles:

| Profile | What you get | |---------|--------------| | Recommended | Curated starter set: pyATS, NetBox, ServiceNow, GAIT audit trail, Chrome DevTools, nmap, diagrams, utilities | | Custom | Hand-pick from every component in a categorized checklist | | Everything | The classic full install — every component | | Cisco | pyATS, ACI, ISE, Catalyst Center, Meraki, SD-WAN, CML, FMC, RADKit, ThousandEyes | | Multivendor | Cisco + Juniper, Arista, Aruba, F5, NetBox, Nautobot | | Cloud | AWS, Azure, GCP, Cloudflare, Terraform, Vault, GitHub | | Security | ISE, FMC, Panorama, FortiManager, Check Point, Zscaler, Claroty, nmap, CVE | | Labs | CML, ContainerLab, Batfish, protocol peering, N2N federation, SuzieQ | | Observability | Grafana, Prometheus, Datadog, Splunk, PagerDuty, ThousandEyes, Kubeshark | | Minimal | pyATS + audit trail + core utilities |

Scripted / non-interactive installs:

./scripts/install.sh --profile recommended        # any profile, no TUI
./scripts/install.sh --components "pyats netbox"  # exact component list
./scripts/install.sh --all                        # everything
./scripts/install.sh --list                       # see all components & profiles

The installer reports the host OS, version, architecture and component Python, then checks the selected components before installing packages or changing runtime configuration. Known unsupported components are disabled in the custom checklist; explicit selections and profiles fail with all detected blockers rather than silently dropping components. A full selection can therefore be blocked on macOS.

./scripts/install.sh --runtime hermes --preflight --components "forward panorama zabbix zoom-rtms"
./scripts/install.sh --preflight --all             # report all declared prerequisites; no installation

Preflight checks declared Python bounds, native SDK platforms, external commands, Forward's Go/CGO toolchain and Docker daemon availability. It does not prove package resolution or vendor connectivity. Existing Python 3.12 is preferred for component runtimes unless NETCLAW_PY is explicitly set; python3 on PATH must still be 3.10+. See Python compatibility and prerequisites.

Filled .env and first-time setup

You can fill credentials before installing: copy .env.example to .env in the NetClaw checkout, then edit and uncomment the settings you need. The installer imports supported settings into ~/.openclaw/.env before onboarding starts (~/.hermes/.env for Hermes). It resolves the checkout path regardless of where you run the installer. Existing runtime assignments, including empty ones, win; conflicts are listed by variable name without printing values.

Onboarding still chooses your provider, model, gateway and channels. Reuse detected credentials when the runtime offers that choice. Filling an API key does not supply those other choices. Onboarding failure now stops installation with an error instead of reporting completion.

For an existing installation, import without reinstalling components:

python3 scripts/import-env.py             # preview; writes nothing
python3 scripts/import-env.py --apply     # add missing runtime settings
Hermes: add --runtime hermes to both commands

If OpenClaw has not been configured, continue with openclaw onboard --install-daemon. For an already-running gateway, run openclaw gateway restart to load newly imported settings. ./scripts/setup.sh also imports before its platform questions; skip platforms that are already configured. To replace an existing runtime value, edit the runtime .env deliberately; import never overwrites it.

The importer accepts single-line dotenv assignments declared in .env.example, keeps their literal syntax, skips blank values and obvious placeholders such as changeme/sk-ant-..., and never executes or expands them. Quote values containing #. Unknown names are reported for manual runtime configuration; malformed or multiline records fail before any write. Destination writes are atomic with mode 0600; symlinks are refused. Generated MCP launcher paths remain installer-managed. An inherited process variable can still take precedence over either dotenv file.

For a custom OpenClaw state directory, export OPENCLAW_STATE_DIR before import, installation and later OpenClaw commands; OPENCLAW_CONFIG_PATH can select its config file. For Hermes use HERMES_HOME. NetClaw retains its historical OPENCLAW_HOME state-directory fallback in the installer/importer; prefer OPENCLAW_STATE_DIR for consistency with upstream OpenClaw.

Current OpenClaw intentionally filters provider keys from a working-directory .env; the durable runtime file is the appropriate location for them. See OpenClaw environment precedence.

Agent runtime — OpenClaw or Hermes

NetClaw runs on top of an agent runtime. OpenClaw is the default. You can also run NetClaw on Hermes (Nous Research's self-improving agent). The interactive installer asks which runtime to use; scripted installs pick it explicitly:

./scripts/install.sh --runtime hermes --profile recommended
NETCLAW_RUNTIME=hermes ./scripts/install.sh --all

| | OpenClaw (default) | Hermes | |---|---|---| | Install | npm install -g openclaw@latest | curl -fsSL https://hermes-agent.nousresearch.com/install.sh \| bash | | Binary | openclaw | hermes (~/.local/bin) | | State dir | ~/.openclaw/ | ~/.hermes/ (override with $HERMES_HOME) | | Config | openclaw.json | config.yaml (mcp_servers:) | | Skills | workspace/skills/ | skills/ | | Onboard | openclaw onboard --install-daemon | hermes setup + hermes gateway install | | Talk to it | openclaw tui | hermes --tui / hermes chat |

On a Hermes install the installer still deploys the same **MCP servers, skills, SOUL, and platform credentials** — NetClaw's MCP registrations (config/openclaw.json → mcpServers) are translated into Hermes' mcp_servers: block by scripts/openclaw-to-hermes-mcp.py (paths made absolute, ${VAR} resolved from the shared .env, merged non-destructively). Inspect the result with hermes mcp list.

Scope: the runtime choice covers install, onboarding, gateway, MCP

registration, skills, credentials and the shared HUD. Hermes HUD conversations

use the protected companion's qualified tools. Spec149 / 1.8.0 adds protected Hermes iN2N/eN2N execution and Mobile Ask Border.

See qualification and compatibility; installed does not mean qualified.

For the shared HUD, install --runtime hermes --add "subnet-calc hermes-hud", then run ./scripts/netclaw hud select hermes "$HOME/.hermes" and ./scripts/netclaw hud. See Hermes HUD setup and limits. The eight-tool conversation bridge is HUD-private and excluded from agent-native registrations. Windows uses the Linux launcher inside Ubuntu on WSL2.

A Risk of NetClaws (iN2N)

A risk is the (real) collective noun for a group of lobsters — and NetClaw is a lobster. You can now run a risk of NetClaws: instead of one monolith carrying every skill, run a group of focused, specialized claws coordinated by a single Border Claw. You talk only to the Border; it routes each request to the member that owns the capability (a CML claw, a pyATS claw, an Azure claw…) and returns the result.

• Focus & token economy — each member carries only the skills it needs.
• Least privilege — each member gets only its integration's secrets.
• One door — the Border is the single interface, single external identity, and

At install you pick standalone, Border, or Member. This is the internal counterpart to N2N federation between different operators (eN2N). A classic standalone NetClaw is just "a risk of one, its own Border."

NCFED is documented as an IETF Internet-Draft — draft-capobianco-ncfed-00

(Experimental), specifying the wire protocol (BGP-multiplexed discrimination,

13-octet handshake, framing, eN2N consent + iN2N TOFU trust models) for the IETF

agentproto effort: docs/ietf/draft-capobianco-ncfed-00.md.

Claw Certification (feature 060) closes the eN2N crypto gap: federation

channels are TLS-encrypted and certificate-authenticated — domain-verified

(ACME/Let's Encrypt via DNS-01, identity bound to a DNS name you own, not the

tunnel) or pinned self-signed TOFU. The Border is its risk's CA so members

verify the hub (mutual auth); credentials auto-rotate before expiry. Enable with

N2N_CERT_MODE=on|enforce; existing claws upgrade in one command

(scripts/patch-claw-certs.sh). New to peering? See

docs/N2N-FEDERATION-GUIDE.md.

Production mode — enforced, honest, and durable (feature 057)

N2N_RISK_MODE=production enforces, fail-closed, rather than merely flagging. Layered, production-grade security — and posture that never lies:

• Member sandbox — host-level kernel confinement. Each member runs as a

• Model-guard — DefenseClaw LLM guardrail proxy. Model I/O routes through the

• Audit — GAIT immutable git trail. Every delegation/enrollment/removal/

• Least-privilege secrets by construction — each member gets only its

• Honest posture — testing / production — enforced / production — DEGRADED

• Durable runtime — mesh daemon + always-on members as systemd --user

• A2A cards advertise the risk's posture and LLM capability (model +

Token/context economy: the monolith loaded ~194 skills + ~37–52 MCP servers (hundreds–thousands of tool schemas) into every turn. A risk runs a lean Border (0 domain skills, ~32 broker tools) that routes to members carrying **~3 specialty skills + 1 vendor MCP each — roughly a 15–30× reduction in per-claw tool-schema context**, plus tiered models (Opus Border, Sonnet/Haiku/Ollama members). See docs/N2N-RISK.md and specs/057-in2n-production-enforcement.

→ Full guide: docs/N2N-RISK.md · external peering: N2N-PEERING-NETCLAWS.md · already federated with a peer? docs/N2N-RISK-MIGRATION-FOR-PEERS.md

Whatever you pick, the installer then runs a two-phase setup:

Phase 1: openclaw onboard (OpenClaw's built-in wizard)

• Pick your AI provider (Anthropic, OpenAI, Bedrock, Vertex, 30+ options)
• Set up the gateway (local mode, auth, port)
• Connect channels (Slack, Discord, Telegram, WhatsApp, etc.)
• Install the daemon service

• Network devices (testbed.yaml editor)
• Platform credentials — only for the components you installed (your selection is remembered in ~/.openclaw/netclaw-components.conf)
• Your identity (name, role, timezone for USER.md)

openclaw gateway              # terminal 1
openclaw tui                  # terminal 2

Reconfigure anytime:

• openclaw configure — AI provider, gateway, channels
• ./scripts/setup.sh — network platform credentials
• ./scripts/install.sh — add or remove MCP servers (re-run keeps your current selection preselected)

Enterprise Security (DefenseClaw + OpenShell)

NetClaw includes enterprise-grade security via Cisco DefenseClaw and NVIDIA OpenShell:

| Layer | Technology | Protection | |-------|------------|------------| | Container | NVIDIA OpenShell | Docker-based sandbox with YAML policies | | Guardrails | Cisco DefenseClaw | LLM inspection, tool call filtering | | Scanning | CodeGuard | Credential detection, injection prevention | | Audit | SQLite + SIEM | Full compliance logging |

Enable Security

# During install (recommended)
./scripts/install.sh
Answer 'y' to "Enable DefenseClaw + OpenShell?"
Or enable later
./scripts/defenseclaw-enable.sh

Run NetClaw Securely

# One-command secure startup (recommended)
./scripts/netclaw-secure-start.sh
Then connect to sandbox:
openshell sandbox connect netclaw
export HOME=/sandbox
openclaw gateway run &
openclaw tui

# Or guardrails only (no container)
defenseclaw setup guardrail --mode action
claw

Full security guide >>>

Visual HUD

The capability catalogue covers currently 176 MCP integrations and 237 skills; configured entries are not proof of live connectivity.

The function-first HUD opens on standard Chat, with an operations dashboard and a preserved, branching Canvas workspace. Inspect internal Claws, mobile edges and external neighbours; drill into reported MCPs and LLM identities; compare Jev evidence; upload/search RAG; review token usage, estimates and budgets; inspect LAB/production mode, DefenseClaw and OpenShell; filter service logs; and browse guides, CLI declarations, MCP signatures and the HUD OpenAPI reference. Three.js views are optional companions to the panels and tables. Configured capabilities, recorded usage and estimates stay distinct from verified live state.

On Windows, start the gateway and Visual HUD together by double-clicking Start-NetClaw.cmd, or from PowerShell:

.\Start-NetClaw.ps1

The launcher verifies Node.js, npm, and OpenClaw; installs Visual HUD dependencies on the first run; avoids starting duplicate services; waits for the configured gateway port plus ports 3000 and 3001; and opens Canvas Chat. Use .\Start-NetClaw.ps1 -Interface HUD to open the main dashboard instead, or add -NoBrowser when you only want to start the services.

cd ui/netclaw-visual
npm install
npm run dev                   # then open http://localhost:3000

Requires the OpenClaw gateway to be running for live chat (openclaw gateway run). After updating your checkout, run scripts/upgrade-hud.sh --check from the repository root, then scripts/upgrade-hud.sh --apply to rebuild. Add --install-deps only when the lockfile dependencies need installation. This helper preserves configuration, security modes and Canvas storage; it does not pull Git or restart services.

HUD guide · Logging guide · Security modes · CLI/interface reference · HUD OpenAPI · Setup and legacy utilities

What It Does

NetClaw is an autonomous network engineering agent powered by Claude that can:

• Monitor device health — CPU, memory, interfaces, hardware, NTP, logs — fleet-wide in parallel
• Troubleshoot connectivity, routing adjacencies, performance, and flapping using OSI-layer methodology with multi-hop parallel state collection
• Analyze routing protocols — OSPF (LSDB, LSA types, area design), BGP (11-step path selection, NOTIFICATION codes), EIGRP (DUAL states)
• Audit security posture — ACLs, AAA, CoPP, management plane hardening, CIS benchmarks, ISE NAD verification, NVD CVE scanning
• Discover topology via CDP/LLDP, ARP, routing peers — reconcile against NetBox cables
• Configure devices with full ITSM-gated change management — ServiceNow CR, baseline, apply, verify, rollback
• Reconcile NetBox or Nautobot source of truth against live device state — flag IP drift, undocumented links, missing interfaces; query Nautobot IPAM for IP addresses, prefixes, VRF/tenant/site filtering when the org uses Nautobot instead of NetBox
• Manage ACI fabric — health audits, policy analysis, safe tenant/VRF/BD/EPG changes with fault delta rollback
• Investigate endpoints via ISE — auth history, posture, profiling, human-authorized quarantine
• Audit Cisco Secure Firewall policies via FMC — search access rules by IP/FQDN, resolve FTD device policies, cross-FMC consistency checks, and SGT-based policy review
• Operate Infoblox DDI — inspect DNS zones and records, DHCP scopes and leases, and IPAM utilization before address-related changes
• Inspect Cisco Meraki infrastructure via Cisco's official remote MCP — 494 read-only Dashboard capabilities behind 2 tools: org inventory, networks, devices, wireless SSIDs, RF profiles, Air Marshal, switch ports and ACLs, MX L3/L7 firewall rules, site-to-site VPN, content filtering, security events, loss/latency history, and the configuration change audit. Writes are structurally absent upstream — changes are made in the dashboard
• Audit Palo Alto Panorama and FortiManager estates — policy search, device-group/ADOM/package review, NAT validation, and commit/install readiness checks
• Monitor network paths via Cisco ThousandEyes — synthetic test results, agent health, hop-by-hop path visualization (latency, loss, MPLS labels per hop), BGP route analysis (AS path, reachability, origin validation), outage investigation, anomaly detection, instant on-demand tests, endpoint VPN diagnostics, and AI-powered views explanations — via both community (9 tools, local stdio) and official (~20 tools, remote HTTP) MCP servers
• Access remote devices via Cisco RADKit cloud relay — discover device inventory, inspect device attributes and capabilities, execute CLI commands with timeout/truncation controls, and perform SNMP GET operations on air-gapped or cloud-unreachable devices without direct SSH/SNMP connectivity
• Automate Juniper JunOS devices via PyEZ/NETCONF — CLI command execution, configuration management, Jinja2 template rendering, device facts collection, and batch operations across router fleets
• Monitor Arista fabric via CloudVision Portal REST API — device inventory, event stream, connectivity monitor status, and device tag management for fleet-wide health assessment
• Monitor Cisco SD-WAN fabric via vManage API (read-only) — device inventory (vManage, vSmart, vBond, vEdge), WAN Edge serial/chassis details, device and feature templates, centralized policies, active alarms, audit events, interface statistics, BFD session health, OMP route analysis, DTLS/TLS control connections, and running config retrieval
• Observe infrastructure via Grafana (75+ tools) — search/view/modify dashboards, query Prometheus metrics with PromQL (interface traffic, CPU, BGP state, error rates, histogram percentiles), query Loki logs with LogQL (syslog, SNMP traps, application logs), manage alerting rules and contact points, track incidents with timeline activities, view OnCall schedules and current responders, annotate dashboards, render panel images, and generate deep links
• Query Prometheus directly (6 tools) — execute instant and range PromQL queries, browse available metrics with pagination, retrieve metric metadata (type, help, unit), inspect scrape target health and status, and verify Prometheus server availability. Supports basic auth, bearer tokens (Grafana Cloud, Thanos, Cortex), and multi-tenant org IDs
• Inspect Kubernetes traffic with Kubeshark (6 tools) — capture L4/L7 traffic across cluster pods, export pcaps for Wireshark analysis, create point-in-time snapshots, filter with KFL expressions, list TCP/UDP flows with RTT metrics, and get top-talker summaries. Automatic TLS decryption via eBPF. Dissects HTTP, gRPC, GraphQL, Redis, Kafka, DNS
• Observe network state with SuzieQ (5 tools) — query current and historical network state across 20+ tables, run BGP/OSPF/interface/EVPN assertions, get aggregated summaries, trace forwarding paths hop-by-hop, and discover value distributions. Time-travel queries for historical analysis
• Troubleshoot EVPN/VXLAN fabrics — VTEP reachability, VNI mapping, EVPN route-type inspection, multihoming state, and underlay/overlay correlation
• Participate in BGP and OSPF as a live routing peer — inject/withdraw routes, query RIB/LSDB, adjust LOCAL_PREF and OSPF cost, peer with real routers over GRE tunnels via native protocol speakers (RFC 4271/5340)
• Trace network paths with gtrace — advanced traceroute with MPLS label detection, ECMP path discovery, and NAT detection; continuous MTR monitoring with per-hop loss and jitter; distributed GlobalPing probes from 500+ worldwide locations; ASN ownership lookup, geolocation, and reverse DNS for IP enrichment
• Scan for CVE vulnerabilities against the NVD database with CVSS severity correlation and exposure confirmation
• Manage F5 BIG-IP load balancers — virtual servers, pools, iRules, stats, and change management
• Audit F5 BIG-IP via iControl REST API — LTM virtual servers, pools, nodes, 40+ monitor types, 60+ profile types, iRules, GTM wide IPs, system health (CPU, memory, disk), HA sync-status, certificates, analytics (HTTP, TCP, DNS, DoS), live-update signature freshness
• Operate Catalyst Center — device inventory, client monitoring, site management, and troubleshooting
• Calculate IPv4 and IPv6 subnets — VLSM planning, wildcard masks, allocation standards
• Alert via Slack — severity-formatted notifications, incident workflows, and user-aware routing
• Alert via Cisco WebEx — Adaptive Card-formatted notifications with interactive incident management buttons, threaded investigation, user-aware escalation via People API, and voice responses
• Diagram your network with Draw.io topology maps (color-coded by reconciliation status)
• Visualize protocol hierarchies as interactive Markmap mind maps
• Render inline Canvas/A2UI visualizations in chat — topology maps with health-colored nodes, real-time dashboards (CPU, memory, BGP, OSPF), severity-sorted alert cards, ServiceNow change request timelines, config/routing/ACL diffs, hop-by-hop path traces with ECMP and black hole detection, and aggregated health scorecards with drill-down
• Generate UML and infrastructure diagrams via Kroki — 27+ types including network topology (nwdiag), rack layouts (rackdiag), packet headers (packetdiag), protocol state machines, sequence diagrams, C4 architecture, Mermaid, D2, Graphviz, ERD — output as SVG, PNG, PDF
• Reference IETF RFCs and Wikipedia for standards-compliant configuration
• Store reports, config backups, and diagrams on SharePoint via Microsoft Graph
• Generate Visio topology diagrams from CDP/LLDP discovery and upload to SharePoint
• Notify via Microsoft Teams — health alerts, change updates, and report delivery to Teams channels
• Analyze packet captures — upload a pcap to Slack and NetClaw runs deep tshark analysis: protocol hierarchy, conversations, endpoints, DNS/HTTP extraction, expert info, and filtered inspection
• Track network changes in GitHub — create issues from findings, commit config backups, open PRs for changes, link to ServiceNow CRs
• Manage Jenkins CI/CD pipelines (16 tools via remote HTTP) — monitor job and build status, trigger parameterized builds with human-in-the-loop confirmation, analyze build logs with regex search, track SCM changes and correlate commits with builds, verify Jenkins health and authentication — via the official Jenkins MCP Server plugin (Streamable HTTP transport)
• Track Jira issues and Confluence pages (72 tools via stdio) — search issues with JQL, create and update issues with human-in-the-loop, transition through workflows, link issues, manage Confluence pages with CQL search, create postmortems and runbooks, cross-product incident-to-documentation workflows — via the community mcp-atlassian server (Cloud + Server/DC support)
• Orchestrate network services via Cisco NSO — retrieve device configs from NSO's CDB, check sync status, inspect operational state, discover service types and deployed instances, platform inventory, and NED management — all via RESTCONF from Slack
• Simulate network topologies in Cisco CML — create labs, add nodes, wire links, start/stop labs, execute CLI commands, capture packets on lab links, and manage CML users — all from natural language via Slack
• Deploy containerized network labs via ContainerLab — deploy multi-vendor topologies (SR Linux, cEOS, IOS XR, NX-OS, FRR, cRPD), inspect running labs, execute commands on nodes, and destroy labs when done — all through the ContainerLab API
• Inspect AWS cloud networking — VPCs, Transit Gateways, Cloud WAN, VPN tunnels, Network Firewalls, flow logs, ENI details, and route tables via 27 read-only AWS Network tools
• Monitor AWS CloudWatch — query metrics (VPN tunnel state, NAT GW drops, TGW traffic), check alarms, run Logs Insights queries, analyze VPC flow logs
• Audit AWS security — IAM users/roles/policies (read-only), CloudTrail API event history, credential rotation compliance, MFA enforcement
• Analyze AWS costs — service breakdowns, network cost drivers (NAT GW, TGW, VPN, data transfer), monthly trends, forecasts, anomaly investigation
• Diagram AWS architecture — auto-discover and render VPCs, subnets, TGWs, load balancers as visual topology diagrams (requires graphviz)
• Stream gNMI telemetry from Cisco IOS-XR, Juniper, Arista, and Nokia SR OS devices — structured YANG model queries, SAMPLE/ON_CHANGE subscriptions, ITSM-gated configuration changes, YANG capability browsing, and gNMI-vs-CLI state comparison
• Audit every action in an immutable Git-based trail (GAIT) — there is always an answer to "what did the AI do and why"
• Track token consumption and cost in real-time — every interaction displays input/output tokens, USD cost, and GCF savings. Session-level tracking with per-tool breakdown. Powered by Anthropic's count_tokens() API with local estimation fallback
• Encode tool responses with GCF (Graph Compact Format), with JSON fallback. Generic encoding is checked for a lossless round trip. Graph summaries and deltas retain a complete authoritative source snapshot so metrics, errors, timestamps, and other fields are never silently dropped. Savings depend on the payload and mode; earlier 91–99% figures described reduced graph projections, not complete operational evidence. Configure NETCLAW_GCF_MODE as full (default), graph, generic, or off.
• Remember across sessions with MemPalace — semantic search across all past sessions, temporal knowledge graph for network facts (upgrades, peer changes, maintenance windows) with validity windows, cross-domain navigation between wings, and per-agent diaries. Complements OpenClaw's file-based daily logs (memory/YYYY-MM-DD.md) with structured, searchable long-term memory — "GAIT records what happened. MemPalace remembers why."
• Secure production deployments with DefenseClaw — Cisco AI Defense enterprise security: OpenShell kernel-level sandbox (Landlock, seccomp, namespaces), component scanning before execution, CodeGuard static analysis, LLM prompt/completion inspection, runtime guardrails, SQLite audit logging with SIEM export (Splunk HEC, OTLP) for SOC2/PCI-DSS/HIPAA compliance

Enterprise Security

NetClaw includes DefenseClaw from Cisco AI Defense as the recommended enterprise security layer:

| Feature | Description | |---------|-------------| | OpenShell Sandbox | Kernel-level isolation (Landlock, seccomp, network namespaces) | | Component Scanning | Skills, MCPs, and plugins scanned before execution | | CodeGuard Analysis | Detect hardcoded credentials, eval, shell commands, SQL injection | | Runtime Guardrails | LLM inspection + tool call inspection with 6 rule categories | | Audit Logging | SQLite database with SIEM export (Splunk HEC, OTLP) |

Enable DefenseClaw

# During installation
./scripts/install.sh
Answer "y" to "Enable DefenseClaw (recommended)?"
Or enable later
./scripts/defenseclaw-enable.sh

Key Commands

defenseclaw --version              # Check installation
defenseclaw skill scan <name>      # Scan a skill before use
defenseclaw tool block <tool>      # Block a dangerous tool
defenseclaw alerts                 # View security alerts

Full documentation: docs/DEFENSECLAW.md | Security Principles | Upgrade Guide

Check Point Security Integration

NetClaw integrates with Check Point's enterprise security platform through 15 official MCP servers, providing AI-powered automation for firewall policies, threat intelligence, gateway diagnostics, SASE management, and malware analysis.

| Domain | MCP Servers | Capabilities | |--------|-------------|--------------| | Policy Management | management, policy-insights | Audit rules, suggest optimizations, NAT review | | Threat Intelligence | reputation-service | IP/URL/file reputation lookups | | Gateway Diagnostics | quantum-gw-cli, gw-connection-analysis | Health, ClusterXL, connection debug | | Threat Prevention | threat-prevention | IPS signatures, IOC feeds, profiles | | SASE | harmony-sase | Cloud-delivered security regions and apps | | Malware Analysis | threat-emulation | File sandboxing and verdicts | | HTTPS Inspection | https-inspection | SSL/TLS decryption policies | | More | gaia, docs, spark, cpinfo, argos, logs | OS mgmt, docs search, MSP, diagnostics, ERM |

Enable Check Point Integration

# During installation
./scripts/install.sh
Answer "y" to "Enable Check Point Security Integration?"
Or enable for existing installation
./scripts/checkpoint-enable.sh

Example Queries

/checkpoint show me all firewall policies
/checkpoint check reputation of IP 185.220.101.1
/checkpoint show gateway health status
/checkpoint what IPS protections are available for CVE-2024-1234
/checkpoint cross-reference firewall rules with my CML lab topology

Full documentation: docs/CHECKPOINT.md | Skill Definition

Optional Jev Science Officer

Border can consult Jev for evidence review, specialist selection, answer review, diagnostic advice, change-plan review and incident triage. It invents typed questions from the current human request and member evidence, then explains whether Jev's assessment supported, challenge

... (README truncated for length)