@prismatic-io/lux 0.0.2-preview.5 → 0.0.2-preview.8

package/src/drivers/codex/index.ts

@@ -24,11 +24,13 @@ import { copyRegularFileNoFollow } from "../shared/secure-copy.js";
 import { subprocessDriver } from "../subprocess/index.js";
 import {
   type AppTurnFacets,
+  appAgentLifecycleProgress,
   appItemProgress,
   appItemToolName,
   appTurnLabel,
   appUsage,
   asRecord,
+  CodexSubagentTracker,
   messageOf,
   type RpcId,
   type RpcRecord,
@@ -316,7 +318,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
     { resolve: (result: RpcRecord) => void; reject: (error: Error) => void }
   >();
   private readonly interrupts = new Map<string, { id: RpcId; method: string; params: RpcRecord }>();
-  private readonly subagentParents = new Map<string, string>();
+  private readonly subagents = new CodexSubagentTracker();
   private readonly turnFacets = new Map<string, AppTurnFacets>();
   private interruptCount = 0;
   private idleTimer: NodeJS.Timeout | null = null;
@@ -702,22 +704,22 @@ class CodexAppServerDriverImpl implements AgentDriver {
     const toolName = item ? appItemToolName(item) : null;
     if (toolName && !facets.tools.includes(toolName)) facets.tools.push(toolName);
     if (turnId) this.turnFacets.set(turnId, facets);
-    this.recordSubagentParents(item);
-    const parentToolUseId =
-      typeof params.threadId === "string" ? this.subagentParents.get(params.threadId) : undefined;
+    const threadId = typeof params.threadId === "string" ? params.threadId : undefined;
+    this.subagents.record(item, threadId, this.threadId);
+    const agent = this.subagents.attribution(threadId, this.threadId);
     const event = item
-      ? appItemProgress(item, method === "item/started" ? "started" : "completed", parentToolUseId)
+      ? appItemProgress(item, method === "item/started" ? "started" : "completed", agent)
       : null;
     if (event?.tag === "progress") await this.emitter.emit("progress", event.progress);
-  }
-
-  private recordSubagentParents(item: RpcRecord | null): void {
-    if (item?.type !== "collabAgentToolCall" || typeof item.id !== "string") return;
-    const receiverThreadIds = Array.isArray(item.receiverThreadIds)
-      ? item.receiverThreadIds.filter((value): value is string => typeof value === "string")
-      : [];
-    for (const receiverThreadId of receiverThreadIds) {
-      this.subagentParents.set(receiverThreadId, item.id);
+    if (item) {
+      for (const lifecycle of appAgentLifecycleProgress(
+        item,
+        method === "item/started" ? "started" : "completed",
+        agent,
+        event?.tag === "progress" ? event.progress.ts : Date.now(),
+      )) {
+        await this.emitter.emit("progress", lifecycle);
+      }
     }
   }
 

package/src/index.ts

@@ -153,6 +153,19 @@ export {
   ActionTimingSchema,
   actionTiming,
 } from "./core/action-events.js";
+export {
+  type AgentActivity,
+  AgentActivitySchema,
+  summarizeAgentActivity,
+} from "./core/agent-activity.js";
+export {
+  AGENT_COMPLETED_KIND,
+  AGENT_SPAWN_KIND,
+  type AgentCompletedPayload,
+  AgentCompletedPayloadSchema,
+  type AgentSpawnPayload,
+  AgentSpawnPayloadSchema,
+} from "./core/agent-events.js";
 export {
   defineGraderAnnotations,
   type GraderAnnotation,
@@ -254,6 +267,8 @@ export {
 } from "./core/driver-metrics.js";
 export { type EventHandler, TypedEmitter } from "./core/emitter.js";
 export {
+  type AgentAttribution,
+  AgentAttributionSchema,
   type Answer,
   AnswerSchema,
   ApproveAnswerSchema,

package/src/orchestrator/compare.ts

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import {
   type ActionTiming,
+  type AgentActivity,
   type DriverMetrics,
   emptyRunUsage,
   type GradingReport,
@@ -52,6 +53,7 @@ export type RunComparison = {
     durationMsB: number | null;
     actionTiming: { a: ActionTiming; b: ActionTiming };
     driverMetrics: { a: DriverMetrics; b: DriverMetrics };
+    agentActivity: { a: AgentActivity[]; b: AgentActivity[] };
     interruptCounts: {
       a: { ask: number; approve: number; custom: number };
       b: { ask: number; approve: number; custom: number };
@@ -272,6 +274,10 @@ export const compareRuns = async (input: ComparisonInput): Promise<RunComparison
             a: a.runJson?.driverMetrics ?? {},
             b: b.runJson?.driverMetrics ?? {},
           },
+          agentActivity: {
+            a: a.runJson?.agentActivity ?? [],
+            b: b.runJson?.agentActivity ?? [],
+          },
           interruptCounts: {
             a: a.runJson?.interruptCounts ?? { ask: 0, approve: 0, custom: 0 },
             b: b.runJson?.interruptCounts ?? { ask: 0, approve: 0, custom: 0 },

package/src/orchestrator/list-runs.ts

@@ -3,6 +3,8 @@ import { constants, lstat, open, readdir } from "node:fs/promises";
 import { basename, join, relative, sep } from "node:path";
 import {
   ActionProgressPayloadSchema,
+  AgentCompletedPayloadSchema,
+  AgentSpawnPayloadSchema,
   type Artifact,
   ArtifactSchema,
   type GradingReport,
@@ -38,6 +40,7 @@ export type ListedRun = {
   timeToFirstMutationMs: number | null;
   timeToFirstDurableMutationMs: number | null;
   driverMetrics: NonNullable<RunMetadata["driverMetrics"]>;
+  subagentCount: number;
   casePassed: boolean | null;
   caseScore: number | null;
   assertionPassed: number;
@@ -74,6 +77,8 @@ const summarizeRun = async (
     timeToFirstMutationMs: meta?.actionTiming?.timeToFirstMutationMs ?? null,
     timeToFirstDurableMutationMs: meta?.actionTiming?.timeToFirstDurableMutationMs ?? null,
     driverMetrics: meta?.driverMetrics ?? {},
+    subagentCount:
+      meta?.agentActivity?.filter((activity) => activity.agent.role === "subagent").length ?? 0,
     casePassed: grading?.casePassed ?? null,
     caseScore: grading?.caseScore ?? null,
     assertionPassed: passing,
@@ -138,7 +143,7 @@ export const listRuns = async (runsRoot: string): Promise<ListedRun[]> => {
 export const formatRunsTable = (runs: ListedRun[]): string => {
   if (runs.length === 0) return "(no runs found)";
   const rows: string[][] = [
-    ["status", "case", "driver", "ts", "exit", "score", "duration"],
+    ["status", "case", "driver", "agents", "ts", "exit", "score", "duration"],
     ...runs.map((r) => {
       let status = "ungraded";
       if (r.casePassed === true) status = "PASS";
@@ -148,7 +153,8 @@ export const formatRunsTable = (runs: ListedRun[]): string => {
           ? `${(r.caseScore * 100).toFixed(0)}% (${r.assertionPassed}/${r.assertionTotal})`
           : "—";
       const duration = r.durationMs !== null ? `${(r.durationMs / 1000).toFixed(1)}s` : "—";
-      return [status, r.caseSlug, r.driverName, r.ts, r.exitReason ?? "?", score, duration];
+      const agents = r.subagentCount > 0 ? `1+${r.subagentCount}` : "1";
+      return [status, r.caseSlug, r.driverName, agents, r.ts, r.exitReason ?? "?", score, duration];
     }),
   ];
   const header = rows[0] ?? [];
@@ -312,6 +318,20 @@ const appendMetadataDetail = (lines: string[], detail: RunDetail): void => {
         `first action: any=${value(actions.timeToFirstActionMs)} mutation=${value(actions.timeToFirstMutationMs)} durable-mutation=${value(actions.timeToFirstDurableMutationMs)}`,
       );
     }
+    const activities = detail.metadata.agentActivity ?? [];
+    const subagents = activities.filter((activity) => activity.agent.role === "subagent");
+    if (subagents.length > 0) {
+      lines.push(`subagents: ${subagents.length}`);
+      for (const activity of subagents) {
+        const label = activity.agent.name
+          ? `${activity.agent.name} (${activity.agent.id})`
+          : activity.agent.id;
+        const agentActions = activity.actions;
+        lines.push(
+          `  ${label}: ${activity.status}, ${(activity.durationMs / 1000).toFixed(1)}s, events=${activity.eventCount}, tokens=${totalTokens(activity.usage)}, tools=${activity.toolCalls.total} (${activity.toolCalls.succeeded} ok/${activity.toolCalls.failed} failed/${activity.toolCalls.unresolved} unresolved), actions=${agentActions.total}, mutations=${agentActions.mutations}`,
+        );
+      }
+    }
   }
 };
 
@@ -382,21 +402,37 @@ const formatEventLine = (event: RunEvent): string => {
         }`;
       }
       return `responded(custom): ${JSON.stringify(event.payload).slice(0, 80)}`;
-    case "progress":
+    case "progress": {
+      const agent = event.agent?.role === "subagent" ? ` [subagent ${event.agent.id}]` : "";
+      if (event.kind === "agent-spawn") {
+        const payload = AgentSpawnPayloadSchema.safeParse(event.payload).data;
+        return payload
+          ? `agent-spawn: ${payload.agent.name ?? payload.agent.id} (${payload.agent.id})`
+          : "agent-spawn: malformed";
+      }
+      if (event.kind === "agent-completed") {
+        const payload = AgentCompletedPayloadSchema.safeParse(event.payload).data;
+        return payload
+          ? `agent-completed: ${payload.agentId} (${payload.status})`
+          : "agent-completed: malformed";
+      }
       if (event.kind === "action") {
         const payload = ActionProgressPayloadSchema.safeParse(event.payload).data;
-        return payload ? `action: ${payload.name} (${payload.category})` : "action: malformed";
+        return payload
+          ? `action${agent}: ${payload.name} (${payload.category})`
+          : "action: malformed";
       }
       if (event.kind === "tool-call") {
         const payload = ToolCallPayloadSchema.safeParse(event.payload).data;
-        return payload ? `tool-call: ${payload.name}` : "tool-call: malformed";
+        return payload ? `tool-call${agent}: ${payload.name}` : "tool-call: malformed";
       }
       if (event.kind === "tool-result") {
         const payload = ToolResultPayloadSchema.safeParse(event.payload).data;
         if (!payload) return "tool-result: malformed";
-        return `tool-result: ${payload.name} (${payload.isError ? "failed" : "succeeded"})`;
+        return `tool-result${agent}: ${payload.name} (${payload.isError ? "failed" : "succeeded"})`;
       }
       return `progress(${event.kind})`;
+    }
     case "lifecycle":
       return `lifecycle: ${event.stage}`;
     case "ready":

package/src/orchestrator/run-execution.ts

@@ -30,6 +30,7 @@ import {
   type RunMetadata,
   type RunProvenance,
   type RunUsage,
+  summarizeAgentActivity,
   summarizeToolOutcomes,
   sumUsage,
   type TokenUsage,
@@ -516,6 +517,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
   private fallbackFailureMetadata(): RunMetadata {
     const failedAt = new Date();
     const answererAccounting = readAnswererModelAccounting(this.args.answerer);
+    const ready = this.ready ?? { agentId: "start-failed" };
     return {
       schemaVersion: 1,
       luxVersion: this.args.luxVersion,
@@ -524,7 +526,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       agentEndedAt: failedAt.toISOString(),
       endedAt: failedAt.toISOString(),
       exitReason: "error",
-      driver: { name: this.args.driverName, ...(this.ready ?? { agentId: "start-failed" }) },
+      driver: { name: this.args.driverName, ...ready },
       answerer: answererMetadata(this.args.answererName, this.args.answererConfig),
       usage: {
         agent: emptyUsage(),
@@ -540,6 +542,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       interruptCounts: this.interruptCounts,
       toolCallCount: this.toolCallCount,
       toolOutcomes: summarizeToolOutcomes(this.runDir.recorded),
+      agentActivity: summarizeAgentActivity(this.runDir.recorded, ready),
       artifacts: { count: this.collection.artifacts.length },
       provenance: this.runProvenance(),
     };
@@ -582,6 +585,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       answerer: readAnswererUsage(this.args.answerer),
       grading: emptyUsage(),
     };
+    const ready = this.ready ?? { agentId: "not-started" };
     const metadata: RunMetadata = {
       schemaVersion: 1,
       luxVersion: this.args.luxVersion,
@@ -590,7 +594,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       agentEndedAt: agentEndedAt.toISOString(),
       endedAt: agentEndedAt.toISOString(),
       exitReason,
-      driver: { name: this.args.driverName, ...(this.ready ?? { agentId: "not-started" }) },
+      driver: { name: this.args.driverName, ...ready },
       answerer: answererMetadata(this.args.answererName, this.args.answererConfig),
       usage,
       modelAccounting: {
@@ -604,6 +608,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       interruptCounts: this.interruptCounts,
       toolCallCount: this.toolCallCount,
       toolOutcomes: summarizeToolOutcomes(this.runDir.recorded),
+      agentActivity: summarizeAgentActivity(this.runDir.recorded, ready),
       artifacts: await artifactMeasurements(this.collection.artifacts, this.runDir.path),
       ...(operationalFailure ? { operationalFailure } : {}),
       provenance: this.runProvenance(),

package/src/orchestrator/suite-summary.ts

@@ -158,6 +158,71 @@ const collectMetadata = (samples: MetricSamples, metadata: RunMetadata): void =>
   add(samples, "timeToFirstActionMs", metadata.actionTiming?.timeToFirstActionMs);
   add(samples, "timeToFirstMutationMs", metadata.actionTiming?.timeToFirstMutationMs);
   add(samples, "timeToFirstDurableMutationMs", metadata.actionTiming?.timeToFirstDurableMutationMs);
+  const subagents = (metadata.agentActivity ?? []).filter(
+    (activity) => activity.agent.role === "subagent",
+  );
+  add(samples, "subagents.count", subagents.length, {
+    unit: "count",
+    label: "Subagents spawned",
+    better: "neutral",
+  });
+  add(
+    samples,
+    "subagents.events",
+    subagents.reduce((sum, activity) => sum + activity.eventCount, 0),
+    { unit: "count", label: "Subagent events", better: "neutral" },
+  );
+  add(
+    samples,
+    "subagents.toolCalls",
+    subagents.reduce((sum, activity) => sum + activity.toolCalls.total, 0),
+    { unit: "count", label: "Subagent tool calls", better: "neutral" },
+  );
+  add(
+    samples,
+    "subagents.toolCalls.failed",
+    subagents.reduce((sum, activity) => sum + activity.toolCalls.failed, 0),
+    { unit: "count", label: "Failed subagent tool calls", better: "lower" },
+  );
+  add(
+    samples,
+    "subagents.tokens",
+    subagents.reduce((sum, activity) => sum + activity.usage.total, 0),
+    { unit: "tokens", label: "Subagent tokens", better: "lower" },
+  );
+  add(
+    samples,
+    "subagents.actions",
+    subagents.reduce((sum, activity) => sum + activity.actions.total, 0),
+    { unit: "count", label: "Subagent actions", better: "neutral" },
+  );
+  add(
+    samples,
+    "subagents.mutations",
+    subagents.reduce((sum, activity) => sum + activity.actions.mutations, 0),
+    { unit: "count", label: "Subagent mutations", better: "neutral" },
+  );
+  add(
+    samples,
+    "subagents.totalDurationMs",
+    subagents.reduce((sum, activity) => sum + activity.durationMs, 0),
+    { unit: "milliseconds", label: "Total subagent time", better: "neutral" },
+  );
+  add(
+    samples,
+    "subagents.maxDurationMs",
+    subagents.length > 0 ? Math.max(...subagents.map((activity) => activity.durationMs)) : 0,
+    { unit: "milliseconds", label: "Longest subagent", better: "lower" },
+  );
+  const firstSubagentAction = subagents
+    .map((activity) => activity.actions.timeToFirstActionMs)
+    .filter((value): value is number => value !== undefined)
+    .sort((a, b) => a - b)[0];
+  add(samples, "subagents.timeToFirstActionMs", firstSubagentAction, {
+    unit: "milliseconds",
+    label: "First subagent action",
+    better: "lower",
+  });
   for (const [name, metric] of Object.entries(metadata.driverMetrics ?? {})) {
     const { value, ...descriptor } = metric;
     add(samples, `driver.${name}`, value, descriptor);

package/src/previewer/server.ts

@@ -38,6 +38,7 @@ type PreviewRun = {
   timeToFirstMutationMs: number | null;
   timeToFirstDurableMutationMs: number | null;
   driverMetrics: DriverMetrics;
+  subagentCount: number;
   score: number | null;
   assertions: { passed: number; total: number };
   path: string;
@@ -171,6 +172,7 @@ const buildSnapshot = async (
         timeToFirstMutationMs: run.timeToFirstMutationMs,
         timeToFirstDurableMutationMs: run.timeToFirstDurableMutationMs,
         driverMetrics: run.driverMetrics,
+        subagentCount: run.subagentCount,
         score: run.caseScore,
         assertions: { passed: run.assertionPassed, total: run.assertionTotal },
         path: displayPath(absoluteRunsRoot, run.runDir),

package/viewer/app.css

@@ -1060,6 +1060,59 @@ h1 {
   white-space: pre-wrap;
 }
 
+.agent-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+  gap: 12px;
+}
+
+.agent-card {
+  padding: 14px;
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  background: var(--panel-raised);
+}
+
+.agent-card header,
+.agent-card header div {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.agent-card header div {
+  min-width: 0;
+  flex-direction: column;
+}
+
+.agent-card header small,
+.agent-parent {
+  color: var(--muted);
+  overflow-wrap: anywhere;
+}
+
+.agent-card dl {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 8px;
+  margin: 14px 0;
+}
+
+.agent-card dl div {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.agent-card dt {
+  color: var(--muted);
+}
+
+.agent-card dd {
+  margin: 0;
+  font-weight: 650;
+}
+
 .trace-item {
   display: grid;
   grid-template-columns: 58px minmax(0, 1fr);

package/viewer/app.js

@@ -98,7 +98,12 @@ const rowMetric = (item) => {
 
 const rowMeta = (item) => {
   if (item.kind === "run") {
-    return [item.driver, item.agentId, relativeTime(item.startedAt)].filter(Boolean);
+    return [
+      item.driver,
+      item.agentId,
+      item.subagentCount > 0 ? `1 + ${item.subagentCount} agents` : "1 agent",
+      relativeTime(item.startedAt),
+    ].filter(Boolean);
   }
   if (item.kind === "suite") {
     return [item.profileId ?? "default profile", fullDate(item.startedAt), `j=${item.concurrency}`];

package/viewer/detail.js

@@ -49,14 +49,28 @@ const eventContent = (event) => {
   }
   if (event.type === "progress") {
     const payload = event.payload ?? {};
+    const actor = event.agent?.role === "subagent" ? ` · Subagent ${event.agent.id}` : "";
+    if (event.kind === "agent-spawn") {
+      const spawned = payload.agent ?? {};
+      return [
+        `Subagent spawned · ${spawned.name ?? spawned.id ?? "unknown"}`,
+        [spawned.id, spawned.model, payload.prompt].filter(Boolean).join(" · "),
+      ];
+    }
+    if (event.kind === "agent-completed") {
+      return [
+        `Subagent ${payload.status ?? "completed"} · ${payload.agentId ?? "unknown"}`,
+        "Agent lifecycle",
+      ];
+    }
     if (event.kind === "action") {
       return [
-        `Action · ${payload.name ?? "unknown"}`,
+        `Action${actor} · ${payload.name ?? "unknown"}`,
         payload.category ? `Category: ${payload.category}` : json(payload),
       ];
     }
     const name = event.kind === "tool-call" ? payload.name : event.kind;
-    return [`Progress · ${name ?? event.kind}`, json(payload)];
+    return [`Progress${actor} · ${name ?? event.kind}`, json(payload)];
   }
   if (event.type === "error") return [`Error · ${event.exitReason}`, event.reason];
   return ["Completed", event.summary ? json(event.summary) : "Driver finished"];
@@ -121,6 +135,36 @@ const driverMetricStats = (metrics) =>
     )
     .join("");
 
+const agentActivityCards = (activities) =>
+  (activities ?? [])
+    .filter((activity) => activity.agent?.role === "subagent")
+    .map((activity, index) => {
+      const agent = activity.agent;
+      const actions = activity.actions ?? {};
+      const tools = activity.toolCalls ?? {};
+      const label = agent.name ?? `Subagent ${index + 1}`;
+      return `<article class="agent-card">
+        <header><div><strong>${escapeHtml(label)}</strong><small>${escapeHtml(agent.id)}</small></div><span>${escapeHtml(
+          `${activity.status ?? "unknown"} · ${duration(activity.durationMs)}`,
+        )}</span></header>
+        <dl>
+          <div><dt>Events</dt><dd>${compactNumber(activity.eventCount)}</dd></div>
+          <div><dt>Tokens</dt><dd>${compactNumber(activity.usage?.total)}</dd></div>
+          <div><dt>Tool calls</dt><dd>${compactNumber(tools.total)}</dd></div>
+          <div><dt>Succeeded</dt><dd>${compactNumber(tools.succeeded)}</dd></div>
+          <div><dt>Failed</dt><dd>${compactNumber(tools.failed)}</dd></div>
+          <div><dt>Actions</dt><dd>${compactNumber(actions.total)}</dd></div>
+          <div><dt>Mutations</dt><dd>${compactNumber(actions.mutations)}</dd></div>
+          <div><dt>First action</dt><dd>${escapeHtml(duration(actions.timeToFirstActionMs))}</dd></div>
+          <div><dt>First mutation</dt><dd>${escapeHtml(duration(actions.timeToFirstMutationMs))}</dd></div>
+        </dl>
+        <small class="agent-parent">Spawn ${escapeHtml(agent.spawnToolUseId ?? "unknown")} · parent ${escapeHtml(
+          agent.parentId ?? "unknown",
+        )}</small>
+      </article>`;
+    })
+    .join("");
+
 export const renderRunDetail = (item, detail) => {
   const metadata = detail.metadata;
   const grading = detail.grading;
@@ -135,6 +179,7 @@ export const renderRunDetail = (item, detail) => {
   const actionTiming = metadata?.actionTiming;
   const prompt = detail.case?.prompt;
   const driverMetrics = driverMetricStats(metadata?.driverMetrics);
+  const subagents = agentActivityCards(metadata?.agentActivity);
   return `
     <header class="detail-header">
       <div class="detail-kicker">
@@ -182,6 +227,13 @@ export const renderRunDetail = (item, detail) => {
             )}</span></h3><dl class="detail-stats driver-metrics">${driverMetrics}</dl></section>`
           : ""
       }
+      ${
+        subagents
+          ? `<section class="detail-section"><h3>Subagent activity <span>${
+              metadata.agentActivity.filter((activity) => activity.agent.role === "subagent").length
+            } spawned</span></h3><div class="agent-grid">${subagents}</div></section>`
+          : ""
+      }
       <div class="evidence-visual-grid">
         ${compositionFigure(
           "Judgment outcome",
@@ -799,6 +851,16 @@ const driverMetricComparisons = (runDelta) => {
     .join("");
 };
 
+const subagentTotals = (activities) => {
+  const subagents = (activities ?? []).filter((activity) => activity.agent?.role === "subagent");
+  return {
+    count: subagents.length,
+    toolCalls: subagents.reduce((sum, activity) => sum + (activity.toolCalls?.total ?? 0), 0),
+    tokens: subagents.reduce((sum, activity) => sum + (activity.usage?.total ?? 0), 0),
+    durationMs: subagents.reduce((sum, activity) => sum + (activity.durationMs ?? 0), 0),
+  };
+};
+
 export const renderRunComparison = (payload, labels) => {
   const comparison = payload.comparison;
   const runDelta = comparison.runDelta;
@@ -819,6 +881,8 @@ export const renderRunComparison = (payload, labels) => {
       ? comparison.grading.caseScoreB - comparison.grading.caseScoreA
       : null;
   const driverMetrics = driverMetricComparisons(runDelta);
+  const subagentsA = subagentTotals(runDelta?.agentActivity?.a);
+  const subagentsB = subagentTotals(runDelta?.agentActivity?.b);
   return `
     <header class="detail-header comparison-header">
       <div class="detail-kicker">${badge(
@@ -904,6 +968,48 @@ export const renderRunComparison = (payload, labels) => {
             deltaText: `${tokenDelta > 0 ? "+" : ""}${compactNumber(tokenDelta)}`,
             deltaTone: toneForDelta(tokenDelta, true),
           })}
+          ${comparisonBars({
+            title: "Subagents spawned",
+            before: subagentsA.count,
+            after: subagentsB.count,
+            beforeText: compactNumber(subagentsA.count),
+            afterText: compactNumber(subagentsB.count),
+            deltaText: `${subagentsB.count - subagentsA.count > 0 ? "+" : ""}${compactNumber(
+              subagentsB.count - subagentsA.count,
+            )}`,
+            deltaTone: "metric-neutral",
+          })}
+          ${comparisonBars({
+            title: "Subagent tool calls",
+            before: subagentsA.toolCalls,
+            after: subagentsB.toolCalls,
+            beforeText: compactNumber(subagentsA.toolCalls),
+            afterText: compactNumber(subagentsB.toolCalls),
+            deltaText: `${subagentsB.toolCalls - subagentsA.toolCalls > 0 ? "+" : ""}${compactNumber(
+              subagentsB.toolCalls - subagentsA.toolCalls,
+            )}`,
+            deltaTone: "metric-neutral",
+          })}
+          ${comparisonBars({
+            title: "Total subagent time",
+            before: subagentsA.durationMs,
+            after: subagentsB.durationMs,
+            beforeText: duration(subagentsA.durationMs),
+            afterText: duration(subagentsB.durationMs),
+            deltaText: signedDuration(subagentsB.durationMs - subagentsA.durationMs),
+            deltaTone: "metric-neutral",
+          })}
+          ${comparisonBars({
+            title: "Subagent tokens",
+            before: subagentsA.tokens,
+            after: subagentsB.tokens,
+            beforeText: compactNumber(subagentsA.tokens),
+            afterText: compactNumber(subagentsB.tokens),
+            deltaText: `${subagentsB.tokens - subagentsA.tokens > 0 ? "+" : ""}${compactNumber(
+              subagentsB.tokens - subagentsA.tokens,
+            )}`,
+            deltaTone: toneForDelta(subagentsB.tokens - subagentsA.tokens, true),
+          })}
         </div>
         <div class="comparison-distributions">
           ${compositionFigure(