| |
| """Head-to-head comparison between the Claude Code and Codex SDK sweeps. |
| |
| Both swept the same 28 cells (7 benchmarks x 4 base models) with the same |
| 10-hour budget on the same hardware, so the cells pair exactly. Claude has |
| reruns on 20 cells; for a paired comparison each cell contributes its latest |
| analysed run, which is also how the sweep's own results table is built. |
| |
| python analysis/compare.py # tables + json |
| python analysis/compare.py --figures |
| |
| Writes `analysis/out/compare.json`, the comparison tables into the report at |
| `docs/results/agent_trace_comparison_2026-10.md`, and figures under |
| `docs/results/figures/compare/`. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import sys |
| from collections import defaultdict |
| from statistics import mean |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
|
|
| from run_analysis import AGENT_ROOTS, OUT_DIR, ROOT, build |
|
|
| AGENTS = ("claude", "codex") |
|
|
|
|
| def latest_per_cell(feats) -> dict[tuple[str, str], object]: |
| """One run per (task, base model): the most recent analysed one.""" |
| best: dict[tuple[str, str], object] = {} |
| for f in feats: |
| if f.cohort not in ("primary", "recovered"): |
| continue |
| key = (f.task, f.base_model) |
| if key not in best or f.run_id > best[key].run_id: |
| best[key] = f |
| return best |
|
|
|
|
| def _avg(xs): |
| xs = [x for x in xs if x is not None] |
| return round(mean(xs), 4) if xs else None |
|
|
|
|
| def headline(cells: dict[str, dict]) -> list[dict]: |
| """The per-run metrics that actually differ between the two scaffolds.""" |
| spec = [ |
| ("accuracy", "final accuracy", 3), |
| ("wall_h", "wall clock (h)", 2), |
| ("turns", "turns", 0), |
| ("tool_calls", "tool calls", 0), |
| ("n_distinct_model_versions", "model versions evaluated", 1), |
| ("n_eval_calls", "official eval invocations", 1), |
| ("n_observed_scores", "distinct scores observed", 1), |
| ("first_eval_h", "first eval (h)", 3), |
| ("machine_busy_frac", "machine busy fraction", 3), |
| ("dead_air_h", "idle hours", 2), |
| ("tail_idle_h", "hours after best score", 2), |
| ("bg_tasks", "background jobs launched", 1), |
| ("tool_errors", "tool errors", 1), |
| ("output_tokens", "output tokens", 0), |
| ("thinking_chars", "readable reasoning chars", 0), |
| ("narration_chars", "visible narration chars", 0), |
| ("final_message_chars", "final report chars", 0), |
| ("time_awareness_calls", "timer.sh checks", 1), |
| ] |
| rows = [] |
| for field, label, nd in spec: |
| row = {"metric": label} |
| for a in AGENTS: |
| v = _avg([getattr(f, field) for f in cells[a].values()]) |
| row[a] = round(v, nd) if v is not None and nd else (int(v) if v is not None else None) if nd == 0 else v |
| rows.append(row) |
| return rows |
|
|
|
|
| def paired_accuracy(cells: dict[str, dict]) -> list[dict]: |
| keys = sorted(set(cells["claude"]) & set(cells["codex"])) |
| rows = [] |
| for task, model in keys: |
| c = cells["claude"][(task, model)].accuracy |
| x = cells["codex"][(task, model)].accuracy |
| rows.append( |
| { |
| "task": task, |
| "base_model": model.split("/")[-1], |
| "claude": round(c, 4) if c is not None else None, |
| "codex": round(x, 4) if x is not None else None, |
| "delta": round(c - x, 4) if None not in (c, x) else None, |
| } |
| ) |
| return rows |
|
|
|
|
| def per_task_accuracy(rows: list[dict]) -> list[dict]: |
| by: defaultdict[str, list[dict]] = defaultdict(list) |
| for r in rows: |
| by[r["task"]].append(r) |
| out = [] |
| for task, g in sorted(by.items()): |
| out.append( |
| { |
| "task": task, |
| "claude": _avg([r["claude"] for r in g]), |
| "codex": _avg([r["codex"] for r in g]), |
| "delta": _avg([r["delta"] for r in g]), |
| "claude_wins": sum(1 for r in g if (r["delta"] or 0) > 0), |
| "n": len(g), |
| } |
| ) |
| return out |
|
|
|
|
| def prose_compare(summaries: dict[str, dict]) -> list[dict]: |
| """Only the surfaces both SDKs expose. |
| |
| `said_` is report + narration; the plain report-only rows understate |
| Codex (340-character sign-offs) and the `anywhere_` rows flatter it |
| (only Codex exposes readable extended thinking), so neither is usable |
| across agents. |
| """ |
| probes = summaries["claude"]["prose_probes"] |
| keys = [k for k in probes if k.startswith("said_")] + [ |
| k for k in probes if not k.startswith(("said_", "anywhere_")) and probes[k]["surface"] == "narration" |
| ] |
| rows = [] |
| for k in keys: |
| row = {"habit": k.replace("said_", "")} |
| for a in AGENTS: |
| p = summaries[a]["prose_probes"].get(k) |
| row[a] = f"{p['runs_with_evidence']}/{p['of']} ({p['pct']}%)" if p else "" |
| row["surface"] = (summaries["claude"]["prose_probes"].get(k) or {}).get("surface", "") |
| rows.append(row) |
| return rows |
|
|
|
|
| def md_table(rows: list[dict], cols: list[tuple[str, str]]) -> str: |
| out = ["| " + " | ".join(h for _, h in cols) + " |", "|" + "---|" * len(cols)] |
| for r in rows: |
| cells = [] |
| for k, _ in cols: |
| v = r.get(k) |
| cells.append("" if v is None else (f"{v:g}" if isinstance(v, float) else str(v))) |
| out.append("| " + " | ".join(cells) + " |") |
| return "\n".join(out) |
|
|
|
|
| |
| def make_figures(cells, paired, per_task): |
| import numpy as np |
| from trace_analysis.figures import C, GRID, INK2, MUTED, SURFACE, _save |
|
|
| import matplotlib.pyplot as plt |
|
|
| |
| fig, ax = plt.subplots(figsize=(9, 4.2)) |
| tasks = [r["task"] for r in per_task] |
| y = np.arange(len(tasks)) |
| h = 0.34 |
| ax.barh(y - h / 2, [r["claude"] for r in per_task], height=h, color=C[0], label="Claude Code (opus-5)", edgecolor=SURFACE, linewidth=1.5) |
| ax.barh(y + h / 2, [r["codex"] for r in per_task], height=h, color=C[1], label="Codex SDK (gpt-5.6-sol)", edgecolor=SURFACE, linewidth=1.5) |
| for i, r in enumerate(per_task): |
| ax.text(max(r["claude"], r["codex"]) + 0.012, i, f"Δ{r['delta']:+.3f}", va="center", fontsize=8.5, color=INK2) |
| ax.set_yticks(y, tasks) |
| ax.invert_yaxis() |
| ax.set_xlim(0, 1.08) |
| ax.set_xlabel("mean final accuracy over the 4 base models") |
| ax.set_title("Same 28 cells, two scaffolds") |
| ax.grid(axis="x", lw=0.6) |
| ax.set_axisbelow(True) |
| ax.legend(frameon=False, ncol=2, loc="upper center", bbox_to_anchor=(0.5, -0.16), fontsize=9) |
| _save(fig, "accuracy_by_task.png", "compare") |
|
|
| |
| fig, ax = plt.subplots(figsize=(7.5, 4.2)) |
| grid = np.linspace(0, 1, 101) |
| for a, col in zip(AGENTS, (C[0], C[1])): |
| curves = [] |
| for f in cells[a].values(): |
| if not f.observed_scores or (f.observed_gain or 0) <= 0.01: |
| continue |
| xs = np.array([t / 3600 / max(f.wall_h, 1e-6) for t, _ in f.observed_scores]) |
| ys = np.maximum.accumulate([v for _, v in f.observed_scores]) |
| lo, hi = ys[0], ys.max() |
| if hi <= lo: |
| continue |
| curves.append(np.interp(grid, xs, (ys - lo) / (hi - lo), left=0.0, right=1.0)) |
| med = np.median(np.vstack(curves), axis=0) |
| half = grid[np.argmax(med >= 0.5)] * 100 |
| ax.plot(grid * 100, med * 100, lw=2.5, color=col, label=f"{a} (n={len(curves)}, half by {half:.0f}%)") |
| ax.plot([0, 100], [0, 100], lw=1.5, ls=(0, (4, 3)), color=MUTED, label="if progress were uniform") |
| ax.set_xlabel("% of the run's wall clock elapsed") |
| ax.set_ylabel("% of the run's total score gain captured") |
| ax.set_title("Both front-load their gains") |
| ax.grid(lw=0.6) |
| ax.set_axisbelow(True) |
| ax.legend(frameon=False, loc="lower right", fontsize=9) |
| _save(fig, "progress_curve.png", "compare") |
|
|
| |
| fig, ax = plt.subplots(figsize=(7, 4.4)) |
| for a, col in zip(AGENTS, (C[0], C[1])): |
| xs = [f.wall_h for f in cells[a].values()] |
| ys = [f.n_distinct_model_versions for f in cells[a].values()] |
| ax.scatter(xs, ys, s=58, color=col, edgecolor=SURFACE, linewidth=1.5, label=a, zorder=3) |
| ax.set_xlabel("wall clock used (h, of a 10 h budget)") |
| ax.set_ylabel("distinct model versions evaluated") |
| ax.set_title("Codex iterates faster and stops earlier") |
| ax.grid(lw=0.6) |
| ax.set_axisbelow(True) |
| ax.legend(frameon=False, fontsize=9, loc="upper left") |
| _save(fig, "loop_shape.png", "compare") |
|
|
| |
| fig, ax = plt.subplots(figsize=(7, 3.6)) |
| labels = ["readable reasoning", "visible narration", "final report"] |
| vals = { |
| a: [ |
| _avg([f.thinking_chars for f in cells[a].values()]), |
| _avg([f.narration_chars for f in cells[a].values()]), |
| _avg([f.final_message_chars for f in cells[a].values()]), |
| ] |
| for a in AGENTS |
| } |
| y = np.arange(len(labels)) |
| h = 0.34 |
| for i, (a, col) in enumerate(zip(AGENTS, (C[0], C[1]))): |
| v = [x or 0 for x in vals[a]] |
| ax.barh(y + (i - 0.5) * h, v, height=h, color=col, label=a, edgecolor=SURFACE, linewidth=1.5) |
| for j, x in enumerate(v): |
| ax.text(x + 600, y[j] + (i - 0.5) * h, f"{x:,.0f}", va="center", fontsize=8, color=INK2) |
| ax.set_yticks(y, labels) |
| ax.invert_yaxis() |
| ax.set_xlabel("characters per run") |
| ax.set_title("How much of its own thinking each trace preserves") |
| ax.grid(axis="x", lw=0.6) |
| ax.set_axisbelow(True) |
| ax.legend(frameon=False, ncol=2, fontsize=9, loc="lower right") |
| _save(fig, "reasoning_visibility.png", "compare") |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--figures", action="store_true") |
| args = ap.parse_args() |
|
|
| cells, summaries = {}, {} |
| for a in AGENTS: |
| _, feats = build(AGENT_ROOTS[a]) |
| cells[a] = latest_per_cell(feats) |
| summaries[a] = json.load(open(os.path.join(OUT_DIR, a, "summary.json"))) |
| print(f"{a}: {len(cells[a])} paired cells") |
|
|
| paired = paired_accuracy(cells) |
| per_task = per_task_accuracy(paired) |
| head = headline(cells) |
|
|
| result = { |
| "paired_cells": len(paired), |
| "headline": head, |
| "per_task_accuracy": per_task, |
| "paired_accuracy": paired, |
| "overall": { |
| a: _avg([f.accuracy for f in cells[a].values()]) for a in AGENTS |
| }, |
| "cells_claude_wins": sum(1 for r in paired if (r["delta"] or 0) > 0), |
| "prose": prose_compare(summaries), |
| "risks": {a: summaries[a]["risk_run_counts"] for a in AGENTS}, |
| "errors": {a: summaries[a]["error_run_counts"] for a in AGENTS}, |
| "verification": {a: summaries[a]["final_verification"] for a in AGENTS}, |
| "dev_drop": {a: summaries[a]["dev_to_harness_drop"] for a in AGENTS}, |
| "techniques": {a: summaries[a]["technique_run_counts"] for a in AGENTS}, |
| "actions": {a: summaries[a]["action_totals"] for a in AGENTS}, |
| "tools": {a: summaries[a]["tool_totals"] for a in AGENTS}, |
| } |
| with open(os.path.join(OUT_DIR, "compare.json"), "w") as fh: |
| json.dump(result, fh, indent=1) |
| print(f"wrote {os.path.join(OUT_DIR, 'compare.json')}") |
|
|
| tables = [ |
| "## 每 run 行为画像", |
| "", |
| md_table(head, [("metric", "指标(每 run 均值)"), ("claude", "Claude Code"), ("codex", "Codex SDK")]), |
| "", |
| "## 各 benchmark 准确率(同样 4 个 base model 取均值)", |
| "", |
| md_table( |
| per_task, |
| [("task", "benchmark"), ("claude", "Claude"), ("codex", "Codex"), ("delta", "Δ(C−X)"), ("claude_wins", "Claude 胜出格数"), ("n", "格数")], |
| ), |
| "", |
| "## 逐格配对", |
| "", |
| md_table(paired, [("task", "benchmark"), ("base_model", "base model"), ("claude", "Claude"), ("codex", "Codex"), ("delta", "Δ")]), |
| "", |
| "## 文本习惯", |
| "", |
| md_table(prose_compare(summaries), [("habit", "习惯"), ("claude", "Claude"), ("codex", "Codex"), ("surface", "出现在")]), |
| "", |
| ] |
| tpath = os.path.join(OUT_DIR, "compare_tables.md") |
| with open(tpath, "w") as fh: |
| fh.write("\n".join(tables)) |
| print(f"wrote {tpath}") |
|
|
| if args.figures: |
| make_figures(cells, paired, per_task) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
