NetPilot

AI-Native Network Testing Lab

The agent builds the lab, writes the test plan, runs the tests, and hands you the report.

Watch Demo
app.netpilot.io

See It in Action

Watch NetPilot build a multi-vendor lab from a single description — then run the tests and verify on real CLIs.

Why lab-based network testing matters

11%
of orgs apply pre-change validation consistently — 98% claim a process (EMA)
$5,600
average cost of network downtime per minute (Gartner)
~2 min
from plain-English objective to a runnable multi-vendor test lab
12+
network OSes in one lab — FRR test neighbors built in

Testing a specific production change? Network Change Validation covers the mirror-lab pre/post snapshot workflow; Network Digital Twin is the umbrella platform; rehearsing a vendor swap belongs in the Network Migration Lab.

How NetPilot differs for network testing

Not a framework you script, not a chassis you rack — an agent that builds the test lab and runs the tests end to end, with real CLIs one SSH away.

The agent runs the tests

State the objective in plain English — the agent runs iperf3, tc, ping, and vendor show commands, and reads the results.

The alternative

pyATS / ANTA / Robot suites are powerful but hand-coded — most teams never get past the spreadsheet test plan.

Real traffic, real protocol stacks

Measured throughput, loss, jitter, and RTT on real links; BGP/OSPF/IS-IS actually converging — not a model's prediction.

The alternative

Offline verifiers analyze configs but never send a packet; simulators approximate behavior instead of executing NOS code.

Test plan in, report out

The agent writes the test plan from your design, executes every case, and hands you a pass/fail report with CLI evidence.

The alternative

Test plans live in spreadsheets and run by hand — EMA found 98% of orgs claim a validation process; 11% apply it consistently.

Lab in ~2 minutes

Browser only — multi-vendor topology with FRR test neighbors deployed in ~2 minutes, tested the same hour.

The alternative

DIY EVE-NG / GNS3 test rigs take days of image hunting and wiring before the first iperf flow runs.

The testing loop, in product

Objective in, evidence out. The agent designs the lab, executes the test plan with real tools — iperf3, tc/netem, vendor CLIs — and reports every measurement.

Describe the test, get the lab

State the objective — topology, vendors, and what to prove. The agent designs the lab, adds FRR neighbors for BGP/OSPF/IS-IS peering, and deploys it on real NOS images in ~2 minutes.

app.netpilot.io

The agent executes the test plan

iperf3 flows for throughput and jitter, tc/netem impairments for loss and delay, DSCP-marked traffic for QoS, link failures for convergence — the agent runs each case and captures the measurements as it goes.

app.netpilot.io

Report in hand, CLIs open

Every test returns pass/fail with the measured numbers and the command output behind them. SSH into any device to reproduce a result by hand — the agent is for speed, the CLI is the trust layer.

app.netpilot.io

Network tests the agent runs for you

Every test executes on real NOS code with real traffic — described in plain English, measured and reported by the agent, reproducible by hand over SSH.

Throughput & bandwidth testing

iperf3 flows between lab endpoints measure TCP/UDP throughput, loss, jitter, and RTT across any path — the agent runs the flows and reports the numbers.

Impairment testing (tc/netem)

Inject delay, jitter, and packet loss on chosen interfaces to model a degraded WAN — then prove your apps and protocols survive it.

QoS & DSCP validation

Generate DSCP-marked flows, congest the link, and verify classification and queuing counters keep each class inside its targets.

BGP / OSPF / IS-IS convergence

Peer your device under test against built-in FRR neighbors, fail the primary path, and measure reconvergence with in-flight probes.

Failover & HA testing

Shut links, kill peers, or destroy a device container — verify HSRP/VRRP, LACP, and routing failover behave under real failure.

Cutover rehearsal

Execute the maintenance-window runbook against a mirror of the affected segment — time each step, catch ordering mistakes, practice rollback.

Test plans & NRFU acceptance

The agent derives the NRFU battery from your design — adjacencies, routes, reachability, failover, baselines — executes it, and signs off with evidence.

Regression & automation suites

Run existing pyATS, ANTA, or Ansible checks against the lab over SSH, and let the agent cover the cases nobody scripted.

NetPilot vs network testing alternatives

Head-to-head across hardware traffic generators, test frameworks, DIY lab rigs, and NetPilot. Hardware keeps line-rate certification; frameworks keep scripted assertions — NetPilot owns the agent-run functional tier.

Primary use case
NetPilot
Agent-run functional testing — traffic, impairments, convergence, QoS
Hardware testers (Keysight / VIAVI)
Line-rate 100/400G characterization + conformance
Test frameworks (pyATS / ANTA)
Scripted state assertions on existing devices
DIY lab + iperf/TRex
Hand-built functional testing on owned rigs
Who writes & runs the tests
NetPilot
The agent — from a plain-English objective
Hardware testers (Keysight / VIAVI)
Dedicated test engineers per chassis
Test frameworks (pyATS / ANTA)
You code and maintain every test
DIY lab + iperf/TRex
You script and drive everything
Builds the test environment
NetPilot
Multi-vendor lab in ~2 min, FRR neighbors built in
Hardware testers (Keysight / VIAVI)
Ports only — DUT rig is on you
Test frameworks (pyATS / ANTA)
Needs an environment to run against
DIY lab + iperf/TRex
Days of image hunting + wiring
Live traffic + impairments
NetPilot
iperf3 + tc/netem, agent-driven and measured
Hardware testers (Keysight / VIAVI)
Line-rate, port-dense, protocol-rich
Test frameworks (pyATS / ANTA)
State checks, not traffic
DIY lab + iperf/TRex
iperf3 / TRex / tc by hand
Test plan → report
NetPilot
Generated plan, executed, evidence report out
Hardware testers (Keysight / VIAVI)
Vendor tooling, per-platform
Test frameworks (pyATS / ANTA)
You assemble reporting
DIY lab + iperf/TRex
Spreadsheets and screenshots
100/400G line-rate performance
NetPilot
Software-tier rates — not claimed
Hardware testers (Keysight / VIAVI)
The category owner
Test frameworks (pyATS / ANTA)
Not a traffic tool
DIY lab + iperf/TRex
Software-tier rates
Cost model
NetPilot
Free tier + enterprise plan
Hardware testers (Keysight / VIAVI)
Six-figure chassis + licenses
Test frameworks (pyATS / ANTA)
Open source (your time)
DIY lab + iperf/TRex
Server + weeks of setup time

Where NetPilot fits vs testing alternatives

Pick hardware traffic generators, test frameworks, and DIY test rigs when you need:

  • •Keysight IxNetwork / VIAVI TestCenter for line-rate 100/400G characterization and conformance certification
  • •Cisco pyATS / Arista ANTA when you want code-defined assertions maintained in your own repo
  • •DIY EVE-NG / GNS3 rigs for fully offline testing on owned hardware

Pick NetPilot when you need:

  • •Agent designs the lab, writes the test plan, and runs the tests from plain English
  • •Live traffic + impairments measured with iperf3 and tc/netem — throughput, loss, jitter, RTT
  • •BGP/OSPF/IS-IS convergence and failover against built-in FRR neighbors
  • •Pass/fail evidence report out of every run — NRFU and change-board ready
  • •Real CLIs via SSH on 12+ NOSes to reproduce any result by hand

Verdict:Hardware testers keep the line-rate lane and frameworks keep code-defined suites. NetPilot is the agent-run choice for the functional 80% of network testing — traffic, impairments, QoS, convergence, and acceptance — executed from a plain-English objective in minutes.

Frequently Asked Questions

Common questions about lab-based network testing and the agent-run workflow

A network testing lab is an isolated environment — physical or virtual — where you exercise network behavior before it reaches production: generate traffic and measure throughput, inject impairments like packet loss and jitter, validate QoS policy, and watch routing protocols converge under failure. It is distinct from production monitoring (which observes a live network) and from consumer speed tests. NetPilot is an AI-native network testing lab: describe the test objective in plain English and the agent builds a multi-vendor lab on real NOS images in ~2 minutes, writes the test plan, runs the tests with standard tools like iperf3 and tc, and hands you a pass/fail report you can verify on real CLIs via SSH.
Yes. In a NetPilot lab the agent has real CLI access to every node, so it runs the same tools an engineer would: iperf3 for throughput, packet loss, jitter, and RTT measurement; tc/netem to inject delay, loss, and jitter on specific interfaces; ping/traceroute for reachability and path checks; and vendor show commands for protocol state. You state the objective — 'prove the backup path sustains 500 Mbps with under 50 ms added latency' — and the agent designs the test, executes it end to end, and reports the measured numbers. The same CLIs stay open to you via SSH, so every result is hand-verifiable.
Use software traffic generation inside the lab: iperf3 between Linux endpoints measures TCP/UDP throughput, loss, jitter, and RTT on real links; tc shapes or impairs that traffic to model WAN conditions. This software tier covers most functional and behavioral testing — does the QoS policy classify correctly, does the backup path carry the load, does routing converge under loss. In NetPilot the agent places the endpoints, runs the flows, and reports the measurements from a plain-English request. Hardware platforms such as Keysight IxNetwork and VIAVI TestCenter (formerly Spirent TestCenter) remain the right tool for line-rate 100/400G performance characterization and conformance certification — a lane NetPilot does not claim.
Inject the impairment with tc/netem on a chosen interface — for example 30 ms delay with 5 ms jitter and 1% loss to model a congested WAN link — then measure the effect with iperf3 and ping while your protocols and applications run over it. This answers questions monitoring can't: will VoIP survive the backup circuit, does the routing protocol flap under loss, how does the QoS policy behave when the link degrades. In NetPilot you describe the condition in plain English and the agent applies the netem profile, drives the traffic, and reports measured loss, jitter, and RTT per flow — with SSH access to reproduce any number by hand.
Send marked traffic and verify treatment: generate flows with distinct DSCP values (iperf3 sets DSCP per flow), confirm classification with the vendor's policy counters, then congest the link and measure which class keeps its throughput, delay, and loss targets. A lab is the only safe place to do this — deliberately congesting production to test queuing is not an option. In a NetPilot lab the agent generates the marked flows, congests the path, reads the per-class counters across Cisco, Juniper, Arista, or Nokia devices, and reports whether each class met its target.
Build the routing topology with real protocol stacks, run continuous traffic through it, then fail the primary path and measure what happens: how long until the protocol reconverges, how many packets drop mid-convergence, whether the backup path carries the load. NetPilot ships FRR built in as the neighbor device — a full BGP/OSPF/IS-IS stack that peers with your Cisco, Juniper, Arista, or Nokia device under test — so you can stand up realistic multi-AS or multi-area topologies without extra licenses. The agent runs the failover, measures convergence with in-flight UDP probes, and reports the numbers; SSH in to inspect neighbor state yourself.
Yes — and running it is the part that matters. Give NetPilot the design or the change objective and the agent derives a test plan: reachability matrix, protocol-state assertions, failover cases, throughput and impairment tests, QoS checks. It then executes every case against the lab's real NOS devices and returns a pass/fail report with the command output as evidence. That closes the gap that keeps test plans theoretical — the EMA change-validation study found 98% of organizations claim validation processes while only 11% apply them consistently, largely because writing and running the tests is manual, skill-gated work.
NRFU — network ready for use — is the acceptance-testing phase at the end of a build or migration: a structured battery of checks proving the network's actual operating state matches the design before it carries production traffic. Typical NRFU checks: interface and optics state, protocol adjacencies, expected routing tables, end-to-end reachability, failover behavior, and performance baselines. Teams traditionally script this with pytest or Arista ANTA, or run it from a spreadsheet by hand. In NetPilot the agent generates the NRFU battery from the design, executes it, and produces the signed-off evidence report — and you can rehearse the whole NRFU on a lab mirror before running it against the real deployment.
Yes. Build a mirror of the affected segment, then execute the cutover runbook against it step by step — move the links, swing the routing, watch convergence, run the post-checks, and practice the rollback. Rehearsal surfaces the step ordering mistakes, missed dependencies, and slow convergence that turn a 2-hour window into a 10-hour incident. In NetPilot the mirror lab deploys from a plain-English description or sanitized configs in ~2 minutes, the agent executes and times each runbook step, and the same session produces the evidence your change board wants before the real window.
Only for the top of the market. Hardware platforms — Keysight IxNetwork/IxLoad and VIAVI TestCenter (formerly Spirent TestCenter) — are built for line-rate 100/400G performance characterization, conformance certification, and port-dense chassis testing, and they remain the right tool there. Most day-to-day network testing is functional and behavioral: does the policy work, does the path fail over, does the QoS hold under congestion, does routing converge fast enough. That tier runs on software tools inside a lab — iperf3, tc/netem, real protocol stacks — at a fraction of the cost. NetPilot productizes that tier: the agent builds the lab and runs those tests from plain English.
They are test frameworks; NetPilot is an agent with a lab. Cisco pyATS/Genie and Arista ANTA assert device state from Python — powerful, but you write and maintain the test code, and they need an environment to run against. Batfish analyzes configs offline without running the network. NetPilot supplies both missing halves: a multi-vendor lab that deploys in ~2 minutes, and an agent that designs and executes the tests — traffic, impairments, convergence, QoS — from plain English, no test code required. They compose: run your existing pyATS or ANTA suites against the NetPilot lab over SSH, and let the agent cover the tests nobody scripted.
Two different depths of automation. Script-generation tools such as Netpicker use AI to help you write validation tests, which then run agentless against your existing devices' configs and state — strong for compliance auditing across a live estate, and no lab required. NetPilot's agent owns the whole loop: it builds the lab topology itself, generates the test plan, executes live traffic, impairments, and failover with real tools (iperf3, tc, vendor CLIs), evaluates the results, and writes the report — end to end from one plain-English request. If your need is config-compliance checks on production, a script-based tool fits; if you need to actually run the network and prove behavior before production, that is the NetPilot lane.

Related resources

Traffic Generators for Lab Testing

iperf3 vs TRex vs Ostinato vs OTG — which software traffic generator fits which lab test, honestly compared.

AI-Generated Test Plans & NRFU

From design to executed NRFU battery — how the agent writes and runs the acceptance tests.

Rehearse Your Network Cutover

Why lab-tested changes still blow the window — and how a timed rehearsal catches it first.

AI Network Testing in 2026

The three lanes of AI in network testing — assurance, script generation, and the agent that runs the tests.

Network Change Validation

The mirror-lab pre/post snapshot workflow for validating BGP, ACL, and routing changes.

Network Digital Twin

The umbrella platform — change validation, what-if modeling, and pre-deployment verification.

Run your next test on a lab, not on prod

Describe the objective in plain English. Lab in ~2 minutes. The agent runs the tests and hands you the report.

Try It Free