Finalize efficiency review updates

README.md

@@ -19,77 +19,45 @@ Compare coding-agent models and harnesses across benchmark performance, cost, la
 
 ## Leaderboard views
 
-### Cost vs Performance
+### Efficiency
 
-The Cost vs Performance scatter plot compares benchmark score with mean cost per task. Use its controls to select the benchmark, grouping, color palette, image background, and optional point labels.
+The **Efficiency** tab compares benchmark score with resource use for one selected benchmark at a time. Keeping the view benchmark-specific avoids misleading comparisons when model and harness combinations have incomplete benchmark coverage.
+The generalized performance-vs-resource chart covers tokens, cost, and agent time in one benchmark-specific view.
 
-Point labels are disabled by default to keep the chart uncluttered. When enabled, concise run labels are shown without replacing the full hover details.
+The scatter plot supports three resource metrics on the x-axis:
 
-### Token Efficiency
+- **Total tokens**: mean total token usage per task.
+- **Cost per task**: the repository's reported `mean_cost_usd_per_task` value, in USD.
+- **Agent time per task**: the repository's reported `mean_agent_time_seconds_per_task` value, in seconds.
 
-The **Efficiency** tab shows that score alone is insufficient: agents with similar benchmark performance can use substantially different token budgets.
+Only positive, available values for the selected resource are plotted. Missing, zero, and negative values are treated as unavailable rather than as perfect efficiency. The UI reports how many runs for the selected benchmark were excluded for the chosen resource metric.
 
-The tab provides:
-
-- benchmark filtering, including **All benchmarks**
-- total, input, output, or solved-task-normalized token metrics
-- linear or logarithmic token axes
-- coloring by model, harness, or benchmark
-- optional point labels
-- an optional token-efficiency Pareto frontier
-- a sortable token-efficiency ranking table
-
-#### Metric definitions
-
-Scores are stored internally as fractions from 0 to 1 and displayed as percentages.
-
-- **Total Tokens Per Task**: mean total token usage for one task.
-- **Input Tokens Per Task**: mean input token usage for one task.
-- **Output Tokens Per Task**: mean output token usage for one task.
-- **Cache Tokens Per Task**: mean cached token usage for one task.
-- **Tokens Per Solved Task**: `Total Tokens Per Task / Score`, where Score is the fractional value from 0 to 1.
-
-For example, a run using 10,000 total tokens per task with a score of 0.5 has 20,000 Tokens Per Solved Task.
-
-#### Missing and invalid token data
-
-A token measurement is available only when its value is present and greater than zero. Missing, zero, and negative token values are excluded from token-efficiency plots rather than treated as perfect efficiency.
-
-Tokens Per Solved Task is also unavailable when the score is zero or negative, which avoids division by zero. The UI reports how many runs were omitted because the selected token metric was missing or non-positive.
+Scores are stored internally as fractions from 0 to 1 and displayed as percentages. Point labels are optional and coloring can be grouped by **Model** or **Harness**. Linear and logarithmic resource axes are available.
 
 #### Pareto frontier
 
-A run is token Pareto-efficient when no other displayed run:
+For all three resource metrics, lower resource use and higher score are better. A displayed run is Pareto-efficient when no other valid run on the selected benchmark:
 
-- uses fewer or equal tokens, and
+- uses an equal or lower amount of the selected resource, and
 - achieves an equal or higher score,
 
-with at least one of those comparisons being a strict improvement.
+with at least one strict improvement. Tied nondominated points are preserved. The dashed line connects the Pareto-efficient observations.
 
-The dashed frontier connects the efficient runs. Points below and to the right of the frontier are dominated: another run achieves at least as much score with no more token usage.
+#### Ranking table
 
-The dotted horizontal lines at **70%** and **80%** are fixed capability guides for visual orientation. They do not affect Pareto membership and are not statistical thresholds.
-
-#### Color palettes and themes
+The ranking table remains benchmark-specific and begins with **Model**, **Harness**, and **Benchmark**. Displayed scores are rounded to one decimal place without reducing the precision used for calculations.
 
-The Cost vs Performance and Efficiency charts share the same palette registry and support:
+**Tokens Per Solved Task** remains available in the table as a reference metric even though it is no longer an Efficiency scatter x-axis option. It is defined as `Total Tokens Per Task / Score`, where Score is the fractional value from 0 to 1. It is unavailable when total token data is missing/non-positive or when Score is zero or negative.
 
-- Default
-- Pastel
-- Bold
-- Safe
-- Grayscale
-- Viridis
-- Plasma
-- Cividis
+#### Color palettes and themes
 
-All palettes are available with light and dark chart backgrounds. The grayscale endpoints use near-white and near-black shades to retain practical contrast on both backgrounds.
+The Efficiency chart uses the shared palette registry and supports Citrus, Okabe-Ito, High contrast, Rainbow, Grayscale, Viridis, Plasma, and Cividis palettes with light and dark chart backgrounds.
 
 ## Adding a New Leaderboard Entry
 
 Create a pull request adding a new entry to the `results/` folder. See [`results/qwen3-6-35b-nvfp4-claude-code.json`](./results/qwen3-6-35b-nvfp4-claude-code.json) for an example result.
 
-Do not change the result JSON schema for token-efficiency analysis. The feature uses token and performance metrics already present in the existing result model.
+Do not change the result JSON schema for Efficiency analysis. The feature uses resource and performance metrics already present in the existing result model.
 
 ## Development
 
@@ -115,3 +83,39 @@ Do not change the result JSON schema for token-efficiency analysis. The feature
    ```sh
    pytest
    ```
+
+## Manual validation
+
+After automated checks pass, launch the app from a clean process with `python app.py` and verify the Efficiency view in a real browser. Unit tests and figure-level smoke tests do not replace this browser validation.
+
+### Efficiency behavior
+
+- Confirm there is no **All benchmarks** option and that a valid benchmark is selected by default.
+- Confirm **Color By** offers only **Model** and **Harness**.
+- Confirm the resource selector offers **Total tokens**, **Cost per task**, and **Agent time per task**.
+- Switch through all three resource metrics and verify axis labels and hover formatting.
+- Verify the Pareto frontier for all three metrics.
+- Verify linear and logarithmic scales where valid.
+- Verify point labels off and on.
+- Confirm the ranking table starts with **Model**, **Harness**, **Benchmark**, shows scores to one decimal place, and retains **Tokens Per Solved Task**.
+- Confirm the existing Leaderboard and Benchmark Runs tabs still work without new terminal tracebacks.
+
+### Responsive layout verification
+
+- Restart the app from a clean launch.
+- Open **Efficiency** as the first non-default tab and confirm the plot is not squished.
+- Switch away from Efficiency and back several times.
+- Resize the browser narrower and wider.
+- Confirm the plot resizes correctly without requiring a control change.
+- Verify there is no legend overlap or clipping.
+- Verify the ranking table below does not force the plot into a narrow column.
+- Repeat the checks with point labels off and on, Pareto off and on, each resource metric, and light and dark plot backgrounds.
+- Also switch **Leaderboard → Efficiency** and **Benchmark Runs → Efficiency** to confirm hidden-tab initialization does not collapse the chart.
+
+### PR completion report
+
+The final PR report should state the files changed, metric definitions, tests and results, data-quality limitations, and whether the app was manually verified. For the responsive-layout fix, it must additionally record:
+
+- the root cause of the initial squished-chart issue;
+- the exact responsive-layout fix used; and
+- whether the behavior was manually verified from a fresh app launch.

app.py

@@ -50,8 +50,7 @@ from huggingface_hub import HfApi
 from src.charts import (
     clean_markdown_link,
     create_leaderboard_benchmark_plot,
-    create_score_vs_cost_plot,
-    create_score_vs_tokens_plot,
+    create_performance_vs_resource_plot,
 )
 from src.display.text_blocks import (
     HOW_TO_USE_TEXT,
@@ -59,13 +58,11 @@ from src.display.text_blocks import (
     LLM_BENCHMARKS_TEXT,
 )
 from src.leaderboard import (
-    ALL_BENCHMARKS,
-    TOKEN_METRICS,
+    EFFICIENCY_RESOURCE_METRICS,
     get_analysis_df,
     get_benchmark_names,
     get_benchmark_run_df,
-    get_score_vs_cost_df,
-    get_token_efficiency_df,
+    get_efficiency_df,
     get_token_efficiency_table_df,
 )
 
@@ -73,7 +70,7 @@ REPO_ID = "taagarwa/coding-agent-leaderboard"
 TOKEN = os.environ.get("HF_TOKEN")
 API = HfApi(token=TOKEN)
 COLOR_BY_CHOICES = ["Model", "Harness"]
-EFFICIENCY_COLOR_BY_CHOICES = ["Model", "Harness", "Benchmark"]
+EFFICIENCY_COLOR_BY_CHOICES = ["Model", "Harness"]
 COLOR_PALETTE_CHOICES = [
     "Citrus",
     "Okabe-Ito",
@@ -87,7 +84,24 @@ COLOR_PALETTE_CHOICES = [
 DEFAULT_COLOR_PALETTE = "Citrus"
 PLOT_BACKGROUND_CHOICES = ["Dark", "White"]
 DEFAULT_PLOT_BACKGROUND = "Dark"
-FORCE_DARK_MODE_HEAD = """
+RESPONSIVE_PLOT_MIN_HEIGHT_PX = 420
+RESPONSIVE_PLOT_CSS = f"""
+<style>
+.responsive-plot {{
+  overflow-x: auto;
+  width: 100%;
+  min-height: {RESPONSIVE_PLOT_MIN_HEIGHT_PX}px;
+}}
+.responsive-plot .plot-container,
+.responsive-plot .js-plotly-plot,
+.responsive-plot .plotly-graph-div {{
+  width: 100% !important;
+  min-height: {RESPONSIVE_PLOT_MIN_HEIGHT_PX}px;
+}}
+</style>
+"""
+FORCE_DARK_MODE_HEAD = (
+    """
 <script>
 (() => {
   const url = new URL(window.location.href);
@@ -97,10 +111,9 @@ FORCE_DARK_MODE_HEAD = """
   }
 })();
 </script>
-<style>
-.responsive-plot { overflow-x: auto; }
-</style>
 """
+    + RESPONSIVE_PLOT_CSS
+)
 
 
 def restart_space():
@@ -110,7 +123,6 @@ def restart_space():
 BENCHMARK_NAMES = get_benchmark_names()
 DEFAULT_BENCHMARK = BENCHMARK_NAMES[0] if BENCHMARK_NAMES else None
 BENCHMARK_RUN_DF = get_benchmark_run_df()
-SCORE_VS_COST_DF = get_score_vs_cost_df()
 ANALYSIS_DF = get_analysis_df()
 
 
@@ -129,24 +141,8 @@ def render_leaderboard_benchmark_plot(
     )
 
 
-def render_score_vs_cost_plot(
-    benchmark_name,
-    color_by,
-    show_labels=False,
-    color_palette=DEFAULT_COLOR_PALETTE,
-    plot_background=DEFAULT_PLOT_BACKGROUND,
-):
-    return create_score_vs_cost_plot(
-        SCORE_VS_COST_DF,
-        benchmark_name=benchmark_name,
-        color_by=color_by,
-        show_labels=show_labels,
-        palette_name=color_palette,
-        background_name=plot_background,
-    )
-
 
-def render_token_efficiency(
+def render_efficiency(
     benchmark_name,
     token_metric,
     color_by,
@@ -156,9 +152,9 @@ def render_token_efficiency(
     color_palette=DEFAULT_COLOR_PALETTE,
     plot_background=DEFAULT_PLOT_BACKGROUND,
 ):
-    plot_df = get_token_efficiency_df(
+    plot_df = get_efficiency_df(
         benchmark_name=benchmark_name,
-        token_metric=token_metric,
+        resource_metric=token_metric,
         analysis_df=ANALYSIS_DF,
     )
     table_df = get_token_efficiency_table_df(
@@ -166,10 +162,10 @@ def render_token_efficiency(
         analysis_df=ANALYSIS_DF,
     )
     exclusion_count = plot_df.attrs.get("exclusion_count", 0)
-    note = f"{exclusion_count} runs excluded because {token_metric.lower()} was missing or non-positive."
-    figure = create_score_vs_tokens_plot(
+    note = f"{exclusion_count} runs excluded for this benchmark because {token_metric.lower()} was missing or non-positive."
+    figure = create_performance_vs_resource_plot(
         plot_df,
-        token_metric=token_metric,
+        resource_metric=token_metric,
         color_by=color_by,
         x_scale=x_scale,
         show_pareto_frontier=show_pareto_frontier,
@@ -302,81 +298,25 @@ with demo:
                         outputs=plot,
                     )
 
-        with gr.Tab("💰 Cost vs Performance"):
-            cost_benchmark = gr.Dropdown(
-                choices=BENCHMARK_NAMES,
-                value=DEFAULT_BENCHMARK,
-                label="Benchmark",
-            )
-            with gr.Row():
-                cost_color_by = gr.Radio(
-                    choices=COLOR_BY_CHOICES,
-                    value="Model",
-                    label="Color by",
-                    elem_classes="color-control",
-                )
-                cost_palette = gr.Dropdown(
-                    choices=COLOR_PALETTE_CHOICES,
-                    value=DEFAULT_COLOR_PALETTE,
-                    label="Color palette",
-                    elem_classes="color-control",
-                )
-                cost_background = gr.Dropdown(
-                    choices=PLOT_BACKGROUND_CHOICES,
-                    value=DEFAULT_PLOT_BACKGROUND,
-                    label="Image background",
-                    elem_classes="color-control",
-                )
-                cost_labels = gr.Checkbox(
-                    value=False,
-                    label="Show point labels",
-                    elem_classes="color-control",
-                )
-            score_vs_cost_plot = gr.Plot(
-                value=render_score_vs_cost_plot(
-                    DEFAULT_BENCHMARK,
-                    "Model",
-                    False,
-                    DEFAULT_COLOR_PALETTE,
-                    DEFAULT_PLOT_BACKGROUND,
-                ),
-                show_label=False,
-                elem_classes="responsive-plot",
-            )
-            cost_controls = [
-                cost_benchmark,
-                cost_color_by,
-                cost_labels,
-                cost_palette,
-                cost_background,
-            ]
-            for control in cost_controls:
-                control.change(
-                    fn=render_score_vs_cost_plot,
-                    inputs=cost_controls,
-                    outputs=score_vs_cost_plot,
-                )
-
-        with gr.Tab("⚡ Efficiency"):
+        with gr.Tab("⚡ Efficiency") as efficiency_tab:
             gr.Markdown(
-                "### Token Efficiency\n"
-                "Score alone does not show how much token budget an agent uses to achieve it. "
-                "Tokens Per Solved Task divides mean tokens per task by the fractional score. "
-                "The dashed Pareto frontier connects runs for which no other run uses fewer or equal tokens "
-                "while achieving an equal or higher score; points below and to the right are dominated. "
-                "The dotted 70% and 80% horizontal lines are fixed capability guides only—they do not affect "
-                "Pareto membership and are not statistical thresholds."
+                "### Efficiency\n"
+                "Compare score with resource use within one benchmark. The x-axis can show total tokens, "
+                "cost per task, or agent execution time per task. The dashed Pareto frontier connects runs "
+                "for which no other displayed run uses an equal or lower amount of the selected resource "
+                "while achieving an equal or higher score. Tokens Per Solved Task remains in the ranking "
+                "table as a reference metric."
             )
             with gr.Row():
                 efficiency_benchmark = gr.Dropdown(
-                    choices=[ALL_BENCHMARKS, *BENCHMARK_NAMES],
-                    value=ALL_BENCHMARKS,
+                    choices=BENCHMARK_NAMES,
+                    value=BENCHMARK_NAMES[0] if BENCHMARK_NAMES else None,
                     label="Benchmark",
                 )
                 efficiency_metric = gr.Dropdown(
-                    choices=list(TOKEN_METRICS),
-                    value="Tokens Per Solved Task",
-                    label="Token metric",
+                    choices=list(EFFICIENCY_RESOURCE_METRICS),
+                    value="Total tokens",
+                    label="Resource metric",
                 )
                 efficiency_color_by = gr.Radio(
                     choices=EFFICIENCY_COLOR_BY_CHOICES,
@@ -398,9 +338,9 @@ with demo:
                     label="Image background",
                 )
 
-            initial_efficiency = render_token_efficiency(
-                ALL_BENCHMARKS,
-                "Tokens Per Solved Task",
+            initial_efficiency = render_efficiency(
+                BENCHMARK_NAMES[0] if BENCHMARK_NAMES else None,
+                "Total tokens",
                 "Model",
                 "Log",
                 True,
@@ -414,7 +354,7 @@ with demo:
                 show_label=False,
                 elem_classes="responsive-plot",
             )
-            gr.Markdown("#### Token-efficiency ranking")
+            gr.Markdown("#### Efficiency ranking")
             efficiency_table = gr.Dataframe(
                 value=initial_efficiency[1],
                 interactive=False,
@@ -433,11 +373,20 @@ with demo:
             ]
             for control in efficiency_controls:
                 control.change(
-                    fn=render_token_efficiency,
+                    fn=render_efficiency,
                     inputs=efficiency_controls,
                     outputs=[efficiency_plot, efficiency_table, efficiency_note],
                 )
 
+            # Gradio initially lays out hidden tabs without reliable dimensions. Re-render
+            # once Efficiency becomes visible so Plotly can autosize against the real
+            # container instead of keeping the hidden-tab geometry.
+            efficiency_tab.select(
+                fn=render_efficiency,
+                inputs=efficiency_controls,
+                outputs=[efficiency_plot, efficiency_table, efficiency_note],
+            )
+
         with gr.Tab("🏃 Benchmark Runs"):
             benchmark_runs = init_benchmark_runs(BENCHMARK_RUN_DF)
 

src/charts.py

@@ -103,31 +103,6 @@ PLOT_BACKGROUNDS: dict[PlotBackground, dict[str, str]] = {
 
 
 
-CAPABILITY_TIER_BOUNDARIES = (70.0, 80.0)
-
-
-def add_capability_tier_guides(fig: Figure, background_name: str | None = DEFAULT_BACKGROUND) -> None:
-    """Add fixed score-band guides without affecting Pareto calculations."""
-    theme = get_plot_background(background_name)
-    for boundary in CAPABILITY_TIER_BOUNDARIES:
-        fig.add_hline(
-            y=boundary,
-            line={"width": 1.5, "dash": "dot", "color": theme["zero_line_color"]},
-            layer="below",
-        )
-        fig.add_annotation(
-            x=1.0,
-            xref="paper",
-            xanchor="right",
-            y=boundary,
-            yref="y",
-            yshift=8,
-            text=f"{boundary:.0f}% guide",
-            showarrow=False,
-            font={"size": 11, "color": theme["text_muted"]},
-        )
-
-
 def clean_markdown_link(value: object) -> str:
     """Return human-readable text from Markdown links used in leaderboard tables."""
     text = str(value).replace("<sup>*</sup>", "")
@@ -312,9 +287,7 @@ def prepare_benchmark_run_plot_df(dataframe: pd.DataFrame) -> pd.DataFrame:
     plot_df["Model Label"] = plot_df["Model"].map(clean_markdown_link)
     plot_df["Harness Label"] = plot_df["Harness"].map(clean_markdown_link)
     plot_df["Benchmark Label"] = plot_df["Benchmark"].map(clean_markdown_link)
-    plot_df["Run Label"] = (
-        plot_df["Model Label"] + " / " + plot_df["Harness Label"]
-    )
+    plot_df["Run Label"] = plot_df["Model Label"] + "<br>" + plot_df["Harness Label"]
     plot_df["Score"] = pd.to_numeric(plot_df["Score"], errors="coerce")
     return plot_df
 
@@ -323,6 +296,7 @@ def create_leaderboard_benchmark_plot(
     dataframe: pd.DataFrame,
     benchmark_name: str,
     color_by: ColorBy = "Model",
+    show_labels: bool = False,
     palette_name: str | None = DEFAULT_PALETTE,
     background_name: str | None = DEFAULT_BACKGROUND,
 ) -> Figure:
@@ -451,36 +425,82 @@ def create_score_vs_cost_plot(
     return apply_plot_theme(fig, background_name)
 
 
-def create_score_vs_tokens_plot(
+RESOURCE_AXIS_CONFIG = {
+    "Total tokens": {
+        "column": "Total Tokens Per Task",
+        "axis_title": "Total tokens per task",
+        "hover_label": "Total tokens/task",
+        "hover_format": ",.0f",
+    },
+    "Cost per task": {
+        "column": "Cost Per Task",
+        "axis_title": "Cost per task (USD)",
+        "hover_label": "Cost/task",
+        "hover_format": ".4f",
+        "tickprefix": "$",
+    },
+    "Agent time per task": {
+        "column": "Agent Time Per Task",
+        "axis_title": "Agent time per task (seconds)",
+        "hover_label": "Agent time/task",
+        "hover_format": ",.1f",
+        "ticksuffix": "s",
+    },
+}
+
+
+def _resource_axis_config(resource_metric: str) -> dict[str, str]:
+    """Return display metadata for a supported Efficiency resource metric."""
+    if resource_metric in RESOURCE_AXIS_CONFIG:
+        return RESOURCE_AXIS_CONFIG[resource_metric]
+    for config in RESOURCE_AXIS_CONFIG.values():
+        if resource_metric == config["column"]:
+            return config
+    raise ValueError(f"Unsupported efficiency resource metric: {resource_metric}")
+
+
+def create_performance_vs_resource_plot(
     dataframe: pd.DataFrame,
-    token_metric: str = "Tokens Per Solved Task",
-    color_by: Literal["Model", "Harness", "Benchmark"] = "Model",
+    resource_metric: str = "Total tokens",
+    color_by: ColorBy = "Model",
     x_scale: Literal["Linear", "Log"] = "Log",
     show_pareto_frontier: bool = True,
     show_labels: bool = False,
     palette_name: str | None = DEFAULT_PALETTE,
     background_name: str | None = DEFAULT_BACKGROUND,
 ) -> Figure:
-    """Plot score against a positive token metric, optionally with its Pareto frontier."""
-    from src.leaderboard import get_token_pareto_frontier_df
+    """Plot benchmark score against one positive resource metric.
+
+    Lower resource use and higher score define the optional Pareto frontier.
+    The caller is expected to provide rows for one benchmark only.
+    """
+    from src.leaderboard import get_resource_pareto_frontier_df
+
+    try:
+        resource_config = _resource_axis_config(resource_metric)
+    except ValueError:
+        return empty_figure(f"Resource metric not available: {resource_metric}.", background_name)
+    resource_column = resource_config["column"]
 
     if dataframe is None or dataframe.empty:
-        return empty_figure("No valid token data available.", background_name)
-    if token_metric not in dataframe.columns:
-        return empty_figure(f"Token metric not available: {token_metric}.", background_name)
-    if color_by not in dataframe.columns:
+        return empty_figure("No valid resource data available for this benchmark.", background_name)
+    if resource_column not in dataframe.columns:
+        return empty_figure(f"Resource metric not available: {resource_column}.", background_name)
+    if color_by not in ("Model", "Harness") or color_by not in dataframe.columns:
         return empty_figure(f"Color dimension not available: {color_by}.", background_name)
 
     plot_df = dataframe.copy()
-    plot_df[token_metric] = pd.to_numeric(plot_df[token_metric], errors="coerce")
+    if "Benchmark" in plot_df.columns and plot_df["Benchmark"].dropna().nunique() > 1:
+        return empty_figure("Select one benchmark for the Efficiency view.", background_name)
+
+    plot_df[resource_column] = pd.to_numeric(plot_df[resource_column], errors="coerce")
     plot_df["Score (%)"] = pd.to_numeric(plot_df["Score (%)"], errors="coerce")
-    plot_df = plot_df.dropna(subset=[token_metric, "Score (%)"])
-    plot_df = plot_df[plot_df[token_metric] > 0]
+    plot_df = plot_df.dropna(subset=[resource_column, "Score (%)"])
+    plot_df = plot_df[plot_df[resource_column] > 0]
     if plot_df.empty:
-        return empty_figure("No valid token data available.", background_name)
+        return empty_figure("No valid resource data available for this benchmark.", background_name)
 
-    palette_color_by: ColorBy = color_by if color_by in ("Model", "Harness") else "Model"
-    colors = color_map_for(plot_df[color_by], palette_color_by, palette_name)
+    colors = color_map_for(plot_df[color_by], color_by, palette_name)
     theme = get_plot_background(background_name)
     fig = go.Figure()
     hover_columns = [
@@ -500,11 +520,17 @@ def create_score_vs_tokens_plot(
         if column not in plot_df:
             plot_df[column] = None
 
+    resource_hover = f"{resource_config['hover_label']}: %{{x:{resource_config['hover_format']}}}"
+    if resource_metric == "Cost per task" or resource_column == "Cost Per Task":
+        resource_hover = f"{resource_config['hover_label']}: $%{{x:{resource_config['hover_format']}}}"
+    elif resource_metric == "Agent time per task" or resource_column == "Agent Time Per Task":
+        resource_hover += "s"
+
     for group, group_df in plot_df.groupby(color_by, sort=True):
         label_kwargs = scatter_label_kwargs(group_df, show_labels)
         fig.add_trace(
             go.Scatter(
-                x=group_df[token_metric],
+                x=group_df[resource_column],
                 y=group_df["Score (%)"],
                 name=str(group),
                 **label_kwargs,
@@ -519,24 +545,30 @@ def create_score_vs_tokens_plot(
                     "Harness: %{customdata[1]}<br>"
                     "Benchmark: %{customdata[2]}<br>"
                     "Score: %{customdata[3]:.1f}%<br>"
+                    f"{resource_hover}<br>"
                     "Input tokens/task: %{customdata[4]:,.0f}<br>"
                     "Output tokens/task: %{customdata[5]:,.0f}<br>"
                     "Cache tokens/task: %{customdata[6]:,.0f}<br>"
                     "Total tokens/task: %{customdata[7]:,.0f}<br>"
                     "Cost/task: $%{customdata[8]:.4f}<br>"
-                    "Total time/task: %{customdata[9]:,.0f}s<br>"
-                    "Agent time/task: %{customdata[10]:,.0f}s"
+                    "Total time/task: %{customdata[9]:,.1f}s<br>"
+                    "Agent time/task: %{customdata[10]:,.1f}s"
                     "<extra></extra>"
                 ),
             )
         )
 
     if show_pareto_frontier:
-        frontier_df = get_token_pareto_frontier_df(plot_df, token_metric)
+        frontier_df = get_resource_pareto_frontier_df(plot_df, resource_column)
         if not frontier_df.empty:
+            frontier_hover = f"{resource_config['hover_label']}: %{{x:{resource_config['hover_format']}}}"
+            if resource_column == "Cost Per Task":
+                frontier_hover = f"{resource_config['hover_label']}: $%{{x:{resource_config['hover_format']}}}"
+            elif resource_column == "Agent Time Per Task":
+                frontier_hover += "s"
             fig.add_trace(
                 go.Scatter(
-                    x=frontier_df[token_metric],
+                    x=frontier_df[resource_column],
                     y=frontier_df["Score (%)"],
                     mode="lines+markers",
                     name="Pareto frontier",
@@ -551,35 +583,67 @@ def create_score_vs_tokens_plot(
                     hovertemplate=(
                         "<b>Pareto frontier</b><br>"
                         "%{customdata[0]}<br>"
-                        f"{token_metric}: %{{x:,.0f}}<br>"
+                        f"{frontier_hover}<br>"
                         "Score: %{y:.1f}%<extra></extra>"
                     ),
                 )
             )
 
-    add_capability_tier_guides(fig, background_name)
+
+    xaxis = {
+        "title": resource_config["axis_title"],
+        "type": "log" if x_scale == "Log" else "linear",
+    }
+    if "tickprefix" in resource_config:
+        xaxis["tickprefix"] = resource_config["tickprefix"]
+    if "ticksuffix" in resource_config:
+        xaxis["ticksuffix"] = resource_config["ticksuffix"]
 
     fig.update_layout(
         title=None,
-        xaxis={"title": token_metric, "type": "log" if x_scale == "Log" else "linear"},
+        xaxis=xaxis,
         yaxis={"title": "Score (%)", "range": [0, 105]},
         legend_title_text=color_by,
     )
     return apply_plot_theme(fig, background_name)
 
 
+def create_score_vs_tokens_plot(
+    dataframe: pd.DataFrame,
+    token_metric: str = "Total tokens",
+    color_by: ColorBy = "Model",
+    x_scale: Literal["Linear", "Log"] = "Log",
+    show_pareto_frontier: bool = True,
+    show_labels: bool = False,
+    palette_name: str | None = DEFAULT_PALETTE,
+    background_name: str | None = DEFAULT_BACKGROUND,
+) -> Figure:
+    """Backward-compatible wrapper around the performance-vs-resource chart."""
+    return create_performance_vs_resource_plot(
+        dataframe=dataframe,
+        resource_metric=token_metric,
+        color_by=color_by,
+        x_scale=x_scale,
+        show_pareto_frontier=show_pareto_frontier,
+        show_labels=show_labels,
+        palette_name=palette_name,
+        background_name=background_name,
+    )
+
+
 def create_token_pareto_frontier_plot(
     dataframe: pd.DataFrame,
-    token_metric: str = "Tokens Per Solved Task",
-    color_by: Literal["Model", "Harness", "Benchmark"] = "Model",
+    token_metric: str = "Total tokens",
+    color_by: ColorBy = "Model",
     x_scale: Literal["Linear", "Log"] = "Log",
     show_labels: bool = False,
     palette_name: str | None = DEFAULT_PALETTE,
     background_name: str | None = DEFAULT_BACKGROUND,
 ) -> Figure:
-    return create_score_vs_tokens_plot(
+    """Backward-compatible convenience wrapper with the Pareto frontier enabled."""
+    return create_performance_vs_resource_plot(
         dataframe=dataframe,
-        token_metric=token_metric,
+        resource_metric=token_metric,
         color_by=color_by,
         x_scale=x_scale,
         show_pareto_frontier=True,

src/leaderboard.py

@@ -12,13 +12,11 @@ BENCHMARK_SORT_ORDER = {
     "SWE-Bench Pro -- Ansible": 1,
 }
 
-ALL_BENCHMARKS = "All benchmarks"
-TOKEN_METRICS = (
-    "Total Tokens Per Task",
-    "Input Tokens Per Task",
-    "Output Tokens Per Task",
-    "Tokens Per Solved Task",
-)
+EFFICIENCY_RESOURCE_METRICS = {
+    "Total tokens": "Total Tokens Per Task",
+    "Cost per task": "Cost Per Task",
+    "Agent time per task": "Agent Time Per Task",
+}
 ANALYSIS_COLUMNS = [
     "Benchmark",
     "Model",
@@ -40,11 +38,13 @@ ANALYSIS_COLUMNS = [
     "Token Data Available",
 ]
 TOKEN_EFFICIENCY_TABLE_COLUMNS = [
-    "Benchmark",
     "Model",
     "Harness",
+    "Benchmark",
     "Score (%)",
     "Total Tokens Per Task",
+    "Cost Per Task",
+    "Agent Time Per Task",
     "Input Tokens Per Task",
     "Output Tokens Per Task",
     "Cache Tokens Per Task",
@@ -81,6 +81,28 @@ def get_benchmark_names(results: list[Result] | None = None) -> list[str]:
     return sorted({r.benchmark.name for r in results}, key=benchmark_sort_key)
 
 
+def _positive_number_or_none(value: object) -> float | None:
+    """Return a positive numeric value, otherwise ``None``."""
+    if value is None:
+        return None
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        return None
+    if pd.isna(numeric) or numeric <= 0:
+        return None
+    return numeric
+
+
+def get_efficiency_resource_column(metric_name: str) -> str:
+    """Resolve an Efficiency UI metric name to its canonical analysis column."""
+    if metric_name in EFFICIENCY_RESOURCE_METRICS:
+        return EFFICIENCY_RESOURCE_METRICS[metric_name]
+    if metric_name in EFFICIENCY_RESOURCE_METRICS.values():
+        return metric_name
+    raise ValueError(f"Unsupported efficiency resource metric: {metric_name}")
+
+
 def get_analysis_df(results: list[Result] | None = None) -> pd.DataFrame:
     """Return one normalized analysis row per benchmark result."""
     if results is None:
@@ -90,8 +112,10 @@ def get_analysis_df(results: list[Result] | None = None) -> pd.DataFrame:
     for result in results:
         metrics = result.metrics
         model_label = result.model.repo or result.model.name
-        total_tokens = metrics.mean_tokens_per_task
-        token_data_available = total_tokens is not None and total_tokens > 0
+        total_tokens = _positive_number_or_none(metrics.mean_tokens_per_task)
+        cost_per_task = _positive_number_or_none(metrics.mean_cost_usd_per_task)
+        agent_time_per_task = _positive_number_or_none(metrics.mean_agent_time_seconds_per_task)
+        token_data_available = total_tokens is not None
         tokens_per_solved_task = (
             total_tokens / metrics.score
             if token_data_available and metrics.score > 0
@@ -113,9 +137,9 @@ def get_analysis_df(results: list[Result] | None = None) -> pd.DataFrame:
                 "Output Tokens Per Task": metrics.mean_output_tokens_per_task,
                 "Total Tokens Per Task": total_tokens,
                 "Tokens Per Solved Task": tokens_per_solved_task,
-                "Cost Per Task": metrics.mean_cost_usd_per_task,
+                "Cost Per Task": cost_per_task,
                 "Total Time Per Task": metrics.mean_total_time_seconds_per_task,
-                "Agent Time Per Task": metrics.mean_agent_time_seconds_per_task,
+                "Agent Time Per Task": agent_time_per_task,
                 "Token Data Available": token_data_available,
             }
         )
@@ -123,61 +147,80 @@ def get_analysis_df(results: list[Result] | None = None) -> pd.DataFrame:
     return pd.DataFrame(rows, columns=ANALYSIS_COLUMNS)
 
 
-def get_token_efficiency_df(
-    benchmark_name: str | None = ALL_BENCHMARKS,
-    token_metric: str = "Tokens Per Solved Task",
+def get_efficiency_df(
+    benchmark_name: str,
+    resource_metric: str = "Total tokens",
     analysis_df: pd.DataFrame | None = None,
 ) -> pd.DataFrame:
-    """Filter normalized analysis data for a selected positive token metric.
+    """Return valid resource rows for one benchmark-specific Efficiency plot.
 
-    The number of rows excluded because the selected metric is missing or
-    non-positive is available as ``dataframe.attrs["exclusion_count"]``.
+    The number of rows excluded because the selected resource is missing or
+    non-positive is exposed via ``dataframe.attrs["exclusion_count"]``.
     """
-    if token_metric not in TOKEN_METRICS:
-        raise ValueError(f"Unsupported token metric: {token_metric}")
-
+    metric_column = get_efficiency_resource_column(resource_metric)
     dataframe = get_analysis_df() if analysis_df is None else analysis_df.copy()
-    if benchmark_name and benchmark_name != ALL_BENCHMARKS:
-        dataframe = dataframe[dataframe["Benchmark"] == benchmark_name].copy()
+    dataframe = dataframe[dataframe["Benchmark"] == benchmark_name].copy()
 
     if dataframe.empty:
         dataframe.attrs["exclusion_count"] = 0
         return dataframe
 
-    metric_values = pd.to_numeric(dataframe[token_metric], errors="coerce")
+    metric_values = pd.to_numeric(dataframe[metric_column], errors="coerce")
     valid_mask = metric_values.notna() & (metric_values > 0)
     exclusion_count = int((~valid_mask).sum())
     dataframe = dataframe.loc[valid_mask].copy()
-    dataframe[token_metric] = metric_values.loc[valid_mask]
+    dataframe[metric_column] = metric_values.loc[valid_mask]
     dataframe = dataframe.sort_values(
-        ["Tokens Per Solved Task", "Score (%)", "Benchmark", "Model", "Harness"],
-        ascending=[True, False, True, True, True],
+        [metric_column, "Score (%)", "Model", "Harness"],
+        ascending=[True, False, True, True],
         na_position="last",
     )
     dataframe.attrs["exclusion_count"] = exclusion_count
     return dataframe
 
 
+def get_token_efficiency_df(
+    benchmark_name: str,
+    token_metric: str = "Total tokens",
+    analysis_df: pd.DataFrame | None = None,
+) -> pd.DataFrame:
+    """Backward-compatible wrapper for :func:`get_efficiency_df`."""
+    return get_efficiency_df(benchmark_name, token_metric, analysis_df)
+
+
 def get_token_efficiency_table_df(
-    benchmark_name: str | None = ALL_BENCHMARKS,
+    benchmark_name: str,
     analysis_df: pd.DataFrame | None = None,
 ) -> pd.DataFrame:
-    dataframe = get_token_efficiency_df(
-        benchmark_name=benchmark_name,
-        token_metric="Tokens Per Solved Task",
-        analysis_df=analysis_df,
+    """Return the benchmark-specific Efficiency ranking table for display."""
+    dataframe = get_analysis_df() if analysis_df is None else analysis_df.copy()
+    dataframe = dataframe[dataframe["Benchmark"] == benchmark_name].copy()
+    if dataframe.empty:
+        return pd.DataFrame(columns=TOKEN_EFFICIENCY_TABLE_COLUMNS)
+
+    dataframe["Score (%)"] = pd.to_numeric(dataframe["Score (%)"], errors="coerce")
+    dataframe = dataframe.sort_values(
+        ["Tokens Per Solved Task", "Score (%)", "Model", "Harness"],
+        ascending=[True, False, True, True],
+        na_position="last",
     )
     table_df = dataframe.reindex(columns=TOKEN_EFFICIENCY_TABLE_COLUMNS).copy()
-    table_df.attrs.update(dataframe.attrs)
+    table_df["Score (%)"] = table_df["Score (%)"].round(1)
+    if "Cost Per Task" in table_df:
+        table_df["Cost Per Task"] = pd.to_numeric(table_df["Cost Per Task"], errors="coerce").round(4)
+    if "Agent Time Per Task" in table_df:
+        table_df["Agent Time Per Task"] = pd.to_numeric(
+            table_df["Agent Time Per Task"], errors="coerce"
+        ).round(1)
     return table_df
 
 
-def get_token_pareto_frontier_df(
+def get_resource_pareto_frontier_df(
     dataframe: pd.DataFrame,
     token_metric: str,
     score_column: str = "Score (%)",
 ) -> pd.DataFrame:
-    """Return deterministic non-dominated points for lower tokens/higher score."""
+    """Return deterministic non-dominated points for lower resource use/higher score."""
     if token_metric not in dataframe.columns or score_column not in dataframe.columns:
         return dataframe.iloc[0:0].copy()
 
@@ -211,6 +254,15 @@ def get_token_pareto_frontier_df(
     )
 
 
+def get_token_pareto_frontier_df(
+    dataframe: pd.DataFrame,
+    token_metric: str,
+    score_column: str = "Score (%)",
+) -> pd.DataFrame:
+    """Backward-compatible wrapper for the generic resource Pareto helper."""
+    return get_resource_pareto_frontier_df(dataframe, token_metric, score_column)
+
+
 def get_benchmark_run_df():
     results = get_results()
 

tests/test_token_efficiency.py

@@ -1,13 +1,21 @@
+from pathlib import Path
 import pandas as pd
 import plotly.graph_objects as go
 
-from src.charts import create_score_vs_tokens_plot, create_token_pareto_frontier_plot
+from src.charts import (
+    create_performance_vs_resource_plot,
+    create_score_vs_cost_plot,
+    create_score_vs_tokens_plot,
+)
 from src.leaderboard import (
-    ALL_BENCHMARKS,
     ANALYSIS_COLUMNS,
+    EFFICIENCY_RESOURCE_METRICS,
+    TOKEN_EFFICIENCY_TABLE_COLUMNS,
     get_analysis_df,
-    get_token_efficiency_df,
-    get_token_pareto_frontier_df,
+    get_efficiency_resource_column,
+    get_efficiency_df,
+    get_token_efficiency_table_df,
+    get_resource_pareto_frontier_df,
 )
 from src.models import Benchmark, Environment, Harness, Metrics, Model, Result
 
@@ -18,14 +26,29 @@ def make_result(
     model: str = "model-a",
     harness: str = "harness-a",
     score: float = 0.5,
+    n_tasks: int | None = 10,
     total_tokens: int | None = 100,
     input_tokens: int | None = 60,
     cache_tokens: int | None = 10,
     output_tokens: int | None = 30,
+    cost_per_task: float | None = 0.25,
+    agent_time_per_task: int | None = 10,
+    cost_usd: float | None = None,
+    agent_time_seconds: int | None = None,
 ) -> Result:
     return Result(
-        benchmark=Benchmark(name=benchmark, repo="repo", num_tasks=10, url="https://example.com/benchmark"),
-        harness=Harness(name=harness, skills=[], is_oss=True, url="https://example.com/harness"),
+        benchmark=Benchmark(
+            name=benchmark,
+            repo="repo",
+            num_tasks=10,
+            url="https://example.com/benchmark",
+        ),
+        harness=Harness(
+            name=harness,
+            skills=[],
+            is_oss=True,
+            url="https://example.com/harness",
+        ),
         model=Model(
             name=model,
             repo=None,
@@ -37,39 +60,58 @@ def make_result(
         environment=Environment(name="env", url="https://example.com/env"),
         metrics=Metrics(
             score=score,
-            n_tasks=10,
+            n_tasks=n_tasks,
             n_errors=1,
             mean_input_tokens_per_task=input_tokens,
             mean_cache_tokens_per_task=cache_tokens,
             mean_output_tokens_per_task=output_tokens,
             mean_tokens_per_task=total_tokens,
-            mean_cost_usd_per_task=0.25,
+            mean_cost_usd_per_task=cost_per_task,
             mean_total_time_seconds_per_task=12,
-            mean_agent_time_seconds_per_task=10,
+            mean_agent_time_seconds_per_task=agent_time_per_task,
+            cost_usd=cost_usd,
+            agent_time_seconds=agent_time_seconds,
         ),
     )
 
 
-def test_get_analysis_df_columns_and_derived_values():
-    dataframe = get_analysis_df([make_result(score=0.25, total_tokens=200)])
+def test_cost_vs_performance_tab_removed_without_efficiency_cost_regression():
+    app_source = Path("app.py").read_text()
+
+    assert 'gr.Tab("💰 Cost vs Performance")' not in app_source
+    assert "cost_benchmark" not in app_source
+    assert "cost_controls" not in app_source
+    assert "render_score_vs_cost_plot" not in app_source
+    assert 'with gr.Tab("⚡ Efficiency")' in app_source
+    assert app_source.index('with gr.Tab("🏆 Leaderboard")') < app_source.index('with gr.Tab("⚡ Efficiency")')
+    assert app_source.index('with gr.Tab("⚡ Efficiency")') < app_source.index('with gr.Tab("🏃 Benchmark Runs")')
+
+def test_analysis_df_columns_and_derived_metrics():
+    dataframe = get_analysis_df(
+        [make_result(score=0.25, total_tokens=200, cost_per_task=0.125, agent_time_per_task=7)]
+    )
 
     assert set(ANALYSIS_COLUMNS).issubset(dataframe.columns)
     assert dataframe.loc[0, "Score (%)"] == 25
     assert dataframe.loc[0, "Tokens Per Solved Task"] == 800
+    assert dataframe.loc[0, "Cost Per Task"] == 0.125
+    assert dataframe.loc[0, "Agent Time Per Task"] == 7
     assert bool(dataframe.loc[0, "Token Data Available"]) is True
 
 
-def test_missing_zero_and_negative_tokens_are_unavailable():
+def test_missing_zero_negative_resource_values_are_unavailable():
     dataframe = get_analysis_df(
         [
-            make_result(model="missing", total_tokens=None),
-            make_result(model="zero", total_tokens=0),
-            make_result(model="negative", total_tokens=-10),
+            make_result(model="missing", total_tokens=None, cost_per_task=None, agent_time_per_task=None),
+            make_result(model="zero", total_tokens=0, cost_per_task=0, agent_time_per_task=0),
+            make_result(model="negative", total_tokens=-10, cost_per_task=-1, agent_time_per_task=-3),
         ]
     )
 
     assert dataframe["Token Data Available"].tolist() == [False, False, False]
     assert dataframe["Tokens Per Solved Task"].isna().all()
+    assert dataframe["Cost Per Task"].isna().all()
+    assert dataframe["Agent Time Per Task"].isna().all()
 
 
 def test_zero_score_does_not_divide_by_zero():
@@ -79,84 +121,205 @@ def test_zero_score_does_not_divide_by_zero():
     assert bool(dataframe.loc[0, "Token Data Available"]) is True
 
 
-def test_token_efficiency_filtering_and_exclusion_count():
+def test_invalid_task_denominator_does_not_trigger_total_metric_fallback():
+    dataframe = get_analysis_df(
+        [
+            make_result(
+                n_tasks=0,
+                cost_per_task=None,
+                agent_time_per_task=None,
+                cost_usd=1.5,
+                agent_time_seconds=30,
+            )
+        ]
+    )
+
+    assert pd.isna(dataframe.loc[0, "Cost Per Task"])
+    assert pd.isna(dataframe.loc[0, "Agent Time Per Task"])
+
+
+def test_efficiency_resource_metric_choices_are_exact():
+    assert list(EFFICIENCY_RESOURCE_METRICS) == [
+        "Total tokens",
+        "Cost per task",
+        "Agent time per task",
+    ]
+    assert "Tokens Per Solved Task" not in EFFICIENCY_RESOURCE_METRICS
+    assert get_efficiency_resource_column("Total tokens") == "Total Tokens Per Task"
+    assert get_efficiency_resource_column("Cost per task") == "Cost Per Task"
+    assert get_efficiency_resource_column("Agent time per task") == "Agent Time Per Task"
+
+
+def test_efficiency_filtering_is_benchmark_specific_and_counts_exclusions():
     analysis_df = get_analysis_df(
         [
-            make_result(model="valid", total_tokens=100),
-            make_result(model="zero", total_tokens=0),
-            make_result(model="missing", total_tokens=None),
+            make_result(benchmark="Benchmark A", model="valid", total_tokens=100),
+            make_result(benchmark="Benchmark A", model="zero", total_tokens=0),
+            make_result(benchmark="Benchmark A", model="missing", total_tokens=None),
+            make_result(benchmark="Benchmark B", model="other", total_tokens=100),
         ]
     )
 
-    filtered = get_token_efficiency_df(
-        token_metric="Total Tokens Per Task",
+    filtered = get_efficiency_df(
+        benchmark_name="Benchmark A",
+        resource_metric="Total tokens",
         analysis_df=analysis_df,
     )
 
     assert filtered["Model"].tolist() == ["valid"]
+    assert filtered["Benchmark"].unique().tolist() == ["Benchmark A"]
     assert filtered.attrs["exclusion_count"] == 2
+    assert get_efficiency_df(
+        "All benchmarks", "Total tokens", analysis_df
+    ).empty
 
 
-def test_all_benchmarks_and_single_benchmark_filtering():
+def test_cost_and_agent_time_filtering_use_positive_values_only():
     analysis_df = get_analysis_df(
         [
-            make_result(benchmark="Benchmark A", model="a"),
-            make_result(benchmark="Benchmark B", model="b"),
+            make_result(model="valid", cost_per_task=0.2, agent_time_per_task=9),
+            make_result(model="invalid", cost_per_task=0, agent_time_per_task=-1),
         ]
     )
 
-    all_rows = get_token_efficiency_df(ALL_BENCHMARKS, analysis_df=analysis_df)
-    one_benchmark = get_token_efficiency_df("Benchmark B", analysis_df=analysis_df)
+    cost = get_efficiency_df("Benchmark A", "Cost per task", analysis_df)
+    agent_time = get_efficiency_df("Benchmark A", "Agent time per task", analysis_df)
+
+    assert cost["Model"].tolist() == ["valid"]
+    assert agent_time["Model"].tolist() == ["valid"]
+    assert cost.attrs["exclusion_count"] == 1
+    assert agent_time.attrs["exclusion_count"] == 1
+
+
+def test_efficiency_table_keeps_tokens_per_solved_task_and_expected_order():
+    analysis_df = get_analysis_df(
+        [make_result(score=0.333333333333, total_tokens=120, cost_per_task=0.123456)]
+    )
+
+    table = get_token_efficiency_table_df("Benchmark A", analysis_df)
 
-    assert set(all_rows["Benchmark"]) == {"Benchmark A", "Benchmark B"}
-    assert one_benchmark["Benchmark"].tolist() == ["Benchmark B"]
+    assert list(table.columns) == TOKEN_EFFICIENCY_TABLE_COLUMNS
+    assert list(table.columns[:3]) == ["Model", "Harness", "Benchmark"]
+    assert "Tokens Per Solved Task" in table.columns
+    assert table.loc[0, "Score (%)"] == 33.3
+    assert table.loc[0, "Cost Per Task"] == 0.1235
 
 
-def test_pareto_frontier_identification():
+def test_pareto_frontier_for_all_resource_metrics():
     dataframe = pd.DataFrame(
         {
             "Run Label": ["a", "b", "c", "d"],
+            "Model": ["a", "b", "c", "d"],
             "Total Tokens Per Task": [100, 200, 300, 400],
+            "Cost Per Task": [0.1, 0.2, 0.3, 0.4],
+            "Agent Time Per Task": [10, 20, 30, 40],
             "Score (%)": [50, 60, 55, 80],
         }
     )
 
-    frontier = get_token_pareto_frontier_df(dataframe, "Total Tokens Per Task")
+    for metric in ("Total Tokens Per Task", "Cost Per Task", "Agent Time Per Task"):
+        frontier = get_resource_pareto_frontier_df(dataframe, metric)
+        assert frontier["Run Label"].tolist() == ["a", "b", "d"]
 
-    assert frontier["Run Label"].tolist() == ["a", "b", "d"]
 
-
-def test_pareto_ties_are_deterministic_and_not_falsely_dominated():
+def test_pareto_equal_x_equal_score_ties_are_preserved():
     dataframe = pd.DataFrame(
         {
             "Run Label": ["z", "a", "dominated", "higher"],
             "Model": ["z", "a", "d", "h"],
-            "Total Tokens Per Task": [100, 100, 100, 200],
+            "Cost Per Task": [0.1, 0.1, 0.1, 0.2],
             "Score (%)": [50, 50, 40, 60],
         }
     )
 
-    frontier = get_token_pareto_frontier_df(dataframe, "Total Tokens Per Task")
+    frontier = get_resource_pareto_frontier_df(dataframe, "Cost Per Task")
 
     assert frontier["Run Label"].tolist() == ["a", "z", "higher"]
     assert "dominated" not in frontier["Run Label"].tolist()
 
 
-def test_chart_functions_return_figures_for_valid_data():
-    dataframe = get_analysis_df([make_result(), make_result(model="model-b", score=0.7, total_tokens=200)])
+def test_pareto_excludes_missing_zero_and_negative_resources():
+    dataframe = pd.DataFrame(
+        {
+            "Run Label": ["valid", "missing", "zero", "negative"],
+            "Agent Time Per Task": [10, None, 0, -1],
+            "Score (%)": [50, 100, 100, 100],
+        }
+    )
+
+    frontier = get_resource_pareto_frontier_df(dataframe, "Agent Time Per Task")
+
+    assert frontier["Run Label"].tolist() == ["valid"]
+
+
+def test_performance_resource_charts_construct_with_metric_specific_axes():
+    dataframe = get_analysis_df(
+        [
+            make_result(),
+            make_result(model="model-b", score=0.7, total_tokens=200, cost_per_task=0.4, agent_time_per_task=20),
+        ]
+    )
+
+    expected_titles = {
+        "Total tokens": "Total tokens per task",
+        "Cost per task": "Cost per task (USD)",
+        "Agent time per task": "Agent time per task (seconds)",
+    }
+    for metric, title in expected_titles.items():
+        figure = create_performance_vs_resource_plot(dataframe, resource_metric=metric)
+        assert isinstance(figure, go.Figure)
+        assert figure.layout.xaxis.type == "log"
+        assert figure.layout.xaxis.title.text == title
+        assert any(trace.name == "Pareto frontier" for trace in figure.data)
+
+    compatibility = create_score_vs_tokens_plot(dataframe, token_metric="Total tokens")
+    assert isinstance(compatibility, go.Figure)
 
-    scatter = create_score_vs_tokens_plot(dataframe, token_metric="Total Tokens Per Task")
-    pareto = create_token_pareto_frontier_plot(dataframe, token_metric="Total Tokens Per Task")
 
-    assert isinstance(scatter, go.Figure)
-    assert isinstance(pareto, go.Figure)
-    assert scatter.layout.xaxis.type == "log"
 
+def test_performance_resource_chart_rejects_multiple_benchmarks():
+    dataframe = get_analysis_df(
+        [
+            make_result(benchmark="Benchmark A"),
+            make_result(benchmark="Benchmark B", model="model-b"),
+        ]
+    )
+    figure = create_performance_vs_resource_plot(dataframe, resource_metric="Total tokens")
+
+    assert len(figure.layout.annotations) == 1
+    assert "Select one benchmark" in figure.layout.annotations[0].text
+
+def test_linear_scale_and_point_labels_still_work():
+    dataframe = get_analysis_df([make_result()])
+    figure = create_performance_vs_resource_plot(
+        dataframe,
+        resource_metric="Cost per task",
+        x_scale="Linear",
+        show_labels=True,
+        show_pareto_frontier=False,
+    )
+
+    assert figure.layout.xaxis.type == "linear"
+    assert figure.data[0].mode == "markers+text"
+    assert list(figure.data[0].text) == ["model-a / harness-a"]
 
-def test_empty_and_fully_invalid_chart_data_are_graceful():
-    empty = create_score_vs_tokens_plot(pd.DataFrame(), token_metric="Total Tokens Per Task")
+
+def test_color_by_benchmark_is_not_supported_in_efficiency_chart():
+    dataframe = get_analysis_df([make_result()])
+    figure = create_performance_vs_resource_plot(
+        dataframe,
+        resource_metric="Total tokens",
+        color_by="Benchmark",  # type: ignore[arg-type]
+    )
+
+    assert len(figure.layout.annotations) == 1
+    assert "Color dimension not available" in figure.layout.annotations[0].text
+
+
+def test_empty_and_fully_invalid_resource_chart_data_are_graceful():
+    empty = create_performance_vs_resource_plot(pd.DataFrame(), resource_metric="Total tokens")
     invalid_df = get_analysis_df([make_result(total_tokens=0)])
-    invalid = create_score_vs_tokens_plot(invalid_df, token_metric="Total Tokens Per Task")
+    invalid = create_performance_vs_resource_plot(invalid_df, resource_metric="Total tokens")
 
     assert isinstance(empty, go.Figure)
     assert isinstance(invalid, go.Figure)
@@ -177,9 +340,7 @@ def test_palette_lookup_new_palettes_fallback_and_copy():
     assert "#000000" not in COLOR_PALETTES["Citrus"]
 
 
-def test_cost_and_token_scatter_labels_toggle_consistently():
-    from src.charts import create_score_vs_cost_plot
-
+def test_cost_and_efficiency_scatter_labels_toggle_consistently():
     cost_df = pd.DataFrame(
         {
             "Benchmark": ["Benchmark A"],
@@ -190,52 +351,43 @@ def test_cost_and_token_scatter_labels_toggle_consistently():
             "Label": ["model-a<br>harness-a"],
         }
     )
-    token_df = get_analysis_df([make_result()])
+    efficiency_df = get_analysis_df([make_result()])
 
     cost_without = create_score_vs_cost_plot(cost_df, "Benchmark A", show_labels=False)
     cost_with = create_score_vs_cost_plot(cost_df, "Benchmark A", show_labels=True)
-    token_without = create_score_vs_tokens_plot(token_df, show_labels=False, show_pareto_frontier=False)
-    token_with = create_score_vs_tokens_plot(token_df, show_labels=True, show_pareto_frontier=False)
+    efficiency_without = create_performance_vs_resource_plot(
+        efficiency_df,
+        show_labels=False,
+        show_pareto_frontier=False,
+    )
+    efficiency_with = create_performance_vs_resource_plot(
+        efficiency_df,
+        show_labels=True,
+        show_pareto_frontier=False,
+    )
 
     assert cost_without.data[0].mode == "markers"
     assert cost_with.data[0].mode == "markers+text"
-    assert list(cost_with.data[0].text) == ["model-a<br>harness-a"]
-    assert token_without.data[0].mode == "markers"
-    assert token_with.data[0].mode == "markers+text"
-    assert list(token_with.data[0].text) == ["model-a / harness-a"]
+    assert efficiency_without.data[0].mode == "markers"
+    assert efficiency_with.data[0].mode == "markers+text"
     assert cost_without.data[0].hovertemplate == cost_with.data[0].hovertemplate
-    assert token_without.data[0].hovertemplate == token_with.data[0].hovertemplate
-
-
-def test_label_toggle_handles_empty_data():
-    from src.charts import create_score_vs_cost_plot
+    assert efficiency_without.data[0].hovertemplate == efficiency_with.data[0].hovertemplate
 
-    cost = create_score_vs_cost_plot(pd.DataFrame(), "Benchmark A", show_labels=True)
-    tokens = create_score_vs_tokens_plot(pd.DataFrame(), show_labels=True)
+def test_efficiency_figure_uses_responsive_autosizing_without_fixed_width():
+    dataframe = get_analysis_df([make_result()])
+    figure = create_performance_vs_resource_plot(
+        dataframe,
+        resource_metric="Total tokens",
+    )
 
-    assert isinstance(cost, go.Figure)
-    assert isinstance(tokens, go.Figure)
-    assert len(cost.layout.annotations) == 1
-    assert len(tokens.layout.annotations) == 1
+    assert figure.layout.autosize is True
+    assert figure.layout.width is None
+    assert figure.layout.height is None
 
 
-def test_score_vs_tokens_plot_adds_capability_guide_lines():
-    dataframe = pd.DataFrame(
-        {
-            "Benchmark": ["bench"],
-            "Model": ["model"],
-            "Harness": ["harness"],
-            "Run Label": ["model / harness"],
-            "Score (%)": [75.0],
-            "Tokens Per Solved Task": [1000.0],
-        }
-    )
-
-    figure = create_score_vs_tokens_plot(dataframe, show_pareto_frontier=False)
+def test_shared_plot_container_has_minimum_height_and_efficiency_tab_refresh():
+    app_source = (Path(__file__).parents[1] / "app.py").read_text()
 
-    horizontal_lines = [
-        shape
-        for shape in figure.layout.shapes
-        if shape.type == "line" and shape.y0 == shape.y1
-    ]
-    assert {shape.y0 for shape in horizontal_lines} == {70.0, 80.0}
+    assert "RESPONSIVE_PLOT_MIN_HEIGHT_PX = 420" in app_source
+    assert "min-height: {RESPONSIVE_PLOT_MIN_HEIGHT_PX}px" in app_source
+    assert "efficiency_tab.select(" in app_source