@@ -196,9 +196,10 @@ def _write_json_atomic(path: str, value) -> None:
 
 
 def kernel_generation(backend) -> str:
-    """The adapter's kernel family; `-cudagraph` keeps replayed rows a separate series."""
+    """Identify the kernel family and captured-all-reduce measurement regime."""
     family = backend.kernel_generation or "n-a"
-    return f"{family}-cudagraph" if backend.cuda_graph_enabled else family
+    # Historical -cudagraph rows used an external barrier and alignment spin.
+    return f"{family}-cudagraph-in-graph-ar" if backend.cuda_graph_enabled else family
 
 
 class _Collectives:
 
@@ -32,18 +32,16 @@ def sample():
     return [sample() for _ in range(iters)]
 
 
-def time_cuda_graph_phase_us(torch, fn, warmup: int, iters: int, interval, align) -> list[float]:
+def time_cuda_graph_phase_us(torch, fn, warmup: int, iters: int, interval) -> list[float]:
     """Time one event-record interval captured inside graph replay.
 
-    `align()` enqueues a device-side rank barrier before each replay, so replays start together
-    rather than ~75us apart (b200 EP16), which the cross-rank MAX would report as latency.
+    The graph contains an all-reduce before the timing events to reduce rank entry skew.
     """
     for _ in range(max(0, warmup)):
         fn()
         torch.cuda.synchronize()
     samples = []
     for _ in range(iters):
-        align()
         fn()
         torch.cuda.synchronize()
         samples.append(interval[0].elapsed_time(interval[1]) * 1000.0)
@@ -223,53 +221,24 @@ def poison(tensor):
 
 
 class GraphTiming:
-    """Captured dispatch -> combine pairs timed by event nodes inside the graph, each timed replay
-    started behind a device-side rank barrier so the cross-rank MAX is the operation, not launch
-    skew."""
+    """Measure dispatch/combine latency with CUDA events inside a replayed CUDA graph.
+
+    Each replay first runs an all-reduce to bring ranks closer together before timed work
+    begins. The all-reduce is part of the graph but precedes the timing events, so its cost
+    is excluded from the reported latency.
+    """
 
     graph = True
     # Handle attributes dispatch writes; the replay value check poisons them.
     DISPATCH_OUTPUT_FIELDS = ("recv_x", "recv_scales", "dispatch_output")
 
     def __init__(self, backend):
         self.backend = backend
-        self.align_cycles = None
         self._align_token = None
 
     def components(self):
         return ["roundtrip", "dispatch", "combine"]
 
-    def calibrate_align_spin(self, spin_us=100.0):
-        """Size the post-barrier spin to `spin_us` of wall time on this GPU.
-
-        The spin lets every host enqueue its replay before the stream reaches it. `_sleep` counts
-        SM cycles, so a fixed count left ~15us of skew between differently clocked gb200 ranks.
-        """
-        import torch
-
-        probe = 200_000
-        start = torch.cuda.Event(enable_timing=True)
-        end = torch.cuda.Event(enable_timing=True)
-        torch.cuda._sleep(probe // 10)  # ramp clocks before the measured spin
-        start.record()
-        torch.cuda._sleep(probe)
-        end.record()
-        torch.cuda.synchronize()
-        elapsed_us = max(start.elapsed_time(end) * 1000.0, 1e-3)
-        self.align_cycles = max(1, int(probe * spin_us / elapsed_us))
-
-    def align(self):
-        """Enqueue a device-side rank barrier on the current stream, without a host sync."""
-        import torch
-        import torch.distributed as dist
-
-        if self._align_token is None:
-            self._align_token = torch.zeros(1, device=self.backend.device)
-        if self.align_cycles is None:
-            self.calibrate_align_spin()
-        dist.all_reduce(self._align_token)
-        torch.cuda._sleep(self.align_cycles)
-
     def capture_pairs(self, problem, staged, pairs, marks):
         """Capture `pairs` back-to-back pairs into one graph; `marks` picks the windows that get
         event nodes ("pair", "dispatch", "combine"). Returns (graph, {mark: (starts, ends)},
@@ -278,6 +247,9 @@ def capture_pairs(self, problem, staged, pairs, marks):
         import torch.distributed as dist
 
         b = self.backend
+        if self._align_token is None:
+            self._align_token = torch.zeros(1, device=b.device)
+            dist.all_reduce(self._align_token)
         stamps = {mark: ([graph_event() for _ in range(pairs)], [graph_event() for _ in range(pairs)])
                   for mark in marks}
 
@@ -290,6 +262,14 @@ def record(mark, edge, i):
         graph = torch.cuda.CUDAGraph()
         combined = handle = None
         with torch.cuda.graph(graph, capture_error_mode="relaxed"):
+            # A separate all-reduce followed by a host-launched graph can let CPU launch
+            # delays spread the ranks apart again, inflating the measured communication time.
+            # Capture the all-reduce and its stream dependencies in this graph so each replay
+            # reaches the timed work without another host launch after alignment. Place it
+            # before the first timing event to exclude alignment cost, and only once per graph
+            # to preserve back-to-back dispatch/combine pairs. This reduces entry skew; it
+            # does not guarantee that every rank starts the timed work simultaneously.
+            dist.all_reduce(self._align_token)
             for i in range(pairs):
                 record("pair", 0, i)
                 record("dispatch", 0, i)
@@ -313,10 +293,9 @@ def component(self, name, problem, warmup, iters):
         staged = self.backend.warm_and_hoist_stage(problem, warmup)
         mark = "pair" if name == "roundtrip" else name
         graph, stamps, combined, _ = self.capture_pairs(problem, staged, 1, (mark,))
-        self.calibrate_align_spin()  # clocks move with load and temperature: per timed series
         starts, ends = stamps[mark]
         samples = time_cuda_graph_phase_us(
-            torch, graph.replay, warmup, iters, (starts[0], ends[0]), align=self.align
+            torch, graph.replay, warmup, iters, (starts[0], ends[0])
         )
         combined.fill_(float("nan"))
         torch.cuda.synchronize()
@@ -329,16 +308,14 @@ def component(self, name, problem, warmup, iters):
 
     def chain(self, problem, staged, iters, drop):
         """Each sibling is ONE graph of `iters` unrolled pairs, the shape of a decode graph, replayed
-        once untimed (upload) and once aligned and timed."""
+        once untimed (upload) and once timed, with alignment captured before the first event."""
         import torch
 
         floors, floor_stamps, _, _ = self.capture_pairs(problem, staged, iters, ("dispatch", "combine"))
         period, period_stamps, combined, _ = self.capture_pairs(problem, staged, iters, ("pair",))
-        self.calibrate_align_spin()
         for graph in (floors, period):
             graph.replay()
             torch.cuda.synchronize()
-            self.align()
             graph.replay()
             torch.cuda.synchronize()
         return _chain_result(period_stamps["pair"], floor_stamps, drop, combined)
 
@@ -335,9 +335,10 @@ every check, without changing its contract.
 Only the launch mechanism changes; every family keeps its eager meaning:
 
 - **Fresh-entry components** (`roundtrip`, `dispatch`, `combine`) capture one pair with event
-  nodes around the timed window. Each timed replay starts behind a device-side rank barrier (an
-  all-reduce, then a spin of fixed wall time, calibrated per GPU because `torch.cuda._sleep`
-  counts SM cycles); without it b200 EP16 ranks entered ~75 µs apart. A rank whose host launches
+  nodes around the timed window. An all-reduce is captured before the first timing event,
+  including its stream dependencies, so alignment stays outside the measured interval without
+  a host-side handoff or spin kernel. This reduces skew but does not guarantee simultaneous
+  release across ranks. A rank whose host launches
   late still stalls the others, so these series publish **only p50** (p90/p95/p99 and the matching
   token rate are null). Component origin is `cuda-graph-replay`.
 - **The chained family** (`pair_period`, floors, health) captures each sibling chain as one graph
 
@@ -241,19 +241,18 @@ def _graph_backend(self, stage_device_work=False, precision="bf16"):
         backend.mode, backend.CUDA_GRAPH_MODES = "normal", ("normal",)
         return backend
 
-    def _aligned_replays(self, calls):
-        """Replays preceded by the device-side rank barrier (all-reduce, then the spin)."""
-        return [i for i, call in enumerate(calls)
-                if call == "graph_replay" and calls[i - 2:i] == ["all_reduce", "align_spin"]]
-
-    def test_every_timed_replay_starts_behind_a_device_side_rank_barrier(self):
-        # Without it each replay restarts from the preceding sync and ranks enter ~75us apart.
+    def test_alignment_is_captured_before_the_timed_window_without_spin(self):
         backend = self._graph_backend()
         with mock.patch.dict(os.environ, {}, clear=True), \
                 trace_torch(backend.clock, backend.calls):
             backend.benchmark_component("roundtrip", new_problem(), warmup=2, iters=3)
-        replays = [i for i, call in enumerate(backend.calls) if call == "graph_replay"]
-        self.assertEqual(self._aligned_replays(backend.calls), replays[2:5])
+        calls = backend.calls
+        begin, end = calls.index("capture_begin"), calls.index("capture_end")
+        first_event = calls.index("record", begin)
+        self.assertEqual(calls[begin:first_event].count("all_reduce"), 1)
+        self.assertNotIn("all_reduce", calls[first_event:end])
+        self.assertNotIn("all_reduce", calls[end:])
+        self.assertNotIn("align_spin", calls)
 
     def test_the_graph_chain_is_one_capture_of_unrolled_pairs_per_sibling(self):
         iters, drop = 5, 1
@@ -269,7 +268,11 @@ def test_the_graph_chain_is_one_capture_of_unrolled_pairs_per_sibling(self):
         for lo, hi in zip(begin, end):
             self.assertEqual(ops_only(calls[lo:hi]), ["dispatch", "stage", "combine"] * iters)
         self.assertEqual(calls.count("graph_replay"), 4)
-        self.assertEqual(len(self._aligned_replays(calls)), 2)
+        self.assertNotIn("align_spin", calls)
+        for lo, hi in zip(begin, end):
+            first_event = calls.index("record", lo)
+            self.assertEqual(calls[lo:first_event].count("all_reduce"), 1)
+            self.assertNotIn("all_reduce", calls[first_event:hi])
         self.assertEqual({len(series[k]) for k in ("pair", "dispatch", "combine")}, {iters - drop})
         self.assertEqual(len(series["start_to_start"]), iters - drop - 1)
         self.assertTrue(series["combined"].cloned)
@@ -290,25 +293,6 @@ def test_external_switch_restores_the_eager_component_pipeline(self):
 
 
 class GraphAlignmentAndValueCheck(unittest.TestCase):
-    def test_the_alignment_spin_is_sized_to_wall_time_not_a_cycle_count(self):
-        # A GPU spinning twice as fast (the probe spin takes half the time) must be handed twice
-        # the cycles, so every rank releases after the same wall time whatever its SM clock.
-        spins = []
-        fake = types.SimpleNamespace(cuda=types.SimpleNamespace(
-            _sleep=spins.append, synchronize=lambda: None,
-            Event=lambda **kwargs: types.SimpleNamespace(
-                record=lambda: None, elapsed_time=lambda other: probe_ms,
-            ),
-        ))
-        timing = ep_timing.GraphTiming(_ChainBackend())
-        results = {}
-        for probe_ms in (0.1, 0.05):  # the 200k-cycle probe took 100us, then 50us
-            with mock.patch.dict(sys.modules, {"torch": fake}):
-                timing.calibrate_align_spin()
-            results[probe_ms] = timing.align_cycles
-        self.assertEqual(results[0.1], 200_000)  # the default 100us spin at 2 cycles/ns
-        self.assertEqual(results[0.05], 2 * results[0.1])
-
     def test_the_replay_value_check_poisons_what_dispatch_wrote_before_replaying(self):
         backend = _ChainBackend(stage_device_work=True, fp8_consume="native", precision="fp8")
         order, combined = [], _Combined(1.0)