diff --git a/src/app/api/citable/route.ts b/src/app/api/citable/route.ts
index 03d6b55c..e1283e1e 100644
--- a/src/app/api/citable/route.ts
+++ b/src/app/api/citable/route.ts
@@ -2,12 +2,7 @@ import { NextResponse } from "next/server";
 import { getBenchmarks } from "@/data/benchmarks";
 import { SITE } from "@/data/site";
 import { AllBenchmarksDraftError } from "@/lib/spec";
-import {
-  fieldValue,
-  headlineSentence,
-  isInsufficient,
-  leader,
-} from "@/lib/citation";
+import { citeBundle, fieldValue, leader, headlineSentence } from "@/lib/citation";
 import { clientKey, rateLimit, tooManyRequests } from "@/lib/rate-limit";
 
 export const runtime = "nodejs";
@@ -52,21 +47,29 @@ export async function GET(req: Request) {
     throw err;
   }
   const data = benches.map((b) => {
-    const insufficient = isInsufficient(b);
-    const top = insufficient ? null : leader(b);
-    const status: "live" | "draft" | "insufficient" = insufficient
-      ? "insufficient"
-      : b.status;
+    const top = leader(b);
+    // Insufficient aggregate: explicitly null the value + leader so
+    // downstream LLM agents and journalists do not quote a number drawn
+    // from an undersized field. The headline sentence is rewritten to
+    // "insufficient data" by headlineSentence above.
+    const insufficient = b.dataConfidence === "insufficient";
     return {
       slug: b.slug,
       title: b.title,
       category: b.category,
       metric: b.metric,
       unit: b.unit,
-      status,
+      status: b.status,
       value: insufficient ? null : fieldValue(b),
-      leader: top ? { name: top.name, slug: top.slug, value: top.value } : null,
-      sampleSize: insufficient ? 0 : b.sampleSize,
+      leader:
+        insufficient
+          ? null
+          : top
+            ? { name: top.name, slug: top.slug, value: top.value }
+            : null,
+      sampleSize: b.sampleSize,
+      expectedN: b.expectedN,
+      dataConfidence: b.dataConfidence,
       asOf: b.lastRunAt,
       headline: headlineSentence(b),
       url: `${SITE.url}/benchmarks/${b.slug}`,
@@ -74,6 +77,7 @@ export async function GET(req: Request) {
       ogImage: `${SITE.url}/api/og/${b.slug}`,
       source: b.source,
       license: "CC-BY-4.0",
+      cite: citeBundle(b, SITE.url),
     };
   });
 
diff --git a/src/app/api/stat/[slug]/route.ts b/src/app/api/stat/[slug]/route.ts
index 14d6c7d7..b53c5767 100644
--- a/src/app/api/stat/[slug]/route.ts
+++ b/src/app/api/stat/[slug]/route.ts
@@ -3,9 +3,9 @@ import { getBenchmark } from "@/data/benchmarks";
 import { SITE } from "@/data/site";
 import {
   citationQuote,
+  citeBundle,
   fieldValue,
   headlineSentence,
-  isInsufficient,
   leader,
   sparklineFor,
 } from "@/lib/citation";
@@ -20,16 +20,6 @@ export const revalidate = 60;
  * Single benchmark as a citable atomic unit. Designed to fit into one
  * agent tool call: ranked providers, sparkline, methodology link,
  * pre-formatted attribution string, and stable citation URL.
- *
- * Status field semantics:
- *   "live"          - usable measurement, leader / value populated.
- *   "draft"         - spec author has not published (editorialStatus draft).
- *   "insufficient"  - editorially live but the harness has no usable
- *                     sample yet (every provider p50 = 0, or runtime
- *                     status flipped to draft mid-cycle). value, leader
- *                     and rankings p50 are nulled so a consumer cannot
- *                     accidentally cite a fabricated winner. The shape
- *                     of the response is preserved.
  */
 export async function GET(
   req: Request,
@@ -53,46 +43,8 @@ export async function GET(
     );
   }
 
-  const insufficient = isInsufficient(b);
-  const top = insufficient ? null : leader(b);
-  const value = insufficient ? null : fieldValue(b);
-  // Status surfaced to consumers: "insufficient" wins over the raw
-  // runtime "live" flag when the predicate fires, so /api/stat stops
-  // claiming live data for a bench whose harness has nothing to show.
-  const status: "live" | "draft" | "insufficient" = insufficient
-    ? "insufficient"
-    : b.status;
-
-  // Rankings: when insufficient we still return one entry per provider
-  // (shape preserved for any consumer that diff-tracks the provider set)
-  // but every p50 is nulled to drive home that no comparison is possible.
-  const rankings = insufficient
-    ? b.results.map((r) => ({
-        name: r.name,
-        slug: r.slug,
-        type: r.type ?? null,
-        layer: r.layer ?? null,
-        tag: r.tag ?? null,
-        ms: { p50: null, p90: null, p99: null, mean: null },
-        successRate: r.successRate,
-        sampleSize: r.sampleSize ?? null,
-      }))
-    : b.results
-        .filter((r) => r.ms.p50 > 0)
-        .sort((a, c) =>
-          b.higherIsBetter ? c.ms.p50 - a.ms.p50 : a.ms.p50 - c.ms.p50,
-        )
-        .map((r) => ({
-          name: r.name,
-          slug: r.slug,
-          type: r.type ?? null,
-          layer: r.layer ?? null,
-          tag: r.tag ?? null,
-          ms: r.ms,
-          successRate: r.successRate,
-          sampleSize: r.sampleSize,
-        }));
-
+  const top = leader(b);
+  const insufficient = b.dataConfidence === "insufficient";
   const payload = {
     slug: b.slug,
     title: b.title,
@@ -100,27 +52,44 @@ export async function GET(
     category: b.category,
     metric: b.metric,
     unit: b.unit,
-    status,
+    status: b.status,
     higherIsBetter: b.higherIsBetter,
-    value,
-    leader: top,
-    rankings,
-    sparkline: insufficient ? [] : sparklineFor(b, top?.slug),
-    sampleSize: insufficient ? 0 : b.sampleSize,
+    // Aggregate is "insufficient" (median per-provider sample health
+    // below 10 percent of expected_n): refuse to publish a value or
+    // leader; the headline is rewritten by headlineSentence so the
+    // agent / journalist reads "insufficient data" instead of quoting
+    // a number drawn from undersized samples.
+    value: insufficient ? null : fieldValue(b),
+    leader: insufficient ? null : top,
+    rankings: b.results
+      .filter((r) => r.ms.p50 > 0)
+      // Drop "insufficient" rows from the machine-readable ranking too:
+      // a row that the page hides from the leaderboard must not surface
+      // here either.
+      .filter((r) => r.dataConfidence !== "insufficient")
+      .sort((a, c) => (b.higherIsBetter ? c.ms.p50 - a.ms.p50 : a.ms.p50 - c.ms.p50))
+      .map((r) => ({
+        name: r.name,
+        slug: r.slug,
+        ms: r.ms,
+        successRate: r.successRate,
+        sampleSize: r.sampleSize,
+        sampleHealth: r.sampleHealth,
+        dataConfidence: r.dataConfidence,
+      })),
+    sparkline: sparklineFor(b, top?.slug),
+    sampleSize: b.sampleSize,
+    expectedN: b.expectedN,
+    dataConfidence: b.dataConfidence,
     asOf: b.lastRunAt,
     headline: headlineSentence(b),
     quote: citationQuote(b, SITE.url),
+    cite: citeBundle(b, SITE.url),
     pageUrl: `${SITE.url}/benchmarks/${b.slug}`,
     ogImage: `${SITE.url}/api/og/${b.slug}`,
     source: b.source,
     methodology: b.methodology,
     license: "CC-BY-4.0",
-    // Per-chain leader / worst. Empty for benches without a chain
-    // dimension. Used by the HF publisher to populate chain_leaders.
-    // Insufficient benches null both since the underlying rankings
-    // are not citable.
-    bestPerChain: insufficient ? null : (b.bestPerChain ?? null),
-    worstPerChain: insufficient ? null : (b.worstPerChain ?? null),
   };
 
   return NextResponse.json(payload, {
diff --git a/src/app/benchmarks/category/[cat]/page.tsx b/src/app/benchmarks/category/[cat]/page.tsx
new file mode 100644
index 00000000..f001cc93
--- /dev/null
+++ b/src/app/benchmarks/category/[cat]/page.tsx
@@ -0,0 +1,112 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { getBenchmarksSafe, toBenchmarkCardData } from "@/data/benchmarks";
+import { BenchmarkGrid } from "@/components/benchmark-grid";
+import { Breadcrumb } from "@/components/breadcrumb";
+import { safeJsonLd, buildItemListJsonLd } from "@/lib/jsonld";
+import { SITE } from "@/data/site";
+import { pageMetadata } from "@/lib/page-metadata";
+import { capDescription } from "@/lib/seo-text";
+import { CATEGORIES, CATEGORY_BY_SLUG } from "@/lib/categories";
+
+/**
+ * Per-category hub page. One static route per entry in `CATEGORIES` so
+ * each architectural slice (RPCs, Bridges, Blockchains, ...) has a
+ * crawlable, linkable URL. Lets external sites and internal nav deep
+ * link directly into "all Solana RPC benchmarks" instead of relying on
+ * the client-only filter that lives on `/benchmarks`.
+ *
+ * Prerendered at build time via `generateStaticParams` (closed list, no
+ * Prom calls needed). ISR refresh aligned with the main hub so a freshly
+ * added bench surfaces here on the same cadence.
+ */
+
+export const revalidate = 60;
+
+type Params = { cat: string };
+
+export async function generateStaticParams() {
+  // Closed enum, generated even when a category currently has zero live
+  // benches (e.g. Wallets at time of writing). The page-level fallback
+  // below 404s empty categories so crawlers don't index thin pages.
+  return CATEGORIES.map((c) => ({ cat: c.slug }));
+}
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<Params>;
+}): Promise<Metadata> {
+  const { cat } = await params;
+  const entry = CATEGORY_BY_SLUG.get(cat);
+  if (!entry) return {};
+  const description = capDescription(entry.description, 158);
+  return pageMetadata({
+    path: `/benchmarks/category/${entry.slug}`,
+    title: `${entry.heading}`,
+    description,
+  });
+}
+
+export default async function BenchmarkCategoryPage({
+  params,
+}: {
+  params: Promise<Params>;
+}) {
+  const { cat } = await params;
+  const entry = CATEGORY_BY_SLUG.get(cat);
+  if (!entry) notFound();
+
+  const all = await getBenchmarksSafe();
+  const benchmarks = all.filter((b) => b.category === entry.label);
+  // Empty-category guard: a category in the enum that has no live bench
+  // yet returns 404 so the crawler doesn't land on a thin page. The
+  // category still ships in `generateStaticParams` so adding the first
+  // bench to it lights up the URL without a redeploy gate.
+  if (benchmarks.length === 0) notFound();
+
+  const url = `${SITE.url}/benchmarks/category/${entry.slug}`;
+  const jsonLd = buildItemListJsonLd({
+    name: `${entry.heading} on OpenChainBench`,
+    url,
+    description: entry.description,
+    items: benchmarks.map((b) => ({
+      name: b.title,
+      url: `${SITE.url}/benchmarks/${b.slug}`,
+    })),
+    breadcrumb: [
+      { name: "Home", url: `${SITE.url}/` },
+      { name: "All benchmarks", url: `${SITE.url}/benchmarks` },
+      { name: entry.heading, url },
+    ],
+  });
+
+  return (
+    <article className="mx-auto max-w-[1400px] px-4 sm:px-6 py-12 sm:py-16">
+      <script
+        type="application/ld+json"
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+        dangerouslySetInnerHTML={{ __html: safeJsonLd(jsonLd) }}
+      />
+      <Breadcrumb
+        items={[
+          { label: "Benchmarks", href: "/benchmarks" },
+          { label: entry.heading },
+        ]}
+      />
+      <header className="mb-10 mt-4">
+        <h1 className="display text-4xl sm:text-5xl text-ink">
+          {entry.heading}
+        </h1>
+        <p className="mt-4 max-w-2xl text-base sm:text-lg text-ink-soft leading-snug">
+          {entry.description}
+        </p>
+      </header>
+      <BenchmarkGrid
+        benchmarks={benchmarks.map(toBenchmarkCardData)}
+        lockedCategory={entry.label}
+        allCategories={Array.from(new Set(all.map((b) => b.category)))}
+      />
+    </article>
+  );
+}
diff --git a/src/app/hyperliquid/page.tsx b/src/app/hyperliquid/page.tsx
index a827d8ec..215c60f3 100644
--- a/src/app/hyperliquid/page.tsx
+++ b/src/app/hyperliquid/page.tsx
@@ -62,6 +62,14 @@ export default async function HyperliquidHubPage() {
   // are referenced in the page's plain prose and stayed out of this list
   // intentionally; mixing two ItemLists with overlapping naming would
   // confuse Search Console's rich-results validator more than it helps.
+  // Drop anonymous builder addresses (raw 0x... slugs with no human
+  // brand) from the ItemList. Those /products/<hex> URLs now 404 per the
+  // SEO blacklist in @/lib/providers (thin auto-generated titles, no
+  // editorial body, no inbound brand demand) so emitting them in
+  // schema.org ItemList would point Search Console at known 404s.
+  const linkableFrontends = frontends
+    ? frontends.rows.filter((r) => !/^0x[a-f0-9]+$/.test(r.slug.toLowerCase()))
+    : [];
   const itemListLd = frontends
     ? {
         "@context": "https://schema.org",
@@ -69,8 +77,8 @@ export default async function HyperliquidHubPage() {
         name: "Hyperliquid frontends leaderboard",
         description:
           "Hyperliquid frontends tracked by OpenChainBench, ranked by 30-day builder revenue.",
-        numberOfItems: frontends.rows.length,
-        itemListElement: frontends.rows.slice(0, 100).map((r, i) => ({
+        numberOfItems: linkableFrontends.length,
+        itemListElement: linkableFrontends.slice(0, 100).map((r, i) => ({
           "@type": "ListItem",
           position: i + 1,
           url: `https://openchainbench.com/products/${r.slug}`,
diff --git a/src/components/benchmark-grid.tsx b/src/components/benchmark-grid.tsx
index 380ee9e2..1a2bc261 100644
--- a/src/components/benchmark-grid.tsx
+++ b/src/components/benchmark-grid.tsx
@@ -1,23 +1,54 @@
 "use client";
 
 import { useMemo, useState } from "react";
+import Link from "next/link";
 import { LayoutGrid, List, Search } from "lucide-react";
 import type { BenchmarkCardData } from "@/data/benchmarks";
 import { BenchmarkCard } from "@/components/benchmark-card";
+import { categorySlugFromLabel } from "@/lib/categories";
 
 /**
  * Client-side filter/search shell for the All Benchmarks card grid.
  * Hosts category pills (derived from data), a view-mode toggle (grid is
  * the only fully-implemented mode here - list view degrades to a single
  * column) and a search input with a ⌘K affordance.
+ *
+ * The category pills render as `<Link>` to `/benchmarks/category/<slug>`
+ * so crawlers see real hrefs and can follow them into the per-category
+ * hub pages (otherwise the category facet would only exist as
+ * client-only state and have no linkable URL). On click we still apply
+ * the in-place client filter and preventDefault so the user gets the
+ * snappy instant-filter UX without a navigation roundtrip.
+ *
+ * When `lockedCategory` is passed (e.g. by the `/benchmarks/category/<slug>`
+ * page) the grid renders pre-filtered, the search bar still works, and
+ * the category pills are hidden entirely so the page reads as a focused
+ * category hub instead of a partial filter UI.
  */
-export function BenchmarkGrid({ benchmarks }: { benchmarks: BenchmarkCardData[] }) {
+export function BenchmarkGrid({
+  benchmarks,
+  lockedCategory = null,
+  allCategories,
+}: {
+  benchmarks: BenchmarkCardData[];
+  /** When set, force the grid to this category. The pill row still
+   *  renders so users can jump to other category hubs via the same UI
+   *  they had on the /benchmarks root. */
+  lockedCategory?: string | null;
+  /** Full category list to show in the pills, used by the category hub
+   *  routes where the `benchmarks` prop is pre-filtered to a single
+   *  category. If unset, the grid derives pills from `benchmarks`. */
+  allCategories?: string[];
+}) {
   const [query, setQuery] = useState("");
-  const [activeCategory, setActiveCategory] = useState<string | null>(null);
+  const [activeCategory, setActiveCategory] = useState<string | null>(
+    lockedCategory,
+  );
   const [view, setView] = useState<"grid" | "list">("grid");
   const q = query.trim().toLowerCase();
 
   const categories = useMemo(() => {
+    if (allCategories && allCategories.length > 0) return allCategories;
     const seen = new Set<string>();
     const list: string[] = [];
     for (const b of benchmarks) {
@@ -27,7 +58,7 @@ export function BenchmarkGrid({ benchmarks }: { benchmarks: BenchmarkCardData[]
       }
     }
     return list;
-  }, [benchmarks]);
+  }, [benchmarks, allCategories]);
 
   const filtered = useMemo(() => {
     return benchmarks.filter((b) => {
@@ -46,33 +77,51 @@ export function BenchmarkGrid({ benchmarks }: { benchmarks: BenchmarkCardData[]
     });
   }, [benchmarks, q, activeCategory]);
 
+  // Pills always render. When the grid is locked to a category route,
+  // pill clicks navigate (no preventDefault) so the user moves between
+  // /benchmarks/category/<slug> URLs. On the unlocked /benchmarks page
+  // they filter in place for a snappier UX without a navigation
+  // roundtrip.
   return (
     <div>
       {/* Filter row */}
       <div className="mb-8 flex flex-col sm:flex-row sm:flex-wrap sm:items-center gap-3">
         <ul className="-mx-4 px-4 sm:mx-0 sm:px-0 flex flex-nowrap sm:flex-wrap overflow-x-auto sm:overflow-visible items-center gap-2 [-ms-overflow-style:none] [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
           <li>
-            <button
-              type="button"
+            <Link
+              href="/benchmarks"
               className="pill"
-              data-active={activeCategory === null}
-              onClick={() => setActiveCategory(null)}
+              data-active={!lockedCategory && activeCategory === null}
+              onClick={(e) => {
+                if (lockedCategory) return;
+                e.preventDefault();
+                setActiveCategory(null);
+              }}
             >
               All
-            </button>
+            </Link>
           </li>
-          {categories.map((c) => (
-            <li key={c}>
-              <button
-                type="button"
-                className="pill"
-                data-active={activeCategory === c}
-                onClick={() => setActiveCategory(activeCategory === c ? null : c)}
-              >
-                {c}
-              </button>
-            </li>
-          ))}
+          {categories.map((c) => {
+            const slug = categorySlugFromLabel(c);
+            const href = slug ? `/benchmarks/category/${slug}` : "/benchmarks";
+            const isActive = lockedCategory === c || (!lockedCategory && activeCategory === c);
+            return (
+              <li key={c}>
+                <Link
+                  href={href}
+                  className="pill"
+                  data-active={isActive}
+                  onClick={(e) => {
+                    if (lockedCategory) return;
+                    e.preventDefault();
+                    setActiveCategory(activeCategory === c ? null : c);
+                  }}
+                >
+                  {c}
+                </Link>
+              </li>
+            );
+          })}
         </ul>
 
         <div className="sm:ml-auto flex items-center gap-3">
diff --git a/src/components/ledger-table.tsx b/src/components/ledger-table.tsx
index 3a13124d..a5ea3dec 100644
--- a/src/components/ledger-table.tsx
+++ b/src/components/ledger-table.tsx
@@ -10,6 +10,7 @@ import type {
   ProviderResult,
 } from "@/types/benchmark";
 import { ChainCoverageChip } from "@/components/chain-coverage-chip";
+import { EmbedBadgeButton } from "@/components/embed-badge-button";
 import { Hint } from "@/components/hint";
 import { Sparkline } from "@/components/sparkline";
 import { ProviderLogo } from "@/components/provider-logo";
@@ -17,6 +18,7 @@ import { ProviderTypeBadge } from "@/components/provider-type-badge";
 import { fmtUnit } from "@/lib/format";
 import { buildProviderColors } from "@/lib/series-colors";
 import { isRegion } from "@/lib/brand";
+import { isAll } from "@/lib/dimensions";
 
 type Props = {
   benchmark: Benchmark;
@@ -26,6 +28,12 @@ type Props = {
    *  the headline p50 metric. */
   activePanel?: MetricPanel | null;
   topN?: number | null;
+  /** Active dimension filters on the bench page. Passed through to the
+   *  per-row Embed CTA so the generated snippet/badge stay scoped to what
+   *  the reader is looking at. "all" sentinels are normalized to null. */
+  scopeChain?: string | null;
+  scopeRegion?: string | null;
+  scopeKind?: string | null;
 };
 
 /**
@@ -35,8 +43,20 @@ type Props = {
  * to recognition; sort order remains mechanical (ascending p50) and no
  * row is highlighted as the "winner".
  */
-export function LedgerTable({ benchmark, activePanel, topN }: Props) {
+export function LedgerTable({
+  benchmark,
+  activePanel,
+  topN,
+  scopeChain = null,
+  scopeRegion = null,
+  scopeKind = null,
+}: Props) {
   const { results, extras } = benchmark;
+  // Drop "all" sentinels so the snippet/badge URL stays unscoped instead
+  // of carrying ?chain=all (which the badge route 400s on).
+  const embedChain = scopeChain && !isAll(scopeChain) ? scopeChain : null;
+  const embedRegion = scopeRegion && !isAll(scopeRegion) ? scopeRegion : null;
+  const embedKind = scopeKind && !isAll(scopeKind) ? scopeKind : null;
   const unit = activePanel?.unit ?? benchmark.unit;
   const higherIsBetter = activePanel?.higherIsBetter ?? benchmark.higherIsBetter;
   const panelActive = !!activePanel;
@@ -122,6 +142,12 @@ export function LedgerTable({ benchmark, activePanel, topN }: Props) {
   // lost — only the noisy ledger rows are pruned.
   const sortedAll = [...results]
     .filter((r) => {
+      // Sample-health gate. Rows tagged "insufficient" by the load path
+      // (sampleSize < 0.1 × expectedN) drop out of the ranking entirely
+      // so the leaderboard cannot assert a position from a wildly
+      // undersized field. "low" rows stay; the row renderer shows them
+      // with a soft pill instead.
+      if (r.dataConfidence === "insufficient") return false;
       if (activePanel) {
         const v = activePanel.values[r.slug];
         return v != null && Number.isFinite(v) && v !== 0;
@@ -162,7 +188,7 @@ export function LedgerTable({ benchmark, activePanel, topN }: Props) {
     <div className="overflow-x-auto -mx-4 sm:mx-0 px-4 sm:px-0">
       {hasWindows && (
         <div className="mb-3 flex flex-wrap items-center gap-1">
-          <span className="mr-2 text-[10px] uppercase tracking-[0.16em] text-ink-faint">
+          <span className="mr-2 label-mono-xs">
             Timeframe
           </span>
           {(["24h", "7d", "30d"] as const).map((w) => (
@@ -288,6 +314,9 @@ export function LedgerTable({ benchmark, activePanel, topN }: Props) {
               sparkMax={sparkMax}
               color={colors.get(r.slug) ?? "var(--color-ink-soft)"}
               benchmark={benchmark}
+              embedChain={embedChain}
+              embedRegion={embedRegion}
+              embedKind={embedKind}
             />
           ))}
         </tbody>
@@ -312,6 +341,9 @@ function Row({
   sparkMax,
   color,
   benchmark,
+  embedChain,
+  embedRegion,
+  embedKind,
 }: {
   r: ProviderResult;
   i: number;
@@ -330,6 +362,9 @@ function Row({
   sparkMax: number;
   color: string;
   benchmark: Benchmark;
+  embedChain: string | null;
+  embedRegion: string | null;
+  embedKind: string | null;
 }) {
   const isOffline = r.availability === "unavailable";
   const deltaPct = fieldValue > 0 ? ((value - fieldValue) / fieldValue) * 100 : 0;
@@ -352,7 +387,20 @@ function Row({
       <td className="py-2.5 pr-3 text-ink-muted text-[12px]">
         {String(i + 1).padStart(2, "0")}
       </td>
-      <td className="py-2.5 pr-3 font-serif text-[14px] min-w-0">
+      {/* itemScope/itemType marks each row as a named entity so Google's
+          knowledge graph can link the leaderboard back to that provider.
+          For region rows (Solana, Base, …) the schema.org/Place type is
+          a better fit than Organization; everything else is a vendor and
+          gets Organization. itemProp="name" wraps the visible name. */}
+      <td
+        className="py-2.5 pr-3 font-serif text-[14px] min-w-0"
+        itemScope
+        itemType={
+          isRegion(r.slug)
+            ? "https://schema.org/Place"
+            : "https://schema.org/Organization"
+        }
+      >
         <div className="flex flex-col gap-1 min-w-0">
           <span className="flex items-center gap-2 min-w-0">
             <ProviderLogo slug={r.slug} name={r.name} size={20} />
@@ -360,6 +408,7 @@ function Row({
               <span
                 className="font-semibold truncate min-w-0"
                 style={{ color: isOffline ? "var(--color-ink-muted)" : color }}
+                itemProp="name"
               >
                 {r.name}
               </span>
@@ -368,8 +417,9 @@ function Row({
                 href={`/products/${r.slug}`}
                 className="font-semibold hover:underline underline-offset-2 truncate min-w-0"
                 style={{ color: isOffline ? "var(--color-ink-muted)" : color }}
+                itemProp="url"
               >
-                {r.name}
+                <span itemProp="name">{r.name}</span>
               </Link>
             )}
             {r.tag && !isOffline && (
@@ -385,11 +435,38 @@ function Row({
                 </span>
               </Hint>
             )}
+            {!isOffline && r.dataConfidence === "low" && (
+              <Hint
+                label={
+                  r.sampleHealth != null
+                    ? `Sample count is below half of the expected per provider for this bench (${Math.round(r.sampleHealth * 100)}% of expected). The ranking still includes this provider; confidence in the headline number is lower than for healthy rows.`
+                    : "Sample count is below half of the expected per provider for this bench. The ranking still includes this provider; confidence in the headline number is lower than for healthy rows."
+                }
+              >
+                <span className="inline-flex items-center gap-1 shrink-0 font-sans text-[10px] uppercase tracking-[0.14em] text-ink-muted">
+                  <span className="inline-block w-1.5 h-1.5 rounded-full bg-[var(--color-warn,#c08a3c)]" aria-hidden />
+                  Low sample
+                </span>
+              </Hint>
+            )}
             {r.type && !isOffline && (
               <span className="hidden md:inline-flex">
                 <ProviderTypeBadge type={r.type} />
               </span>
             )}
+            {!isOffline && !isRegion(r.slug) && (
+              <span className="ml-auto pl-2 shrink-0">
+                <EmbedBadgeButton
+                  benchSlug={benchmark.slug}
+                  benchTitle={benchmark.title}
+                  providerSlug={r.slug}
+                  providerName={r.name}
+                  chain={embedChain}
+                  region={embedRegion}
+                  kind={embedKind}
+                />
+              </span>
+            )}
           </span>
           {/* Per-chain coverage chips on their own row — chain-restricted
               providers like GMGN (Solana-only) are flagged so the unfiltered
diff --git a/src/lib/citation.ts b/src/lib/citation.ts
index 544bbc14..35c68cae 100644
--- a/src/lib/citation.ts
+++ b/src/lib/citation.ts
@@ -4,72 +4,32 @@
  * everyone (LLMs, journalists, ourselves) sees.
  */
 
-import type { Benchmark } from "@/types/benchmark";
+import type { Benchmark, ProviderResult } from "@/types/benchmark";
 import { liveResults } from "@/lib/provider-filters";
 import { fmtUnit } from "@/lib/format";
 
-/**
- * Canonical "this bench cannot be ranked right now" predicate, shared by
- * every citable surface (api/stat, api/citable, api/llm-context, llms.txt,
- * /answers, bench page hero, OG image, MCP).
- *
- * A benchmark is insufficient when ANY of:
- *  - editorialStatus is draft (the spec author has not published)
- *  - runtime status flipped to draft (the materialize layer fell back to
- *    draftPlaceholderForSpec because every Prom query came back empty)
- *  - aggregate sampleSize is exactly 0 (harness ran but emitted no
- *    samples; the headline number is then a rolling aggregate over an
- *    empty window and must not be cited)
- *  - no live provider has a usable, finite, positive p50
- *
- * Why both bench.sampleSize and the per-provider p50 check matter:
- *  /api/stat goes through the per-slug cache and routinely returns
- *  status=live with a non-zero p50 even when the aggregator collapsed
- *  the same bench to draft on /api/citable (per-bench throw, fallback
- *  to draftPlaceholderForSpec). Aligning on bench.sampleSize === 0
- *  closes that gap for the network-fees / token-deployment-cost class
- *  of bench, where the harness emits a value but no samples.
- *
- * Notes:
- *  - per-provider `sampleSize` is intentionally NOT used. Several
- *    harnesses do not emit a per-provider count even when the rolling
- *    headline is real, so making it a hard condition would mass-flag
- *    healthy benches.
- *  - Use this predicate BEFORE deriving leader / fieldValue / headline
- *    for any externally-visible surface.
- */
-/** Structural subset accepted by `isInsufficient`. Lets the hub card
- *  call this with the slim BenchmarkCardData shape (which omits the
- *  full Benchmark fields the predicate does not read) without breaking
- *  the existing full-Benchmark call sites. */
-export type InsufficientCheckInput = {
-  editorialStatus: Benchmark["editorialStatus"];
-  status: Benchmark["status"];
-  results: { ms: { p50: number }; availability?: "live" | "unavailable" }[];
-};
-
-export function isInsufficient(b: InsufficientCheckInput): boolean {
-  if (b.editorialStatus !== "live") return true;
-  if (b.status !== "live") return true;
-  // Note: do NOT key on b.sampleSize === 0. The aggregator loader can
-  // fall back to a draft placeholder with sampleSize=0 even when the
-  // per-bench loader holds real data, which mass-flagged 25 of 26
-  // benches as insufficient on /api/citable while /api/stat returned
-  // live values for the same slug. The liveResults length and p50
-  // finiteness checks below already catch the genuine empty case.
-  const live = b.results.filter(
-    (r) => r.availability !== "unavailable" && r.ms.p50 > 0,
-  );
-  if (live.length === 0) return true;
-  return live.every((r) => !Number.isFinite(r.ms.p50) || r.ms.p50 <= 0);
+/** Provider set used to derive the headline figures. Drops rows whose
+ *  per-provider sample-health is "insufficient" (set on the load path
+ *  when the bench declares expected_n and the row falls below the 10
+ *  percent of expected floor). Those rows can still render in some
+ *  surfaces with a soft tag, but they must not contribute to the leader
+ *  claim shipped to AI agents and journalists via the citable APIs. */
+function citationCandidates(b: Benchmark): ProviderResult[] {
+  const live = liveResults(b.results);
+  if (!b.expectedN) return live;
+  return live.filter((r) => r.dataConfidence !== "insufficient");
 }
 
 /** Median value of the benchmark (the field shown in the headline). */
 export function fieldValue(b: Benchmark): number | null {
-  if (isInsufficient(b)) return null;
-  const live = liveResults(b.results);
-  if (live.length === 0) return null;
-  const sorted = [...live].sort((a, c) =>
+  if (b.status !== "live") return null;
+  // Bench-wide aggregate is insufficient: refuse to publish a value
+  // (downstream LLM tools and SERP snippets would otherwise quote a
+  // number drawn from a wildly undersized field).
+  if (b.dataConfidence === "insufficient") return null;
+  const candidates = citationCandidates(b);
+  if (candidates.length === 0) return null;
+  const sorted = [...candidates].sort((a, c) =>
     b.higherIsBetter ? c.ms.p50 - a.ms.p50 : a.ms.p50 - c.ms.p50
   );
   return sorted[0].ms.p50;
@@ -77,10 +37,11 @@ export function fieldValue(b: Benchmark): number | null {
 
 /** Who is currently #1 on this benchmark, if any. */
 export function leader(b: Benchmark): { name: string; slug: string; value: number } | null {
-  if (isInsufficient(b)) return null;
-  const live = liveResults(b.results);
-  if (live.length === 0) return null;
-  const sorted = [...live].sort((a, c) =>
+  if (b.status !== "live") return null;
+  if (b.dataConfidence === "insufficient") return null;
+  const candidates = citationCandidates(b);
+  if (candidates.length === 0) return null;
+  const sorted = [...candidates].sort((a, c) =>
     b.higherIsBetter ? c.ms.p50 - a.ms.p50 : a.ms.p50 - c.ms.p50
   );
   return { name: sorted[0].name, slug: sorted[0].slug, value: sorted[0].ms.p50 };
@@ -89,27 +50,16 @@ export function leader(b: Benchmark): { name: string; slug: string; value: numbe
 /** Honest window wording per unit. "(p50, 24h)" is only true for latency
  *  style benches; USD revenue and count benches repurpose the p50 slot as
  *  a plain rolling-window figure and percentile wording would mislead. */
-export function windowSuffix(unit: string): string {
+function windowSuffix(unit: string): string {
   if (unit === "usd" || unit === "count") return "(24h)";
   if (unit === "pct" || unit === "bps") return "(24h avg)";
   return "(p50, 24h)";
 }
 
-/** Short factual sentence ready to paste into an article. Templated, no LLM.
- *
- *  Three-state output, in priority order:
- *    1. Insufficient data: harness has no usable sample (zero p50 across
- *       every provider, draft status, etc). Refuse to assert a winner.
- *    2. No provider but bench is live (transient edge case): generic
- *       "awaiting first run" sentence.
- *    3. Live with a leader: the standard headline assertion.
- *
- *  The insufficient branch is critical for /answers, /llms.txt,
- *  /api/llm-context and /api/citable so an LLM consumer never reads a
- *  fabricated leader for a bench whose harness has not produced data. */
+/** Short factual sentence ready to paste into an article. Templated, no LLM. */
 export function headlineSentence(b: Benchmark): string {
-  if (isInsufficient(b)) {
-    return `Insufficient data to rank providers. The harness for ${b.title} is awaiting sufficient samples.`;
+  if (b.dataConfidence === "insufficient") {
+    return `${b.title}. Insufficient data to assert a leader.`;
   }
   const top = leader(b);
   if (!top) return `${b.title}. Awaiting first run.`;
@@ -123,6 +73,51 @@ export function citationQuote(b: Benchmark, origin: string): string {
   return `${sentence} Source: OpenChainBench (${origin}/benchmarks/${b.slug}).`;
 }
 
+/** Pre-formatted citation strings (Plain / BibTeX / APA) for the page
+ *  `<CiteBlock>` and the public JSON endpoints. Computed server-side so
+ *  the same canonical wording lands in HTML, in the API, and in whatever
+ *  an LLM scrapes. Date is computed from the current request time and
+ *  spelled out in ISO so journalists and BibTeX both stay happy. */
+export type CiteBundle = {
+  plain: string;
+  bibtex: string;
+  apa: string;
+};
+
+const MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December",
+];
+
+export function citeBundle(
+  b: Pick<Benchmark, "slug" | "title">,
+  origin: string,
+  now: Date = new Date(),
+): CiteBundle {
+  const url = `${origin}/benchmarks/${b.slug}`;
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(now.getUTCDate()).padStart(2, "0");
+  const isoDate = `${yyyy}-${mm}-${dd}`;
+  const longDate = `${MONTHS[now.getUTCMonth()]} ${now.getUTCDate()}, ${yyyy}`;
+  const bibKey = `ocb_${b.slug.replace(/-/g, "_")}`;
+  return {
+    plain: `OpenChainBench. "${b.title}". Retrieved ${isoDate}. ${url}`,
+    bibtex: `@misc{${bibKey},\n  author = {OpenChainBench},\n  title  = {${b.title}},\n  year   = {${yyyy}},\n  url    = {${url}},\n  note   = {Retrieved ${isoDate}}\n}`,
+    apa: `OpenChainBench. (${yyyy}). ${b.title}. Retrieved ${longDate}, from ${url}`,
+  };
+}
+
 /** Compact sparkline (last N points, 24h) for the JSON payload. */
 export function sparklineFor(b: Benchmark, providerSlug?: string): number[] {
   const series = b.extras.series24h ?? {};
@@ -137,3 +132,35 @@ function firstSeries(s: Record<string, number[]>): number[] | null {
   }
   return null;
 }
+
+/** Structural subset accepted by `isInsufficient`. Lets the hub card
+ *  call this with the slim BenchmarkCardData shape (which omits the
+ *  full Benchmark fields the predicate does not read) without breaking
+ *  the existing full-Benchmark call sites. */
+export type InsufficientCheckInput = {
+  editorialStatus: Benchmark["editorialStatus"];
+  status: Benchmark["status"];
+  results: { ms: { p50: number }; availability?: "live" | "unavailable" }[];
+};
+
+/** Lightweight predicate used by hub cards + machine-readable APIs to
+ *  decide whether a benchmark should be hidden from leader assertions.
+ *  Stricter than the `dataConfidence === "insufficient"` check (which
+ *  requires the spec to declare expected_n): also catches editorial
+ *  draft state and the cold-start "no live providers" case where the
+ *  aggregator returned a placeholder. */
+export function isInsufficient(b: InsufficientCheckInput): boolean {
+  if (b.editorialStatus !== "live") return true;
+  if (b.status !== "live") return true;
+  // Note: do NOT key on b.sampleSize === 0. The aggregator loader can
+  // fall back to a draft placeholder with sampleSize=0 even when the
+  // per-bench loader holds real data, which mass-flagged 25 of 26
+  // benches as insufficient on /api/citable while /api/stat returned
+  // live values for the same slug. The liveResults length and p50
+  // finiteness checks below already catch the genuine empty case.
+  const live = b.results.filter(
+    (r) => r.availability !== "unavailable" && r.ms.p50 > 0,
+  );
+  if (live.length === 0) return true;
+  return live.every((r) => !Number.isFinite(r.ms.p50) || r.ms.p50 <= 0);
+}
diff --git a/src/lib/providers.ts b/src/lib/providers.ts
index 202879eb..1e1b3084 100644
--- a/src/lib/providers.ts
+++ b/src/lib/providers.ts
@@ -379,7 +379,7 @@ async function buildProviders(): Promise<ProviderProfile[]> {
   }
 
   const profiles = Array.from(byKey.values()).filter(
-    (p) => !DEAD_COMPOSITE_SLUGS.has(p.slug),
+    (p) => !isBlacklistedSlug(p.slug),
   );
   profiles.sort((a, b) => {
     if (a.wins !== b.wins) return b.wins - a.wins;
@@ -395,9 +395,14 @@ async function buildProviders(): Promise<ProviderProfile[]> {
 // now ranks the parent provider only (codex, predexon), but stale
 // materialize-worker snapshots can recreate ghost /products/<slug>
 // pages with no data. Hard-block so getProvider() returns undefined and
-// the route 404s cleanly. Keep in sync with the same set in
-// related-providers.ts.
-const DEAD_COMPOSITE_SLUGS = new Set([
+// the route 404s cleanly.
+//
+// Exported as the single source of truth. related-providers.ts imports
+// this set instead of duplicating the literal — PR #728 originally
+// shipped two copies and they immediately drifted (composite URLs kept
+// leaking into sitemap.xml + /products listing even after the page
+// itself 404'd, see SEO audit 2026-06-24).
+export const DEAD_COMPOSITE_SLUGS = new Set([
   "codex-kalshi",
   "codex-polymarket",
   "predexon-kalshi",
@@ -405,6 +410,29 @@ const DEAD_COMPOSITE_SLUGS = new Set([
   "predexon-polymarket",
 ]);
 
+// Anonymous Hyperliquid builder addresses with no human-readable brand.
+// The hyperliquid-frontends bench tracks 104 builders, ~15 of which have
+// never been claimed by a frontend operator — they surface as raw
+// `0x40e9d9fe...` slugs. Each one mints a thin /products/<hex> page
+// titled "0x... review and live performance benchmarks", with no editorial
+// body and no inbound brand search demand. Google indexed the lot as
+// thin content and they were burning PageRank from the products hub.
+//
+// Filter at the profile and resolution layers so:
+//   - `getProviders()` drops them before /products/index renders the table
+//   - `getProviderSlugs()` drops them before sitemap.ts emits URLs
+//   - `getProvider()` returns undefined so the per-slug page 404s and
+//     Google deindexes via 404 signal
+// The HL bench page itself still lists every builder in its leaderboard
+// (that's the bench's job); only the dedicated /products/<hex> route is
+// suppressed.
+const HEX_ADDRESS_SLUG = /^0x[a-f0-9]+$/;
+
+function isBlacklistedSlug(slug: string): boolean {
+  const lc = slug.toLowerCase();
+  return DEAD_COMPOSITE_SLUGS.has(lc) || HEX_ADDRESS_SLUG.test(lc);
+}
+
 // Cohort venues that should have a /products/<slug> page even when no
 // bench in benchmarks/ ranks them. Imported as a flat list here to
 // avoid a build-time cycle with the perp-stats module.
@@ -436,7 +464,12 @@ const PERP_VENUE_SEED = [
  *  bump this key when the buildProviders() output shape changes. */
 const buildProvidersCached = unstable_cache(
   buildProviders,
-  ["providers-v3"],
+  // v4 bump: hex builder addresses + composite zombies are now filtered
+  // at buildProviders() exit. Without this bump, Vercel ISR would keep
+  // serving the v3 list (containing 0x... slugs) until the `benchmarks`
+  // tag fires, leaving thin /products/<hex> URLs in the sitemap for the
+  // next 60s window after deploy.
+  ["providers-v4"],
   { revalidate: 60, tags: ["benchmarks"] },
 );
 
@@ -450,6 +483,11 @@ export async function getProviderSlugs(): Promise<string[]> {
 }
 
 export async function getProvider(slug: string): Promise<ProviderProfile | undefined> {
+  // Early reject blacklisted slugs (dead composites + anonymous hex
+  // builder addresses) so /products/<slug> 404s cleanly even if a stale
+  // cache layer ever produces a profile. Mirrors the buildProviders()
+  // filter; cheap second guard against eventual-consistency leaks.
+  if (isBlacklistedSlug(slug)) return undefined;
   const profiles = await getProviders();
   // Aliased URLs (e.g. /products/helius-sender, /products/btc-usd) resolve
   // to the canonical profile so backward-compat links keep working.
diff --git a/src/lib/related-providers.ts b/src/lib/related-providers.ts
index 689156be..0be3bbdd 100644
--- a/src/lib/related-providers.ts
+++ b/src/lib/related-providers.ts
@@ -19,7 +19,10 @@
 
 import { cache } from "react";
 import { unstable_cache } from "next/cache";
-import { canonicalize, getProviders } from "@/lib/providers";
+// DEAD_COMPOSITE_SLUGS lives in providers.ts (the canonical source of
+// /products/<slug> eligibility); re-imported here so both modules share
+// one list and we never drift the two literals out of sync.
+import { canonicalize, DEAD_COMPOSITE_SLUGS, getProviders } from "@/lib/providers";
 import { canonicalPairSlug } from "@/lib/compare-pairing-shared";
 import { loadAllAlternatives } from "@/lib/alternatives";
 import { loadBenchmark } from "@/lib/spec";
@@ -48,23 +51,6 @@ const COMPARE_CAP = 12;
 /** Hard cap on how many alternatives lists we render. */
 const ALTERNATIVES_CAP = 8;
 
-/**
- * Zombie slugs from pre-PR #647 pm-api-latency, when each aggregator was
- * split per venue (codex-kalshi, codex-polymarket, predexon-*). The bench
- * now collapses everything into the parent provider slug (codex,
- * predexon) but the materialize worker's per-slug Redis blobs survive
- * for the TTL window after each schema change, and old slugs leak into
- * compare candidates / alternatives links until they expire. Filtering
- * here keeps the UI clean across the eventual-consistency gap.
- */
-const DEAD_COMPOSITE_SLUGS = new Set([
-  "codex-kalshi",
-  "codex-polymarket",
-  "predexon-kalshi",
-  "predexon-limitless",
-  "predexon-polymarket",
-]);
-
 /**
  * Returns the providers that share at least one live benchmark with the
  * given product, sorted by shared-bench count descending then by name.