@@ -330,7 +330,9 @@ class _BatchDecodeIndexerBase:
     that position divided by 128. The eight tokens of all ``num_heads`` heads
     are scored together, reading each K page once. A wrapper instance owns its
     workspace and buffers and must not be shared by concurrently running
-    streams.
+    streams. ``score_buffer`` (fp32, at least ``batch * 8 * num_heads *
+    max_pages`` elements) replaces the per-wrapper page-score scratch, so
+    wrappers of different batch sizes that never run concurrently can share it.
 
     Wrappers with ``_supports_query_len`` also plan requests of fewer queries
     (``query_len``): ``q`` and the output then hold only those, which take the
@@ -345,7 +347,12 @@ def __init__(
         use_cuda_graph: bool = False,
         block_table_buffer: torch.Tensor | None = None,
         seq_lens_buffer: torch.Tensor | None = None,
+        score_buffer: torch.Tensor | None = None,
     ) -> None:
+        if score_buffer is not None:
+            _check_cuda_tensor(score_buffer, name="score_buffer", dtype=torch.float32)
+            if score_buffer.ndim != 1:
+                raise ValueError("score_buffer must be one-dimensional")
         if workspace_buffer is not None:
             _check_cuda_tensor(workspace_buffer, name="workspace_buffer", dtype=torch.uint8)
             if workspace_buffer.ndim != 1:
@@ -368,6 +375,7 @@ def __init__(
         self._seq_lens_buffer = seq_lens_buffer
         self._block_table: torch.Tensor | None = None
         self._seq_lens: torch.Tensor | None = None
+        self._score_buffer = score_buffer
         self._scores: torch.Tensor | None = None
         self._num_valid_pages: torch.Tensor | None = None
         self._topk_indices: torch.Tensor | None = None
@@ -434,6 +442,13 @@ def workspace_size(cls, batch_size: int, *, num_heads: int = 1) -> int:
             batch_size, _check_num_heads(num_heads, cls._supported_num_heads)
         )
 
+    @classmethod
+    def score_buffer_size(cls, batch_size: int, max_pages: int, *, num_heads: int = 1) -> int:
+        """Return the fp32 elements ``score_buffer`` needs for a batch."""
+
+        num_heads = _check_num_heads(num_heads, cls._supported_num_heads)
+        return batch_size * _DECODE_QUERY_LENGTH * num_heads * max_pages
+
     @staticmethod
     def _check_metadata(block_table: torch.Tensor, seq_lens: torch.Tensor) -> None:
         _check_cuda_tensor(seq_lens, name="seq_lens", dtype=torch.int32)
@@ -499,13 +514,24 @@ def plan(
 
         tokens = batch_size * query_len
         score_shape = (batch_size, _DECODE_QUERY_LENGTH * self._num_heads, max_pages)
-        if (
+        if self._score_buffer is not None:
+            score_elems = self.score_buffer_size(batch_size, max_pages, num_heads=self._num_heads)
+            if self._score_buffer.device != device or self._score_buffer.numel() < score_elems:
+                raise ValueError(
+                    f"score_buffer must be on {device} with at least {score_elems} elements"
+                )
+            self._scores = self._score_buffer[:score_elems].view(score_shape)
+        elif (
             self._scores is None
             or self._scores.shape != score_shape
             or self._scores.device != device
-            or self._topk_indices.shape[0] != tokens
         ):
             self._scores = torch.empty(score_shape, dtype=torch.float32, device=device)
+        if (
+            self._topk_indices is None
+            or self._topk_indices.shape[0] != tokens
+            or self._topk_indices.device != device
+        ):
             self._num_valid_pages = torch.empty(
                 (tokens * self._num_heads,), dtype=torch.int32, device=device
             )
 
@@ -552,6 +552,53 @@ def test_decode_concurrent_streams_do_not_alias(fmt, num_heads):
         assert torch.equal(out, expected)
 
 
+@pytest.mark.parametrize("fmt,num_heads", DECODE_CASES)
+def test_decode_wrappers_share_a_score_buffer(fmt, num_heads):
+    """Graph-mode wrappers of two batch sizes share one score buffer: replaying one after the
+    other ran matches its own result, and a buffer too small for the batch is rejected."""
+
+    max_pages = 6
+    inputs = [
+        _make_decode(fmt, batch, max_pages, seed, num_heads=num_heads)
+        for batch, seed in ((64, 51), (96, 52))
+    ]
+    shared = torch.empty(
+        DECODE_WRAPPERS[fmt].score_buffer_size(96, max_pages, num_heads=num_heads),
+        dtype=torch.float32,
+        device="cuda",
+    )
+    wrappers, outs, expected = [], [], []
+    for q, k, block_table, seq_lens in inputs:
+        own = DECODE_WRAPPERS[fmt](num_heads=num_heads)
+        own.plan(block_table, seq_lens)
+        expected.append(own.run(q, k.cache).clone())
+        wrapper = DECODE_WRAPPERS[fmt](
+            num_heads=num_heads,
+            use_cuda_graph=True,
+            block_table_buffer=torch.empty_like(block_table),
+            seq_lens_buffer=torch.empty_like(seq_lens),
+            score_buffer=shared,
+        )
+        wrapper.plan(block_table, seq_lens)
+        wrappers.append(wrapper)
+        outs.append(torch.empty_like(expected[-1]))
+    (q0, k0, _, _), (q1, k1, block_table, seq_lens) = inputs
+    wrappers[0].run(q0, k0.cache, out=outs[0])
+    graph = torch.cuda.CUDAGraph()
+    with torch.cuda.graph(graph):
+        wrappers[0].run(q0, k0.cache, out=outs[0])
+    wrappers[1].run(q1, k1.cache, out=outs[1])
+    outs[0].fill_(-777)
+    graph.replay()
+    torch.cuda.synchronize()
+    assert torch.equal(outs[0], expected[0])
+    assert torch.equal(outs[1], expected[1])
+
+    small = DECODE_WRAPPERS[fmt](num_heads=num_heads, score_buffer=shared[: shared.numel() - 1])
+    with pytest.raises(ValueError, match="score_buffer"):
+        small.plan(block_table, seq_lens)
+
+
 @pytest.mark.parametrize("num_heads", DECODE_HEADS["q8kv4"])
 @pytest.mark.parametrize("query_len", (1, 2, 4, 7))
 @pytest.mark.parametrize("batch,max_pages", [(1, 1), (5, 6), (129, 4)])
 
@@ -273,6 +273,21 @@ static int get_runtime_sm_count(int device) {
 static std::unordered_map<int, int> g_num_cta;
 static std::mutex g_num_cta_mutex;
 
+// The CUTLASS kernels need no workspace (get_workspace_size is 0), so every plan on a device
+// passes the same buffer instead of allocating its own. Never freed: it outlives the plans.
+static auto *g_cute_workspace = new std::unordered_map<int, at::Tensor>();
+static std::mutex g_cute_workspace_mutex;
+
+static at::Tensor shared_cute_workspace(int device) {
+  std::lock_guard<std::mutex> lock(g_cute_workspace_mutex);
+  auto it = g_cute_workspace->find(device);
+  if (it == g_cute_workspace->end())
+    it = g_cute_workspace
+             ->emplace(device, allocate_plan_buffer(32 * 1024 * 1024, device, torch::kUInt8))
+             .first;
+  return it->second;
+}
+
 static int get_num_cta(int device) {
   std::lock_guard<std::mutex> lock(g_num_cta_mutex);
   auto [it, inserted] = g_num_cta.try_emplace(device, -1);
@@ -406,7 +421,7 @@ PlanInfo _make_decode_plan_impl(at::Tensor qo_segment_lens, at::Tensor kv_segmen
 
   PlanInfo info;
 
-  auto cute_workspace = allocate_plan_buffer(32 * 1024 * 1024, device, torch::kUInt8);
+  auto cute_workspace = shared_cute_workspace(device);
 
   int num_ctas = get_num_cta(device);
   if (usable_SM_count > 0)
 
@@ -121,3 +121,17 @@ def plan(batch, q_len, ctas=128):
     plan(65536, 1, ctas=127)  # split 4-item last wave
     with pytest.raises(RuntimeError, match="at most 65536 sequences"):
         plan(65537, 1, ctas=127)
+
+
+def test_plans_share_one_kernel_workspace(device):
+    """A plan holds only its schedule; the kernel workspace is one buffer per device."""
+    def plan(batch):
+        return plan_decode(batch_size=batch, q_len_per_req=8, topk=16, device=device, num_q_heads=16,
+                           num_kv_heads=1)
+
+    plans = [plan(8)]
+    torch.cuda.synchronize(device)
+    before = torch.cuda.memory_allocated(device)
+    plans += [plan(batch) for batch in (129, 256, 512, 1024)]
+    torch.cuda.synchronize(device)
+    assert torch.cuda.memory_allocated(device) - before < 32 * 2**20  # was 32 MiB per plan