Can an LLM Pick the Right EIGRP Feasible Successor? DUAL's Strict-Inequality Trap
Small, real, reproducible test run 16 November 2026 - EIGRP DUAL successor and feasible-successor selection evaluated case-by-case, not a benchmark claim. The deterministic ground-truth script and the model's raw reply are linked in Sources. Disclosure: this article was drafted with AI assistance; the test itself was run against a second, independent model instance so the author's own writing didn't also grade its own homework.
The first eleven tests in this series covered BGP, LPM, LDP/LFIB, SPF, ACLs, CIDR, STP, redistribution, VRRP/HSRP, QoS policing, and BGP route-reflector loop prevention. This twelfth test goes back to the control plane with EIGRP's DUAL (Diffusing Update Algorithm): given a router with several neighbors advertising a route, which one is the successor, which others (if any) qualify as feasible successors for instant backup, and - critically - does the router have a loop-free backup at all, or would a link failure force it into "active" state and a full query/recompute?
- Tested 3 independent EIGRP DUAL scenarios: a clean case, a reported-distance comparison trap, and a strict-inequality boundary trap.
- 3/3 cases matched an independently computed ground truth, including both traps.
- Trap 1 (Case B): among the non-successor neighbors, N2 has the numerically lowest reported distance (RD=700), but the feasibility condition compares RD to the feasible distance (FD=600), not to other neighbors' RD - N2's RD is still ≥ FD, so it does NOT qualify. N3, with a higher RD (550) that happens to be below FD, is the real feasible successor. The model did not fall for "lowest RD among the rest wins."
- Trap 2 (Case C): N3's RD (600) lands exactly equal to FD (600). The feasibility condition is a STRICT inequality (RD < FD, not ≤), so an exact tie does NOT qualify as a feasible successor - with zero feasible successors, DUAL must go active (query neighbors) if the successor fails, even though N3 looked close. The model got the boundary direction right.
- Same operational conclusion as the first eleven tests: diff the model's successor/FD/feasible-successor-list/active-or-not output against a deterministic DUAL simulator, never eyeball it.
Why EIGRP DUAL is a good test · The test: three neighbor tables · What came back · Citations · Twelve tests, one verification pattern · FAQ
Why EIGRP DUAL is a good test
EIGRP's DUAL algorithm is often summarized loosely as "pick the lowest-cost path, keep a backup." The actual feasibility condition is more specific and easy to misstate: a neighbor only qualifies as a feasible successor if its own reported distance (RD) to the destination - the metric it is advertising, not the metric through the local router - is strictly less than the feasible distance (FD), defined as the lowest total metric via the current successor. This guarantees the backup path cannot loop back through the local router. The common wrong mental model is comparing a candidate neighbor's RD against other candidates' RD ("pick whichever leftover neighbor looks cheapest"), or treating the comparison as RD ≤ FD instead of RD < FD. Both mistakes are easy to make reading a topology table casually, and both produce a specific, predictable wrong answer: accepting a neighbor that is not actually guaranteed loop-free, or declaring a feasible successor exists when DUAL would in fact have to go active.
The test: three neighbor tables
Three independent cases, each giving a router's neighbors with their reported distance (RD, the neighbor's own metric to the destination) and the link cost from the local router to that neighbor. Total metric via a neighbor = link_cost + RD. The successor is the neighbor with the lowest total metric (this becomes FD). A feasible successor is any OTHER neighbor whose RD is strictly less than FD.
Case A (clean case): N1: RD=500, link_cost=100 -> total 600 N2: RD=300, link_cost=500 -> total 800 N3: RD=900, link_cost=50 -> total 950 Case B (RD-vs-FD trap): N1: RD=500, link_cost=100 -> total 600 N2: RD=700, link_cost=50 -> total 750 N3: RD=550, link_cost=400 -> total 950 Case C (strict-inequality boundary trap): N1: RD=500, link_cost=100 -> total 600 N2: RD=650, link_cost=20 -> total 670 N3: RD=600, link_cost=10 -> total 610
Ground truth was computed independently in Python (ops/eigrp_fs_test_calc.py → ops/eigrp_fs_test_ground_truth.json), not hand-checked: Case A -> successor N1, FD=600, feasible successors=[N2] (RD 300 < 600); Case B -> successor N1, FD=600, feasible successors=[N3] only (N3's RD 550 < 600, but N2's RD 700 is NOT < 600 despite N2 looking "cheaper" than N3 on raw RD); Case C -> successor N1, FD=600, feasible successors=[] (N3's RD 600 is NOT strictly less than FD 600 - exact tie fails the condition), so DUAL would have to go active if N1 failed.
What came back
| Case | Ground truth | Why it's notable | Model's answer | Match? |
|---|---|---|---|---|
| A | Successor N1, FD=600, FS=[N2], active=false | Straightforward - one clear backup | Successor N1, FD=600, FS=[N2], active=false | Yes |
| B | Successor N1, FD=600, FS=[N3], active=false | Trap: N2 has the lowest raw RD among non-successors but RD(700) ≥ FD(600) - not feasible; N3 qualifies instead | Successor N1, FD=600, FS=[N3], active=false | Yes |
| C | Successor N1, FD=600, FS=[], active=true | Boundary trap: N3's RD(600) exactly equals FD(600) - feasibility condition is strict <, so no feasible successor exists at all | Successor N1, FD=600, FS=[], active=true | Yes |
All 3 cases matched the independently computed ground truth on successor, FD, the feasible-successor list, and the active/no-active call - including both traps. Case B is the sharper of the two in practice: it's the one that bites engineers reading a topology table by eye, because N2's RD genuinely is the lowest number among the non-successor rows, and "lowest number wins" is the instinctive (wrong) read. Case C is the one that matters operationally: getting it wrong in either direction either hides a real risk of an active/query storm, or wrongly assumes no risk exists.
Citations
Unlike the pure-arithmetic tests (SPF, LPM, CIDR, STP cost math, QoS policing), this test's correct handling of the RD-vs-FD comparison and the strict-inequality boundary maps directly to specific, named protocol behavior documented in EIGRP's informational RFC and Cisco's own EIGRP documentation - both checked live before publishing, see Sources below.
Twelve tests, one verification pattern
Twelve tests now, twelve different flavors of network-engineering judgment - BGP best-path, longest-prefix-match, LDP/LFIB construction, OSPF SPF, ACL ordering, CIDR route summarization, STP root/port election, route redistribution, VRRP/HSRP election, QoS token-bucket policing, BGP route-reflector loop prevention, and now EIGRP DUAL feasible successors - and the same operational conclusion every time: a model's structured output is either demonstrably right or demonstrably wrong against a deterministic ground truth, never just "plausible." This test is worth flagging separately because its trap isn't about tiebreak ordering or stateful arithmetic, it's about which TWO quantities you're allowed to compare - RD against FD, never RD against another neighbor's RD, and never with a loose inequality where the protocol specifies a strict one. That is exactly the kind of subtle comparison-target error that reads fine in prose and is wrong on the wire.
| Step | Who does it | How you check it |
|---|---|---|
| 1. Topology table (neighbors, RD, link cost) → structured input | LLM | Schema check against the actual per-neighbor RD and link-cost values |
| 2. Successor / FD / feasible-successor-list / active-or-not verdict | LLM, or your own code | Diff against a deterministic script that compares every non-successor neighbor's RD strictly against FD, never against each other |
| 3. Present the result | LLM, fed the already-verified decision | Specifically re-check any case where a non-successor's RD is numerically close to or exactly equal to FD |
For the earlier tests in this series, see Can an LLM Reason About BGP Route-Reflector Loops?, Can an LLM Run a Token-Bucket QoS Policer?, and Can an LLM Get Route Redistribution Right?. For keeping an AI agent bounded and read-only around real device state more generally, see our piece on a read-only network change reviewer.
Frequently asked questions
What is the feasibility condition in EIGRP DUAL?
A neighbor qualifies as a feasible successor only if its own reported distance (RD) to the destination is strictly less than the feasible distance (FD) - the lowest total metric via the current successor. This guarantees the neighbor's path cannot loop back through the local router.
Is a feasible successor's RD compared to the successor's metric or to other neighbors' RD?
Neither. It is compared only to the feasible distance (FD), which is the router's own lowest total metric to the destination. A neighbor with a numerically lower RD than other candidates can still fail the feasibility condition if its RD is not below FD.
What happens if a successor fails and there is no feasible successor?
EIGRP cannot do an instant local switchover. The route goes into "active" state and the router sends queries to its neighbors to recompute a loop-free path, which is slower than a feasible-successor switch and can affect convergence time.
Does an RD exactly equal to FD qualify as a feasible successor?
No. The feasibility condition is a strict inequality (RD < FD). An exact tie does not satisfy it, so that neighbor is not a feasible successor.
Sources
Checked 16 November 2026.
- IETF, RFC 7868 "Cisco's Enhanced Interior Gateway Routing Protocol (EIGRP)" (informational) - defines reported distance, feasible distance, and the feasibility condition for feasible successors - rfc-editor.org/rfc/rfc7868.html
- Cisco, "Enhanced Interior Gateway Routing Protocol (EIGRP)" support/technology page - DUAL successor and feasible-successor behavior as implemented on real routers - cisco.com/.../16406-eigrp-toc.html
- Ground-truth script and raw model reply:
ops/eigrp_fs_test_calc.py,ops/eigrp_fs_test_ground_truth.json, full exchange logged inops/szafa_log.md(2026-11-16T21:21).
Try it: EIGRP Metric Calculator - free, runs in your browser.
Related reading
- Claude Fable 5.2: Six Useful Projects Beyond the Viral Demos
- Build a Read-Only Network Change Reviewer with Claude Fable 5.2
- GPT-6 Cyber and Prompt Injection: How Untrusted Text Reaches Agent Tools
- Administrative Distance vs Metric vs Longest Prefix Match Explained
- Route Redistribution Risks Between OSPF, EIGRP and BGP: Loops, Tags and Metrics
- EIGRP Metric and K-Values Explained: Formula, Examples and Troubleshooting
Comments
Post a Comment