@@ -1,25 +1,50 @@
-import { useMemo } from "react";
+import { useCallback, useMemo, useRef } from "react";
 
 import type { ScenarioDataset } from "@pretable-internal/scenario-data";
 import { AgGridReact } from "ag-grid-react";
 import {
   AllCommunityModule,
   ModuleRegistry,
   type ColDef,
+  type GridApi,
+  type GridReadyEvent,
 } from "ag-grid-community";
 
 import "ag-grid-community/styles/ag-grid.css";
 import "ag-grid-community/styles/ag-theme-quartz.css";
 
+import type { ApplyBenchUpdates } from "./bench-runtime";
+
 ModuleRegistry.registerModules([AllCommunityModule]);
 
 export interface AGGridAdapterProps {
   dataset: ScenarioDataset;
   runKey: number;
+  /**
+   * AG Grid's idiomatic streaming pattern: gridApi.applyTransaction({
+   * update }). Native batching, no wrapper layer.
+   */
+  onUpdateApiReady?: (apply: ApplyBenchUpdates) => void;
 }
 
-export function AGGridAdapter({ dataset, runKey }: AGGridAdapterProps) {
+export function AGGridAdapter({
+  dataset,
+  runKey,
+  onUpdateApiReady,
+}: AGGridAdapterProps) {
   const rowData = useMemo(() => [...dataset.rows], [dataset.rows]);
+
+  const onUpdateApiReadyRef = useRef(onUpdateApiReady);
+  // eslint-disable-next-line react-hooks/refs -- sync ref to latest prop for use in callbacks
+  onUpdateApiReadyRef.current = onUpdateApiReady;
+
+  const handleGridReady = useCallback((event: GridReadyEvent) => {
+    const api: GridApi = event.api;
+    const apply: ApplyBenchUpdates = (patches) => {
+      api.applyTransaction({ update: patches });
+    };
+    onUpdateApiReadyRef.current?.(apply);
+  }, []);
   const columnDefs = useMemo<ColDef[]>(
     () =>
       dataset.columns.map((column) => ({
@@ -81,6 +106,7 @@ export function AGGridAdapter({ dataset, runKey }: AGGridAdapterProps) {
           defaultColDef={defaultColDef}
           getRowId={(params) => String(params.data.id)}
           rowData={rowData}
+          onGridReady={handleGridReady}
         />
       </div>
     </section>
 
@@ -1,4 +1,11 @@
-import { useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useEffectEvent,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import type { PretableGrid } from "@pretable/react";
 import type { PretableTelemetry } from "@pretable/react/internal";
 
@@ -17,6 +24,7 @@ import {
 
 import type { BenchQueryState } from "./bench-types";
 import {
+  type ApplyBenchUpdates,
   createBenchInteractionStateFromTelemetry,
   createPretableTelemetryNotes,
   createBenchRequest,
@@ -91,6 +99,16 @@ export function BenchApp({ search, browserVersion }: BenchAppProps) {
   const autorunRef = useRef(false);
   const pretableTelemetryRef = useRef<PretableTelemetry | null>(null);
   const pretableGridRef = useRef<PretableGrid<ScenarioRow> | null>(null);
+  /**
+   * Adapter-agnostic update API ref. Each adapter wires its idiomatic
+   * streaming pattern (Pretable: stream-adapter batcher → applyTransaction;
+   * AG Grid: gridApi.applyTransaction; MUI: apiRef.updateRows; TanStack:
+   * setRows merge) and exposes a uniform `apply(patches)` callback here.
+   */
+  const updateApiRef = useRef<ApplyBenchUpdates | null>(null);
+  const handleUpdateApiReady = useCallback((apply: ApplyBenchUpdates) => {
+    updateApiRef.current = apply;
+  }, []);
   const interactionPlan =
     interactionPlanOverride?.search === search
       ? interactionPlanOverride.plan
@@ -187,11 +205,25 @@ export function BenchApp({ search, browserVersion }: BenchAppProps) {
             : null
           : null;
 
+      // Wait up to ~1s for the current adapter to publish its update API.
+      // AG Grid in particular fires onGridReady asynchronously a few RAFs
+      // after mount, so kicking off the updates script in the very next
+      // frame after setRunKey would race past it and leave updateApiRef
+      // null (no metrics get collected).
+      let updatesApi = updateApiRef.current;
+      if (scriptName === "updates" && !updatesApi) {
+        for (let i = 0; i < 60 && !updateApiRef.current; i++) {
+          await waitForNextAnimationFrame();
+        }
+        updatesApi = updateApiRef.current;
+      }
+
       const updatesRun =
-        scriptName === "updates" && pretableGridRef.current
+        scriptName === "updates" && updatesApi
           ? await measureBenchUpdatesRun(
               viewportRef.current ?? document.body,
-              pretableGridRef.current,
+              query.adapterId,
+              updatesApi,
               dataset,
             )
           : null;
@@ -371,10 +403,16 @@ export function BenchApp({ search, browserVersion }: BenchAppProps) {
                 onTelemetryChange={(telemetry) => {
                   pretableTelemetryRef.current = telemetry;
                 }}
+                onUpdateApiReady={handleUpdateApiReady}
                 runKey={runKey}
               />
             ) : (
-              <AdapterSurface dataset={dataset} key={runKey} runKey={runKey} />
+              <AdapterSurface
+                dataset={dataset}
+                key={runKey}
+                onUpdateApiReady={handleUpdateApiReady}
+                runKey={runKey}
+              />
             )}
           </div>
 
 
@@ -568,17 +568,27 @@ export interface UpdatesBenchRunResult {
   notes: string[];
 }
 
+/**
+ * Caller-supplied function that applies a batch of update patches to the
+ * adapter's grid. Each adapter wires this to its idiomatic streaming
+ * pattern (Pretable: stream-adapter batcher → applyTransaction; AG Grid:
+ * gridApi.applyTransaction directly; MUI: apiRef.updateRows directly;
+ * TanStack: setRows merge).
+ */
+export type ApplyBenchUpdates = (
+  patches: Record<string, unknown>[],
+) => void | Promise<void>;
+
 export async function measureBenchUpdatesRun(
   root: HTMLElement,
-  grid: {
-    applyTransaction(transaction: { update?: Record<string, unknown>[] }): void;
-  },
+  adapterId: BenchQueryState["adapterId"],
+  apply: ApplyBenchUpdates,
   dataset: {
     rows: readonly Record<string, unknown>[];
     columns: readonly { id: string }[];
   },
 ): Promise<UpdatesBenchRunResult> {
-  const profile = scrollRuntimeProfiles.pretable;
+  const profile = scrollRuntimeProfiles[adapterId];
   const viewport = await waitForScrollViewport(root, profile.viewportSelector);
   const viewportPolicyNotes = viewport
     ? detectViewportPolicyNotes(viewport)
@@ -597,9 +607,6 @@ export async function measureBenchUpdatesRun(
   const UPDATES_PER_TICK = 50;
   const columnIds = dataset.columns.map((c) => c.id);
 
-  const { createBatcher } = await import("@pretable-internal/stream-adapter");
-  const batcher = createBatcher(grid);
-
   let totalUpdates = 0;
   const longTaskDurations: number[] = [];
   const observer = createLongTaskObserver(longTaskDurations);
@@ -641,12 +648,21 @@ export async function measureBenchUpdatesRun(
             patches.push({ id, [columnId]: `upd-${totalUpdates + i}` });
           }
 
-          batcher.update(patches);
+          const applyResult = apply(patches);
+          if (applyResult && typeof applyResult.then === "function") {
+            // The caller can return a Promise (e.g., flush before resolve);
+            // we don't await within the interval to keep the cadence honest,
+            // but we do swallow rejections so they surface via the outer
+            // try/catch above.
+            applyResult.catch((err) => {
+              clearInterval(interval);
+              reject(err);
+            });
+          }
           totalUpdates += UPDATES_PER_TICK;
 
           if (elapsed >= DURATION_MS) {
             clearInterval(interval);
-            batcher.flush();
             resolve();
           }
         } catch (err) {
@@ -656,7 +672,6 @@ export async function measureBenchUpdatesRun(
       }, BATCH_INTERVAL_MS);
     });
   } finally {
-    batcher.dispose();
     rafHandle.running = false;
     cancelAnimationFrame(rafHandle.id);
     observer?.disconnect();
 
@@ -1,14 +1,44 @@
-import { useMemo } from "react";
+import { useEffect, useMemo, useRef } from "react";
 
 import type { ScenarioDataset } from "@pretable-internal/scenario-data";
-import { DataGrid, type GridColDef } from "@mui/x-data-grid";
+import { DataGrid, useGridApiRef, type GridColDef } from "@mui/x-data-grid";
+
+import type { ApplyBenchUpdates } from "./bench-runtime";
 
 export interface MuiAdapterProps {
   dataset: ScenarioDataset;
   runKey: number;
+  /**
+   * MUI X DataGrid's idiomatic streaming pattern:
+   * apiRef.current.updateRows([{ id, ...patch }]). Native batching.
+   */
+  onUpdateApiReady?: (apply: ApplyBenchUpdates) => void;
 }
 
-export function MuiAdapter({ dataset, runKey }: MuiAdapterProps) {
+export function MuiAdapter({
+  dataset,
+  runKey,
+  onUpdateApiReady,
+}: MuiAdapterProps) {
+  const apiRef = useGridApiRef();
+  const onUpdateApiReadyRef = useRef(onUpdateApiReady);
+  // eslint-disable-next-line react-hooks/refs -- sync ref to latest prop for use in callbacks
+  onUpdateApiReadyRef.current = onUpdateApiReady;
+
+  // Wire updates after mount, when apiRef.current is populated.
+  useEffect(() => {
+    const api = apiRef.current;
+    if (!api) return;
+    const apply: ApplyBenchUpdates = (patches) => {
+      // MUI X Community caps updateRows to a single row per call (batched
+      // updates are a Pro/Premium feature). To exercise the idiomatic
+      // Community API faithfully, loop per patch.
+      for (const patch of patches) {
+        api.updateRows([patch]);
+      }
+    };
+    onUpdateApiReadyRef.current?.(apply);
+  }, [apiRef, runKey]);
   const rows = useMemo(
     () =>
       dataset.rows.map((row, index) => ({
@@ -76,6 +106,7 @@ export function MuiAdapter({ dataset, runKey }: MuiAdapterProps) {
       >
         <DataGrid
           key={runKey}
+          apiRef={apiRef}
           rows={rows}
           columns={columns}
           getRowHeight={() => "auto" as const}
 
@@ -1,20 +1,29 @@
-import { useCallback, useMemo, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
 
 import type { PretableGrid } from "@pretable/react";
 import type { PretableTelemetry } from "@pretable/react/internal";
 import { PretableSurface } from "@pretable/react/internal";
+import { createBatcher } from "@pretable-internal/stream-adapter";
 import type {
   ScenarioDataset,
   ScenarioRow,
 } from "@pretable-internal/scenario-data";
 
+import type { ApplyBenchUpdates } from "./bench-runtime";
 import type { BenchInteractionPlan } from "./interaction-plan";
 
 export interface PretableAdapterProps {
   dataset: ScenarioDataset;
   interactionPlan?: BenchInteractionPlan | null;
   onGridReady?: (grid: PretableGrid<ScenarioRow>) => void;
   onTelemetryChange?: (telemetry: PretableTelemetry) => void;
+  /**
+   * Called once the adapter has wired up its update mechanism. Pretable
+   * routes batches through @pretable-internal/stream-adapter's RAF-based
+   * batcher → grid.applyTransaction. This is the wedge's idiomatic
+   * streaming pattern.
+   */
+  onUpdateApiReady?: (apply: ApplyBenchUpdates) => void;
   runKey: number;
 }
 
@@ -36,6 +45,7 @@ export function PretableAdapter({
   interactionPlan,
   onGridReady,
   onTelemetryChange,
+  onUpdateApiReady,
   runKey,
 }: PretableAdapterProps) {
   const adapterRef = useRef<HTMLElement>(null);
@@ -47,12 +57,31 @@ export function PretableAdapter({
   const onGridReadyRef = useRef(onGridReady);
   // eslint-disable-next-line react-hooks/refs -- sync ref to latest prop for use in callbacks
   onGridReadyRef.current = onGridReady;
+  const onUpdateApiReadyRef = useRef(onUpdateApiReady);
+  // eslint-disable-next-line react-hooks/refs -- sync ref to latest prop for use in callbacks
+  onUpdateApiReadyRef.current = onUpdateApiReady;
 
   const handleGridReady = useCallback((grid: PretableGrid<ScenarioRow>) => {
     gridRef.current = grid;
     onGridReadyRef.current?.(grid);
   }, []);
 
+  // Wire updates through the stream-adapter batcher (RAF-aligned), the
+  // same path real consumers use for LLM-rate streaming. The batcher is
+  // recreated on each runKey change so a re-run starts with empty buffers.
+  useEffect(() => {
+    const grid = gridRef.current;
+    if (!grid) return;
+    const batcher = createBatcher<ScenarioRow>(grid);
+    const apply: ApplyBenchUpdates = (patches) => {
+      batcher.update(patches as Partial<ScenarioRow>[]);
+    };
+    onUpdateApiReadyRef.current?.(apply);
+    return () => {
+      batcher.dispose();
+    };
+  }, [runKey]);
+
   const onTelemetryChangeRef = useRef(onTelemetryChange);
   // eslint-disable-next-line react-hooks/refs -- sync ref to latest prop for use in callbacks
   onTelemetryChangeRef.current = onTelemetryChange;