diff --git a/evalboard/app/_overview/__tests__/efficiency-charts.test.tsx b/evalboard/app/_overview/__tests__/efficiency-charts.test.tsx
index 0e33607a7..14276709c 100644
--- a/evalboard/app/_overview/__tests__/efficiency-charts.test.tsx
+++ b/evalboard/app/_overview/__tests__/efficiency-charts.test.tsx
@@ -32,7 +32,7 @@ describe("EfficiencyCharts", () => {
     test("opens on the wall-clock metric", () => {
         renderCharts();
         expect(screen.getByRole("heading")).toHaveTextContent(
-            "Time per Passed Task",
+            "Agent Time per Passed Task",
         );
         expect(
             screen.getByRole("tab", { name: "Time" }),
diff --git a/evalboard/app/_overview/efficiency-charts.tsx b/evalboard/app/_overview/efficiency-charts.tsx
index 002e74b9c..095fbc2c9 100644
--- a/evalboard/app/_overview/efficiency-charts.tsx
+++ b/evalboard/app/_overview/efficiency-charts.tsx
@@ -40,10 +40,10 @@ const TABS: Array<{
     {
         key: "time",
         label: "Time",
-        heading: "Time per Passed Task",
-        title: "Total wall clock ÷ tasks passed. Every task's seconds count, failures included; only passes count in the denominator, so a run that fails more reads slower.",
+        heading: "Agent Time per Passed Task",
+        title: "Agent wall clock ÷ tasks passed. Counts the agent's turns only: sandbox setup, pre_run, grading and cleanup are excluded. Every task's agent seconds count, failures included; only passes count in the denominator, so a run that fails more reads slower.",
         blurb: (scoped) =>
-            "Seconds of every task that ran ÷ the number that passed · hover a point for the share within 2× expected" +
+            "Agent seconds of every task that ran (setup and grading excluded) ÷ the number that passed · hover a point for the share within 2× expected" +
             (scoped ? " · scoped to the active filter" : ""),
         render: (props) => <TimePerPassedTaskChart {...props} />,
     },
diff --git a/evalboard/app/_overview/window-summary.tsx b/evalboard/app/_overview/window-summary.tsx
index e67ace75b..b95c95c1e 100644
--- a/evalboard/app/_overview/window-summary.tsx
+++ b/evalboard/app/_overview/window-summary.tsx
@@ -36,7 +36,7 @@ function Tile({
 // Front-page window rollup: total spend + shape of the runs in scope. Every
 // tile is summed over the same set — `runCount` and `totals` both come out of
 // getOverview's single pass, so the Runs tile can never disagree with the
-// Cost/Tasks/Pass/Compute tiles or with the charts. The totals are scoped to
+// Cost/Tasks/Pass/Agent time tiles or with the charts. The totals are scoped to
 // matching tasks whenever a filter is active.
 //
 // This describes the window the charts plot, NOT however far the run table below
@@ -91,9 +91,9 @@ export function WindowSummary({
                     valueClass={passClass(pct)}
                 />
                 <Tile
-                    label="Compute time"
-                    value={fmtDuration(totals.durationSeconds)}
-                    sub={totals.durationPartial ? "some runs missing" : undefined}
+                    label="Agent time"
+                    value={fmtDuration(totals.agentSeconds)}
+                    sub={totals.agentPartial ? "some runs missing" : undefined}
                 />
             </div>
         </section>
diff --git a/evalboard/app/runs/[id]/[...task]/__tests__/message-timeline.test.tsx b/evalboard/app/runs/[id]/[...task]/__tests__/message-timeline.test.tsx
index e8a3b7095..ebbfaf4da 100644
--- a/evalboard/app/runs/[id]/[...task]/__tests__/message-timeline.test.tsx
+++ b/evalboard/app/runs/[id]/[...task]/__tests__/message-timeline.test.tsx
@@ -544,9 +544,8 @@ describe("MessageTimelineSection — Unaccounted cell", () => {
         expect(cell("Unaccounted").textContent).toBe("5.0s (50%)");
     });
 
-    test("the four pre-existing cells still render their values", () => {
+    test("the pre-existing cells still render their values", () => {
         renderStrip(10);
-        expect(cell("Messages").textContent).toBe("1");
         expect(cell("Generation").textContent).toBe("4.0s");
         expect(cell("Tool exec").textContent).toBe("1.0s");
         expect(cell("Slow events").textContent).toBe("0 gen · 0 tool");
@@ -753,6 +752,72 @@ describe("MessageTimelineSection — Unaccounted cell", () => {
     });
 });
 
+describe("MessageTimelineSection — agent time vs eval overhead", () => {
+    function cell(label: string): HTMLElement {
+        const parent = screen.getByText(label).parentElement as HTMLElement;
+        return parent.children[1] as HTMLElement;
+    }
+
+    const message = () => makeMessage({ generationMs: 4000, textMs: 4000 });
+
+    function renderSplit() {
+        return render(
+            <MessageTimelineSection
+                messages={[message()]}
+                taskDurationSeconds={10}
+                agentSeconds={6}
+                harnessStartupMs={1000}
+                harnessTeardownMs={500}
+                setupMs={2500}
+                gradingMs={1000}
+            />,
+        );
+    }
+
+    test("the task total splits into agent time and eval overhead", () => {
+        renderSplit();
+        expect(cell("Task total").textContent).toBe("10.0s");
+        expect(cell("Agent time").textContent).toBe("6.0s (60%)");
+        expect(cell("Eval overhead").textContent).toBe("4.0s (40%)");
+    });
+
+    test("each group's cells sum to its header", () => {
+        renderSplit();
+        // 6s agent = 1s startup + 4s generation + 0.5s teardown + 0.5s unaccounted.
+        expect(cell("Unaccounted").textContent).toBe("500ms (8%)");
+        // 4s overhead = 2.5s setup + 1s grading + 0.5s other.
+        expect(cell("Other").textContent).toBe("500ms");
+    });
+
+    test("a residual that rounds to 0% of agent time is hidden", () => {
+        render(
+            <MessageTimelineSection
+                messages={[message()]}
+                taskDurationSeconds={10}
+                agentSeconds={6.002}
+                harnessStartupMs={1000}
+                harnessTeardownMs={1000}
+            />,
+        );
+        expect(screen.queryByText("Unaccounted")).toBeNull();
+    });
+
+    test("without per-turn durations the residual spans the whole task", () => {
+        render(
+            <MessageTimelineSection
+                messages={[message()]}
+                taskDurationSeconds={10}
+                setupMs={2500}
+                gradingMs={1000}
+            />,
+        );
+        expect(cell("Agent time").textContent).toBe("—");
+        expect(cell("Eval overhead").textContent).toBe("—");
+        expect(cell("Other").textContent).toBe("—");
+        expect(cell("Unaccounted").textContent).toBe("2.5s (25%)");
+    });
+});
+
 describe("MessageTimelineSection — a row's EXEC cell", () => {
     function span(start: number, end: number) {
         return {
diff --git a/evalboard/app/runs/[id]/[...task]/_sections.tsx b/evalboard/app/runs/[id]/[...task]/_sections.tsx
index 2cced0936..83fbc12d3 100644
--- a/evalboard/app/runs/[id]/[...task]/_sections.tsx
+++ b/evalboard/app/runs/[id]/[...task]/_sections.tsx
@@ -267,6 +267,114 @@ function fmtMs(ms: number | null): string {
     return `${sign}${Math.round(abs)}ms`;
 }
 
+const SWATCH = {
+    startup: "bg-indigo-300",
+    generation: "bg-studio-blue",
+    tool: "bg-sky-300",
+    teardown: "bg-indigo-200",
+    unaccounted: "bg-amber-300",
+    setup: "bg-gray-400",
+    grading: "bg-gray-300",
+    other: "bg-gray-200",
+};
+
+function StripCell({
+    label,
+    title,
+    swatch,
+    strong = false,
+    valueClass,
+    children,
+}: {
+    label: string;
+    title?: string;
+    swatch?: string;
+    strong?: boolean;
+    valueClass?: string;
+    children: ReactNode;
+}) {
+    return (
+        <div title={title} className="flex items-baseline gap-1.5 whitespace-nowrap">
+            <div
+                className={`flex items-center gap-1 ${strong ? "text-gray-700 font-semibold" : "text-gray-500"}`}
+            >
+                {swatch && (
+                    <span aria-hidden="true" className={`inline-block h-2 w-2 rounded-sm ${swatch}`} />
+                )}
+                {label}
+            </div>
+            <div className={valueClass ?? (strong ? "text-gray-900 font-semibold" : "text-gray-900 font-medium")}>
+                {children}
+            </div>
+        </div>
+    );
+}
+
+function SplitCell({
+    label,
+    ms,
+    totalMs,
+    valueClass = "text-gray-800 font-medium",
+}: {
+    label: string;
+    ms: number;
+    totalMs: number;
+    valueClass?: string;
+}) {
+    return (
+        <div className="flex items-baseline gap-1 whitespace-nowrap">
+            <div className="text-gray-500">{label}</div>
+            <div className={valueClass}>
+                {fmtMs(ms)}
+                {totalMs > 0 && <ShareOf share={ms / totalMs} />}
+            </div>
+        </div>
+    );
+}
+
+// Widths are flex-grow weights, so negative residuals (overlap) and unmeasured
+// buckets simply drop out instead of skewing the rest.
+function TimeBar({
+    groups,
+}: {
+    groups: { label: string; ms: number | null; swatch: string }[][];
+}) {
+    const shown = groups
+        .map((g) => g.filter((s): s is { label: string; ms: number; swatch: string } => s.ms != null && s.ms > 0))
+        .filter((g) => g.length > 0);
+    if (shown.length === 0) return null;
+    return (
+        <div aria-hidden="true" className="flex h-2.5 w-full gap-0.5">
+            {shown.map((g, i) => (
+                <div
+                    key={i}
+                    className="flex overflow-hidden rounded-sm"
+                    style={{ flex: `${g.reduce((a, s) => a + s.ms, 0)} 1 0` }}
+                >
+                    {g.map((s) => (
+                        <div
+                            key={s.label}
+                            title={`${s.label} ${fmtMs(s.ms)}`}
+                            className={s.swatch}
+                            style={{ flex: `${s.ms} 1 0` }}
+                        />
+                    ))}
+                </div>
+            ))}
+        </div>
+    );
+}
+
+function ShareOf({ share }: { share: number | null }) {
+    if (share == null) return null;
+    return (
+        <span className="text-gray-400">
+            {" "}
+            ({Math.round(share * 100)}%)
+        </span>
+    );
+}
+
 function fmtTokens(n: number | null): string {
     if (n == null) return "—";
     if (n === 0) return "0";
@@ -318,6 +426,7 @@ export function MessageTimelineSection({
     subAgentUsageByToolId = {},
     impactByIndex,
     taskDurationSeconds,
+    agentSeconds,
     harnessStartupMs,
     harnessTeardownMs,
     storedToolMs,
@@ -337,6 +446,9 @@ export function MessageTimelineSection({
     // tool execution do NOT account for. Null/absent on a run predating
     // duration capture — the cell then renders "—" rather than a fake residual.
     taskDurationSeconds?: number | null;
+    // The agent's turns, summed. Absent on a run without per-turn durations,
+    // and the strip then falls back to one task-wide residual.
+    agentSeconds?: number | null;
     // The turn-level head and tail, summed over the task's turns: wall clock
     // before the first generation window opened and after the last one closed.
     // Turn-scoped, so they cannot be derived from the per-message stream the
@@ -438,29 +550,41 @@ export function MessageTimelineSection({
     const attributableGenMs = totalGenMs - mixedMs;
     const thinkingShare = attributableGenMs > 0 ? thinkingMs / attributableGenMs : 0;
 
-    // Wall clock the agent stream does not explain, AFTER every named bucket.
-    // Startup and teardown are subtracted because they are measured intervals,
-    // not residual — leaving them in reported a harness's CLI boot as
-    // unexplained time. `?? 0` subtracts only what was actually measured, so an
-    // older run with neither field keeps exactly its previous number.
-    // Negative means generation and tool execution overlapped, which is a real
-    // signal — never clamped.
+    // With per-turn durations the strip splits into Agent time and Eval
+    // overhead, and each group's cells sum to its header. Without them, one
+    // residual over the whole task, exactly as older runs published it.
+    // Negative residuals mean buckets overlapped and are never clamped.
     const taskMs =
         taskDurationSeconds != null ? taskDurationSeconds * 1000 : null;
+    const agentMs = agentSeconds != null ? agentSeconds * 1000 : null;
+    const overheadMs =
+        taskMs != null && agentMs != null ? taskMs - agentMs : null;
+    const agentBucketsMs =
+        totalGenMs +
+        (toolExecMs ?? 0) +
+        (harnessStartupMs ?? 0) +
+        (harnessTeardownMs ?? 0);
+    const phaseMs = (setupMs ?? 0) + (gradingMs ?? 0);
     const unaccountedMs =
-        taskMs != null
-            ? taskMs -
-              totalGenMs -
-              (toolExecMs ?? 0) -
-              (harnessStartupMs ?? 0) -
-              (harnessTeardownMs ?? 0) -
-              (setupMs ?? 0) -
-              (gradingMs ?? 0)
-            : null;
+        agentMs != null
+            ? agentMs - agentBucketsMs
+            : taskMs != null
+              ? taskMs - agentBucketsMs - phaseMs
+              : null;
+    const unaccountedBase = agentMs ?? taskMs;
     const unaccountedShare =
-        taskMs != null && taskMs > 0 && unaccountedMs != null
-            ? unaccountedMs / taskMs
+        unaccountedBase != null && unaccountedBase > 0 && unaccountedMs != null
+            ? unaccountedMs / unaccountedBase
             : null;
+    // In the split, the four buckets tile each turn, so a residual that rounds
+    // to 0% is the expected case and only noise.
+    const showUnaccounted =
+        agentMs == null ||
+        unaccountedShare == null ||
+        Math.round(unaccountedShare * 100) !== 0;
+    const otherOverheadMs = overheadMs != null ? overheadMs - phaseMs : null;
+    const shareOfTask = (ms: number | null) =>
+        taskMs != null && taskMs > 0 && ms != null ? ms / taskMs : null;
 
     return (
         <section className="space-y-2">
@@ -473,189 +597,150 @@ export function MessageTimelineSection({
             <p className="text-[10px] text-gray-500">
                 MIXED = multiple block types · red = slow (gen ≥10s, tool ≥5s)
             </p>
-            {/* TWO LEVELS, two rows. The top row's five time cells — Startup,
-                Generation, Tool exec, Teardown, Unaccounted — sum to the task's
-                wall clock; the bottom row splits Generation alone and sums to
-                IT. Rendering the split as a sub-cell of one top-row cell put
-                both sums on one line, where nothing said which total each part
-                belonged to. The time cells are ordered as the turn runs. */}
-            <div className="bg-gray-50 border border-gray-200 rounded-lg p-3 tabular-nums space-y-3">
-                <div className="grid grid-cols-2 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-9 gap-3 text-xs">
-                    <div>
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Messages
-                        </div>
-                        <div className="text-gray-900 font-medium">{messageCount}</div>
-                    </div>
-                    <div title="sandbox provisioning, agent start() and pre_run — everything before the first turn begins. TASK-scoped, so it is NOT one of the turn's four buckets: those tile a single turn and their identity is asserted to the millisecond, while this happens once for a task that may run many turns. It is the orchestrator's own cost, not the harness's — measured at ~1.9s for claude-code and pi alike. Blank on runs recorded before the field existed.">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Setup
-                        </div>
-                        <div className="text-gray-900 font-medium">
-                            {fmtMs(setupMs ?? null)}
-                        </div>
-                    </div>
-                    <div title="wall clock from the turn starting until the harness first observed model output — a latency that INCLUDES time-to-first-token, and the same instant its first generation window opens. Named for the interval it measures, not for what it contains. Deliberately NOT decomposed further: a harness with a CLI to boot fuses CLI boot, provider resolution, dispatch and TTFT here, and no stream carries a marker between them. See docs/agents/HARNESS_PARITY.md.">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Startup
-                        </div>
-                        <div className="text-gray-900 font-medium">
-                            {fmtMs(harnessStartupMs ?? null)}
-                        </div>
-                    </div>
-                    <div title="model-generation time, split per block kind on the row below">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Generation
-                        </div>
-                        <div className="text-gray-900 font-medium">
-                            {fmtMs(totalGenMs)}
-                        </div>
-                    </div>
-                    <div title="wall clock the tools occupied — overlapping calls counted once, not twice">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Tool exec
-                        </div>
-                        <div className="text-gray-900 font-medium">
-                            {fmtMs(toolExecMs ?? null)}
-                        </div>
-                    </div>
-                    <div title="wall clock after the last generation window closed: SDK/CLI finalization, result assembly and process teardown">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Teardown
-                        </div>
-                        <div className="text-gray-900 font-medium">
-                            {fmtMs(harnessTeardownMs ?? null)}
-                        </div>
-                    </div>
-                    <div title="every success-criteria check this row made, summed — the single-shot check, each dialog turn's check, and the post-failure diagnostic pass. Blank when nothing was graded (coder-eval execute) or on runs recorded before the field existed.">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Grading
-                        </div>
-                        <div className="text-gray-900 font-medium">
-                            {fmtMs(gradingMs ?? null)}
-                        </div>
-                    </div>
-                    <div title="task wall clock minus every named bucket above. A TRUE residual now that setup and grading are measured: it used to hold the ~1.9s setup phase, a known constant reading as unexplained time. What is left is post_run, sandbox cleanup, simulator calls and any interval the harness did not report.">
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Unaccounted
-                        </div>
-                        <div
-                            className={
-                                unaccountedMs != null && unaccountedMs < 0
-                                    ? // Overlap or unreported overrun, not
-                                      // unexplained time — a different fact
-                                      // from a large positive residual, so a
-                                      // different colour rather than the same
-                                      // grey a healthy row gets.
-                                      "text-amber-700 font-medium"
-                                    : unaccountedShare != null && unaccountedShare >= 0.25
-                                      ? "text-red-700 font-medium"
-                                      : "text-gray-900 font-medium"
-                            }
+            {/* Task total splits into Agent time and Eval overhead, each
+                group's items sum to its header, and the Generation split sums
+                to Generation. */}
+            <div className="bg-gray-50 border border-gray-200 rounded-lg p-3 tabular-nums space-y-2 text-xs">
+                <div className="flex flex-wrap items-baseline justify-between gap-x-4 gap-y-1">
+                    <StripCell
+                        label="Task total"
+                        title="the task's full wall clock: agent time plus eval overhead"
+                        strong
+                    >
+                        {fmtMs(taskMs)}
+                    </StripCell>
+                    <StripCell
+                        label="Slow events"
+                        valueClass={
+                            slowGen + slowTool > 0
+                                ? "text-red-700 font-medium"
+                                : "text-gray-900 font-medium"
+                        }
+                    >
+                        {slowGen} gen · {slowTool} tool
+                    </StripCell>
+                </div>
+                {taskMs != null && taskMs > 0 && (
+                    <TimeBar
+                        groups={[
+                            [
+                                { label: "Startup", ms: harnessStartupMs ?? null, swatch: SWATCH.startup },
+                                { label: "Generation", ms: totalGenMs, swatch: SWATCH.generation },
+                                { label: "Tool exec", ms: toolExecMs ?? null, swatch: SWATCH.tool },
+                                { label: "Teardown", ms: harnessTeardownMs ?? null, swatch: SWATCH.teardown },
+                                { label: "Unaccounted", ms: unaccountedMs, swatch: SWATCH.unaccounted },
+                            ],
+                            [
+                                { label: "Setup", ms: setupMs ?? null, swatch: SWATCH.setup },
+                                { label: "Grading", ms: gradingMs ?? null, swatch: SWATCH.grading },
+                                { label: "Other", ms: otherOverheadMs, swatch: SWATCH.other },
+                            ],
+                        ]}
+                    />
+                )}
+                <div className="grid grid-cols-1 md:grid-cols-[minmax(0,3fr)_minmax(0,2fr)] gap-x-6 gap-y-2">
+                    <div className="space-y-1">
+                        <StripCell
+                            label="Agent time"
+                            title="the agent's turns, summed: the time the Agent time headline and run card count"
+                            strong
                         >
-                            {fmtMs(unaccountedMs)}
-                            {unaccountedShare != null && (
-                                <span className="text-gray-400">
-                                    {" "}
-                                    ({Math.round(unaccountedShare * 100)}%)
-                                </span>
+                            {fmtMs(agentMs)}
+                            <ShareOf share={shareOfTask(agentMs)} />
+                        </StripCell>
+                        <div className="flex flex-wrap gap-x-4 gap-y-1">
+                            <StripCell label="Startup" swatch={SWATCH.startup} title="wall clock from the turn starting until the harness first observed model output — a latency that INCLUDES time-to-first-token, and the same instant its first generation window opens. Named for the interval it measures, not for what it contains. Deliberately NOT decomposed further: a harness with a CLI to boot fuses CLI boot, provider resolution, dispatch and TTFT here, and no stream carries a marker between them. See docs/agents/HARNESS_PARITY.md.">
+                                {fmtMs(harnessStartupMs ?? null)}
+                            </StripCell>
+                            <StripCell label="Generation" swatch={SWATCH.generation} title="model-generation time, split per block kind on the line below">
+                                {fmtMs(totalGenMs)}
+                            </StripCell>
+                            <StripCell label="Tool exec" swatch={SWATCH.tool} title="wall clock the tools occupied — overlapping calls counted once, not twice">
+                                {fmtMs(toolExecMs ?? null)}
+                            </StripCell>
+                            <StripCell label="Teardown" swatch={SWATCH.teardown} title="wall clock after the last generation window closed: SDK/CLI finalization, result assembly and process teardown">
+                                {fmtMs(harnessTeardownMs ?? null)}
+                            </StripCell>
+                            {showUnaccounted && (
+                                <StripCell
+                                    label="Unaccounted"
+                                    swatch={SWATCH.unaccounted}
+                                    title={
+                                        agentMs != null
+                                            ? "agent time minus Startup, Generation, Tool exec and Teardown: intervals inside a turn the harness did not report. Negative means buckets overlapped. Hidden when it rounds to 0%."
+                                            : "task wall clock minus every named bucket above. A TRUE residual now that setup and grading are measured: it used to hold the ~1.9s setup phase, a known constant reading as unexplained time. What is left is post_run, sandbox cleanup, simulator calls and any interval the harness did not report."
+                                    }
+                                    valueClass={
+                                        unaccountedMs != null && unaccountedMs < 0
+                                            ? "text-amber-700 font-medium"
+                                            : unaccountedShare != null && unaccountedShare >= 0.25
+                                              ? "text-red-700 font-medium"
+                                              : "text-gray-900 font-medium"
+                                    }
+                                >
+                                    {fmtMs(unaccountedMs)}
+                                    <ShareOf share={unaccountedShare} />
+                                </StripCell>
                             )}
                         </div>
-                    </div>
-                    <div>
-                        <div className="text-gray-500 uppercase tracking-wide text-[10px]">
-                            Slow events
-                        </div>
                         <div
-                            className={
-                                slowGen + slowTool > 0
-                                    ? "text-red-700 font-medium"
-                                    : "text-gray-900 font-medium"
-                            }
+                            className="flex flex-wrap items-baseline gap-x-3 gap-y-1 border-l-2 border-gray-200 pl-2 text-[10px]"
+                            title="how the Generation figure above divides across block kinds. Within an emission that mixed kinds the split is apportioned by content size — an estimate for those emissions, not a measurement. 'unsplit' is time in an emission with no apportionable content at all, so it belongs to no kind."
                         >
-                            {slowGen} gen · {slowTool} tool
-                        </div>
-                    </div>
-                </div>
-                <div
-                    className="border-t border-gray-200 pt-2 text-[10px]"
-                    title="how the Generation figure above divides across block kinds. Within an emission that mixed kinds the split is apportioned by content size — an estimate for those emissions, not a measurement. 'unsplit' is time in an emission with no apportionable content at all, so it belongs to no kind."
-                >
-                    <div className="text-gray-500 uppercase tracking-wide">
-                        Generation split
-                    </div>
-                    <div
-                        className={
-                            "mt-1 grid gap-2 " +
-                            (mixedMs > 0 ? "grid-cols-4" : "grid-cols-3")
-                        }
-                    >
-                        <div>
-                            <div className="text-gray-500">thinking</div>
-                            <div
-                                className={
+                            <div className="text-gray-500">Generation split</div>
+                            <SplitCell
+                                label="thinking"
+                                ms={thinkingMs}
+                                totalMs={totalGenMs}
+                                valueClass={
                                     thinkingShare >= 0.4
-                                        ? "text-red-700 font-medium tabular-nums"
-                                        : "text-gray-800 font-medium tabular-nums"
+                                        ? "text-red-700 font-medium"
+                                        : "text-gray-800 font-medium"
                                 }
-                            >
-                                {fmtMs(thinkingMs)}
-                                {totalGenMs > 0 && (
-                                    <span className="text-gray-400">
-                                        {" "}
-                                        ({Math.round((thinkingMs / totalGenMs) * 100)}%)
-                                    </span>
-                                )}
-                            </div>
-                        </div>
-                        <div>
+                            />
                             {/* "tool args", never "tool": this is time the model
-                                spent WRITING a tool call, and the Tool exec cell
-                                one row up is time the tool spent RUNNING. The
-                                bare word named both. */}
-                            <div className="text-gray-500">tool args</div>
-                            <div className="text-gray-800 font-medium tabular-nums">
-                                {fmtMs(toolGenMs)}
-                                {totalGenMs > 0 && (
-                                    <span className="text-gray-400">
-                                        {" "}
-                                        ({Math.round((toolGenMs / totalGenMs) * 100)}%)
-                                    </span>
-                                )}
-                            </div>
+                                spent WRITING a tool call, and the Tool exec item
+                                above is time the tool spent RUNNING. */}
+                            <SplitCell label="tool args" ms={toolGenMs} totalMs={totalGenMs} />
+                            <SplitCell label="text" ms={textMs} totalMs={totalGenMs} />
+                            {/* NOT "mixed": the legend above already uses MIXED
+                                for a message carrying multiple block types. This
+                                is the leftover no kind claimed. Backed by
+                                MessageEvent.mixedGenMs. */}
+                            {mixedMs > 0 && (
+                                <SplitCell label="unsplit" ms={mixedMs} totalMs={totalGenMs} />
+                            )}
                         </div>
-                        <div>
-                            <div className="text-gray-500">text</div>
-                            <div className="text-gray-800 font-medium tabular-nums">
-                                {fmtMs(textMs)}
-                                {totalGenMs > 0 && (
-                                    <span className="text-gray-400">
-                                        {" "}
-                                        ({Math.round((textMs / totalGenMs) * 100)}%)
-                                    </span>
-                                )}
-                            </div>
+                    </div>
+                    <div className="space-y-1">
+                        <StripCell
+                            label="Eval overhead"
+                            title="task wall clock outside the agent's turns: sandbox setup, pre_run, grading, post_run and cleanup. No skill can change it."
+                            strong
+                        >
+                            {fmtMs(overheadMs)}
+                            <ShareOf share={shareOfTask(overheadMs)} />
+                        </StripCell>
+                        <div className="flex flex-wrap gap-x-4 gap-y-1">
+                            <StripCell label="Setup" swatch={SWATCH.setup} title="sandbox provisioning, agent start() and pre_run — everything before the first turn begins. TASK-scoped, so it is NOT one of the turn's four buckets: those tile a single turn and their identity is asserted to the millisecond, while this happens once for a task that may run many turns. It is the orchestrator's own cost, not the harness's — measured at ~1.9s for claude-code and pi alike. Blank on runs recorded before the field existed.">
+                                {fmtMs(setupMs ?? null)}
+                            </StripCell>
+                            <StripCell label="Grading" swatch={SWATCH.grading} title="every success-criteria check this row made, summed — the single-shot check, each dialog turn's check, and the post-failure diagnostic pass. Blank when nothing was graded (coder-eval execute) or on runs recorded before the field existed.">
+                                {fmtMs(gradingMs ?? null)}
+                            </StripCell>
+                            <StripCell
+                                label="Other"
+                                swatch={SWATCH.other}
+                                title="eval overhead minus Setup and Grading: post_run, sandbox cleanup and simulator calls"
+                                valueClass={
+                                    otherOverheadMs != null && otherOverheadMs < 0
+                                        ? "text-amber-700 font-medium"
+                                        : "text-gray-900 font-medium"
+                                }
+                            >
+                                {fmtMs(otherOverheadMs)}
+                            </StripCell>
                         </div>
-                        {mixedMs > 0 && (
-                            <div>
-                                {/* NOT "mixed": the legend above already uses
-                                    MIXED for a message carrying multiple block
-                                    types, which is ~93% of Delegate's rows and
-                                    the very case this cell is usually EMPTY
-                                    for. This is the leftover no kind claimed.
-                                    Backed by MessageEvent.mixedGenMs. */}
-                                <div className="text-gray-500">unsplit</div>
-                                <div className="text-gray-800 font-medium tabular-nums">
-                                    {fmtMs(mixedMs)}
-                                    {totalGenMs > 0 && (
-                                        <span className="text-gray-400">
-                                            {" "}
-                                            ({Math.round((mixedMs / totalGenMs) * 100)}%)
-                                        </span>
-                                    )}
-                                </div>
-                            </div>
-                        )}
                     </div>
                 </div>
             </div>
@@ -858,6 +943,7 @@ export function CostExplorerSection({
     tokens,
     recordedCostUsd,
     taskDurationSeconds,
+    agentSeconds,
     harnessStartupMs,
     harnessTeardownMs,
     storedToolMs,
@@ -870,6 +956,7 @@ export function CostExplorerSection({
     recordedCostUsd: number | null;
     // Forwarded verbatim to the timeline's Unaccounted cell.
     taskDurationSeconds?: number | null;
+    agentSeconds?: number | null;
     // Forwarded verbatim to the timeline's Startup/Teardown cells.
     harnessStartupMs?: number | null;
     harnessTeardownMs?: number | null;
@@ -916,6 +1003,7 @@ export function CostExplorerSection({
                 subAgentUsageByToolId={subAgentUsageByToolId}
                 impactByIndex={impactByIndex}
                 taskDurationSeconds={taskDurationSeconds}
+                agentSeconds={agentSeconds}
                 harnessStartupMs={harnessStartupMs}
                 harnessTeardownMs={harnessTeardownMs}
                 storedToolMs={storedToolMs}
diff --git a/evalboard/app/runs/[id]/[...task]/page.tsx b/evalboard/app/runs/[id]/[...task]/page.tsx
index 760dcf53d..d2ea563b1 100644
--- a/evalboard/app/runs/[id]/[...task]/page.tsx
+++ b/evalboard/app/runs/[id]/[...task]/page.tsx
@@ -365,6 +365,7 @@ export default async function TaskPage({
                     tokens={task.tokens}
                     recordedCostUsd={task.totalCostUsd}
                     taskDurationSeconds={task.durationSeconds}
+                    agentSeconds={task.agentSeconds}
                     harnessStartupMs={task.harnessStartupMs}
                     setupMs={task.setupMs}
                     gradingMs={task.gradingMs}
diff --git a/evalboard/app/runs/[id]/__tests__/run-view.render.test.tsx b/evalboard/app/runs/[id]/__tests__/run-view.render.test.tsx
index 4b4ed252e..dcd6add7e 100644
--- a/evalboard/app/runs/[id]/__tests__/run-view.render.test.tsx
+++ b/evalboard/app/runs/[id]/__tests__/run-view.render.test.tsx
@@ -1,15 +1,20 @@
-import { describe, expect, test, vi } from "vitest";
-import { render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
 import type { TaskResultSummary } from "@/lib/runs";
 
 // RunView reads the URL via next/navigation hooks; stub them so it renders in
 // jsdom. The filter state we don't exercise here just resolves to "no filter".
+const nav = vi.hoisted(() => ({ search: new URLSearchParams() }));
 vi.mock("next/navigation", () => ({
     useRouter: () => ({ replace: vi.fn(), push: vi.fn() }),
     usePathname: () => "/runs/r1",
-    useSearchParams: () => new URLSearchParams(),
+    useSearchParams: () => nav.search,
 }));
 
+afterEach(() => {
+    nav.search = new URLSearchParams();
+});
+
 const { RunView } = await import("../run-view");
 
 function row(
@@ -23,6 +28,7 @@ function row(
         status: "SUCCESS",
         weightedScore: 1.0,
         durationSeconds: 1.0,
+        agentSeconds: 1.0,
         totalCostUsd: 0.1,
         actualCommands: null,
         totalTurns: null,
@@ -90,10 +96,10 @@ describe("RunView — multi-variant runs replace the pooled pass rate", () => {
     // 50%, which describes neither configuration; the whole point of the tile
     // change is that this number no longer appears anywhere on the page.
     const AB = [
-        row("X", { variantId: "A", status: "SUCCESS", totalCostUsd: 0.1, durationSeconds: 1 }),
-        row("Y", { variantId: "A", status: "SUCCESS", totalCostUsd: 0.1, durationSeconds: 1 }),
-        row("X", { variantId: "B", status: "FAILURE", totalCostUsd: 0.3, durationSeconds: 5 }),
-        row("Y", { variantId: "B", status: "FAILURE", totalCostUsd: 0.3, durationSeconds: 5 }),
+        row("X", { variantId: "A", status: "SUCCESS", totalCostUsd: 0.1, agentSeconds: 1 }),
+        row("Y", { variantId: "A", status: "SUCCESS", totalCostUsd: 0.1, agentSeconds: 1 }),
+        row("X", { variantId: "B", status: "FAILURE", totalCostUsd: 0.3, agentSeconds: 5 }),
+        row("Y", { variantId: "B", status: "FAILURE", totalCostUsd: 0.3, agentSeconds: 5 }),
     ];
 
     test("each arm gets its own rate and the blended rate is gone", () => {
@@ -111,6 +117,8 @@ describe("RunView — multi-variant runs replace the pooled pass rate", () => {
 
         // Pooled totals stay: a run's cost is real however many arms produced it.
         expect(screen.getByText("$0.80")).toBeInTheDocument();
+        expect(screen.getByText("Agent time")).toBeInTheDocument();
+        // Agent seconds (1+1+5+5), not the rows' full durations (4 x 1s).
         expect(screen.getByText("12s")).toBeInTheDocument();
         // ...with the per-arm split replacing p50/p90, which would describe a
         // pooled population that does not exist.
@@ -136,3 +144,62 @@ describe("RunView — multi-variant runs replace the pooled pass rate", () => {
         expect(screen.getAllByText(/p50/).length).toBe(2);
     });
 });
+
+describe("RunView — variant filter", () => {
+    const AB = [
+        row("X", { variantId: "A", status: "SUCCESS" }),
+        row("Y", { variantId: "A", status: "SUCCESS" }),
+        row("X", { variantId: "B", status: "FAILURE" }),
+        row("Y", { variantId: "B", status: "FAILURE" }),
+    ];
+
+    test("offered on a multi-arm run only", () => {
+        const { unmount } = render(
+            <RunView sourceId="skills" runId="r1" tasks={AB} />,
+        );
+        const group = screen.getByRole("group", { name: "Filter by variant" });
+        expect(group).toHaveTextContent("allAB");
+        expect(screen.getByRole("button", { name: "all" })).toHaveAttribute(
+            "aria-pressed",
+            "true",
+        );
+        unmount();
+
+        render(
+            <RunView
+                sourceId="skills"
+                runId="r1"
+                tasks={[row("X", { variantId: "only" })]}
+            />,
+        );
+        expect(screen.queryByRole("group", { name: "Filter by variant" })).toBeNull();
+    });
+
+    test("a selected arm scopes the tiles and the grid to its rows", () => {
+        nav.search = new URLSearchParams("variant=B");
+        render(<RunView sourceId="skills" runId="r1" tasks={AB} />);
+
+        expect(screen.getByRole("button", { name: "B" })).toHaveAttribute(
+            "aria-pressed",
+            "true",
+        );
+        expect(screen.getByText("0%")).toBeInTheDocument();
+        expect(screen.queryByText("100%")).toBeNull();
+        expect(screen.queryByText(/arms · spread/)).toBeNull();
+        expect(screen.getByText("2 / 4")).toBeInTheDocument();
+    });
+
+    test("an unknown arm in the URL is ignored", () => {
+        nav.search = new URLSearchParams("variant=nope");
+        render(<RunView sourceId="skills" runId="r1" tasks={AB} />);
+        expect(screen.getByText(/2 arms · spread 100 pts/)).toBeInTheDocument();
+    });
+
+    test("picking an arm writes it to the URL", () => {
+        const replace = vi.spyOn(window.history, "replaceState");
+        render(<RunView sourceId="skills" runId="r1" tasks={AB} />);
+        fireEvent.click(screen.getByRole("button", { name: "B" }));
+        expect(replace).toHaveBeenLastCalledWith(null, "", "/runs/r1?variant=B");
+        replace.mockRestore();
+    });
+});
diff --git a/evalboard/app/runs/[id]/__tests__/run-view.test.ts b/evalboard/app/runs/[id]/__tests__/run-view.test.ts
index 3b1c45aec..7da6b8379 100644
--- a/evalboard/app/runs/[id]/__tests__/run-view.test.ts
+++ b/evalboard/app/runs/[id]/__tests__/run-view.test.ts
@@ -17,6 +17,7 @@ function row(
         status: "SUCCESS",
         weightedScore: 1.0,
         durationSeconds: 1.0,
+        agentSeconds: 1.0,
         totalCostUsd: 0.1,
         actualCommands: null,
         totalTurns: null,
@@ -36,14 +37,14 @@ function row(
 }
 
 describe("computeRunMetrics — mature-skipped exclusion", () => {
-    test("mature rows count as passes but are excluded from cost/duration totals and percentiles", () => {
+    test("mature rows count as passes but are excluded from cost/agent-time totals and percentiles", () => {
         const m = computeRunMetrics([
-            row("ran-a", { totalCostUsd: 0.1, durationSeconds: 1.0 }),
-            row("ran-b", { totalCostUsd: 0.3, durationSeconds: 3.0 }),
+            row("ran-a", { totalCostUsd: 0.1, agentSeconds: 1.0 }),
+            row("ran-b", { totalCostUsd: 0.3, agentSeconds: 3.0 }),
             // Carried-forward mature row: 0 cost / 0 duration, never ran.
             row("mature", {
                 totalCostUsd: 0,
-                durationSeconds: 0,
+                agentSeconds: 0,
                 matureSkipped: true,
             }),
         ]);
@@ -56,19 +57,19 @@ describe("computeRunMetrics — mature-skipped exclusion", () => {
 
         // Totals reflect only the two tasks that actually ran (0.1 + 0.3, 1 + 3).
         expect(m.cost).toBeCloseTo(0.4, 10);
-        expect(m.duration).toBeCloseTo(4.0, 10);
+        expect(m.agentSeconds).toBeCloseTo(4.0, 10);
 
         // Percentiles are taken over [0.1, 0.3] / [1, 3] only. If the mature 0s
         // leaked in, the p50 would be dragged to 0.1 / 1.0 (median of three).
         expect(m.costP50).toBeCloseTo(0.2, 10);
         expect(m.costP90).toBeCloseTo(0.28, 10);
-        expect(m.durationP50).toBeCloseTo(2.0, 10);
+        expect(m.agentSecondsP50).toBeCloseTo(2.0, 10);
     });
 
     test("an all-mature run reports passes but null cost/duration (renders as —)", () => {
         const m = computeRunMetrics([
-            row("m1", { totalCostUsd: 0, durationSeconds: 0, matureSkipped: true }),
-            row("m2", { totalCostUsd: 0, durationSeconds: 0, matureSkipped: true }),
+            row("m1", { totalCostUsd: 0, agentSeconds: 0, matureSkipped: true }),
+            row("m2", { totalCostUsd: 0, agentSeconds: 0, matureSkipped: true }),
         ]);
 
         expect(m.total).toBe(2);
@@ -77,8 +78,8 @@ describe("computeRunMetrics — mature-skipped exclusion", () => {
         expect(m.cost).toBeNull();
         expect(m.costP50).toBeNull();
         expect(m.costP90).toBeNull();
-        expect(m.duration).toBeNull();
-        expect(m.durationP50).toBeNull();
+        expect(m.agentSeconds).toBeNull();
+        expect(m.agentSecondsP50).toBeNull();
     });
 });
 
@@ -153,13 +154,13 @@ describe("computeVariantMetrics", () => {
     // finding, and pooling would erase it.
     test("cost and duration are per arm, not pooled", () => {
         const rows = computeVariantMetrics([
-            row("A", { variantId: "a", totalCostUsd: 1, durationSeconds: 10 }),
-            row("A", { variantId: "b", totalCostUsd: 3, durationSeconds: 30 }),
+            row("A", { variantId: "a", totalCostUsd: 1, agentSeconds: 10 }),
+            row("A", { variantId: "b", totalCostUsd: 3, agentSeconds: 30 }),
         ]);
         expect(rows[0].metrics.cost).toBeCloseTo(1, 10);
         expect(rows[1].metrics.cost).toBeCloseTo(3, 10);
-        expect(rows[0].metrics.duration).toBeCloseTo(10, 10);
-        expect(rows[1].metrics.duration).toBeCloseTo(30, 10);
+        expect(rows[0].metrics.agentSeconds).toBeCloseTo(10, 10);
+        expect(rows[1].metrics.agentSeconds).toBeCloseTo(30, 10);
     });
 
     // Rows with no variant_id belong to the default arm, so a run that mixes
diff --git a/evalboard/app/runs/[id]/run-view.tsx b/evalboard/app/runs/[id]/run-view.tsx
index 68398baf9..15b23b620 100644
--- a/evalboard/app/runs/[id]/run-view.tsx
+++ b/evalboard/app/runs/[id]/run-view.tsx
@@ -61,9 +61,9 @@ export interface RunMetrics {
     cost: number | null;
     costP50: number | null;
     costP90: number | null;
-    duration: number | null;
-    durationP50: number | null;
-    durationP90: number | null;
+    agentSeconds: number | null;
+    agentSecondsP50: number | null;
+    agentSecondsP90: number | null;
 }
 
 // Aggregate run-level metrics from a set of task rows. Status categorization is
@@ -82,9 +82,9 @@ export function computeRunMetrics(tasks: TaskResultSummary[]): RunMetrics {
     let errored = 0;
     let ungraded = 0;
     let cost = 0;
-    let durationSum = 0;
+    let agentSum = 0;
     const costSamples: number[] = [];
-    const durSamples: number[] = [];
+    const agentSamples: number[] = [];
     for (const t of tasks) {
         // A `switch` with an assertNever default, not an if/else chain with a
         // catch-all `else failed++`. That chain is what made adding "ungraded"
@@ -115,9 +115,9 @@ export function computeRunMetrics(tasks: TaskResultSummary[]): RunMetrics {
             cost += t.totalCostUsd;
             costSamples.push(t.totalCostUsd);
         }
-        if (t.durationSeconds != null) {
-            durationSum += t.durationSeconds;
-            durSamples.push(t.durationSeconds);
+        if (t.agentSeconds != null) {
+            agentSum += t.agentSeconds;
+            agentSamples.push(t.agentSeconds);
         }
     }
     const graded = total - ungraded;
@@ -147,9 +147,9 @@ export function computeRunMetrics(tasks: TaskResultSummary[]): RunMetrics {
         cost: costSamples.length ? cost : null,
         costP50: percentile(costSamples, 0.5),
         costP90: percentile(costSamples, 0.9),
-        duration: durSamples.length ? durationSum : null,
-        durationP50: percentile(durSamples, 0.5),
-        durationP90: percentile(durSamples, 0.9),
+        agentSeconds: agentSamples.length ? agentSum : null,
+        agentSecondsP50: percentile(agentSamples, 0.5),
+        agentSecondsP90: percentile(agentSamples, 0.9),
     };
 }
 
@@ -208,6 +208,46 @@ function Metric({
     );
 }
 
+function VariantFilter({
+    variants,
+    selected,
+    onSelect,
+}: {
+    variants: string[];
+    selected: string | null;
+    onSelect: (variant: string | null) => void;
+}) {
+    return (
+        <div
+            className="flex flex-wrap items-center gap-1.5"
+            role="group"
+            aria-label="Filter by variant"
+        >
+            <span className="text-xs text-gray-500 uppercase tracking-wide mr-1">
+                Variant
+            </span>
+            {[null, ...variants].map((v) => {
+                const active = v === selected;
+                return (
+                    <button
+                        key={v === null ? "all:" : `v:${v}`}
+                        type="button"
+                        aria-pressed={active}
+                        onClick={() => onSelect(v)}
+                        className={`font-mono text-xs px-2 py-0.5 rounded border transition-colors ${
+                            active
+                                ? "bg-studio-blue text-white border-studio-blue"
+                                : "bg-white text-gray-600 border-gray-200 hover:bg-gray-50"
+                        }`}
+                    >
+                        {v ?? "all"}
+                    </button>
+                );
+            })}
+        </div>
+    );
+}
+
 // Replaces the pooled number inside the Pass rate tile: a blended rate averages
 // configurations that were deliberately made to differ, and moves when the arms
 // are merely reordered. Spend and time keep their pooled totals instead, since a
@@ -329,6 +369,13 @@ export function RunView({
     const q = searchParams.get("q") ?? "";
     const [showAllTags, setShowAllTags] = useState(false);
 
+    const allVariants = useMemo(() => variantsOf(tasks), [tasks]);
+    const rawVariant = searchParams.get("variant");
+    const selectedVariant =
+        allVariants.length > 1 && rawVariant && allVariants.includes(rawVariant)
+            ? rawVariant
+            : null;
+
     // Commit a filter change to the URL WITHOUT a server round-trip.
     //
     // Every reader of `tags` / `rtags` / `q` on this page is client-side (see
@@ -388,11 +435,22 @@ export function RunView({
         [selectedReviewSet, selectedReviewTags, updateParam],
     );
 
+    const selectVariant = useCallback(
+        (variant: string | null) => {
+            const params = new URLSearchParams(window.location.search);
+            if (variant == null) params.delete("variant");
+            else params.set("variant", variant);
+            setSearchParams(params);
+        },
+        [setSearchParams],
+    );
+
     const clearAll = useCallback(() => {
         const params = new URLSearchParams(window.location.search);
         params.delete("q");
         params.delete("tags");
         params.delete("rtags");
+        params.delete("variant");
         setSearchParams(params);
     }, [setSearchParams]);
 
@@ -427,6 +485,11 @@ export function RunView({
 
     const filtered = useMemo(() => {
         let arr = tasks;
+        if (selectedVariant != null) {
+            arr = arr.filter(
+                (t) => (t.variantId ?? DEFAULT_VARIANT_ID) === selectedVariant,
+            );
+        }
         if (selectedTags.length > 0) {
             // Match on either real tags or the derived skill, so the same
             // `tags` URL param works for both rails. Robust to new runs where
@@ -459,9 +522,17 @@ export function RunView({
             });
         }
         return arr;
-    }, [tasks, selectedTags, selectedReviewTags, reviewsByTask, qLower]);
+    }, [
+        tasks,
+        selectedVariant,
+        selectedTags,
+        selectedReviewTags,
+        reviewsByTask,
+        qLower,
+    ]);
 
     const isFiltered =
+        selectedVariant != null ||
         selectedTags.length > 0 ||
         selectedReviewTags.length > 0 ||
         qLower.length > 0;
@@ -676,23 +747,31 @@ export function RunView({
                     }
                 />
                 <Metric
-                    label="Time"
-                    value={fmtDuration(metrics.duration)}
+                    label="Agent time"
+                    value={fmtDuration(metrics.agentSeconds)}
                     sub={
                         hasVariants
                             ? variantSub(variantMetrics, (m) =>
-                                  m.duration != null
-                                      ? fmtDuration(m.duration)
+                                  m.agentSeconds != null
+                                      ? fmtDuration(m.agentSeconds)
                                       : null,
                               )
-                            : metrics.durationP50 != null &&
-                                metrics.durationP90 != null
-                              ? `p50 ${fmtDuration(metrics.durationP50)} · p90 ${fmtDuration(metrics.durationP90)}`
+                            : metrics.agentSecondsP50 != null &&
+                                metrics.agentSecondsP90 != null
+                              ? `p50 ${fmtDuration(metrics.agentSecondsP50)} · p90 ${fmtDuration(metrics.agentSecondsP90)}`
                               : undefined
                     }
                 />
             </div>
 
+            {allVariants.length > 1 && (
+                <VariantFilter
+                    variants={allVariants}
+                    selected={selectedVariant}
+                    onSelect={selectVariant}
+                />
+            )}
+
             {/* The colored skill/review/tag filter rail (+ its color legend)
                 is an internal-only surface — see lib/edition.ts. The public OSS
                 edition hides it; per-task chips on the grid below still render
diff --git a/evalboard/lib/__tests__/no-zero-coalesce.test.ts b/evalboard/lib/__tests__/no-zero-coalesce.test.ts
index b65fab91b..08d22f15e 100644
--- a/evalboard/lib/__tests__/no-zero-coalesce.test.ts
+++ b/evalboard/lib/__tests__/no-zero-coalesce.test.ts
@@ -85,24 +85,20 @@ const ALLOWED = new Map<string, string>([
         "A threshold comparison: an untimed call is not a slow call, so 0 answers the question asked.",
     ],
     [
-        "(toolExecMs ?? 0) -",
+        "(toolExecMs ?? 0) +",
         "The residual's tool half, and the reason the cell itself now renders a dash: a turn with no BOUNDED span measured no tool time, so its time belongs IN the residual rather than being subtracted as a zero.",
     ],
     [
-        "(harnessStartupMs ?? 0) -",
+        "(harnessStartupMs ?? 0) +",
         "The residual. Subtracting only what was measured is the whole point; an unmeasured head leaves its time IN the residual rather than silently claiming it.",
     ],
     [
-        "(harnessTeardownMs ?? 0) -",
+        "(harnessTeardownMs ?? 0);",
         "The residual's tail half: subtracting only what was measured leaves unmeasured time IN the residual.",
     ],
     [
-        "(setupMs ?? 0) -",
-        "Same residual rule: a run predating the field leaves its setup time IN the residual rather than having it silently subtracted as zero.",
-    ],
-    [
-        "(gradingMs ?? 0)",
-        "Same residual rule, and it is also the ungraded case — `coder-eval execute` grades nothing, so there is no grading time to subtract.",
+        "const phaseMs = (setupMs ?? 0) + (gradingMs ?? 0);",
+        "Same residual rule: a run predating the fields leaves setup and grading time IN the residual, and `coder-eval execute` grades nothing, so there is no grading time to subtract.",
     ],
     [
         "const slowExec = (execMs ?? 0) >= SLOW_TOOL_MS;",
diff --git a/evalboard/lib/__tests__/overview.test.ts b/evalboard/lib/__tests__/overview.test.ts
index 38b20899e..113816506 100644
--- a/evalboard/lib/__tests__/overview.test.ts
+++ b/evalboard/lib/__tests__/overview.test.ts
@@ -60,55 +60,55 @@ describe("summarizeListing", () => {
             tasksSucceeded: 0,
             tasksRun: 0,
             tasksGraded: 0,
-            durationSeconds: null,
-            durationPartial: false,
+            agentSeconds: null,
+            agentPartial: false,
         });
     });
 
-    test("sums cost, duration, and task counts across runs", () => {
+    test("sums cost, agent time, and task counts across runs", () => {
         const t = summarizeListing([
             row({
                 tasksSucceeded: 8,
                 tasksRun: 10,
                 totalCostUsd: 1.5,
-                taskDurationSeconds: 120,
+                agentSeconds: 120,
             }),
             row({
                 tasksSucceeded: 3,
                 tasksRun: 5,
                 totalCostUsd: 2.25,
-                taskDurationSeconds: 60,
+                agentSeconds: 60,
             }),
         ]);
         expect(t.costUsd).toBeCloseTo(3.75);
-        expect(t.durationSeconds).toBe(180);
+        expect(t.agentSeconds).toBe(180);
         expect(t.tasksSucceeded).toBe(11);
         expect(t.tasksRun).toBe(15);
         expect(t.costPartial).toBe(false);
-        expect(t.durationPartial).toBe(false);
+        expect(t.agentPartial).toBe(false);
     });
 
-    test("flags partial when a run lacks cost or duration", () => {
-        // One run recorded cost/duration, one didn't: sum reflects only the
+    test("flags partial when a run lacks cost or agent time", () => {
+        // One run recorded cost/agent time, one didn't: sum reflects only the
         // recorded run and the *Partial flags say so.
         const t = summarizeListing([
-            row({ totalCostUsd: 4, taskDurationSeconds: 30 }),
-            row({ totalCostUsd: null, taskDurationSeconds: null }),
+            row({ totalCostUsd: 4, agentSeconds: 30 }),
+            row({ totalCostUsd: null, agentSeconds: null }),
         ]);
         expect(t.costUsd).toBe(4);
         expect(t.costPartial).toBe(true);
-        expect(t.durationSeconds).toBe(30);
-        expect(t.durationPartial).toBe(true);
+        expect(t.agentSeconds).toBe(30);
+        expect(t.agentPartial).toBe(true);
     });
 
     test("all-missing cost stays null, not zero", () => {
         // A window where no run has a cost must read "—", not "$0.00" — the
-        // sum is unknown, not zero. Same for duration.
+        // sum is unknown, not zero. Same for agent time.
         const t = summarizeListing([row({}), row({})]);
         expect(t.costUsd).toBeNull();
         expect(t.costPartial).toBe(false);
-        expect(t.durationSeconds).toBeNull();
-        expect(t.durationPartial).toBe(false);
+        expect(t.agentSeconds).toBeNull();
+        expect(t.agentPartial).toBe(false);
     });
 });
 
@@ -304,12 +304,12 @@ describe("timePerPassedTaskForTasks", () => {
         // divided real seconds by tasks that never ran. A codex nightly whose
         // runner block said 3m12s rendered as 1m17s on the front page.
         const executed = [
-            task({ durationSeconds: 100 }),
-            task({ durationSeconds: 300 }),
+            task({ agentSeconds: 100 }),
+            task({ agentSeconds: 300 }),
         ];
         const carried = [
-            task({ durationSeconds: 0, matureSkipped: true }),
-            task({ durationSeconds: 0, matureSkipped: true }),
+            task({ agentSeconds: 0, matureSkipped: true }),
+            task({ agentSeconds: 0, matureSkipped: true }),
         ];
         expect(timePerPassedTaskForTasks([...executed, ...carried])).toBe(
             timePerPassedTaskForTasks(executed),
@@ -332,8 +332,8 @@ describe("timePerPassedTaskForTasks", () => {
     test("divides all seconds that ran by the number that passed", () => {
         expect(
             timePerPassedTaskForTasks([
-                task({ durationSeconds: 100 }),
-                task({ durationSeconds: 300 }),
+                task({ agentSeconds: 100 }),
+                task({ agentSeconds: 300 }),
             ]),
         ).toBe(200);
     });
@@ -343,8 +343,8 @@ describe("timePerPassedTaskForTasks", () => {
         // says so: 400 seconds over the single pass.
         expect(
             timePerPassedTaskForTasks([
-                task({ durationSeconds: 100 }),
-                task({ status: "FAILURE", durationSeconds: 300 }),
+                task({ agentSeconds: 100 }),
+                task({ status: "FAILURE", agentSeconds: 300 }),
             ]),
         ).toBe(400);
     });
@@ -352,7 +352,7 @@ describe("timePerPassedTaskForTasks", () => {
     test("null when nothing passed", () => {
         expect(
             timePerPassedTaskForTasks([
-                task({ status: "FAILURE", durationSeconds: 300 }),
+                task({ status: "FAILURE", agentSeconds: 300 }),
             ]),
         ).toBeNull();
     });
@@ -360,6 +360,15 @@ describe("timePerPassedTaskForTasks", () => {
     test("null when no duration was recorded", () => {
         expect(timePerPassedTaskForTasks([task({})])).toBeNull();
     });
+
+    test("counts agent seconds, not the row's full duration", () => {
+        expect(
+            timePerPassedTaskForTasks([
+                task({ durationSeconds: 130, agentSeconds: 100 }),
+                task({ durationSeconds: 330, agentSeconds: 300 }),
+            ]),
+        ).toBe(200);
+    });
 });
 
 describe("collectPipelineRuns", () => {
@@ -1267,6 +1276,16 @@ describe("projectRunRow", () => {
             );
             expect(scoped?.tasks).toHaveLength(2);
         });
+
+        test("sums agent time over the tasks that ran, whole or filtered", () => {
+            const r = run("r", [
+                task({ taskId: "a", tags: ["keep"], agentSeconds: 30 }),
+                task({ taskId: "b", agentSeconds: 12 }),
+                task({ taskId: "c", tags: ["keep"], agentSeconds: 99, matureSkipped: true }),
+            ]);
+            expect(scopeRunTasks(r, null, null)?.agentSeconds).toBe(42);
+            expect(scopeRunTasks(r, "keep", null)?.agentSeconds).toBe(30);
+        });
     });
 });
 
diff --git a/evalboard/lib/__tests__/runs.test.ts b/evalboard/lib/__tests__/runs.test.ts
index d7736f8de..2c1b90e29 100644
--- a/evalboard/lib/__tests__/runs.test.ts
+++ b/evalboard/lib/__tests__/runs.test.ts
@@ -11,6 +11,7 @@ import {
     test,
 } from "vitest";
 import {
+    agentSecondsFromRaw,
     aggregateSubAgentUsage,
     type ArtifactRef,
     clearRunCacheDir,
@@ -500,6 +501,24 @@ describe("visibleTurnsFromRaw (historical backfill)", () => {
     });
 });
 
+describe("agentSecondsFromRaw", () => {
+    test("sums every turn, leaving out setup and grading", () => {
+        expect(
+            agentSecondsFromRaw({
+                duration: 130,
+                iterations: [{ duration_seconds: 40 }, { duration_seconds: 60 }],
+            }),
+        ).toBe(100);
+    });
+
+    test("null when no turn recorded a duration", () => {
+        expect(agentSecondsFromRaw({ duration: 24 })).toBeNull();
+        expect(
+            agentSecondsFromRaw({ iterations: [{ duration_seconds: null }] }),
+        ).toBeNull();
+    });
+});
+
 describe("extractComponentShas", () => {
     const baseEnv = {
         git_commit: "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2",
diff --git a/evalboard/lib/overview.ts b/evalboard/lib/overview.ts
index bd32866cd..4b9250495 100644
--- a/evalboard/lib/overview.ts
+++ b/evalboard/lib/overview.ts
@@ -131,12 +131,15 @@ export function withinExpectedTimeRateForTasks(
     return eligible > 0 ? (within / eligible) * 100 : null;
 }
 
-// Seconds of every task that ran, over the number that passed. Mirrors the
+// Agent seconds of every task that ran, over the number that passed. Mirrors the
 // runner's headline (timing.py::time_per_passed_task) so a filtered front-page
 // view and the block stamped into run.json compute the same thing on the same
 // rows. The Slack rollup does not report this yet — the metric is being watched
 // on the dashboard first.
 //
+// Agent time, not the row's `duration`: setup and grading are eval scaffolding
+// no skill can change, and their share differs by harness.
+//
 // Mature-skipped rows leave BOTH sides. They are carried-forward passes with no
 // duration, so counting them only in the denominator divides real seconds by a
 // task count that never ran: on a codex nightly that reported 3m12s, including
@@ -147,7 +150,7 @@ export function timePerPassedTaskForTasks(
     const executed = tasks.filter((t) => !t.matureSkipped);
     const passed = executed.filter((t) => isPassStatus(t.status)).length;
     if (!passed) return null;
-    const total = executed.reduce((a, t) => a + (t.durationSeconds ?? 0), 0);
+    const total = executed.reduce((a, t) => a + (t.agentSeconds ?? 0), 0);
     return total > 0 ? total / passed : null;
 }
 
@@ -191,6 +194,8 @@ export interface RunListingRow {
     tasksExecuted: number;
     totalCostUsd: number | null;
     taskDurationSeconds: number | null;
+    // Optional so existing test factories stay valid.
+    agentSeconds?: number | null;
     // Run-level harness (coder-eval AgentKind) for the Harness column; null on
     // legacy runs that predate the RunConfig stamp / carry no agent_config.type.
     // Optional so existing test factories stay valid.
@@ -208,8 +213,8 @@ export interface RunListingTotals {
     tasksSucceeded: number;
     tasksRun: number;
     tasksGraded: number; // the pass-rate denominator; see RunListingRow.tasksGraded
-    durationSeconds: number | null; // null when no matched run recorded a duration
-    durationPartial: boolean;
+    agentSeconds: number | null; // null when no matched run recorded agent time
+    agentPartial: boolean;
 }
 
 // Sum a matched-run slice into a window rollup. Pure over RunListingRow[] so it
@@ -221,8 +226,8 @@ export function summarizeListing(rows: RunListingRow[]): RunListingTotals {
     let tasksSucceeded = 0;
     let tasksRun = 0;
     let tasksGraded = 0;
-    let durationSeconds = 0;
-    let durationRuns = 0;
+    let agentSeconds = 0;
+    let agentRuns = 0;
     for (const r of rows) {
         tasksSucceeded += r.tasksSucceeded;
         tasksRun += r.tasksRun;
@@ -231,9 +236,9 @@ export function summarizeListing(rows: RunListingRow[]): RunListingTotals {
             costUsd += r.totalCostUsd;
             costRuns += 1;
         }
-        if (r.taskDurationSeconds != null) {
-            durationSeconds += r.taskDurationSeconds;
-            durationRuns += 1;
+        if (r.agentSeconds != null) {
+            agentSeconds += r.agentSeconds;
+            agentRuns += 1;
         }
     }
     return {
@@ -242,8 +247,8 @@ export function summarizeListing(rows: RunListingRow[]): RunListingTotals {
         tasksSucceeded,
         tasksRun,
         tasksGraded,
-        durationSeconds: durationRuns > 0 ? durationSeconds : null,
-        durationPartial: durationRuns > 0 && durationRuns < rows.length,
+        agentSeconds: agentRuns > 0 ? agentSeconds : null,
+        agentPartial: agentRuns > 0 && agentRuns < rows.length,
     };
 }
 
@@ -1075,6 +1080,18 @@ export interface ScopedRun {
     // second count over `tasks` — which drops rows with no task_id — could
     // disagree with the duration's own denominator.
     tasksExecuted: number;
+    agentSeconds: number | null;
+}
+
+function sumAgentSeconds(tasks: RunOverviewTask[]): number | null {
+    let sum = 0;
+    let any = false;
+    for (const t of tasks) {
+        if (t.matureSkipped || t.agentSeconds == null) continue;
+        sum += t.agentSeconds;
+        any = true;
+    }
+    return any ? sum : null;
 }
 
 export function scopeRunTasks(
@@ -1089,6 +1106,7 @@ export function scopeRunTasks(
         taskDurationSeconds: overview.taskDurationSeconds,
         // ?? for an overview built before the field existed (test factories).
         tasksExecuted: overview.tasksExecuted ?? overview.tasks.length,
+        agentSeconds: sumAgentSeconds(overview.tasks),
     };
     if (tag == null && needle == null) return wholeRun;
 
@@ -1138,6 +1156,7 @@ export function scopeRunTasks(
         totalCostUsd: costHasAny ? costSum : null,
         taskDurationSeconds: durAllPresent ? durSum : null,
         tasksExecuted: matching.filter((t) => !t.matureSkipped).length,
+        agentSeconds: sumAgentSeconds(matching),
     };
 }
 
@@ -1155,6 +1174,7 @@ function rowFromScoped(
         tasksExecuted: scoped.tasksExecuted,
         totalCostUsd: scoped.totalCostUsd,
         taskDurationSeconds: scoped.taskDurationSeconds,
+        agentSeconds: scoped.agentSeconds,
         harness: harness ?? null,
     };
 }
diff --git a/evalboard/lib/runs.ts b/evalboard/lib/runs.ts
index 47b064709..f93f7aab0 100644
--- a/evalboard/lib/runs.ts
+++ b/evalboard/lib/runs.ts
@@ -102,6 +102,9 @@ export interface TaskResultSummary {
     status: string | null;
     weightedScore: number | null;
     durationSeconds: number | null;
+    // The agent's turns alone, without setup and grading. Optional so test
+    // factories that predate it stay valid.
+    agentSeconds?: number | null;
     totalCostUsd: number | null;
     actualCommands: number | null;
     totalTurns: number | null;
@@ -503,6 +506,7 @@ export interface RawTaskResult {
     status?: string;
     weighted_score?: number;
     duration?: number;
+    iterations?: { duration_seconds?: number | null }[] | null;
     total_cost_usd?: number;
     input_tokens?: number | null;
     output_tokens?: number | null;
@@ -891,6 +895,7 @@ export function toTaskRow(t: RawTaskResult): TaskResultSummary {
         status: t.status ?? null,
         weightedScore: t.weighted_score ?? null,
         durationSeconds: t.duration ?? null,
+        agentSeconds: agentSecondsFromRaw(t),
         totalCostUsd: t.total_cost_usd ?? null,
         actualCommands: t.actual_commands ?? null,
         totalTurns: t.total_turns ?? null,
@@ -1141,6 +1146,9 @@ export interface RunOverviewTask {
     skill: string | null;
     totalCostUsd: number | null;
     durationSeconds: number | null;
+    // The agent's turns alone: `durationSeconds` minus sandbox setup, pre_run,
+    // grading and cleanup. Optional so test factories that predate it stay valid.
+    agentSeconds?: number | null;
     weightedScore: number | null;
     actualCommands: number | null;
     totalTurns: number | null;
@@ -1257,6 +1265,13 @@ function mostCommonAgentType(rows: RawTaskResult[]): string | null {
     return best;
 }
 
+export function agentSecondsFromRaw(t: RawTaskResult): number | null {
+    const seconds = (t.iterations ?? [])
+        .map((i) => i.duration_seconds)
+        .filter((d): d is number => typeof d === "number" && d > 0);
+    return seconds.length ? seconds.reduce((a, d) => a + d, 0) : null;
+}
+
 export async function readRunOverview(
     id: string,
     source: Source = DEFAULT_SOURCE,
@@ -1275,6 +1290,7 @@ export async function readRunOverview(
                 skill: deriveSkill(t.task_path, tags),
                 totalCostUsd: t.total_cost_usd ?? null,
                 durationSeconds: t.duration ?? null,
+                agentSeconds: agentSecondsFromRaw(t),
                 weightedScore: t.weighted_score ?? null,
                 actualCommands: t.actual_commands ?? null,
                 totalTurns: t.total_turns ?? null,