GBOED method

.cache/known_methods_snapshot.json

@@ -125,6 +125,18 @@
         "levenberg-marquardt",
         "gradient_descent"
       ]
+    },
+    "gboed": {
+      "abbreviation": "GBOED",
+      "Method": "Goal-oriented Bayesian Optimal Experimental Design",
+      "parallelism": "parallel-interacting",
+      "update_type": "general",
+      "method_goal": "uq",
+      "emulator_use": "within-optimize",
+      "aliases": [
+        "gboed",
+        "boed"
+      ]
     }
   },
   "observed_methods": [

.claude/skills/leaderboard-manager/references/manage-display.md

@@ -25,9 +25,10 @@ next time someone edits the file.
    whatever `selected_benchmark` is currently chosen.
 3. **Controls — always visible**, not collapsed. Look for `st.subheader("Scoring &
    Target Controls")`: target-level radio, scoring-mode radio (+ blend-weight slider
-   when "Custom Blend" is selected), and the "Methods to display in charts" multiselect.
-   These used to be wrapped in `st.expander(..., expanded=False)`; that was removed so
-   users don't have to open a dropdown to see or change the target level.
+   when "Custom Blend" is selected), and the "Methods to display in charts" pills
+   selector (see "Methods selector" below). These used to be wrapped in
+   `st.expander(..., expanded=False)`; that was removed so users don't have to open a
+   dropdown to see or change the target level.
 4. **Charts** — main "Mean Forward Model Runs vs Ensemble Size" chart, then (UQ only)
    the "Mean Iterations for Coverage" chart, then (if `show_failure_panel=True`) the
    failure-rate bar chart.
@@ -130,6 +131,28 @@ non-blend mode. It lives in the always-visible controls section, not behind an e
 
 ---
 
+## Methods selector
+
+The "Methods to display in charts" control (grep for that string in `leaderboard.py`) uses
+`st.pills(..., selection_mode="multi")`, not `st.multiselect` or `st.selectbox`. Prefer
+`st.pills` in multi mode whenever the goal is "let users see and toggle all options at a
+glance" — every option renders as a clickable button, so nothing is hidden behind a
+dropdown the way `st.multiselect`'s collapsed chip list is. `selection_mode` defaults to
+`"single"`, so it must be passed explicitly to allow more than one method selected at once;
+in multi mode `st.pills` returns a list, same shape as `st.multiselect`. It was added in
+Streamlit 1.40 — the project's pinned `streamlit` (currently 1.57.0 in the `.venv`) already
+covers it.
+
+It reads/writes the same `key=k_methods` session-state slot the old multiselect used, so
+the surrounding logic is unaffected by the widget swap: the default-selection (top 5 by
+rank) and stale-selection-pruning code sets `st.session_state[k_methods]` *before* the
+widget call (search for `st.session_state[k_methods] = valid_saved if valid_saved else
+default_methods`), and the widget itself is called with `key=k_methods` and no `default=`
+argument. If you add a new always-visible, multi-choice control elsewhere in the app,
+follow this same pattern rather than reaching for `st.multiselect` by default.
+
+---
+
 ## Leaderboard line chart
 
 The chart that appears above the table ("Mean Forward Model Runs vs Ensemble Size") is
@@ -305,8 +328,8 @@ This encodes two *separate* requirements that are easy to conflate:
 
 When calling `_method_color()`, compute `present_abbrevs` from the actual DataFrame(s)
 plotted in that chart section (e.g. `all_ens_combos["abbreviation"].unique()`), **not**
-from the global "Methods to display in charts" multiselect. A method can be selected in
-the multiselect but have no data for the current benchmark/target combination — including
+from the global "Methods to display in charts" pills selector. A method can be selected
+there but have no data for the current benchmark/target combination — including
 it in the legend anyway would be misleading. Each chart section (main chart, UQ iters
 chart, failure-rate chart) computes and passes its own `present_abbrevs`, since the set
 of methods with data can differ section to section (e.g. a method might have forward-run
@@ -361,7 +384,7 @@ new Altair chart in the app:
    `leaderboard_df`-emptiness gate (main chart) or have its own independent emptiness
    check (UQ iters chart, failure panel) — see the gotcha under "Page layout" above.
 4. If the chart colors by `abbreviation`: use `_method_color(present_abbrevs)` computed
-   from that section's actual plotted data, not the global multiselect.
+   from that section's actual plotted data, not the global pills selector.
 5. Restart or clear Streamlit cache to pick up Python changes (code changes take effect on
    restart; cache only matters for data changes).
 6. Smoke-test with a benchmark/target combination where every run fails (all-DNF) to

CLAUDE.md

@@ -61,21 +61,11 @@ calibration_benchmark/
 │   ├── *.nc                     Kalman results (TEKI, ETKI, IEKF)
 │   ├── bayesian/                ABC + HM results
 │   ├── UKI_results/             UKI results
-│   ├── adam_results/            ADAM gradient optimizer results
-│   │                            filenames follow `leaderboard_adam_<benchmark-tag>_<date>.nc`;
-│   │                            benchmark tags: `l63` → L63, `l96_const-force` → L96,
-│   │                            `l96_vec-force` → L96_SPATIAL_FORCING (no L96_NN_FORCING yet)
-│   ├── levenberg_marquardt_results/  LM gradient optimizer results
-│   │                            filenames follow `leaderboard_lm_<benchmark-tag>_<date>.nc`;
-│   │                            same benchmark tags as adam_results/ (no L96_NN_FORCING yet)
+│   ├── adam_results/            ADAM gradient optimizer results (per-benchmark files)
+│   ├── levenberg_marquardt_results/  LM gradient optimizer results (per-benchmark files)
 │   ├── ces-eki-dmc_results/     CES-EKI-DMC ensemble-results files (UQ source)
-│   │                            filenames follow `ces-eki-dmc_<benchmark-tag>_ensemble_results_<date>[_minimal].nc`;
-│   │                            benchmark tags: `l63` → L63, `l96` (no suffix) → L96,
-│   │                            `l96_nn_forcing` → L96_NN_FORCING, `l96_spatial_forcing` → L96_SPATIAL_FORCING
+│   ├── gboed-uq_results/        GBOED ensemble-results files (UQ source)
 │   └── gnki-uq_results/         IEKF (a.k.a GNKI) ensemble-results files (UQ source)
-│                                filenames follow `leaderboard_gnki_<benchmark-tag>_<date>[_minimal].nc`;
-│                                benchmark tags: `l63` → L63, `l96_const-force` → L96,
-│                                `l96_flux-force` → L96_NN_FORCING, `l96_vec-force` → L96_SPATIAL_FORCING
 ├── examples/                    lorenz_demo.ipynb + lorenz.py (reference, not app code)
 ├── From_Rob_6-10/               Raw collaborator data drop — NOT read by the app
 ├── .cache/                      known_methods_snapshot.json (auto-generated, safe to delete)
@@ -191,6 +181,7 @@ A quick taxonomy tree is rendered on the home page (`src/streamlit_app.py`).
 | `ces-eki-dmc` | CES-EKI-DMC | parallel-interacting | kalman | uq | after-optimize | — |
 | `adam` | ADAM | serial | gradient | optimization | none | — |
 | `lm` | LM | serial | gradient | optimization | none | gradient_descent |
+| `gboed` | GBOED | parallel-interacting | general | uq | within-optimize | boed |
 
 ## How to extend
 

data/gboed-uq_results/boed_l63_ensemble_results_2026-07-30_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52616c824f068f6de1eb9ccf67f56a1000b56d1cd54c911daa817df4b600e26b
+size 673057

data/gboed-uq_results/boed_l96_const-force_2026-07-30_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84062bc4afda563eba840efcf06c70143037660e99f258d6ecba84538a308b78
+size 809857

data/gboed-uq_results/boed_l96_vec-force_2026-08-07_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1a3cd33db2cef7d81e31cf0a679e93955f3c851153eefbf2c719061b60330b9
+size 618337

src/common/leaderboard.py

@@ -58,13 +58,20 @@ _UPDATE_TYPE_ORDER: dict[str, int] = {
     "general": 2,
 }
 
+# Failure-rate threshold (%) below which a method's runs at a given target are
+# considered reliable. Shared by the suitability table and the default
+# "Methods to display in charts" selection so both surfaces agree on what
+# counts as trustworthy — a method that only reaches a fast Score on the rare
+# seed that didn't fail shouldn't outrank a slower method that never fails.
+_RELIABLE_FAILURE_THRESHOLD = 20.0
+
 
 def _render_suitability_table(
     store: pd.DataFrame,
     target_col: str,
     suitability_target: float,
     benchmark_dims: dict[str, tuple[int, int, int]] | None = None,
-    failure_threshold: float = 20.0,
+    failure_threshold: float = _RELIABLE_FAILURE_THRESHOLD,
     ratio_threshold: float = 3.0,
 ) -> None:
     """Render the method × benchmark suitability grid above the leaderboard controls."""
@@ -279,13 +286,6 @@ def render_leaderboard(
     fwdruns_weight  = current_fwdruns_weight_percent / 100.0
     ensemble_weight = 1.0 - fwdruns_weight
 
-    # Available methods for the current benchmark selection; used to populate the
-    # multiselect and to prune any stale saved selections when the benchmark changes.
-    available_methods = sorted(filtered["abbreviation"].dropna().unique().tolist())
-    saved_methods     = st.session_state.get(k_methods, available_methods)
-    valid_saved       = [m for m in saved_methods if m in available_methods]
-    st.session_state[k_methods] = valid_saved if valid_saved else available_methods
-
     def build_scored_table(input_df: pd.DataFrame, add_rank: bool = True) -> pd.DataFrame:
         ranking_source = input_df[input_df[target_str_col] == selected_target]
         if ranking_source.empty:
@@ -421,6 +421,36 @@ def render_leaderboard(
 
     leaderboard_df = build_scored_table(filtered, add_rank=True)
 
+    # Methods available for the current benchmark; used to populate the pills
+    # selector and to prune stale saved selections when the benchmark changes. The
+    # default selection (first load, or once a prior selection becomes entirely
+    # invalid) is the top 5 methods, not every method — the "Methods to display in
+    # charts" pills selector lets a user opt into seeing more.
+    #
+    # Ranked primarily by reliability (failure rate below _RELIABLE_FAILURE_THRESHOLD)
+    # and only then by performance Rank within each reliability group. Ranking by
+    # Rank/Score alone would let a method that only succeeds on a rare seed (and is
+    # fast on that seed) outrank a method that reliably succeeds but is slower —
+    # e.g. on the UQ leaderboard, a mostly-failing method can post a great mean
+    # budget from its few converged seeds while a method with zero failures scores
+    # worse and gets dropped from the default view.
+    available_methods = sorted(filtered["abbreviation"].dropna().unique().tolist())
+    if not leaderboard_df.empty and leaderboard_df["Rank"].notna().any():
+        ranked_methods = leaderboard_df.dropna(subset=["Rank"]).copy()
+        ranked_methods["_unreliable"] = (
+            ranked_methods["Mean Failure Rate (%)"].fillna(0.0) >= _RELIABLE_FAILURE_THRESHOLD
+        )
+        default_methods = (
+            ranked_methods.sort_values(["_unreliable", "Rank"])["abbreviation"].head(5).tolist()
+        )
+    else:
+        # All runs failed at this target (or no data) — show every method so the
+        # all-DNF warning/chart-suppression path still has something to work with.
+        default_methods = available_methods
+    saved_methods = st.session_state.get(k_methods, default_methods)
+    valid_saved   = [m for m in saved_methods if m in available_methods]
+    st.session_state[k_methods] = valid_saved if valid_saved else default_methods
+
     # Attach the four taxonomy tags (constant per abbreviation, so this is a
     # plain lookup merge rather than a groupby key threaded through every
     # aggregation above).
@@ -485,10 +515,12 @@ def render_leaderboard(
                 ),
             )
 
-    st.multiselect(
+    st.pills(
         "Methods to display in charts",
         options=available_methods,
+        selection_mode="multi",
         key=k_methods,
+        help="Defaults to the top 5 methods by current rank — click to add or remove.",
     )
 
     selected_methods = st.session_state.get(k_methods, available_methods)
@@ -498,6 +530,52 @@ def render_leaderboard(
     st.divider()
 
     # --- Charts (rendered above the leaderboard table, below the controls) ---
+    # Failure panel — shown first so failures are visible before the budget/
+    # iterations charts below. Rendered regardless of whether the scored table
+    # has rows (own emptiness check on failure_source).
+    if show_failure_panel:
+        failure_source = filtered[filtered[target_str_col] == selected_target]
+        failure_source = failure_source[failure_source["abbreviation"].isin(selected_methods)]
+        if not failure_source.empty:
+            failure_df = failure_source.groupby(
+                ["abbreviation", "ensemble_size"], as_index=False
+            ).agg(mean_failure_rate=("failure_rate", "mean"))
+            failure_df = failure_df.sort_values("ensemble_size")
+
+            st.subheader(f"Failure Rate of Hitting Target {selected_target}")
+            ens_ticks_fail = sorted(failure_df["ensemble_size"].unique().tolist())
+            failure_chart = (
+                alt.Chart(failure_df)
+                .mark_bar()
+                .encode(
+                    x=alt.X(
+                        "ensemble_size:O",
+                        title="Ensemble Size",
+                        sort=[str(e) for e in ens_ticks_fail],
+                        axis=alt.Axis(labelAngle=0),
+                    ),
+                    xOffset=alt.XOffset("abbreviation:N"),
+                    y=alt.Y(
+                        "mean_failure_rate:Q",
+                        title="Failure Rate (%)",
+                        scale=alt.Scale(domain=[0, 100]),
+                    ),
+                    color=_method_color(failure_df["abbreviation"].unique().tolist()),
+                    tooltip=[
+                        alt.Tooltip("abbreviation:N", title="Method"),
+                        alt.Tooltip("ensemble_size:O", title="Ensemble Size"),
+                        alt.Tooltip("mean_failure_rate:Q", format=".1f", title="Failure Rate (%)"),
+                    ],
+                )
+            )
+            ceiling_line = (
+                alt.Chart(alt.Data(values=[{}]))
+                .mark_rule(color="grey", strokeDash=[4, 4])
+                .encode(y=alt.datum(100))
+            )
+            st.altair_chart(failure_chart + ceiling_line, use_container_width=True)
+            st.divider()
+
     if not leaderboard_df.empty:
         st.subheader("Mean Forward Model Runs vs Ensemble Size")
         chart_source = filtered[filtered[target_str_col] == selected_target]
@@ -589,6 +667,72 @@ def render_leaderboard(
 
         if chart_layers:
             st.altair_chart(alt.layer(*chart_layers), use_container_width=True)
+            st.caption(
+                "Note: plotted means here and in the charts below are averaged over "
+                "successful seeds only — runs that never reached the target are excluded. "
+                "An ✕ at zero marks ensemble sizes where every seed failed."
+                + (
+                    " Failure frequency is shown in the failure-rate chart further down."
+                    if show_failure_panel
+                    else ""
+                )
+            )
+
+        # Mean-iterations section for the Optimization board: n_iterations =
+        # metric / ensemble_size, since every registered method's forward-model
+        # call count scales as ensemble_size (or restart count) per outer-loop
+        # iteration — see method_registry.py taxonomy. The UQ board instead
+        # renders its own iterations chart below from real k_iter data via
+        # budget_store, so this section only applies when none is supplied.
+        if budget_store is None and not all_ens_combos.empty:
+            iters_chart_df = chart_df.assign(
+                mean_iterations=lambda d: d["mean_forward_runs"] / d["ensemble_size"]
+            )
+            iters_fail_df = fail_df.assign(mean_iterations=0.0)
+
+            st.subheader("Mean Iterations to Reach Target vs Ensemble Size")
+            opt_iters_layers = []
+            if not iters_chart_df.empty:
+                opt_iters_layers.append(
+                    alt.Chart(iters_chart_df)
+                    .mark_line(point=True)
+                    .encode(
+                        x=alt.X(
+                            "ensemble_size:Q",
+                            title="Ensemble Size",
+                            axis=alt.Axis(values=ens_ticks, format="d"),
+                        ),
+                        y=alt.Y("mean_iterations:Q", title="Mean Iterations"),
+                        color=main_color,
+                        tooltip=["abbreviation", "ensemble_size", alt.Tooltip("mean_iterations:Q", format=".2f")],
+                    )
+                )
+            if not iters_fail_df.empty:
+                y_iters_opt = (
+                    alt.Y("mean_iterations:Q", title="Mean Iterations", scale=alt.Scale(domain=[0, 1]))
+                    if all_failed
+                    else alt.Y("mean_iterations:Q", title="Mean Iterations")
+                )
+                opt_iters_layers.append(
+                    alt.Chart(iters_fail_df)
+                    .mark_point(shape="cross", angle=45, size=200, filled=True, opacity=1.0)
+                    .encode(
+                        x=alt.X(
+                            "ensemble_size:Q",
+                            title="Ensemble Size",
+                            axis=alt.Axis(values=ens_ticks, format="d"),
+                        ),
+                        y=y_iters_opt,
+                        color=main_color,
+                        tooltip=[
+                            alt.Tooltip("abbreviation:N", title="Method"),
+                            alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
+                            alt.Tooltip("mean_iterations:Q", title="Value (all failed)"),
+                        ],
+                    )
+                )
+            if opt_iters_layers:
+                st.altair_chart(alt.layer(*opt_iters_layers), use_container_width=True)
 
     # Mean-iterations-for-coverage section (UQ only, when budget_store provided)
     if budget_store is not None and not budget_store.empty:
@@ -664,49 +808,6 @@ def render_leaderboard(
             if iters_layers:
                 st.altair_chart(alt.layer(*iters_layers), use_container_width=True)
 
-    # Failure panel — rendered regardless of whether the scored table has rows
-    if show_failure_panel:
-        failure_source = filtered[filtered[target_str_col] == selected_target]
-        failure_source = failure_source[failure_source["abbreviation"].isin(selected_methods)]
-        if not failure_source.empty:
-            failure_df = failure_source.groupby(
-                ["abbreviation", "ensemble_size"], as_index=False
-            ).agg(mean_failure_rate=("failure_rate", "mean"))
-            failure_df = failure_df.sort_values("ensemble_size")
-
-            st.subheader(f"Failure Rate of Hitting Target {selected_target}")
-            ens_ticks_fail = sorted(failure_df["ensemble_size"].unique().tolist())
-            failure_chart = (
-                alt.Chart(failure_df)
-                .mark_bar()
-                .encode(
-                    x=alt.X(
-                        "ensemble_size:O",
-                        title="Ensemble Size",
-                        sort=[str(e) for e in ens_ticks_fail],
-                        axis=alt.Axis(labelAngle=0),
-                    ),
-                    xOffset=alt.XOffset("abbreviation:N"),
-                    y=alt.Y(
-                        "mean_failure_rate:Q",
-                        title="Failure Rate (%)",
-                        scale=alt.Scale(domain=[0, 100]),
-                    ),
-                    color=_method_color(failure_df["abbreviation"].unique().tolist()),
-                    tooltip=[
-                        alt.Tooltip("abbreviation:N", title="Method"),
-                        alt.Tooltip("ensemble_size:O", title="Ensemble Size"),
-                        alt.Tooltip("mean_failure_rate:Q", format=".1f", title="Failure Rate (%)"),
-                    ],
-                )
-            )
-            ceiling_line = (
-                alt.Chart(alt.Data(values=[{}]))
-                .mark_rule(color="grey", strokeDash=[4, 4])
-                .encode(y=alt.datum(100))
-            )
-            st.altair_chart(failure_chart + ceiling_line, use_container_width=True)
-
     st.divider()
 
     # --- Leaderboard table (rendered below the charts) ---

src/common/method_registry.py

@@ -134,6 +134,15 @@ KNOWN_METHODS = {
         "emulator_use": "none",
         "aliases": ["lm", "levenberg_marquardt", "levenberg-marquardt", "gradient_descent"],
     },
+    "gboed": {
+        "abbreviation": "GBOED",
+        "Method": "Goal-oriented Bayesian Optimal Experimental Design",
+        "parallelism": "parallel-interacting",
+        "update_type": "general",
+        "method_goal": "uq",
+        "emulator_use": "within-optimize",
+        "aliases": ["gboed", "boed"],
+    },
 }
 
 
@@ -142,6 +151,7 @@ KNOWN_METHODS = {
 _METHOD_PALETTE = [
     "#4c78a8", "#f58518", "#e45756", "#72b7b2", "#54a24b",
     "#eeca3b", "#b279a2", "#ff9da6", "#9d755d", "#bab0ac",
+    "#5254a3", "#8ca252",
 ]
 
 # Stable abbreviation → hex color mapping.  Import this wherever Altair charts are built

src/data_store.py

@@ -93,6 +93,7 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l63_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l63_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l63_ensemble_results_2026-07-20_minimal.nc"),
+        ("gboed", "gboed-uq_results/boed_l63_ensemble_results_2026-07-30_minimal.nc"),
     ],
     "L96":                [
         ("ces-eki-dmc", "ces-eki-dmc_results/ces-eki-dmc_l96_ensemble_results_2026-06-15_minimal.nc"),
@@ -100,6 +101,7 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l96_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l96_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l96_const-force_2026-07-20_minimal.nc"),
+        ("gboed", "gboed-uq_results/boed_l96_const-force_2026-07-30_minimal.nc"),
     ],
     "L96_NN_FORCING":     [
         ("ces-eki-dmc", "ces-eki-dmc_results/ces-eki-dmc_l96_nn_forcing_ensemble_results_2026-06-15_minimal.nc"),
@@ -114,6 +116,7 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l96_spatial_forcing_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l96_spatial_forcing_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l96_vec-force_2026-07-22_minimal.nc"),
+        ("gboed", "gboed-uq_results/boed_l96_vec-force_2026-08-07_minimal.nc"),
     ],
 }
 

src/pages/MethodDetails.py

@@ -94,6 +94,11 @@ method_meta = {
         "url": "https://doi.org/10.1090/qam/10666",
         "summary": "Levenberg-Marquardt — damped least-squares algorithm that interpolates between gradient descent and Gauss-Newton steps for efficient nonlinear least-squares minimization.",
     },
+    "GBOED": {
+        "citation": "Holthuijzen et al. 2026",
+        "url": "https://arxiv.org/abs/2508.13071",
+        "summary": "Goal-oriented Bayesian Optimal Experimental Design — selects each batch of forward-model evaluations by maximizing an expected-information-gain criterion targeted at the quantity of interest, refitting the surrogate used by the criterion at every iteration.",
+    },
 }
 
 # Selection UI (defaults to query param if valid)

src/streamlit_app.py

@@ -1,6 +1,17 @@
-import streamlit as st
+import sys
 from pathlib import Path
 
+import pandas as pd
+import streamlit as st
+
+try:
+    from common.method_registry import KNOWN_METHODS
+    from common.leaderboard import _UPDATE_TYPE_ORDER
+except ModuleNotFoundError:
+    sys.path.append(str(Path(__file__).resolve().parent))
+    from common.method_registry import KNOWN_METHODS
+    from common.leaderboard import _UPDATE_TYPE_ORDER
+
 st.set_page_config(page_title="Calibration Benchmark", page_icon="🏠", layout="wide")
 
 # Sidebar navigation
@@ -88,38 +99,51 @@ st.markdown(
     "a surrogate model. See the **📘 Methods** page for citations and per-method "
     "performance charts."
 )
-st.markdown(
-    """
-- **Parallelism** — how the search explores parameter space
-    - **Serial** — `ADAM`, `LM` — a single point estimate advanced step by step.
-    - **Parallel-independent** — `ABC`, `HM` — a population of candidates updated
-      with no coupling between members (accepted samples / per-wave resampling).
-    - **Parallel-interacting** — `TEKI`, `ETKI`, `IEKF`, `UKI`, `CES-EKI-DMC`, `CES-EKI-CONST`,
-      `CES-IEKF-CONST` — an ensemble whose members are coupled through a shared update
-      each iteration.
-- **Update type** — the mechanism driving each update step
-    - **Gradient** — `ADAM`, `LM` — follow the loss gradient (or a Gauss-Newton
-      approximation of it) directly.
-    - **Kalman** — `TEKI`, `ETKI`, `IEKF`, `UKI`, `CES-EKI-DMC`, `CES-EKI-CONST`,
-      `CES-IEKF-CONST` — a (possibly linearized or unscented) Kalman-style ensemble update.
-    - **General** — `ABC`, `HM` — neither gradient- nor Kalman-based (rejection
-      sampling, implausibility cuts).
-- **Method goal** — what the method is built to report
-    - **Optimization** — `TEKI`, `ETKI`, `UKI`, `ADAM`, `LM` — a single best-fit
-      parameter estimate.
-    - **UQ** — `IEKF`, `ABC`, `HM`, `CES-EKI-DMC`, `CES-EKI-CONST`, `CES-IEKF-CONST` — the
-      full posterior / parameter uncertainty. Can still be scored on the Optimization
-      leaderboard, but tends to be less competitive there since it's not optimizing for
-      speed-to-target.
-- **Emulator use** — when/whether a surrogate model of the forward model is used
-    - **None** — `TEKI`, `ETKI`, `IEKF`, `UKI`, `ADAM`, `LM`, `ABC` — samples/evaluates
-      the true forward model throughout.
-    - **Within-optimize** — `HM` — refits a surrogate at each iteration (wave) of the
-      search itself.
-    - **After-optimize** — `CES-EKI-DMC`, `CES-EKI-CONST`, `CES-IEKF-CONST` — fits a
-      surrogate (e.g. a GP) once, after calibration finishes, and samples the posterior
-      through it.
-"""
+_taxonomy_rows = [
+    {
+        "Algorithm": info["abbreviation"],
+        "Method Goal": info["method_goal"],
+        "Update Type": info["update_type"],
+        "Parallelism": info["parallelism"],
+        "Emulator Use": info["emulator_use"],
+        "_update_type_order": _UPDATE_TYPE_ORDER.get(info["update_type"], 99),
+    }
+    for info in KNOWN_METHODS.values()
+]
+_taxonomy_df = (
+    pd.DataFrame(_taxonomy_rows)
+    .sort_values(["_update_type_order", "Algorithm"])
+    .drop(columns="_update_type_order")
+)
+
+_UPDATE_TYPE_ROW_COLOR = {
+    "kalman": "#d9f2e6",    # pastel green
+    "gradient": "#dbe9fa",  # pastel blue
+    "general": "#fde2c8",   # pastel orange
+}
+
+
+def _style_taxonomy_rows(df: pd.DataFrame) -> pd.DataFrame:
+    result = pd.DataFrame("", index=df.index, columns=df.columns)
+    for row in df.index:
+        bg = _UPDATE_TYPE_ROW_COLOR.get(df.loc[row, "Update Type"], "")
+        if bg:
+            result.loc[row, :] = f"background-color: {bg}; color: #212529"
+    return result
+
+
+st.dataframe(
+    _taxonomy_df.style.apply(_style_taxonomy_rows, axis=None),
+    hide_index=True,
+    use_container_width=True,
+    height=int((len(_taxonomy_df) + 1) * 35.2 + 3),
+    column_config={
+        "Algorithm": st.column_config.TextColumn("Algorithm"),
+        "Method Goal": st.column_config.TextColumn("Method Goal"),
+        "Update Type": st.column_config.TextColumn("Update Type"),
+        "Parallelism": st.column_config.TextColumn("Parallelism"),
+        "Emulator Use": st.column_config.TextColumn("Emulator Use"),
+    },
 )
 st.caption(
     "Note: Kalman methods are Bayesian in spirit too (they're approximate Gaussian "