diff --git a/.jules/bolt.md b/.jules/bolt.md
index 2ac6922..2b056f2 100644
--- a/.jules/bolt.md
+++ b/.jules/bolt.md
@@ -5,3 +5,7 @@
 ## 2026-05-01 - Avoid High-Level Tensor Ops in Scalar Reductions
 **Learning:** High-level `Tensor` operations like `sub()` and `mul()` trigger intermediate heap allocations for shape and stride metadata. When computing scalar reductions (like MSE, distances, or loss functions), using these operations introduces severe memory overhead inside hot loops. Attempting to use `.min()` length truncation as a safeguard is an anti-pattern as it masks shape mismatch errors.
 **Action:** For scalar reductions, assert shape equality (`assert_eq!(a.shape, b.shape)`) and perform a single-pass iteration directly over the underlying borrowed data arrays (`a.data.borrow()`) to eliminate intermediate allocations and safely compute the result.
+
+## 2026-06-04 - Avoid libm::sqrt in Distance Comparisons
+**Learning:** In `aether-core::manifold::SparseAttentionGraph::add_point`, the `is_neighbor` function is a critical hot path used to build the spatial proximity graph in $O(N)$ comparisons for each added point. The previous implementation computed the exact Euclidean distance involving an expensive `libm::sqrt` call. Since we only need to compare against a threshold (`epsilon`), computing the squared distance (`d^2 < r^2`) is sufficient and eliminates the costly square root operation.
+**Action:** Always prefer squared distance comparisons over `sqrt` in hot spatial query loops. Use early exits (`!(sum < eps_sq)`) inside the summation loop to further short-circuit the computation, and handle `NaN` cleanly by comparing using `!` logic rather than explicitly matching.
diff --git a/crates/aether-core/src/manifold.rs b/crates/aether-core/src/manifold.rs
index 1bcc201..17d93bb 100644
--- a/crates/aether-core/src/manifold.rs
+++ b/crates/aether-core/src/manifold.rs
@@ -24,7 +24,6 @@
 // ═══════════════════════════════════════════════════════════════════════════════
 //
 
-
 #![allow(dead_code)]
 
 use libm::sqrt;
@@ -76,7 +75,19 @@ impl<const D: usize> ManifoldPoint<D> {
 
     /// Check if within epsilon-neighborhood (sparse attention criterion)
     pub fn is_neighbor(&self, other: &Self, epsilon: f64) -> bool {
-        self.distance(other) < epsilon
+        if !(epsilon > 0.0) {
+            return false;
+        }
+        let eps_sq = epsilon * epsilon;
+        let mut sum = 0.0;
+        for i in 0..D {
+            let d = self.coords[i] - other.coords[i];
+            sum += d * d;
+            if !(sum < eps_sq) {
+                return false;
+            }
+        }
+        true
     }
 }