@@ -2881,32 +2881,42 @@ def _handle_heartbeat(self, handler: BaseHTTPRequestHandler):
             self._maybe_log_stats()
 
     def _record_token_sample(self):
-        """Append a (monotonic ts, total_tokens) sample for the rolling rate.
+        """Append a (monotonic ts, steady_tokens) sample for the rolling rate.
 
         No-op without a token budget (the rate/ETA is only surfaced for budgeted
-        runs). Lock-free on purpose: ``deque.append`` and the ``total_tokens``
-        int read are each atomic under the GIL, and different workers' heartbeats
-        race here (this is NOT serial-per-worker like ``pending_command``). A
-        cross-worker read could append two samples a hair out of order; the
-        ``dt<=0`` / ``dtok<0`` guards in ``_rolling_token_rate`` absorb that, and
-        a momentarily stale gauge is fine.
+        runs). Samples ``steady_tokens`` (NOT ``total_tokens``) so the rate
+        excludes each worker's first-report cumulative catch-up — that burst
+        lands across all workers within ~1-2s and would otherwise grossly
+        overstate the rate on the first heartbeats. Lock-free on purpose:
+        ``deque.append`` and the int read are each atomic under the GIL, and
+        different workers' heartbeats race here (this is NOT serial-per-worker
+        like ``pending_command``). A cross-worker read could append two samples a
+        hair out of order; the ``dt<=0`` / ``dtok<0`` guards in
+        ``_rolling_token_rate`` absorb that, and a momentarily stale gauge is fine.
         """
         if self.token_budget <= 0:
             return
-        self._token_samples.append((time.monotonic(), self._stats.total_tokens))
+        self._token_samples.append((time.monotonic(), self._stats.steady_tokens))
 
     def _rolling_token_rate(self) -> Optional[float]:
         """Tokens/second over the recent window, or None if not yet estimable.
 
         Uses the oldest sample within ``_token_rate_window_s`` as the baseline
         (or the oldest available if the buffer is younger than the window), so a
         rate appears after the second heartbeat rather than waiting a full
-        window. Returns None until there are two spanning samples.
+        window. Returns None until there are two spanning samples, or while no
+        steady (non-catch-up) tokens have been counted yet — during that warm-up
+        the gauge reads "unknown" rather than a misleading 0 or an inflated burst.
         """
         samples = list(self._token_samples)
         if len(samples) < 2:
             return None
         now_t, now_tok = samples[-1]
+        if now_tok <= 0:
+            # No steady increment yet (only first-report catch-ups so far) —
+            # nothing real to rate. Distinct from a genuine stall, where
+            # steady_tokens is already > 0 and stays flat (reads as ~0 tok/s).
+            return None
         cutoff = now_t - self._token_rate_window_s
         base_t, base_tok = samples[0]
         for t, tok in samples:
 
@@ -198,6 +198,15 @@ def __init__(self, train_loss_decay: float = 0.7, eval_loss_decay: float = 0.5):
         self.total_flos: float = 0.0
         self.total_steps: int = 0
 
+        # Like total_tokens but EXCLUDING each worker's first-report catch-up
+        # (the full cumulative a worker dumps on its first heartbeat). Used only
+        # for the rolling throughput rate: that initial burst lands across all
+        # workers within ~1-2s of wall-clock, so counting it would divide a huge
+        # token jump by a tiny interval and grossly overstate the rate. Same
+        # reasoning as the FLOPs `flos_window` below. Not persisted — it's a
+        # live rate signal that resets cleanly on restart.
+        self.steady_tokens: int = 0
+
         # Per-worker last-seen cumulative counters, for delta accumulation
         # (persisted — must survive a restart so a resumed worker_id doesn't
         # re-add its history).
@@ -257,6 +266,10 @@ def update(self, worker_id: str, snap: Dict[str, Any]) -> None:
                         live["flos_window"] = float(delta)
                 elif attr == "total_tokens":
                     self.total_tokens += int(delta)
+                    # Exclude the first-report catch-up from the rate counter
+                    # (only true per-heartbeat increments), mirroring flos_window.
+                    if prev is not None:
+                        self.steady_tokens += int(delta)
                 else:  # total_steps
                     self.total_steps += int(delta)
 
 
@@ -202,6 +202,32 @@ def test_rate_window_uses_recent_baseline(self, tmp_path):
         # window [70,120]: baseline (100.0,100) -> (300-100)/(120-100)=10 tok/s
         assert abs(server._rolling_token_rate() - 10.0) < 1e-9
 
+    def test_steady_tokens_excludes_first_report_catchup(self, tmp_path):
+        """A worker's first heartbeat dumps its whole cumulative (catch-up).
+        steady_tokens must count only true per-heartbeat increments, so the rate
+        derived from it isn't inflated by that one-time burst."""
+        agg = _server(tmp_path, token_budget=10_000)._stats
+        # First reports from 4 workers (catch-up): total jumps, steady stays 0.
+        for wid in ("w0", "w1", "w2", "w3"):
+            agg.update(wid, {"tokens_total": 1000})
+        assert agg.total_tokens == 4000
+        assert agg.steady_tokens == 0
+        # Second heartbeats (+100 each): only these count toward steady.
+        for wid in ("w0", "w1", "w2", "w3"):
+            agg.update(wid, {"tokens_total": 1100})
+        assert agg.total_tokens == 4400
+        assert agg.steady_tokens == 400
+
+    def test_rate_warmup_none_until_steady_tokens(self, tmp_path):
+        """During warm-up (only catch-up samples, steady_tokens still 0) the rate
+        reads 'unknown' (None), not a misleading 0 or an inflated burst."""
+        server = _server(tmp_path, token_budget=10_000)
+        server._token_samples.extend([(1000.0, 0), (1010.0, 0)])
+        assert server._rolling_token_rate() is None
+        # First steady increment lands -> a real rate appears.
+        server._token_samples.append((1020.0, 200))
+        assert abs(server._rolling_token_rate() - 10.0) < 1e-9  # 200 / 20s
+
     def test_stall_reports_zero_rate_not_none(self, tmp_path):
         """After a long stall the only in-window sample is the tail; fall back to
         the previous sample so the gauge reads ~0 tok/s (visible slowdown), not a
 
@@ -1148,7 +1148,10 @@ function DiLoCoPicker(props: DiLoCoPickerProps) {
   // Local UI state for the pool's add/generate controls. Hooks must run
   // unconditionally, so they precede the cluster-fanout early return.
   const [addName, setAddName] = useState<string>("");
-  const [genCount, setGenCount] = useState<string>("4");
+  // Default 1: for the common small-worker-count case it's quicker to leave it
+  // at 1 and click Generate N times than to edit the number first (which is
+  // usually not the value you want anyway).
+  const [genCount, setGenCount] = useState<string>("1");
   const [generating, setGenerating] = useState<boolean>(false);
   const [poolError, setPoolError] = useState<string | null>(null);