EIGRP doesn’t fit neatly into the traditional categories of distance-vector or link-state protocols; it’s often called an "advanced distance-vector" or "hybrid" protocol.
Let’s see it in action. Imagine a small network with two routers, R1 and R2, connected directly. R1 has a network 192.168.1.0/24 attached, and R2 has 192.168.2.0/24. We want them to exchange routes using EIGRP.
First, we enable EIGRP on R1 and tell it to participate in Autonomous System (AS) 100, advertising the local network:
R1(config)# router eigrp 100
R1(config-router)# network 192.168.1.0 0.0.0.255
R1(config-router)# no auto-summary
On R2, we do the same:
R2(config)# router eigrp 100
R2(config-router)# network 192.168.2.0 0.0.0.255
R2(config-router)# no auto-summary
Now, R1 and R2 will form an EIGRP neighbor relationship. You can verify this with show ip eigrp neighbors:
R1# show ip eigrp neighbors
EIGRP-IPv4 Neighbors for AS(100)
H Address Interface Hold Uptime SRTT RTO Q Seq
(sec) (ms) Cnt Num
0 10.1.1.2 GigabitEthernet0/1 12 00:01:30 50 200 0 5
This output tells us R1 sees R2 (at 10.1.1.2) as a neighbor on GigabitEthernet0/1. The Hold Time is how long R1 will wait for a packet from R2 before considering it down. Uptime shows how long they’ve been neighbors.
Shortly after forming the neighbor relationship, they exchange their routing tables. R1 learns about 192.168.2.0/24 from R2, and R2 learns about 192.168.1.0/24 from R1. You can see this in show ip route eigrp:
R1# show ip route eigrp
192.168.2.0/24 is directly connected, GigabitEthernet0/1
Wait, that’s not quite right. show ip route eigrp only shows routes learned via EIGRP. The direct network is advertised by the network command, but the learned route will appear here. Let’s re-examine. The network command means "advertise interfaces matching this and participate in EIGRP". So R1 advertises 192.168.1.0/24. R2 advertises 192.168.2.0/24.
R1 sends its EIGRP update to R2. This update contains information about the 192.168.1.0/24 network. R2 receives this update. For each route, EIGRP calculates a metric. This metric is a composite of bandwidth and delay by default, but can be influenced by load and reliability. The formula is:
Metric = [ (10^7 / Bandwidth) + (10^7 / Delay) ] * 256
Where Bandwidth is in kilobits per second, and Delay is in tens of microseconds. R2 calculates the metric to reach 192.168.1.0/24 via R1. Let’s say R1’s interface to R2 has a bandwidth of 1000000 Kbps (1 Gbps) and a delay of 10 microseconds.
Bandwidth component: 10^7 / 1000000 = 10
Delay component: 10^7 / 10 = 1000000
Composite metric: (10 + 1000000) * 256 = 256002560
R2 adds this metric to the metric of its own directly connected network 192.168.2.0/24 to get the total path cost to 192.168.1.0/24. This total path cost is what gets installed in R2’s routing table.
R2 then sends an EIGRP update back to R1 containing the route to 192.168.2.0/24 with its calculated metric. R1 does the same. This is how EIGRP becomes a distance-vector protocol – it relies on information from its neighbors.
The key to EIGRP’s speed and efficiency is its use of the Diffusing Update Algorithm (DUAL). When a route changes, EIGRP doesn’t just flood the entire network with updates like RIP. Instead, it only sends partial, bounded updates to its neighbors. DUAL ensures loop-free paths by calculating feasible successors.
When R1 learns about 192.168.2.0/24 from R2, R2 becomes the successor (the best path). R1 also looks at all other routes advertised by its neighbors to 192.168.2.0/24. If any neighbor advertises a route with a metric less than R1’s current best path’s feasible distance (the metric from R1 to R2 plus R2’s reported metric to the destination), that neighbor becomes a feasible successor. A feasible successor is a backup path that is guaranteed to be loop-free. If R1’s primary path to 192.168.2.0/24 via R2 fails, R1 can immediately switch to the feasible successor without waiting for new convergence information to propagate.
This is how EIGRP can converge in milliseconds. It’s not just about sending updates; it’s about pre-calculating backup paths.
The command show ip eigrp topology is critical for understanding this. It shows all learned routes, their metrics, and their successors/feasible successors:
R1# show ip eigrp topology
EIGRP-IPv4 Topology for AS(100)
Codes: P - Passive, A - Active, D - Dump, s - suppressed
P 192.168.1.0/24, 1 successors, FD is 256002560, Tag is 0
Serial0/0, 10.1.1.1
P 192.168.2.0/24, 1 successors, FD is 256005120, Tag is 0
10.1.1.2/32 via GigabitEthernet0/1, Successor
Metric is 256005120, attached to 10.1.1.2
Here, R1 sees 192.168.2.0/24. Its Feasible Distance (FD) is 256005120. The successor is via 10.1.1.2 (R2) on GigabitEthernet0/1. The metric R2 reported to reach 192.168.2.0/24 is 256002560. R1 adds its own metric to reach R2 (which is 256002560 for the 192.168.1.0/24 network) to R2’s reported metric, resulting in R1’s total path cost to 192.168.2.0/24 being 256005120.
The most surprising thing about EIGRP is how it uses unequal-cost load balancing by default. If R1 had two neighbors, R2 and R3, both advertising 192.168.2.0/24 with different metrics, EIGRP would normally only use the best path. However, you can configure EIGRP to use multiple paths even if their metrics differ, up to a certain variance. This is controlled by the variance command. If variance 2 is set, EIGRP will consider any path whose metric is within twice the metric of the best path. This allows for more efficient utilization of network resources.
The next concept you’ll encounter is EIGRP stub routing and route summarization.