NetClawAINetwork automation

How My Agent Could Have Prevented All of This

I spent nine hours in a Chicago airport on my way to an event.

Nine hours is a generous amount of time to think about network reliability. Particularly when you build network automation tools for a living.

Then I read what was emerging about Friday, November 13, 2026: a router replacement, another site reacting, a network disruption spreading, and a country full of people going absolutely nowhere.

And yes, my first thought was:

My lobster should have been in that change meeting.

I build NetClaw, an open-source network engineering agent. It connects reasoning to real tools: device testing, routing protocols, sources of truth, change management, network models, labs, and operational systems. That combination matters enormously when the thing you are changing is connected to everything else.

The title says could. I cannot prove the outcome of an FAA deployment that never happened. What I can do is show where a properly equipped, properly authorized NetClaw could have challenged the plan—and how I would require it to behave if its own change went sideways.

Because “trust the humans” deserves the same hard questions as “trust the agent.”

A robotic NetClaw lobster at a Chicago airport watches a conceptual router cascade while a board reads Chicago, delayed, nine hours.
My nine hours in Chicago, illustrated. The network above the terminal is a visual metaphor, not the FAA's topology.

This weekend's failure, with Sunday's update

The FAA's November 15 account says instability began around 3:30 p.m. Eastern on Friday and affected 17 of 22 Air Route Traffic Control Centers, plus several approach-control facilities. It identifies El Dorado, Arkansas, and Amarillo, Texas, as potential sources of excessive data. Blocking those sites stabilized the network. Air traffic resumed at 8:15 p.m. The implicated functionality was disabled on approximately 60 similar routers. The investigation remained open. FAA, November 15

DOT's Sunday update adds the detail that should make every migration engineer sit up: after the new router in El Dorado was switched on, equipment in Amarillo—replaced about three weeks earlier—also began flooding the system. The routers were undergoing laboratory diagnostics. DOT, November 15

Then came today's manufacturer response. HPE, which owns Juniper, told ABC News that, based on its current information, the device operated according to the installer's configuration and had not malfunctioned. That is the manufacturer's position, not a final independent finding. L3Harris says it is supporting the investigation. HPE statement to ABC News · L3Harris statement

But consider the implication if HPE's account holds: a router can obey its configuration perfectly and still participate in a system-wide disaster.

That is why “the config loaded” is such a spectacularly inadequate definition of success.

The public accounts reviewed do not establish the exact offending protocol, firmware, or configuration. “Broadcasting” does not diagnose an Ethernet broadcast storm. “Connection attempts” does not prove an ICMP flood. I am not going to invent a BGP root cause because my agent happens to speak BGP.

A small change does not get to declare itself a small risk

“We're only replacing one router” describes the work order. It says remarkably little about the consequences.

My first instruction to NetClaw would be: show me what this change can touch, including what we changed last month.

Give it the ServiceNow change record, the affected configuration items, recent related changes, the intended topology, and live observations. Make it reconcile the source of truth against the network before anyone treats the diagram as gospel. NetClaw has a ServiceNow change workflow, a NetBox reconciliation procedure, and inventory composition routes covering NetBox, Nautobot, Infrahub, controllers, labs, and other systems.

The useful output is a set of uncomfortable questions. Does another site use the same feature and software? Does a previous migration share this service boundary? Is the “backup” dependent on the same gateway? Does the CMDB agree with the actual interfaces and neighbors? What happens to the old equipment when the new equipment starts talking?

That last question is where a cable-upgrade story becomes a systems-engineering story. Copper and fiber are media. They do not explain every interaction between the services carried over them.

Amarillo belongs in this discussion because of Sunday's reported sequence. A device can be outside today's work order and inside today's blast radius.

There is also an organizational boundary. PASS, the union representing FAA technicians, says its represented technicians were not involved in the upgrades that led to the disruption. That is a stakeholder account, not a completed investigation. It raises an obvious planning requirement: verify that the people responsible for the affected services are actually represented in the change. PASS statement

An agent cannot manufacture missing approvals or missing inventory. It can expose them, refuse to call incomplete evidence a pass, and keep the change from advancing until the gap is resolved. That is useful authority to give an agent.

Break the plan in the twin before the plan breaks the network

I want the rehearsal to include the awkward bits: the legacy neighbor, the previous upgrade, the shared service, the alternate path, and the recovery connection.

NetClaw can connect three kinds of evidence:

What we need to learn Tools NetClaw can bring together What a good result establishes
Will the proposed configuration violate our requirements? Batfish; processed network evidence from Forward Networks or IP Fabric Supported-model reachability, paths, policy, and differences
What actually happens during the transition? CML, containerlab, GNS3, or EVE-NG with suitable images; physical equipment where needed Observed behavior for the tested versions, topology, sequence, and load
Does the real network still deliver the service? pyATS, supported vendor tools, telemetry, and endpoint tests Measured state and service behavior at the observation points

Those are complementary jobs. A gorgeous 3D network visualization helps us understand a dependency. It does not execute router firmware. A static model can catch a forwarding mistake. It does not certify that an appliance survives a startup storm. An executable lab is only as representative as the equipment, versions, traffic, and dependencies we put into it. NetClaw's own Batfish implementation explicitly distinguishes static-model evidence from behavioral equivalence.

So rehearse the sequence, not just the finished configuration. Start the replacement. Bring up its neighbors. Interrupt the new path. Restore it. Repeat the reconnect. Observe the previously migrated equipment. Exercise the alternate path. Lose the management session. Check that recovery still works.

Measure the things the service owner actually cares about: expected flows in both directions, latency and loss, unwanted traffic, session churn, resource pressure, and the survival of the management path. Freeze the assertions before the test. A failed test stays failed even if the agent writes a very persuasive paragraph afterward.

There are practical limits worth being explicit about once: Forward's current NetClaw MCP integration is read-only and snapshot-based; the rehearsal procedure requires qualified images and platform access; a Juniper logo does not establish which OS or tool will work. These are documented integration boundaries, not excuses to skip the rehearsal. NetClaw rehearsal procedure

If we cannot represent the risky interaction, we have found a reason to investigate further. We have not earned a green light.

NetClaw joins change history, source of truth, and live state in an isolated network rehearsal while production remains separated.
Proposed workflow: connect the evidence, reproduce the transition, and contain the experiment. Conceptual illustration; no FAA environment was reproduced.

My agent can actually become a neighbor

This is one of the NetClaw capabilities I wish more people understood: it can participate in BGP.

There is a real protocol implementation under the conversation. A resident daemon maintains sessions; the tools expose peer state and learned routes. The implementation sends actual advertisements and withdrawals. The model is not sitting there improvising every KEEPALIVE. Protocol source

That gives us a useful third viewpoint: what the model predicts, what the device reports, and what a real protocol neighbor receives.

A compatible older router does not need to grow an AI API to participate. It needs an explicitly designed, permitted peering relationship. In a qualified observation setup, I would restrict exports, prevent unintended transit, and compare expected routes and session behavior before and after the change. In an isolated lab, controlled advertisements and withdrawals can exercise the boundary.

I am not selling this as omniscience. A peer sees what its neighbors export. A route in a routing table does not prove the application works. The current announcement code also contains lab-specific behavior that needs qualification before production use. And we still do not know whether BGP had anything to do with Friday's fault.

The value is another independent measurement—not a new theory invented to fit my product.

Fine, John. What if NetClaw made the change and broke it?

Good. Ask that. Ask it before giving the agent credentials.

Here is the operating contract I would require for this class of change. This is a proposed deployment design assembled from NetClaw capabilities, not a claim that today's installation includes an autonomous FAA-grade protection system.

1. Give the change a hard boundary. Identify exact devices, interfaces, candidate configuration, maintenance window, approved actions, and recovery steps. Stage the rollout. Do not allow the next site to proceed because the first device merely accepted a command. NetClaw already has implemented ServiceNow verification gates on specified write paths; that is not universal enforcement across every MCP. Every chosen execution path must be checked.

2. Install the brake before touching the accelerator. Define observable stop conditions and the smallest safe containment action in advance. Service failure, unexpected reachability, excessive session churn, or loss of required telemetry must stop progression. Fast protection belongs in tested device controls or a deterministic workflow with preauthorized actions. We should not wait for a model to finish reasoning while a failure spreads. Itential is one available orchestration integration; the actual watchdog and containment workflow would still need to be built and qualified. Itential integration

3. Contain, notify, and preserve evidence. Freeze further rollout. Execute only the previously approved containment appropriate to that service—possibly isolating the new segment or disabling a specific feature. Capture what changed and what failed. Notify the responsible humans with the affected services, measurements, actions taken, and next decision. NetClaw has PagerDuty incident tooling and communication workflows, but their write permissions and required confirmations still apply. Automatic paging requires an explicitly authorized integration; installing a skill is not that authorization.

4. Recover through a path that survives the outage. Prove out-of-band reachability before the cutover. NetClaw's Lantronix Percepxion workflow can inspect console infrastructure and locate the connection. It does not, by itself, provide an interactive serial session to every attached router. Qualify that recovery route. Rehearse the platform's actual rollback semantics. Pasting old configuration back in may leave new state behind, and no chatbot can physically reconnect a cable. Keep the field recovery plan.

5. Verify the service before declaring victory. Repeat the agreed tests from independent observation points. Watch long enough to catch the behavior the trial is meant to expose. Preserve failed assertions, configuration hashes, timestamps, and actual results. A timed-out write has an unknown outcome until we inspect the device; blindly retrying can compound the incident. NetClaw's configuration workflow supplies the baseline/apply/verify structure. Recovery still needs its own proof.

I want an agent whose failure is bounded and whose actions are explainable. I want exactly the same from the humans.

NetClaw opens a circuit breaker around a failing network segment, with a healthy alternate path and a separate recovery connection.
Proposed containment: a small failure boundary, a surviving service path, and independent recovery access. Illustration of the design goal, not a measured NetClaw response.

The questions hiding behind the headline

The reported rate was over 1,000 connection attempts every four to five seconds—roughly 200–250 per second. That number alone does not tell us whether bandwidth, a control-plane process, fan-out, or retries were the limiting factor. I want packet evidence. NetClaw's Packet Buddy workflow can examine supplied captures; telemetry integrations can add device and flow context. The measurements should determine the remedy. DOT's reported connection rate

Then investigate the fleet. Search for the same software, feature, template, and migration pattern. A single-device ticket can hide a shared configuration problem. The precaution across roughly 60 routers makes that an especially relevant question here.

Test the observers, too. Deliberately lose a telemetry feed during rehearsal. Make sure “no data” cannot become “healthy.” Limit collection so an agent does not hammer a struggling router with a hundred helpful SSH sessions. Protect the model connection, credentials, notification route, and recovery channel from the same outage we expect them to diagnose.

And give the agent its own blast radius. Separate read-only analysis from write authority. Use narrow tool and credential scopes. Treat device output and ticket text as evidence, never as permission to run arbitrary instructions. NetClaw's Border/member architecture provides a way to organize specialists; the actual deployment still has to demonstrate its isolation. Ten agents sharing one bad assumption are ten copies of the same problem.

That is where MCP matters. It connects the systems that hold different pieces of the answer. It does not guarantee the answer, the freshness of the data, or the safety of a write. Commercial systems also retain their own deployment and licensing requirements; NetClaw's open-source license does not include them.

We need to get much less sentimental about human control

Here is the spicy part: human involvement is not a reliability guarantee.

We ask whether an agent might make a mistake. Absolutely. Now apply that standard to the process we already trust. Where is its evidence? Where is its tested containment? Where is its proof that the backup survives the same failure?

I am not going to claim every outage is human error. Hardware fails. Software has defects. Models make mistakes, too. Friday's final root cause is still unresolved. And the FAA credits controllers and pilots with keeping aircraft safe; the ground stop was a protective action. The agency also says SMART was unrelated. FAA's current account

My criticism is of an operating model that relies on people to manually connect every dependency, remember every previous change, spot every mismatch, and remain perfectly attentive throughout the window.

We can give those people something better.

Give an agent enough access to investigate the whole change. Give it repeatable tests. Give it permission to challenge missing evidence. After qualification, give it narrowly defined authority to halt an unsafe progression and carry out a rehearsed response. Keep hard enforcement outside the model's persuasive abilities.

That is the trust I am arguing for. We should be expanding it through measured performance in shadow mode, adversarial rehearsals, and limited deployments. Make agents demonstrate their value, then let them do the work they have demonstrated they can do.

A change request should be a set of executable promises. These services will work. These boundaries will hold. This is how we stop. This is how we recover. Here is the evidence.

I want NetClaw helping make those promises real. I want fewer engineers trapped in emergency calls, fewer passengers trapped at gates, and fewer ordinary maintenance tasks growing into national events.

And the next time I travel to an event, I would very much like to arrive at the event.

My lobster can spend nine hours in the lab. I am done donating them to the airport.


Incident: November 13, 2026; reporting refreshed through November 15, 2026, 22:53 UTC. NetClaw source inspected at commit a5e7c3a3e07d8c8c4f2f26d22b4bd854dd1ba42e. No FAA access, reproduction, or prevention benchmark is claimed. The Chicago experience is the author's account. Images were created with ChatGPT Image Creator and are conceptual illustrations.

← More field notes