Add validated evaluator badge

app/evals/page.tsx

@@ -4,6 +4,7 @@ import { Suspense, useCallback, useDeferredValue, useEffect, useMemo, useState }
 import { useRouter, useSearchParams } from "next/navigation"
 import { Search } from "lucide-react"
 
+import { EvaluatorTable, type EvaluatorTableSortCol } from "@/components/evaluator-table"
 import { FamilyTable, getFamilyNavId, type FamilySortCol } from "@/components/family-table"
 import { InfiniteScrollSentinel } from "@/components/infinite-scroll"
 import { Navigation } from "@/components/navigation"
@@ -13,6 +14,7 @@ import { fetchBenchmarkMetadata, fetchEvalHierarchy, fetchEvalList } from "@/lib
 import type { BenchmarkEvalListItem } from "@/lib/eval-processing"
 import type { BenchmarkCard } from "@/lib/benchmark-schema"
 import { formatTagLabel } from "@/lib/benchmark-tags"
+import { groupEvalsByEvaluator, verifiedEvalIds } from "@/lib/evaluators"
 
 const PAGE_SIZE = 60
 
@@ -39,6 +41,8 @@ function EvalsPageInner() {
   const searchParams = useSearchParams()
   const familyParam = searchParams.get("family")
   const queryParam = searchParams.get("q")
+  const groupByParam = searchParams.get("groupBy")
+  const verifiedParam = searchParams.get("verified")
 
   const [hierarchy, setHierarchy] = useState<EvalHierarchy | null>(null)
   const [totalModels, setTotalModels] = useState<number>(0)
@@ -54,8 +58,27 @@ function EvalsPageInner() {
   const [agentMode, setAgentMode] = useState<"all" | "agentic" | "non-agentic">("all")
   const [sortCol, setSortCol] = useState<FamilySortCol>("name")
   const [sortDir, setSortDir] = useState<"asc" | "desc">("asc")
+  const [groupBy, setGroupBy] = useState<"family" | "evaluator">(
+    groupByParam === "evaluator" ? "evaluator" : "family",
+  )
+  const [verifiedOnly, setVerifiedOnly] = useState<boolean>(
+    verifiedParam === "1" || verifiedParam === "true",
+  )
+  const [evaluatorSortCol, setEvaluatorSortCol] = useState<EvaluatorTableSortCol>("evals")
+  const [evaluatorSortDir, setEvaluatorSortDir] = useState<"asc" | "desc">("desc")
   const deferredSearchQuery = useDeferredValue(searchQuery)
 
+  const handleEvaluatorSort = useCallback((col: EvaluatorTableSortCol) => {
+    setEvaluatorSortCol((current) => {
+      if (current === col) {
+        setEvaluatorSortDir((dir) => (dir === "asc" ? "desc" : "asc"))
+        return current
+      }
+      setEvaluatorSortDir(col === "name" ? "asc" : "desc")
+      return col
+    })
+  }, [])
+
   const handleSort = useCallback((col: FamilySortCol) => {
     if (sortCol === col) {
       setSortDir((d) => (d === "asc" ? "desc" : "asc"))
@@ -122,6 +145,47 @@ function EvalsPageInner() {
     setSearchQuery(fam.display_name || fam.key)
   }, [familyParam, hierarchy, benchmarkCards, router])
 
+  // Reflect groupBy / verified into the URL (nice-to-have deep link).
+  // Shallow replace so the back button isn't spammed and data isn't refetched.
+  useEffect(() => {
+    const params = new URLSearchParams(searchParams.toString())
+    if (groupBy === "evaluator") params.set("groupBy", "evaluator")
+    else params.delete("groupBy")
+    if (verifiedOnly) params.set("verified", "1")
+    else params.delete("verified")
+    const qs = params.toString()
+    router.replace(qs ? `/evals?${qs}` : "/evals", { scroll: false })
+    // searchParams intentionally omitted — we only push when our own toggles change.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [groupBy, verifiedOnly])
+
+  const allEvals = useMemo(() => Array.from(evalItems.values()), [evalItems])
+
+  // Verified-eval id universe — drives the Family-mode "Verified only" gate.
+  const verifiedIds = useMemo(() => verifiedEvalIds(allEvals), [allEvals])
+
+  // Evaluator groups (group-by-Evaluator mode). Verified filter is
+  // evaluator-aware: counts only (eval, org) pairs where org is verified.
+  const evaluatorGroups = useMemo(
+    () => groupEvalsByEvaluator(allEvals, { verifiedOnly }),
+    [allEvals, verifiedOnly],
+  )
+
+  const filteredEvaluators = useMemo(() => {
+    const query = deferredSearchQuery.trim().toLowerCase()
+    let list = evaluatorGroups
+    if (query) list = list.filter((g) => g.name.toLowerCase().includes(query))
+    const dirMul = evaluatorSortDir === "asc" ? 1 : -1
+    return list.slice().sort((a, b) => {
+      let cmp = 0
+      if (evaluatorSortCol === "name") cmp = a.name.localeCompare(b.name)
+      else if (evaluatorSortCol === "verified") cmp = a.verifiedCount - b.verifiedCount
+      else cmp = a.evalCount - b.evalCount
+      if (cmp === 0) cmp = a.name.localeCompare(b.name)
+      return cmp * dirMul
+    })
+  }, [evaluatorGroups, deferredSearchQuery, evaluatorSortCol, evaluatorSortDir])
+
   const families = hierarchy?.families ?? []
 
   // Tags per family — union of derivedTags across the family and every
@@ -244,16 +308,21 @@ function EvalsPageInner() {
 
   useEffect(() => {
     setVisibleCount(PAGE_SIZE)
-  }, [deferredSearchQuery, selectedCategories, agentMode, sortCol, sortDir])
+  }, [deferredSearchQuery, selectedCategories, agentMode, sortCol, sortDir, groupBy, verifiedOnly, evaluatorSortCol, evaluatorSortDir])
 
   const visibleFamilies = useMemo(
     () => filteredFamilies.slice(0, visibleCount),
     [filteredFamilies, visibleCount],
   )
-  const hasMore = visibleCount < filteredFamilies.length
+  const visibleEvaluators = useMemo(
+    () => filteredEvaluators.slice(0, visibleCount),
+    [filteredEvaluators, visibleCount],
+  )
+  const totalRows = groupBy === "evaluator" ? filteredEvaluators.length : filteredFamilies.length
+  const hasMore = visibleCount < totalRows
   const handleLoadMore = useCallback(() => {
-    setVisibleCount((current) => Math.min(current + PAGE_SIZE, filteredFamilies.length))
-  }, [filteredFamilies.length])
+    setVisibleCount((current) => Math.min(current + PAGE_SIZE, totalRows))
+  }, [totalRows])
 
   return (
     <div className="min-h-screen bg-background">
@@ -264,24 +333,76 @@ function EvalsPageInner() {
         <div className="kicker">Index</div>
         <h1 className="ec-page-h1">Evaluations</h1>
         <p className="ec-page-lede">
-          Evaluations are grouped into <strong>families</strong>. A family may hold a single
-          standalone benchmark or many related ones; each benchmark has one or more slices, and
-          each slice reports one or more metrics.
+          {groupBy === "evaluator" ? (
+            <>
+              Evaluations grouped by the <strong>organisation that reported them</strong>. A
+              verified evaluator submitted the results from the org that ran the evaluation.
+            </>
+          ) : (
+            <>
+              Evaluations are grouped into <strong>families</strong>. A family may hold a single
+              standalone benchmark or many related ones; each benchmark has one or more slices, and
+              each slice reports one or more metrics.
+            </>
+          )}
         </p>
 
-        {/* SEARCH ROW ---------------------------------------------- */}
-        <div className="mb-6 flex items-center border-b border-[color:var(--border-soft)] pb-5">
+        {/* MODE + FILTER ROW --------------------------------------- */}
+        <div className="mb-6 flex flex-wrap items-center gap-x-6 gap-y-3 border-y border-[color:var(--border-soft)] py-4">
+          <div className="ec-mode-toggle" role="group" aria-label="Group evaluations by">
+            <button
+              type="button"
+              className={groupBy === "family" ? "on" : ""}
+              onClick={() => setGroupBy("family")}
+            >
+              Family
+            </button>
+            <button
+              type="button"
+              className={groupBy === "evaluator" ? "on" : ""}
+              onClick={() => setGroupBy("evaluator")}
+            >
+              Evaluator
+            </button>
+          </div>
+
+          <div className="ec-mode-toggle" role="group" aria-label="Verified only filter">
+            <button
+              type="button"
+              className={!verifiedOnly ? "on" : ""}
+              onClick={() => setVerifiedOnly(false)}
+            >
+              All
+            </button>
+            <button
+              type="button"
+              className={verifiedOnly ? "on" : ""}
+              onClick={() => setVerifiedOnly(true)}
+            >
+              Verified only
+            </button>
+          </div>
+
           <div className="relative ml-auto min-w-[180px] flex-1 sm:max-w-[360px]">
             <Search className="pointer-events-none absolute left-3 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-[color:var(--fg-subtle)]" />
             <input
               className="ec-input pl-9"
               value={searchQuery}
               onChange={(event) => setSearchQuery(event.target.value)}
-              placeholder="Search family, benchmark, or category…"
+              placeholder={
+                groupBy === "evaluator"
+                  ? "Search evaluator…"
+                  : "Search family, benchmark, or category…"
+              }
             />
           </div>
         </div>
 
+        {/* Family-mode-only filters: interaction style + category pills.
+            These operate on the family hierarchy and have no meaning in
+            the evaluator grouping. */}
+        {groupBy === "family" && (
+        <>
         {/* INTERACTION STYLE TOGGLE — orthogonal axis from category,
             surfaced on its own so users don't mix "is this an agent
             benchmark?" with "what category is this in?" */}
@@ -348,6 +469,8 @@ function EvalsPageInner() {
             })}
           </div>
         )}
+        </>
+        )}
 
         {/* TABLE ---------------------------------------------------- */}
         {loading ? (
@@ -357,10 +480,12 @@ function EvalsPageInner() {
             stages={loadingStages}
             className="py-14"
           />
-        ) : filteredFamilies.length === 0 ? (
+        ) : totalRows === 0 ? (
           <div className="py-16 text-center border border-dashed border-[color:var(--border-soft)] bg-[color:var(--bg-warm)]">
             <p className="mb-4 text-base text-[color:var(--fg-muted)]">
-              No families found matching your filters.
+              {groupBy === "evaluator"
+                ? "No evaluators found matching your filters."
+                : "No families found matching your filters."}
             </p>
             <button
               type="button"
@@ -368,11 +493,20 @@ function EvalsPageInner() {
               onClick={() => {
                 setSearchQuery("")
                 setSelectedCategories([])
+                setVerifiedOnly(false)
               }}
             >
               Reset filters
             </button>
           </div>
+        ) : groupBy === "evaluator" ? (
+          <EvaluatorTable
+            rows={visibleEvaluators}
+            sortCol={evaluatorSortCol}
+            sortDir={evaluatorSortDir}
+            onSort={handleEvaluatorSort}
+            verifiedOnly={verifiedOnly}
+          />
         ) : (
           <FamilyTable
             families={visibleFamilies}
@@ -380,6 +514,7 @@ function EvalsPageInner() {
             benchmarkCards={benchmarkCards}
             categoryFilter={new Set(selectedCategories)}
             searchQuery={deferredSearchQuery}
+            verifiedEvalIds={verifiedOnly ? verifiedIds : null}
             sortCol={sortCol}
             sortDir={sortDir}
             onSort={handleSort}
@@ -390,7 +525,7 @@ function EvalsPageInner() {
           hasMore={hasMore}
           onLoadMore={handleLoadMore}
           loadingLabel="Loading more…"
-          endLabel={`Showing ${Math.min(visibleCount, filteredFamilies.length).toLocaleString()} of ${filteredFamilies.length.toLocaleString()} families`}
+          endLabel={`Showing ${Math.min(visibleCount, totalRows).toLocaleString()} of ${totalRows.toLocaleString()} ${groupBy === "evaluator" ? "evaluators" : "families"}`}
         />
       </main>
     </div>

app/evaluators/[...id]/page.tsx

@@ -0,0 +1,248 @@
+"use client"
+
+import { Suspense, useCallback, useEffect, useMemo, useState } from "react"
+import { useParams, useRouter, useSearchParams } from "next/navigation"
+import { ArrowLeft, Search } from "lucide-react"
+
+import { EvalCard } from "@/components/eval-card"
+import { InfiniteScrollSentinel } from "@/components/infinite-scroll"
+import { Navigation } from "@/components/navigation"
+import { VerifiedBadge } from "@/components/signals/verified-badge"
+import { fetchEvalList } from "@/lib/dashboard-data-client"
+import type { BenchmarkEvalListItem } from "@/lib/eval-processing"
+import { getEvalsForEvaluator } from "@/lib/evaluators"
+
+const PAGE_SIZE = 24
+
+function EvaluatorDetailInner() {
+  const params = useParams()
+  const router = useRouter()
+  const searchParams = useSearchParams()
+  const verifiedOnly = searchParams.get("verified") === "1" || searchParams.get("verified") === "true"
+
+  // The slug is a single URL-safe segment, but the route is a catch-all
+  // ([...id]) to match the developers/models pattern. Join just in case.
+  const slug = useMemo(() => {
+    const raw = params.id as string | string[] | undefined
+    const joined = Array.isArray(raw) ? raw.join("/") : (raw ?? "")
+    return decodeURIComponent(joined)
+  }, [params.id])
+
+  const [allEvals, setAllEvals] = useState<BenchmarkEvalListItem[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [searchQuery, setSearchQuery] = useState("")
+  const [visibleCount, setVisibleCount] = useState(PAGE_SIZE)
+
+  useEffect(() => {
+    fetchEvalList()
+      .then((list) => setAllEvals(list.evals))
+      .catch((err) => {
+        console.error(err)
+        setError("Failed to load evaluations")
+      })
+      .finally(() => setLoading(false))
+  }, [])
+
+  const { name, isVerified, evals } = useMemo(
+    () => getEvalsForEvaluator(allEvals, slug, { verifiedOnly }),
+    [allEvals, slug, verifiedOnly],
+  )
+
+  const filteredEvals = useMemo(() => {
+    const query = searchQuery.trim().toLowerCase()
+    const list = query
+      ? evals.filter((ev) => {
+          const haystacks = [
+            ev.evaluation_name,
+            ev.family_display_name,
+            ev.composite_benchmark_name,
+          ]
+          return haystacks.some((v) => v?.toLowerCase().includes(query))
+        })
+      : evals
+    return list.slice().sort((a, b) => a.evaluation_name.localeCompare(b.evaluation_name))
+  }, [evals, searchQuery])
+
+  // Quantified facts for the header, derived from the org's owned evals.
+  // familyCount = distinct benchmark families covered; verifiedCount = evals
+  // where this org is a verified evaluator.
+  const { familyCount, verifiedCount } = useMemo(() => {
+    const families = new Set<string>()
+    let verified = 0
+    for (const ev of evals) {
+      const fam = ev.family_display_name?.trim()
+      if (fam) families.add(fam)
+      if (name && (ev.verified_evaluator_names ?? []).includes(name)) verified += 1
+    }
+    return {
+      familyCount: families.size,
+      verifiedCount: verified,
+    }
+  }, [evals, name])
+
+  useEffect(() => {
+    setVisibleCount(PAGE_SIZE)
+  }, [searchQuery, slug, verifiedOnly])
+
+  const visibleEvals = useMemo(
+    () => filteredEvals.slice(0, visibleCount),
+    [filteredEvals, visibleCount],
+  )
+  const hasMore = visibleCount < filteredEvals.length
+  const handleLoadMore = useCallback(() => {
+    setVisibleCount((current) => Math.min(current + PAGE_SIZE, filteredEvals.length))
+  }, [filteredEvals.length])
+
+  const handleBack = useCallback(() => {
+    router.push(verifiedOnly ? "/evals?groupBy=evaluator&verified=1" : "/evals?groupBy=evaluator")
+  }, [router, verifiedOnly])
+
+  if (loading) {
+    return (
+      <div className="min-h-screen bg-background">
+        <Navigation />
+        <main className="ec-page">
+          <div className="flex h-96 items-center justify-center">
+            <div className="kicker">Loading evaluator…</div>
+          </div>
+        </main>
+      </div>
+    )
+  }
+
+  // Slug resolved to no org (bad/expired link) — or the org has no evals
+  // under the active verified filter.
+  if (error || !name) {
+    return (
+      <div className="min-h-screen bg-background">
+        <Navigation />
+        <main className="ec-page">
+          <div className="flex flex-col items-center justify-center h-96 space-y-4">
+            <div className="kicker">{error ?? "Evaluator not found"}</div>
+            <button type="button" onClick={handleBack} className="btn-ec outline">
+              <ArrowLeft className="mr-2 h-4 w-4" />
+              Back
+            </button>
+          </div>
+        </main>
+      </div>
+    )
+  }
+
+  return (
+    <div className="min-h-screen bg-background">
+      <Navigation />
+
+      <main className="mx-auto w-full max-w-[96rem] px-4 pt-12 pb-24 sm:px-8">
+        {/* BREADCRUMB ----------------------------------------------- */}
+        <button
+          type="button"
+          onClick={handleBack}
+          className="ec-crumb mb-4 inline-flex items-center gap-1.5"
+        >
+          <ArrowLeft className="h-3 w-3" />
+          Evaluators
+        </button>
+
+        {/* HEADER --------------------------------------------------- */}
+        <div className="kicker">Evaluator</div>
+        <h1 className="ec-page-h1 inline-flex items-center gap-2">
+          {name}
+          {isVerified && <VerifiedBadge verified size="md" />}
+        </h1>
+        <div
+          className="mb-5 flex flex-wrap items-center gap-3 font-mono text-[11px] uppercase tracking-[0.12em]"
+          style={{ color: "var(--fg-muted)" }}
+        >
+          <span>Reporting organisation</span>
+          <span style={{ color: "var(--fg-subtle)" }}>·</span>
+          <span>
+            {familyCount} {familyCount === 1 ? "family" : "families"}
+          </span>
+          <span style={{ color: "var(--fg-subtle)" }}>·</span>
+          <span>{verifiedCount} verified</span>
+        </div>
+        <p className="ec-page-lede">
+          Reported <strong>{filteredEvals.length.toLocaleString()}</strong>{" "}
+          {filteredEvals.length === 1 ? "evaluation" : "evaluations"} across{" "}
+          <strong>{familyCount.toLocaleString()}</strong>{" "}
+          {familyCount === 1 ? "benchmark family" : "benchmark families"}
+          {verifiedCount > 0 && (
+            <>
+              , <strong>{verifiedCount.toLocaleString()}</strong> verified
+            </>
+          )}
+          {verifiedOnly ? " (verified submissions only)" : ""}.
+        </p>
+
+        <div className="ec-page-meta mt-2">
+          <div className="ec-page-meta-item">
+            <span className="ec-page-meta-item-l">Evaluations</span>
+            <span className="ec-page-meta-item-v">{filteredEvals.length.toLocaleString()}</span>
+          </div>
+          <div className="ec-page-meta-item">
+            <span className="ec-page-meta-item-l">Verified</span>
+            <span className="ec-page-meta-item-v">{verifiedCount.toLocaleString()}</span>
+          </div>
+          <div className="ec-page-meta-item">
+            <span className="ec-page-meta-item-l">Families</span>
+            <span className="ec-page-meta-item-v">{familyCount.toLocaleString()}</span>
+          </div>
+        </div>
+
+        {/* META + FILTER BAR --------------------------------------- */}
+        <div className="mb-6 flex flex-wrap items-center gap-x-8 gap-y-3 border-y border-[color:var(--border-soft)] py-4">
+          <div className="flex shrink-0 flex-wrap items-baseline gap-x-4 gap-y-1 font-mono text-[11px] tracking-[0.1em] uppercase text-[color:var(--fg-subtle)]">
+            <span>
+              <span className="text-[color:var(--fg)] tabular-nums font-semibold mr-1">
+                {filteredEvals.length.toLocaleString()}
+              </span>
+              {filteredEvals.length === 1 ? "evaluation" : "evaluations"}
+            </span>
+          </div>
+
+          <span className="hidden h-5 w-px bg-[color:var(--border-soft)] sm:block" />
+
+          <div className="relative min-w-[200px] flex-1 sm:max-w-[300px]">
+            <Search className="pointer-events-none absolute left-3 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-[color:var(--fg-subtle)]" />
+            <input
+              className="ec-input pl-9"
+              value={searchQuery}
+              onChange={(event) => setSearchQuery(event.target.value)}
+              placeholder="Search evaluations…"
+            />
+          </div>
+        </div>
+
+        {/* EVAL CARDS ---------------------------------------------- */}
+        {filteredEvals.length === 0 ? (
+          <div className="border border-dashed border-[color:var(--border-soft)] bg-[color:var(--bg-warm)] py-12 text-center font-mono text-[11px] uppercase tracking-[0.2em] text-[color:var(--fg-subtle)]">
+            No evaluations match the current filters
+          </div>
+        ) : (
+          <div className="grid grid-cols-1 gap-4 md:grid-cols-2 xl:grid-cols-3">
+            {visibleEvals.map((ev, i) => (
+              <EvalCard key={ev.evaluation_id} summary={ev} delayMs={Math.min(i, 8) * 40} />
+            ))}
+          </div>
+        )}
+
+        <InfiniteScrollSentinel
+          hasMore={hasMore}
+          onLoadMore={handleLoadMore}
+          loadingLabel="Loading more…"
+          endLabel={`Showing ${Math.min(visibleCount, filteredEvals.length).toLocaleString()} of ${filteredEvals.length.toLocaleString()} evaluations`}
+        />
+      </main>
+    </div>
+  )
+}
+
+export default function EvaluatorDetailPage() {
+  return (
+    <Suspense fallback={null}>
+      <EvaluatorDetailInner />
+    </Suspense>
+  )
+}

components/benchmark-detail.tsx

@@ -24,6 +24,7 @@ import {
 } from "@/components/signals/provenance-badge"
 import { SignalsRowBadges } from "@/components/signals/signals-row-badges"
 import { SignalTooltip } from "@/components/signals/signal-tooltip"
+import { VerifiedBadge } from "@/components/signals/verified-badge"
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -9443,8 +9444,9 @@ function CategoryStatsView({
                             : normalizeDisplayLabel(eval_.source_data.dataset_name))}
                         </div>
                       </div>
-                      <div className="font-mono font-semibold">
+                      <div className="flex items-center gap-1.5 font-mono font-semibold">
                         {formatRawScoreValue(result.score_details.score, result.metric_config.unit)}
+                        <VerifiedBadge verified={result.is_verified_evaluator} />
                       </div>
                     </div>
                   ))

components/eval-card.tsx

@@ -4,6 +4,7 @@ import type { ComponentType, CSSProperties } from "react"
 import { useAudienceMode } from "@/components/audience-mode-provider"
 import { Badge } from "@/components/ui/badge"
 import { Card, CardContent, CardHeader } from "@/components/ui/card"
+import { VerifiedBadge } from "@/components/signals/verified-badge"
 import { useRouter } from "next/navigation"
 import {
   AlertTriangle,
@@ -16,7 +17,9 @@ import {
   Scale,
   Users,
 } from "lucide-react"
+import Link from "next/link"
 import { routeIdToPath } from "@/lib/utils"
+import { evaluatorSlug } from "@/lib/evaluators"
 import type { BenchmarkEvalListItem } from "@/lib/eval-processing"
 import { getTagColor, tagLabel } from "@/lib/benchmark-schema"
 
@@ -78,6 +81,8 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
   const rawSimilar = card?.benchmark_details?.similar_benchmarks
   const similarBenchmarks: string[] = Array.isArray(rawSimilar) ? rawSimilar : rawSimilar ? [rawSimilar] : []
   const domainPreview = domains.slice(0, 2)
+  // Validated evaluators (subset of evaluator_names) for the badge.
+  const verifiedEvaluators = new Set(summary.verified_evaluator_names ?? [])
   // Source provenance pulled from the pipeline's source_data
   const sourceData = summary.source_data
   const reproducibilitySummary = summary.reproducibility_summary
@@ -258,7 +263,28 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
             <div className="rounded-xl border bg-muted/10 p-3">
               <div className="space-y-1.5 text-sm">
                 <DataRow label="Avg score" value={scorePercent} />
-                <DataRow label="Reported by" value={summary.evaluator_names.join(", ") || "Unknown"} />
+                <div className="flex items-start justify-between gap-3">
+                  <span className="shrink-0 text-muted-foreground">Reported by</span>
+                  <span className="text-right font-medium text-foreground">
+                    {summary.evaluator_names.length === 0
+                      ? "Unknown"
+                      : summary.evaluator_names.map((name, i) => (
+                          <span key={name} className="inline-flex items-center">
+                            {i > 0 ? ", " : null}
+                            <Link
+                              href={`/evaluators/${evaluatorSlug(name)}`}
+                              className="hover:text-[color:var(--accent)] hover:underline"
+                              onClick={(e) => e.stopPropagation()}
+                            >
+                              {name}
+                            </Link>
+                            {verifiedEvaluators.has(name) ? (
+                              <VerifiedBadge verified size="sm" className="ml-1 align-middle" />
+                            ) : null}
+                          </span>
+                        ))}
+                  </span>
+                </div>
                 {reproducibilityGapCount > 0 && (
                   <p className="pt-1 text-xs text-muted-foreground">
                     {reproducibilityGapCount} of {reproducibilityResultsTotal} reported scores are not fully documented.

components/eval-detail.tsx

@@ -5,6 +5,7 @@ import { Fragment, useEffect, useMemo, useState } from "react"
 import Link from "next/link"
 import { BenchmarkSignalsStrip } from "@/components/signals/benchmark-signals-strip"
 import { SignalsRowBadges } from "@/components/signals/signals-row-badges"
+import { VerifiedBadge } from "@/components/signals/verified-badge"
 import { getCompletenessPopulatedCount } from "@/components/signals/signal-utils"
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible"
 import { ScoreDistribution } from "@/components/score-distribution"
@@ -53,6 +54,7 @@ import {
 import type { BenchmarkCard, SourceData } from "@/lib/benchmark-schema"
 import { tagLabel } from "@/lib/benchmark-schema"
 import type { BenchmarkEvalSummary, ModelResultForBenchmark } from "@/lib/eval-processing"
+import { evaluatorSlug } from "@/lib/evaluators"
 import type { ComparisonIndex, EvalHierarchy } from "@/lib/backend-artifacts"
 import type { HierarchyEvalLocation } from "@/lib/hierarchy-lookup"
 import { PolicyOverview } from "@/components/policy-overview"
@@ -406,6 +408,38 @@ function formatMetadataValue(value: unknown): string {
 // and other surfaces format identically.
 const formatDate = formatDateISO
 
+/**
+ * Render an evaluator org name. When `linkName` is a known evaluator (a
+ * de-aliased name with a /evaluators/<slug> page) the name links there;
+ * otherwise it renders as plain text so we never emit a broken link. The
+ * slug uses the shared, deterministic `evaluatorSlug` base helper.
+ */
+function EvaluatorName({
+  display,
+  linkName,
+  className,
+  style,
+}: {
+  display: React.ReactNode
+  linkName: string | null
+  className?: string
+  style?: React.CSSProperties
+}) {
+  if (!linkName) {
+    return <span className={className} style={style}>{display}</span>
+  }
+  return (
+    <Link
+      href={`/evaluators/${evaluatorSlug(linkName)}`}
+      className={cn("hover:text-[color:var(--accent)] hover:underline", className)}
+      style={style}
+      onClick={(e) => e.stopPropagation()}
+    >
+      {display}
+    </Link>
+  )
+}
+
 /**
  * Render a benchmark-card field path (e.g. `methodology.metrics`,
  * `purpose_and_intended_users.goal`) as a human-readable label —
@@ -535,11 +569,42 @@ function getCompactMetricLabel(value: string | undefined): string {
 }
 
 /**
- * Build a chip-friendly label for a leaderboard metric. Prefers
- * display_name, then metric_name, then a humanised tail of metric_id /
- * column_key. The upstream pipeline frequently leaves display_name
- * blank (e.g. inspect_evals/avg_full_score), in which case the
- * column_key tail ('avg_full_score') is what we want to surface.
+ * Humanise a raw metric identifier (metric_id / column_key) into a
+ * compact, readable label.
+ *
+ * Two shapes the upstream view layer leaves un-curated:
+ *  - path-ish keys (`inspect_evals/avg_full_score`) → keep the tail
+ *    (`avg full score`).
+ *  - `<benchmark-slug>.<stat>` keys (`cyse2-vulnerability-exploit.mean`,
+ *    `swebench-…-mariushobbhahn.mean`) → the slug prefix just repeats the
+ *    eval name, so collapse to the trailing stat (`Mean`). Without this the
+ *    column header echoes the raw UPPER.SLUG.
+ */
+function humanizeMetricKey(raw: string): string {
+  const tail = compactizePath(raw)
+  // `<slug>.mean` / `.std` / `.stderr` → just the trailing stat.
+  const dotMatch = /^(.+)\.([a-z0-9_]+)$/i.exec(tail)
+  if (dotMatch) {
+    const [, prefix, stat] = dotMatch
+    // Only collapse when the prefix looks like a slug (has a hyphen or is
+    // long), not a genuinely dotted metric name.
+    if (prefix.includes("-") || prefix.length > 6) {
+      return humanizeMetricKey(stat)
+    }
+  }
+  const spaced = tail.replace(/_/g, " ").trim()
+  if (!spaced) return tail
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1)
+}
+
+/**
+ * Build a chip-friendly label for a leaderboard metric. Prefers a curated
+ * display_name / metric_name, then a humanised tail of metric_id /
+ * column_key. The upstream pipeline frequently leaves display_name blank
+ * (e.g. inspect_evals/avg_full_score → ifeval's final_acc, inst_loose_acc)
+ * or echoes the raw column key as the "display name" (cyse2's
+ * `cyse2-vulnerability-exploit.mean`). In both cases the humanised key tail
+ * is what we want to surface — never the literal 'Metric' or a raw slug.
  */
 function getMetricChipLabel(metric: {
   display_name?: string | null
@@ -547,17 +612,24 @@ function getMetricChipLabel(metric: {
   metric_id?: string | null
   column_key?: string | null
 }): string {
+  const key = metric.metric_id ?? metric.column_key ?? null
+  // Treat a display/metric name that merely echoes the raw column key as
+  // absent — it carries no more information than the key itself.
+  const isRawEcho = (value: string | null | undefined) =>
+    !!value && !!key && value.trim() === key.trim()
+
   const candidates = [
-    metric.display_name,
-    metric.metric_name,
-    metric.metric_id,
-    metric.column_key,
+    isRawEcho(metric.display_name) ? null : metric.display_name,
+    isRawEcho(metric.metric_name) ? null : metric.metric_name,
   ]
   for (const c of candidates) {
     if (c && String(c).trim()) {
       return compactizePath(String(c)).replace(/_/g, " ")
     }
   }
+  if (key && key.trim()) {
+    return humanizeMetricKey(key)
+  }
   return "Metric"
 }
 
@@ -931,17 +1003,6 @@ export function EvalDetail({
     return userRowSort.dir === "asc" ? "↑" : "↓"
   }
 
-  // Hide the "Updated" column when no row has a usable timestamp —
-  // every cell would say "Unknown" otherwise. formatDate returns the
-  // string "Unknown" for null / empty / unparseable inputs.
-  const hasAnyUpdatedTimestamp = useMemo(
-    () =>
-      leaderboardRows.some(
-        ({ modelResult }) => formatDate(modelResult.evaluation_timestamp) !== "Unknown",
-      ),
-    [leaderboardRows],
-  )
-
   const avgScoreLabel = formatRawScore(lb.avg_score, lb.metric_config.unit)
   const scoreDirectionLabel = lb.metric_config.lower_is_better ? "Lower scores rank higher" : "Higher scores rank higher"
   const leaderboardTitle = isResearchView ? "Leaderboard" : "Reporting Comparison"
@@ -989,12 +1050,41 @@ export function EvalDetail({
   // identical in chrome — naming the evaluator up-front is the cheapest
   // way to make the pages visually distinct.
   const evaluatorList = summary.evaluator_names ?? []
-  const reporterLabel = (() => {
-    if (evaluatorList.length === 0) return null
-    const head = evaluatorList.slice(0, 2)
-    const extra = evaluatorList.length - head.length
-    return extra > 0 ? `${head.join(", ")} +${extra} more` : head.join(", ")
-  })()
+  // Validated evaluators (de-aliased names, same space as evaluator_names),
+  // straight from the backend rollup — used to badge the "Reported by" names.
+  const verifiedEvaluators = useMemo(
+    () => new Set(summary.verified_evaluator_names ?? []),
+    [summary.verified_evaluator_names],
+  )
+
+  // De-aliased evaluator names that have a /evaluators/<slug> page. The header
+  // renders these names directly (always linkable); the per-row Source column
+  // shows a *raw* source name, so we resolve it case-insensitively against the
+  // known evaluator names and only link when it maps to a real evaluator page.
+  // We key on the union of summary + active-split evaluator names so a split
+  // view's Source cells still resolve.
+  const knownEvaluatorByLower = useMemo(() => {
+    const m = new Map<string, string>()
+    for (const n of [...(summary.evaluator_names ?? []), ...(lb.evaluator_names ?? [])]) {
+      const t = (n ?? "").trim()
+      if (t) m.set(t.toLowerCase(), t)
+    }
+    return m
+  }, [summary.evaluator_names, lb.evaluator_names])
+
+  // Resolve a (raw or de-aliased) org name to a known evaluator's de-aliased
+  // name, or null when it isn't a known evaluator (→ render plain text). The
+  // per-row Source value is the *raw* source name (e.g. "crfm"), which can be
+  // an alias of a de-aliased evaluator ("Stanford CRFM"); when it doesn't match
+  // directly but the eval has exactly one evaluator, that row unambiguously
+  // belongs to it, so we link to the sole evaluator.
+  const soleEvaluator =
+    knownEvaluatorByLower.size === 1 ? Array.from(knownEvaluatorByLower.values())[0] : null
+  const resolveEvaluatorName = (raw: string | undefined | null): string | null => {
+    const t = (raw ?? "").trim()
+    if (!t) return null
+    return knownEvaluatorByLower.get(t.toLowerCase()) ?? soleEvaluator
+  }
 
   const heroLede = isResearchView
     ? summary.metric_config.evaluation_description
@@ -1006,7 +1096,7 @@ export function EvalDetail({
     <div className="space-y-12">
       {/* HERO ------------------------------------------------ */}
       <header className="motion-academic-enter">
-        {reporterLabel && (
+        {evaluatorList.length > 0 && (
           <div
             className="font-mono uppercase"
             style={{
@@ -1017,7 +1107,18 @@ export function EvalDetail({
             }}
           >
             <span style={{ color: "var(--fg-muted)" }}>Reported by </span>
-            <span style={{ color: "var(--fg)" }}>{reporterLabel}</span>
+            {evaluatorList.slice(0, 2).map((name, i) => (
+              <span key={name} style={{ color: "var(--fg)" }}>
+                {i > 0 ? ", " : null}
+                <EvaluatorName display={name} linkName={resolveEvaluatorName(name)} />
+                {verifiedEvaluators.has(name) ? (
+                  <VerifiedBadge verified size="sm" className="ml-1 align-middle" />
+                ) : null}
+              </span>
+            ))}
+            {evaluatorList.length > 2 ? (
+              <span style={{ color: "var(--fg)" }}> +{evaluatorList.length - 2} more</span>
+            ) : null}
           </div>
         )}
         <h1
@@ -1684,17 +1785,6 @@ export function EvalDetail({
                       title="Sort by model release date"
                     />
                   </th>
-                  {hasAnyUpdatedTimestamp && (
-                    <th className="hidden xl:table-cell num" style={{ width: 110 }}>
-                      <SortableTh
-                        label="Updated"
-                        active={userRowSort.key === "updated"}
-                        indicator={rowSortIndicator("updated")}
-                        onClick={() => cycleRowSort("updated")}
-                        title="Sort by report timestamp"
-                      />
-                    </th>
-                  )}
                 </tr>
               </thead>
               <tbody>
@@ -1735,6 +1825,13 @@ export function EvalDetail({
                     (!Array.isArray(modelResult.source_data) && modelResult.source_data.source_type) ||
                     modelResult.source_metadata.source_type ||
                     ""
+                  // Link the Source value to its evaluator page when the row's
+                  // org resolves to a known (de-aliased) evaluator. Try the org
+                  // name first, then the displayed source label.
+                  const sourceEvaluatorName =
+                    resolveEvaluatorName(modelResult.source_metadata.source_organization_name) ??
+                    resolveEvaluatorName(modelResult.source_metadata.source_name) ??
+                    resolveEvaluatorName(sourceTypeLabel)
                   const familyLabel = modelResult.model_info.architecture
                     ?? modelResult.model_info.parameter_count
                     ?? null
@@ -1898,25 +1995,35 @@ export function EvalDetail({
 
                         <td className="num hidden lg:table-cell align-top">
                           {sourceTypeLabel ? (
-                            modelResult.source_metadata.source_url ? (
-                              <a
-                                href={modelResult.source_metadata.source_url}
-                                target="_blank"
-                                rel="noreferrer"
-                                className="font-mono lowercase hover:text-[color:var(--accent)]"
-                                style={{ fontSize: 11, color: "var(--fg-muted)" }}
-                                onClick={(e) => e.stopPropagation()}
-                              >
-                                {sourceTypeLabel}
-                              </a>
-                            ) : (
-                              <span
-                                className="font-mono lowercase"
-                                style={{ fontSize: 11, color: "var(--fg-muted)" }}
-                              >
-                                {sourceTypeLabel}
-                              </span>
-                            )
+                            <span className="inline-flex items-center justify-end gap-1">
+                              {sourceEvaluatorName ? (
+                                <EvaluatorName
+                                  display={sourceTypeLabel}
+                                  linkName={sourceEvaluatorName}
+                                  className="font-mono lowercase"
+                                  style={{ fontSize: 11, color: "var(--fg-muted)" }}
+                                />
+                              ) : modelResult.source_metadata.source_url ? (
+                                <a
+                                  href={modelResult.source_metadata.source_url}
+                                  target="_blank"
+                                  rel="noreferrer"
+                                  className="font-mono lowercase hover:text-[color:var(--accent)]"
+                                  style={{ fontSize: 11, color: "var(--fg-muted)" }}
+                                  onClick={(e) => e.stopPropagation()}
+                                >
+                                  {sourceTypeLabel}
+                                </a>
+                              ) : (
+                                <span
+                                  className="font-mono lowercase"
+                                  style={{ fontSize: 11, color: "var(--fg-muted)" }}
+                                >
+                                  {sourceTypeLabel}
+                                </span>
+                              )}
+                              <VerifiedBadge verified={modelResult.result?.is_verified_evaluator} size="sm" />
+                            </span>
                           ) : (
                             <span style={{ color: "var(--fg-subtle)" }}>—</span>
                           )}
@@ -1931,16 +2038,11 @@ export function EvalDetail({
                             : <span style={{ color: "var(--fg-subtle)" }}>—</span>}
                         </td>
 
-                        {hasAnyUpdatedTimestamp && (
-                          <td className="num hidden xl:table-cell align-top font-mono tabular-nums" style={{ fontSize: 11, color: "var(--fg-muted)" }}>
-                            {formatDate(modelResult.evaluation_timestamp)}
-                          </td>
-                        )}
                       </tr>
 
                       {isExpanded && (
                         <tr>
-                          <td colSpan={hasAnyUpdatedTimestamp ? 8 : 7} style={{ background: "var(--bg-warm)", padding: 0 }}>
+                          <td colSpan={7} style={{ background: "var(--bg-warm)", padding: 0 }}>
                             <div className="space-y-5 px-4 py-5 sm:px-6">
                               {/* The Model Profile / Provenance / Score Breakdown
                                   panels were removed — model metadata lives on
@@ -2134,7 +2236,7 @@ export function EvalDetail({
                 })}
                 {leaderboardRows.length === 0 && (
                   <tr>
-                    <td colSpan={hasAnyUpdatedTimestamp ? 8 : 7} style={{ padding: "32px 16px", textAlign: "center", color: "var(--fg-muted)" }}>
+                    <td colSpan={7} style={{ padding: "32px 16px", textAlign: "center", color: "var(--fg-muted)" }}>
                       No leaderboard entries match the selected parameter range.
                     </td>
                   </tr>
@@ -2193,6 +2295,24 @@ function MultiMetricLeaderboard({
   const [maxParamStep, setMaxParamStep] = useState(PARAM_RANGE_MAX_INDEX)
   const [expandedRows, setExpandedRows] = useState<Record<string, boolean>>({})
 
+  // Resolve a raw Source-column org name to a known (de-aliased) evaluator name
+  // so the cell can link to /evaluators/<slug>; null → render plain text.
+  const knownEvaluatorByLower = useMemo(() => {
+    const m = new Map<string, string>()
+    for (const n of summary.evaluator_names ?? []) {
+      const t = (n ?? "").trim()
+      if (t) m.set(t.toLowerCase(), t)
+    }
+    return m
+  }, [summary.evaluator_names])
+  const soleEvaluator =
+    knownEvaluatorByLower.size === 1 ? Array.from(knownEvaluatorByLower.values())[0] : null
+  const resolveEvaluatorName = (raw: string | undefined | null): string | null => {
+    const t = (raw ?? "").trim()
+    if (!t) return null
+    return knownEvaluatorByLower.get(t.toLowerCase()) ?? soleEvaluator
+  }
+
   // Index ModelResultForBenchmark entries by model_info.id so we can power the
   // research-mode reproducibility card from a multi-metric row. There may be
   // several entries per model (one per metric); we prefer one with a recorded
@@ -2251,6 +2371,40 @@ function MultiMetricLeaderboard({
 
   const hasSliceTabs = sliceTabs.length > 1
 
+  // A `<benchmark-slug>.mean` column whose per-row values are identical to an
+  // earlier column (e.g. cyse2's `cyse2-vulnerability-exploit.mean` mirrors
+  // `accuracy`) is a redundant alias of the primary score, not a distinct
+  // measure. Suppress it so the matrix doesn't render two columns of the same
+  // numbers under a humanised "Mean" header next to the real metric.
+  const duplicateMeanColumnKeys = useMemo(() => {
+    const dupes = new Set<string>()
+    const meanMetrics = leaderboardMetrics.filter(
+      (m) => m.scope !== "subtask" && /\.mean$/i.test(m.column_key),
+    )
+    if (meanMetrics.length === 0) return dupes
+    const others = leaderboardMetrics.filter((m) => m.scope !== "subtask")
+    const valuesEqual = (a: string, b: string) => {
+      let comparable = 0
+      for (const row of leaderboardRows) {
+        const va = row.values[a]
+        const vb = row.values[b]
+        const aNum = isNumericScore(va)
+        const bNum = isNumericScore(vb)
+        if (aNum !== bNum) return false
+        if (aNum && bNum && Math.abs(va - vb) > 1e-6) return false
+        if (aNum && bNum) comparable += 1
+      }
+      return comparable > 0
+    }
+    for (const mean of meanMetrics) {
+      const twin = others.find(
+        (o) => o.column_key !== mean.column_key && valuesEqual(mean.column_key, o.column_key),
+      )
+      if (twin) dupes.add(mean.column_key)
+    }
+    return dupes
+  }, [leaderboardMetrics, leaderboardRows])
+
   const visibleMetrics = useMemo(
     () =>
       leaderboardMetrics.filter((metric) => {
@@ -2258,6 +2412,10 @@ function MultiMetricLeaderboard({
           return false
         }
 
+        if (duplicateMeanColumnKeys.has(metric.column_key)) {
+          return false
+        }
+
         if (!hasSliceTabs || activeSliceTab === "all") {
           // "All" / no-slice-filter case: only show root metrics so the
           // chips stay one-per-metric instead of one-per-(metric, slice).
@@ -2266,7 +2424,7 @@ function MultiMetricLeaderboard({
 
         return metric.scope === "subtask" && metric.subtask_key === activeSliceTab
       }),
-    [activeSliceTab, hasSliceTabs, leaderboardMetrics, visibleMetricKeySet]
+    [activeSliceTab, duplicateMeanColumnKeys, hasSliceTabs, leaderboardMetrics, visibleMetricKeySet]
   )
   const visibleMetricColumnKeySet = useMemo(
     () => new Set(visibleMetrics.map((metric) => metric.column_key)),
@@ -2683,7 +2841,7 @@ function MultiMetricLeaderboard({
                   // name is already shown above the table — no need to
                   // repeat it as a per-column topline.
                   const showSliceTopline = false
-                  const mainLabel = getCompactMetricLabel(metric.display_name)
+                  const mainLabel = getMetricChipLabel(metric)
                   return (
                     <th
                       key={metric.column_key}
@@ -2710,6 +2868,8 @@ function MultiMetricLeaderboard({
                     </th>
                   )
                 })}
+                <th className="hidden lg:table-cell" style={{ width: 110 }}>Evaluator</th>
+                <th className="num hidden lg:table-cell" style={{ width: 100 }}>Source</th>
                 <th
                   className="num hidden lg:table-cell"
                   style={{ width: 110, cursor: "pointer" }}
@@ -2718,13 +2878,6 @@ function MultiMetricLeaderboard({
                 >
                   Released{getSortIndicator("released")}
                 </th>
-                <th
-                  className="num hidden xl:table-cell"
-                  style={{ width: 110, cursor: "pointer" }}
-                  onClick={() => handleSort("updated")}
-                >
-                  Updated{getSortIndicator("updated")}
-                </th>
               </tr>
             </thead>
             <tbody>
@@ -2818,6 +2971,42 @@ function MultiMetricLeaderboard({
                     )
                   })}
 
+                  <td className="hidden lg:table-cell align-top">
+                    <span className="font-mono uppercase" style={{ fontSize: 11, color: "var(--fg-muted)" }}>
+                      {row.source_metadata?.evaluator_relationship === "first_party"
+                        ? "SELF"
+                        : row.source_metadata?.evaluator_relationship === "third_party"
+                          ? "THIRD-PARTY"
+                          : "—"}
+                    </span>
+                  </td>
+                  <td className="num hidden lg:table-cell align-top">
+                    {(() => {
+                      const sourceLabel =
+                        row.source_metadata?.source_name?.trim()
+                        || row.source_metadata?.source_organization_name?.trim()
+                      const sourceEvaluatorName =
+                        resolveEvaluatorName(row.source_metadata?.source_organization_name)
+                        ?? resolveEvaluatorName(row.source_metadata?.source_name)
+                      return sourceLabel ? (
+                      <span className="inline-flex items-center justify-end gap-1">
+                        <EvaluatorName
+                          display={sourceLabel}
+                          linkName={sourceEvaluatorName}
+                          className="font-mono lowercase"
+                          style={{ fontSize: 11, color: "var(--fg-muted)" }}
+                        />
+                        <VerifiedBadge
+                          verified={Object.values(row.verified ?? {}).some(Boolean)}
+                          size="sm"
+                        />
+                      </span>
+                    ) : (
+                      <span style={{ color: "var(--fg-subtle)" }}>—</span>
+                    )
+                    })()}
+                  </td>
+
                   <td
                     className="num hidden lg:table-cell align-top font-mono tabular-nums"
                     style={{ fontSize: 11, color: "var(--fg-muted)" }}
@@ -2826,14 +3015,11 @@ function MultiMetricLeaderboard({
                       ? formatDate(row.model_info.release_date).split(",")[0]
                       : <span style={{ color: "var(--fg-subtle)" }}>—</span>}
                   </td>
-                  <td className="num hidden xl:table-cell align-top font-mono tabular-nums" style={{ fontSize: 11, color: "var(--fg-muted)" }}>
-                    {formatDate(row.evaluation_timestamp)}
-                  </td>
                 </tr>
                 {isResearchView && isExpanded && matchingResult && (
                   <tr>
                     <td
-                      colSpan={visibleMetrics.length + 6}
+                      colSpan={visibleMetrics.length + 7}
                       style={{ background: "var(--bg-warm)", padding: "20px 24px" }}
                     >
                       <div className="space-y-3">
@@ -2863,7 +3049,7 @@ function MultiMetricLeaderboard({
 
               {filteredRows.length === 0 && (
                 <tr>
-                  <td colSpan={visibleMetrics.length + 5} style={{ padding: "32px 16px", textAlign: "center", color: "var(--fg-muted)" }}>
+                  <td colSpan={visibleMetrics.length + 6} style={{ padding: "32px 16px", textAlign: "center", color: "var(--fg-muted)" }}>
                     No models match the selected parameter range.
                   </td>
                 </tr>

components/evaluator-table.tsx

@@ -0,0 +1,115 @@
+"use client"
+
+import Link from "next/link"
+import { ArrowUpRight, ChevronDown, ChevronUp, ChevronsUpDown } from "lucide-react"
+
+import { VerifiedBadge } from "@/components/signals/verified-badge"
+import type { EvaluatorGroup } from "@/lib/evaluators"
+import { cn } from "@/lib/utils"
+
+export type EvaluatorTableSortCol = "name" | "evals" | "verified"
+
+interface EvaluatorTableProps {
+  rows: EvaluatorGroup[]
+  sortCol: EvaluatorTableSortCol
+  sortDir: "asc" | "desc"
+  onSort: (col: EvaluatorTableSortCol) => void
+  /** When true, the verified filter is active — propagate it into the link. */
+  verifiedOnly?: boolean
+}
+
+export function EvaluatorTable({ rows, sortCol, sortDir, onSort, verifiedOnly }: EvaluatorTableProps) {
+  function SortIcon({ col }: { col: EvaluatorTableSortCol }) {
+    if (sortCol !== col) return <ChevronsUpDown className="h-3 w-3 opacity-30" aria-hidden />
+    return sortDir === "asc"
+      ? <ChevronUp className="h-3 w-3" aria-hidden />
+      : <ChevronDown className="h-3 w-3" aria-hidden />
+  }
+
+  function SortTh({
+    col,
+    children,
+    className,
+    style,
+  }: {
+    col: EvaluatorTableSortCol
+    children: React.ReactNode
+    className?: string
+    style?: React.CSSProperties
+  }) {
+    const active = sortCol === col
+    return (
+      <th
+        className={className}
+        style={{
+          ...style,
+          cursor: "pointer",
+          userSelect: "none",
+          color: active ? "var(--fg)" : undefined,
+        }}
+        onClick={() => onSort(col)}
+      >
+        <span className={cn("inline-flex items-center gap-1", className?.includes("num") && "justify-end")}>
+          {children}
+          <SortIcon col={col} />
+        </span>
+      </th>
+    )
+  }
+
+  const hrefFor = (slug: string) =>
+    verifiedOnly ? `/evaluators/${slug}?verified=1` : `/evaluators/${slug}`
+
+  return (
+    <div className="overflow-x-auto">
+      <table className="ec-htable">
+        <thead>
+          <tr>
+            <SortTh col="name" style={{ width: "55%" }}>Evaluator</SortTh>
+            <SortTh col="evals" className="num">Evaluations reported</SortTh>
+            <SortTh col="verified" className="num">Verified</SortTh>
+            <th style={{ width: 90 }} />
+          </tr>
+        </thead>
+        <tbody>
+          {rows.map((row) => (
+            <tr key={row.slug}>
+              <td>
+                <Link href={hrefFor(row.slug)} className="block min-w-0 group">
+                  <div className="flex items-center gap-1.5">
+                    <span className="font-semibold text-[14px] text-[color:var(--fg)] group-hover:text-[color:var(--accent)] transition-colors">
+                      {row.name}
+                    </span>
+                    {row.isVerified && <VerifiedBadge verified size="sm" />}
+                  </div>
+                </Link>
+              </td>
+              <td className="num font-mono text-[13px]">
+                {row.evalCount.toLocaleString()}
+              </td>
+              <td className="num font-mono text-[13px]">
+                {row.verifiedCount > 0 ? (
+                  <span className="inline-flex items-center gap-1 text-[color:var(--accent)]">
+                    {row.verifiedCount.toLocaleString()}
+                    <VerifiedBadge verified size="sm" withTooltip={false} />
+                  </span>
+                ) : (
+                  <span className="text-[color:var(--fg-subtle)]">—</span>
+                )}
+              </td>
+              <td>
+                <Link
+                  href={hrefFor(row.slug)}
+                  className="font-mono text-[10px] tracking-[0.12em] uppercase text-[color:var(--accent)] hover:text-[color:var(--accent-hover)] inline-flex items-center gap-1"
+                >
+                  Open
+                  <ArrowUpRight className="h-3 w-3" aria-hidden />
+                </Link>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+}

components/family-table.tsx

@@ -24,6 +24,11 @@ interface FamilyTableProps {
    *  decided which families pass; FamilyTable uses the same query to
    *  narrow each row's visible leaves to the matches and auto-expand. */
   searchQuery?: string
+  /** When provided, restrict leaves to those mapping to one of these
+   *  evaluation_ids (drives the /evals "Verified only" filter in Family
+   *  mode — the set is the verified-eval id universe). Null/undefined =
+   *  no restriction. */
+  verifiedEvalIds?: Set<string> | null
   sortCol?: FamilySortCol
   sortDir?: "asc" | "desc"
   onSort?: (col: FamilySortCol) => void
@@ -52,6 +57,8 @@ function humanizeFamilyKey(key: string): string {
 
 interface LeafEntry {
   id: string
+  /** All evaluation_ids this leaf maps to (constituent ids or fallbacks). */
+  evalIds: string[]
   leafKey: string
   leafName: string
   evalsCount: number
@@ -98,6 +105,7 @@ function buildLeafEntry(
 
   return {
     id: ids[0],
+    evalIds: ids,
     leafKey: benchmark.key,
     leafName: benchmark.display_name || benchmark.key,
     evalsCount: ids.length,
@@ -205,6 +213,7 @@ export function FamilyTable({
   domainFilter,
   categoryFilter,
   searchQuery,
+  verifiedEvalIds,
   sortCol,
   sortDir,
   onSort,
@@ -214,9 +223,10 @@ export function FamilyTable({
 
   const domainFilterActive = Boolean(domainFilter && domainFilter.size > 0)
   const categoryFilterActive = Boolean(categoryFilter && categoryFilter.size > 0)
+  const verifiedFilterActive = Boolean(verifiedEvalIds)
   const normalizedQuery = (searchQuery ?? "").trim().toLowerCase()
   const searchActive = normalizedQuery.length > 0
-  const filterActive = domainFilterActive || categoryFilterActive || searchActive
+  const filterActive = domainFilterActive || categoryFilterActive || searchActive || verifiedFilterActive
 
   function leafMatchesDomain(leaf: LeafEntry): boolean {
     if (!domainFilterActive || !domainFilter) return true
@@ -237,9 +247,15 @@ export function FamilyTable({
     return false
   }
 
+  function leafMatchesVerified(leaf: LeafEntry): boolean {
+    if (!verifiedFilterActive || !verifiedEvalIds) return true
+    return leaf.evalIds.some((id) => verifiedEvalIds.has(id))
+  }
+
   function leafMatchesFilter(leaf: LeafEntry, opts?: { skipQuery?: boolean }): boolean {
     if (!leafMatchesDomain(leaf)) return false
     if (!leafMatchesCategory(leaf)) return false
+    if (!leafMatchesVerified(leaf)) return false
     if (!opts?.skipQuery && !leafMatchesQuery(leaf)) return false
     return true
   }
@@ -263,8 +279,14 @@ export function FamilyTable({
     if (leafEntries.some((leaf) => leafMatchesFilter(leaf))) return true
     // Family-level search match keeps the row even if no leaf survives
     // the leaf-query filter (the row will fall back to showing all
-    // leaves).
-    if (searchActive && familyMatchedAtFamilyLevel(fam)) return true
+    // leaves). But the verified filter is a hard leaf-level gate: never
+    // resurrect a family that has zero verified leaves.
+    if (
+      searchActive &&
+      familyMatchedAtFamilyLevel(fam) &&
+      leafEntries.some((leaf) => leafMatchesVerified(leaf))
+    )
+      return true
     if (categoryFilterActive && categoryFilter) {
       for (const tag of fam.derivedTags ?? []) {
         if (categoryFilter.has(tag) && !domainFilterActive) return true

components/signals/signal-tooltip.tsx

@@ -3,12 +3,17 @@
 import type { ReactNode } from "react"
 import * as TooltipPrimitive from "@radix-ui/react-tooltip"
 
+import { cn } from "@/lib/utils"
+
 export function SignalTooltip({
   children,
   content,
+  contentClassName,
 }: {
   children: ReactNode
   content: ReactNode
+  /** Per-instance overrides for the tooltip box (e.g. tighter one-line copy). */
+  contentClassName?: string
 }) {
   return (
     <TooltipPrimitive.Provider delayDuration={150}>
@@ -19,7 +24,10 @@ export function SignalTooltip({
             side="top"
             align="center"
             sideOffset={8}
-            className="z-50 max-w-80 rounded-md border border-border/70 bg-popover px-3 py-2 text-xs leading-5 text-popover-foreground shadow-lg"
+            className={cn(
+              "z-50 max-w-80 rounded-md border border-border/70 bg-popover px-3 py-2 text-xs leading-5 text-popover-foreground shadow-lg",
+              contentClassName,
+            )}
           >
             {content}
             <TooltipPrimitive.Arrow className="fill-popover" />

components/signals/verified-badge.tsx

@@ -0,0 +1,245 @@
+"use client"
+
+import { Check, CheckCircle2, ShieldCheck } from "lucide-react"
+
+import { useAudienceMode } from "@/components/audience-mode-provider"
+import { Badge } from "@/components/ui/badge"
+import { cn } from "@/lib/utils"
+import { SignalTooltip } from "./signal-tooltip"
+
+/**
+ * VerifiedBadge — a small, simple "this result is verified" marker shown
+ * next to an individual evaluation result / metric value.
+ *
+ * Driven by a single boolean (`is_verified`) the producer emits per atomic
+ * result (see docs/verified-badge/README.md). When the flag is false / absent
+ * the component renders nothing, so unverified rows stay visually quiet —
+ * mirroring the existing row-signal badges (RowSignalsCompact, etc.).
+ *
+ * Several `design` options are provided so the look can be chosen during
+ * review (see /verified-badge-preview). They split into two families:
+ *
+ *   Icon-only (lowest footprint — best inside dense leaderboards/score cells):
+ *     - "check"  (default): clean geometric check-in-circle. Neutral, not
+ *                  social-media-y.
+ *     - "shield":  shield + check — reads as governance / "validated".
+ *                  Matches the ShieldCheck already used for clean row signals.
+ *     - "glyph":   hairline rounded box + check — matches the editorial
+ *                  .sig-glyph signal-letter vocabulary. Most on-brand.
+ *     - "tick":    bare accent check with a hairline underline. Minimal,
+ *                  proofreading-mark feel.
+ *     - "seal":    scalloped lucide BadgeCheck. Closest to a social verified
+ *                  badge — kept for comparison.
+ *
+ *   Labelled (carry the word "Verified"):
+ *     - "tag":   hairline mono-caps outline pill. Editorial label.
+ *     - "chip":  filled accent pill. Highest emphasis; use sparingly.
+ */
+
+export type VerifiedBadgeDesign =
+  | "tile"
+  | "check"
+  | "shield"
+  | "glyph"
+  | "tick"
+  | "seal"
+  | "tag"
+  | "chip"
+export type VerifiedBadgeSize = "sm" | "md"
+
+const ICON_SIZE: Record<VerifiedBadgeSize, string> = {
+  sm: "h-3.5 w-3.5",
+  md: "h-4 w-4",
+}
+
+const ICON_ONLY: VerifiedBadgeDesign[] = ["tile", "check", "shield", "glyph", "tick", "seal"]
+
+export function verifiedTooltipCopy(_mode: "research" | "policy"): string {
+  // The badge is a provenance signal, not an accuracy/verification claim: it
+  // marks results contributed by the org that ran the evaluation. Same copy in
+  // both audience modes; aria-label mirrors it (see VerifiedBadge).
+  return "Submitted by the organization that ran this evaluation."
+}
+
+function IconOnly({
+  design,
+  size,
+  className,
+}: {
+  design: VerifiedBadgeDesign
+  size: VerifiedBadgeSize
+  className?: string
+}) {
+  const sz = ICON_SIZE[size]
+  const base = "inline-flex shrink-0 items-center justify-center align-middle text-[var(--accent)]"
+
+  switch (design) {
+    case "tile":
+      // Filled accent rounded-square + white check — echoes the EvalEval
+      // brand mark (rounded-square accent tile), so it reads as "our"
+      // verification rather than a generic/social one. Square, not circular.
+      return (
+        <span
+          className={cn(
+            "inline-flex shrink-0 items-center justify-center rounded-[3px] bg-[var(--accent)] align-middle text-[var(--accent-fg)]",
+            size === "md" ? "h-[18px] w-[18px]" : "h-4 w-4",
+            className
+          )}
+        >
+          <Check className={size === "md" ? "h-3 w-3" : "h-2.5 w-2.5"} strokeWidth={3.5} />
+        </span>
+      )
+    case "check":
+      // Clean geometric check-in-circle. Geometric, not scalloped.
+      return (
+        <span className={cn(base, className)}>
+          <CheckCircle2 className={sz} strokeWidth={2.25} />
+        </span>
+      )
+    case "shield":
+      // Governance / "validated" read.
+      return (
+        <span className={cn(base, className)}>
+          <ShieldCheck className={sz} strokeWidth={2} />
+        </span>
+      )
+    case "glyph":
+      // Hairline rounded box + check — matches the .sig-glyph editorial
+      // signal vocabulary (bordered mark, sharp corners).
+      return (
+        <span
+          className={cn(
+            "inline-flex shrink-0 items-center justify-center rounded-[3px] border border-[var(--accent)]/55 align-middle text-[var(--accent)]",
+            size === "md" ? "h-[18px] w-[18px]" : "h-4 w-4",
+            className
+          )}
+        >
+          <Check className={size === "md" ? "h-3 w-3" : "h-2.5 w-2.5"} strokeWidth={3} />
+        </span>
+      )
+    case "tick":
+      // Bare accent check with a hairline underline — minimal proofreading mark.
+      return (
+        <span
+          className={cn(
+            "inline-flex shrink-0 items-center align-middle text-[var(--accent)] border-b border-[var(--accent)]/40 leading-none",
+            className
+          )}
+        >
+          <Check className={sz} strokeWidth={3} />
+        </span>
+      )
+    case "seal":
+    default:
+      // Original scalloped social-style mark, kept for comparison.
+      return (
+        <span className={cn(base, className)} role="img">
+          <BadgeCheckScalloped className={sz} />
+        </span>
+      )
+  }
+}
+
+// Inline copy of lucide's BadgeCheck so "seal" stays available without adding
+// it to the active icon imports above.
+function BadgeCheckScalloped({ className }: { className?: string }) {
+  return (
+    <svg
+      className={className}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2}
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden
+    >
+      <path d="M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z" />
+      <path d="m9 12 2 2 4-4" />
+    </svg>
+  )
+}
+
+export function VerifiedBadge({
+  verified,
+  design = "check",
+  size = "sm",
+  withTooltip = true,
+  label = "Verified",
+  className,
+}: {
+  /** The per-result `is_verified` boolean. Null/false/undefined → renders nothing. */
+  verified?: boolean | null
+  design?: VerifiedBadgeDesign
+  size?: VerifiedBadgeSize
+  withTooltip?: boolean
+  /** Visible text for the "tag" / "chip" designs. */
+  label?: string
+  className?: string
+}) {
+  // Hooks must run unconditionally; guard on the value afterwards.
+  const { mode } = useAudienceMode()
+
+  if (!verified) {
+    return null
+  }
+
+  const tooltip = verifiedTooltipCopy(mode)
+  // Screen-reader text mirrors the tooltip so the two never drift. `label`
+  // ("Verified evaluator") only surfaces visually on the tag/chip designs.
+  const ariaLabel = tooltip
+
+  let node: React.ReactNode
+
+  if (ICON_ONLY.includes(design)) {
+    node = (
+      <span aria-label={ariaLabel} role="img" className="inline-flex">
+        <IconOnly design={design} size={size} className={className} />
+      </span>
+    )
+  } else if (design === "tag") {
+    // Hairline mono-caps outline pill — matches the .ec-tag editorial
+    // vocabulary (sharp corners, IBM Plex Mono, wide tracking).
+    node = (
+      <span
+        className={cn(
+          "inline-flex shrink-0 items-center gap-1 rounded-[2px] border px-1.5 py-0.5 align-middle",
+          "border-[var(--accent)]/40 text-[var(--accent)]",
+          "font-mono text-[10px] font-semibold uppercase tracking-[0.12em]",
+          className
+        )}
+        aria-label={ariaLabel}
+      >
+        <Check className={size === "md" ? "h-3.5 w-3.5" : "h-3 w-3"} strokeWidth={3} />
+        {label}
+      </span>
+    )
+  } else {
+    // "chip" — filled accent pill, highest-emphasis.
+    node = (
+      <Badge
+        className={cn(
+          "shrink-0 gap-1 rounded-full border-transparent align-middle",
+          "bg-[var(--accent)] text-[var(--accent-fg)] hover:bg-[var(--accent-hover)]",
+          className
+        )}
+        aria-label={ariaLabel}
+      >
+        <Check className={ICON_SIZE[size]} strokeWidth={3} />
+        {label}
+      </Badge>
+    )
+  }
+
+  if (!withTooltip) {
+    return node
+  }
+
+  // Short single-sentence copy → render it on one tight line instead of
+  // wrapping inside the default 320px box (which left a lot of empty space).
+  return (
+    <SignalTooltip content={tooltip} contentClassName="max-w-none whitespace-nowrap px-2.5 py-1.5">
+      {node}
+    </SignalTooltip>
+  )
+}

lib/benchmark-schema.ts

@@ -110,6 +110,13 @@ export interface EvaluationResult {
   detailed_evaluation_results_url?: string
   generation_config?: GenerationConfig
   evalcards?: { annotations?: RowAnnotations }
+  /** Per-result verification flag emitted by the producer's
+   *  `eval_results_view.is_verified_evaluator` column (one boolean per
+   *  (model, benchmark, metric) triple). When true the UI renders a
+   *  small VerifiedBadge next to the metric value. Nullable/absent for
+   *  snapshots produced before the column shipped — treated as
+   *  unverified. */
+  is_verified_evaluator?: boolean
 }
 
 export interface MetricConfig {

lib/eval-processing.ts

@@ -36,6 +36,8 @@ export interface ModelResultForBenchmark {
   evaluation_timestamp: string
   source_metadata: SourceMetadata
   source_data: BenchmarkEvaluation['source_data']
+  /** Per-result verification flag; mirrors `result.is_verified_evaluator`. */
+  is_verified_evaluator?: boolean
   result: EvaluationResult
   /** URL to the underlying record JSON in the upstream HF dataset, when known. */
   source_record_url?: string
@@ -68,6 +70,8 @@ export interface BenchmarkEvalSummary extends SignalSummaries {
   models_count: number
   /** Unique evaluator organisation names */
   evaluator_names: string[]
+  /** Subset of `evaluator_names` that are validated submitters (badge). */
+  verified_evaluator_names?: string[]
   source_types: SourceMetadata["source_type"][]
   latest_source_name?: string
   third_party_ratio: number
@@ -177,6 +181,8 @@ export interface BenchmarkLeaderboardRow {
   source_metadata: SourceMetadata
   source_data: BenchmarkEvaluation["source_data"]
   values: Record<string, number | null>
+  /** Per-column verified-evaluator flag, keyed identically to `values`. */
+  verified?: Record<string, boolean>
   annotations_by_metric?: Record<string, RowAnnotations | null | undefined>
   metrics_present: number
 }

lib/evaluators.ts

@@ -0,0 +1,199 @@
+/**
+ * Evaluator (reporting-org) grouping + slug helpers for the /evals
+ * "group by Evaluator" view and the /evaluators/<slug> detail route.
+ *
+ * Frontend-only: every function operates on the already-loaded eval list
+ * (`BenchmarkEvalListItem[]` from /api/eval-list-lite). An eval carries
+ * `evaluator_names` (de-aliased reporting orgs) and a `verified_evaluator_names`
+ * subset (validated submitters). A single eval may name multiple evaluators.
+ *
+ * Membership rule:
+ *   - normal:        (eval, org) counts when org ∈ eval.evaluator_names
+ *   - verified-only: (eval, org) counts when org ∈ eval.verified_evaluator_names
+ *
+ * Slugs are derived deterministically from the full org universe so the
+ * list page and the detail route agree on slug→org without a server round
+ * trip. Junk org strings (a long university list, "CapArena (Cheng et al.,
+ * 2025)") still produce a valid, unique, non-empty slug.
+ */
+
+import type { BenchmarkEvalListItem } from "@/lib/eval-processing"
+
+export interface EvaluatorGroup {
+  /** Canonical org name as it appears in `evaluator_names`. */
+  name: string
+  /** URL-safe slug for /evaluators/<slug>. Unique across the corpus. */
+  slug: string
+  /** Number of evals this org reported (respecting the verified filter). */
+  evalCount: number
+  /** Number of those evals where this org is a *verified* evaluator. */
+  verifiedCount: number
+  /** True when the org is a verified evaluator for ≥1 eval (regardless of filter). */
+  isVerified: boolean
+}
+
+/**
+ * Base slug from an arbitrary org string: lowercase, non-alphanumerics →
+ * single hyphen, trimmed. Falls back to "evaluator" when the string has no
+ * usable characters so we never emit an empty path segment. Length-capped
+ * so a pathological org (e.g. a multi-institution author list) doesn't
+ * produce an absurd URL — uniqueness is restored by the suffix step.
+ */
+export function evaluatorSlug(name: string): string {
+  const slug = (name ?? "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64)
+    .replace(/-+$/g, "")
+  return slug || "evaluator"
+}
+
+/** @deprecated internal alias — use {@link evaluatorSlug}. */
+const baseSlug = evaluatorSlug
+
+/**
+ * Build a deterministic, collision-free slug↔org map over every org that
+ * appears in any eval's `evaluator_names`. Orgs are processed in a stable
+ * order (name-sorted) so the same corpus always yields the same slugs;
+ * collisions get a numeric suffix (`-2`, `-3`, …).
+ */
+export function buildEvaluatorSlugMap(evals: BenchmarkEvalListItem[]): {
+  slugToName: Map<string, string>
+  nameToSlug: Map<string, string>
+} {
+  const names = new Set<string>()
+  for (const ev of evals) {
+    for (const org of ev.evaluator_names ?? []) {
+      const trimmed = (org ?? "").trim()
+      if (trimmed) names.add(trimmed)
+    }
+  }
+
+  const slugToName = new Map<string, string>()
+  const nameToSlug = new Map<string, string>()
+  const used = new Map<string, number>()
+
+  for (const name of Array.from(names).sort((a, b) => a.localeCompare(b))) {
+    const base = baseSlug(name)
+    const seen = used.get(base) ?? 0
+    const slug = seen === 0 ? base : `${base}-${seen + 1}`
+    used.set(base, seen + 1)
+    slugToName.set(slug, name)
+    nameToSlug.set(name, slug)
+  }
+
+  return { slugToName, nameToSlug }
+}
+
+/**
+ * Group the eval list by evaluator org. When `verifiedOnly` is true, an
+ * (eval, org) membership only counts where org ∈ verified_evaluator_names,
+ * so the result collapses to the genuine validated runners. Returns groups
+ * sorted by eval count descending (name as the tie-break).
+ */
+export function groupEvalsByEvaluator(
+  evals: BenchmarkEvalListItem[],
+  opts?: { verifiedOnly?: boolean },
+): EvaluatorGroup[] {
+  const verifiedOnly = opts?.verifiedOnly ?? false
+  const { nameToSlug } = buildEvaluatorSlugMap(evals)
+
+  const acc = new Map<string, { evalCount: number; verifiedCount: number; isVerified: boolean }>()
+
+  for (const ev of evals) {
+    // Slices (is_slice=true) are within-benchmark child rows; the evaluator
+    // surfaces count/show only root benchmarks. The /evals family-tree view
+    // nests slices under their parent, so excluding them here keeps the flat
+    // evaluator list to root benchmarks.
+    if (ev.is_slice) continue
+    const orgs = ev.evaluator_names ?? []
+    const verifiedSet = new Set(ev.verified_evaluator_names ?? [])
+    for (const raw of orgs) {
+      const org = (raw ?? "").trim()
+      if (!org) continue
+      const isVerifiedHere = verifiedSet.has(org)
+      // In verified-only mode, the membership itself only counts when the
+      // org is verified *for this eval*.
+      if (verifiedOnly && !isVerifiedHere) continue
+      const cur = acc.get(org) ?? { evalCount: 0, verifiedCount: 0, isVerified: false }
+      cur.evalCount += 1
+      if (isVerifiedHere) {
+        cur.verifiedCount += 1
+        cur.isVerified = true
+      }
+      acc.set(org, cur)
+    }
+  }
+
+  const groups: EvaluatorGroup[] = []
+  for (const [name, v] of acc) {
+    groups.push({
+      name,
+      slug: nameToSlug.get(name) ?? baseSlug(name),
+      evalCount: v.evalCount,
+      verifiedCount: v.verifiedCount,
+      isVerified: v.isVerified,
+    })
+  }
+
+  groups.sort((a, b) => b.evalCount - a.evalCount || a.name.localeCompare(b.name))
+  return groups
+}
+
+/**
+ * Evals reported by a single evaluator org (resolved from its slug). When
+ * `verifiedOnly` is true, restrict to evals where the org is a verified
+ * evaluator. Returns `{ name, evals }`; `name` is null when the slug
+ * resolves to no org (404 on the detail page).
+ */
+export function getEvalsForEvaluator(
+  allEvals: BenchmarkEvalListItem[],
+  slug: string,
+  opts?: { verifiedOnly?: boolean },
+): { name: string | null; isVerified: boolean; evals: BenchmarkEvalListItem[] } {
+  const verifiedOnly = opts?.verifiedOnly ?? false
+  const { slugToName } = buildEvaluatorSlugMap(allEvals)
+  // Direct hit on the (possibly collision-suffixed) full slug, else fall back
+  // to base-slug matching so links built from the shared `evaluatorSlug(name)`
+  // helper — which can't see the suffix step — still resolve. The fallback is
+  // deterministic via the same name-sorted order buildEvaluatorSlugMap uses.
+  let name = slugToName.get(slug) ?? null
+  if (!name) {
+    for (const [, candidate] of Array.from(slugToName.entries()).sort((a, b) =>
+      a[1].localeCompare(b[1]),
+    )) {
+      if (evaluatorSlug(candidate) === slug) {
+        name = candidate
+        break
+      }
+    }
+  }
+  if (!name) return { name: null, isVerified: false, evals: [] }
+
+  let isVerified = false
+  const evals = allEvals.filter((ev) => {
+    // Exclude slices — evaluator surfaces show root benchmarks only.
+    if (ev.is_slice) return false
+    const orgs = ev.evaluator_names ?? []
+    if (!orgs.includes(name)) return false
+    const verifiedHere = (ev.verified_evaluator_names ?? []).includes(name)
+    if (verifiedHere) isVerified = true
+    if (verifiedOnly) return verifiedHere
+    return true
+  })
+
+  return { name, isVerified, evals }
+}
+
+/**
+ * Evaluation_ids that have ≥1 verified evaluator — drives the Family-mode
+ * "Verified only" filter (restrict the family tree to verified evals).
+ */
+export function verifiedEvalIds(evals: BenchmarkEvalListItem[]): Set<string> {
+  const out = new Set<string>()
+  for (const ev of evals) {
+    if ((ev.verified_evaluator_names ?? []).length > 0) out.add(ev.evaluation_id)
+  }
+  return out
+}

lib/view-data.ts

@@ -67,7 +67,7 @@ const EVAL_LIST_COLUMNS = `
   family_display_name AS benchmark_family_name,
   derived_tags,
   CAST(to_json(metric_config) AS VARCHAR) AS metric_config,
-  models_count, evaluator_names, source_types,
+  models_count, evaluator_names, verified_evaluator_names, source_types,
   latest_source_name, third_party_ratio,
   missing_generation_config_count, best_model, worst_model,
   avg_score, avg_score_norm, has_card, CAST(to_json(benchmark_card) AS VARCHAR) AS benchmark_card,
@@ -111,6 +111,7 @@ const MODEL_CELL_JOIN_COLUMNS = `
   CAST(to_json(r.eval_library) AS VARCHAR) AS eval_library,
   CAST(to_json(r.evalcards_annotations) AS VARCHAR) AS evalcards_annotations,
   r.instance_file_path,
+  r.is_verified_evaluator,
   e.evaluation_name AS eval_evaluation_name,
   e.canonical_display_name AS eval_canonical_display_name,
   e.family_id AS eval_family_id,
@@ -148,6 +149,7 @@ const EVAL_CELL_JOIN_COLUMNS = `
   CAST(to_json(r.aggregate_components) AS VARCHAR) AS aggregate_components,
   CAST(to_json(r.evalcards_annotations) AS VARCHAR) AS evalcards_annotations,
   r.instance_file_path,
+  r.is_verified_evaluator,
   e.evaluation_name AS eval_evaluation_name,
   e.canonical_display_name AS eval_canonical_display_name,
   e.family_id AS eval_family_id,
@@ -539,6 +541,11 @@ function resultFromCell(row: Row): EvaluationResult {
     generation_config: generationConfig,
     detailed_evaluation_results_url: optionalString(row.instance_file_path),
     evalcards: annotations ? { annotations } : undefined,
+    // Per-result verification flag (eval_results_view.is_verified_evaluator).
+    // Coerced to a strict boolean; absent on pre-rollout snapshots →
+    // undefined → treated as unverified by the UI.
+    is_verified_evaluator:
+      row.is_verified_evaluator == null ? undefined : Boolean(row.is_verified_evaluator),
   }
 }
 
@@ -822,7 +829,7 @@ export async function getModelSummaryById(routeId: string): Promise<ModelEvaluat
 // nobody ran `pnpm build-eval-matrices` yet), we fall through and the
 // summary degrades to single-metric exactly like before.
 type MatrixEntry = {
-  leaderboard_rows: Array<{ model_route_id: string; values: Record<string, number | null> }>
+  leaderboard_rows: Array<{ model_route_id: string; values: Record<string, number | null>; verified?: Record<string, boolean> }>
   subtask_metrics: Array<Record<string, unknown>>
 }
 
@@ -928,6 +935,7 @@ export async function getEvalSummaryById(evalId: string): Promise<BenchmarkEvalS
           source_metadata: base.source_metadata,
           source_data: base.source_data,
           values: row.values,
+          verified: row.verified,
           metrics_present: Object.values(row.values).filter(
             (v): v is number => typeof v === "number" && Number.isFinite(v),
           ).length,
@@ -980,6 +988,9 @@ export async function getEvalSummaryById(evalId: string): Promise<BenchmarkEvalS
         source_metadata: mr.source_metadata,
         source_data: mr.source_data,
         values: { [columnKey]: mr.score as number },
+        verified: mr.result?.is_verified_evaluator
+          ? { [columnKey]: true }
+          : undefined,
         metrics_present: 1,
       })) as BenchmarkEvalSummary["leaderboard_rows"]
   }

scripts/build-eval-matrices.mjs

@@ -132,7 +132,8 @@ async function main() {
       r.evaluation_id,
       r.metric_id,
       r.model_route_id,
-      r.score
+      r.score,
+      r.is_verified_evaluator
     FROM read_parquet(${fileRef("eval_results_view.parquet")}) r
     WHERE r.score IS NOT NULL
       AND r.model_route_id IS NOT NULL
@@ -160,7 +161,8 @@ async function main() {
       f.slice_key,
       f.slice_name,
       f.model_id,
-      AVG(f.score) AS score
+      AVG(f.score) AS score,
+      bool_or(f.is_verified_evaluator) AS is_verified_evaluator
     FROM read_parquet(${fileRef("fact_results.parquet")}) f
     WHERE f.score IS NOT NULL
       AND f.slice_key IS NOT NULL
@@ -258,14 +260,25 @@ async function main() {
     return out[evalId]
   }
 
+  // modelEntry holds parallel maps: `values` (column_key → score) and
+  // `verified` (column_key → bool), so the per-cell verified-evaluator flag
+  // rides alongside each non-primary metric / slice column.
+  const ensureModelEntry = (bucket, route) => {
+    let modelEntry = bucket.leaderboard_rows.get(route)
+    if (!modelEntry) {
+      modelEntry = { values: {}, verified: {} }
+      bucket.leaderboard_rows.set(route, modelEntry)
+    }
+    return modelEntry
+  }
+
   for (const row of metricRows.getRowObjects().map(normalizeDuck)) {
     const bucket = ensureEval(row.evaluation_id)
-    let modelEntry = bucket.leaderboard_rows.get(row.model_route_id)
-    if (!modelEntry) {
-      modelEntry = {}
-      bucket.leaderboard_rows.set(row.model_route_id, modelEntry)
+    const modelEntry = ensureModelEntry(bucket, row.model_route_id)
+    modelEntry.values[row.metric_id] = Number(row.score)
+    if (row.is_verified_evaluator != null) {
+      modelEntry.verified[row.metric_id] = Boolean(row.is_verified_evaluator)
     }
-    modelEntry[row.metric_id] = Number(row.score)
   }
 
   // Plant slice scores. Each (metric_id, slice_key) becomes a column
@@ -289,12 +302,11 @@ async function main() {
 
     for (const evalId of evalIds) {
       const bucket = ensureEval(evalId)
-      let modelEntry = bucket.leaderboard_rows.get(route)
-      if (!modelEntry) {
-        modelEntry = {}
-        bucket.leaderboard_rows.set(route, modelEntry)
+      const modelEntry = ensureModelEntry(bucket, route)
+      modelEntry.values[columnKey] = score
+      if (row.is_verified_evaluator != null) {
+        modelEntry.verified[columnKey] = Boolean(row.is_verified_evaluator)
       }
-      modelEntry[columnKey] = score
 
       if (!bucket.subtask_metric_keys.has(columnKey)) {
         bucket.subtask_metric_keys.add(columnKey)
@@ -328,8 +340,8 @@ async function main() {
   const finalEvals = {}
   for (const [evalId, bucket] of Object.entries(out)) {
     const rows = []
-    for (const [routeId, values] of bucket.leaderboard_rows) {
-      rows.push({ model_route_id: routeId, values })
+    for (const [routeId, entry] of bucket.leaderboard_rows) {
+      rows.push({ model_route_id: routeId, values: entry.values, verified: entry.verified })
     }
     // Skip evals where every model has at most one metric and no
     // subtask data — adds no information beyond the existing summary.

tests/evaluators.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from "vitest"
+
+import {
+  buildEvaluatorSlugMap,
+  groupEvalsByEvaluator,
+  getEvalsForEvaluator,
+  verifiedEvalIds,
+} from "../lib/evaluators"
+import type { BenchmarkEvalListItem } from "../lib/eval-processing"
+
+// Minimal eval rows — only the fields the evaluator grouping reads. The
+// cast keeps the fixtures terse without re-declaring the full view shape.
+function evalRow(
+  id: string,
+  evaluators: string[],
+  verified: string[] = [],
+): BenchmarkEvalListItem {
+  return {
+    evaluation_id: id,
+    evaluation_name: id,
+    evaluator_names: evaluators,
+    verified_evaluator_names: verified,
+  } as unknown as BenchmarkEvalListItem
+}
+
+const corpus: BenchmarkEvalListItem[] = [
+  evalRow("e1", ["Stanford CRFM"], ["Stanford CRFM"]),
+  evalRow("e2", ["Stanford CRFM", "OpenAI"], ["Stanford CRFM"]),
+  evalRow("e3", ["OpenAI"]),
+  // Two junk org strings that must still slug cleanly + uniquely.
+  evalRow("e4", ["CapArena (Cheng et al., 2025)"], ["CapArena (Cheng et al., 2025)"]),
+  evalRow("e5", ["University of A, University of B, University of C and many others"]),
+]
+
+describe("groupEvalsByEvaluator", () => {
+  it("groups by org and sorts by eval count desc", () => {
+    const groups = groupEvalsByEvaluator(corpus)
+    const byName = Object.fromEntries(groups.map((g) => [g.name, g]))
+    expect(byName["Stanford CRFM"].evalCount).toBe(2)
+    expect(byName["OpenAI"].evalCount).toBe(2)
+    expect(byName["Stanford CRFM"].verifiedCount).toBe(2)
+    expect(byName["Stanford CRFM"].isVerified).toBe(true)
+    expect(byName["OpenAI"].verifiedCount).toBe(0)
+    expect(byName["OpenAI"].isVerified).toBe(false)
+    // descending eval count
+    expect(groups[0].evalCount).toBeGreaterThanOrEqual(groups[groups.length - 1].evalCount)
+  })
+
+  it("verified-only collapses to verified runners with verified counts", () => {
+    const groups = groupEvalsByEvaluator(corpus, { verifiedOnly: true })
+    const names = groups.map((g) => g.name).sort()
+    expect(names).toEqual(["CapArena (Cheng et al., 2025)", "Stanford CRFM"])
+    const crfm = groups.find((g) => g.name === "Stanford CRFM")!
+    expect(crfm.evalCount).toBe(2)
+    // OpenAI never verified → absent
+    expect(groups.find((g) => g.name === "OpenAI")).toBeUndefined()
+  })
+})
+
+describe("buildEvaluatorSlugMap", () => {
+  it("produces valid, non-empty, unique slugs for junk strings", () => {
+    const { slugToName, nameToSlug } = buildEvaluatorSlugMap(corpus)
+    const slugs = Array.from(slugToName.keys())
+    // unique
+    expect(new Set(slugs).size).toBe(slugs.length)
+    for (const s of slugs) {
+      expect(s.length).toBeGreaterThan(0)
+      expect(s).toMatch(/^[a-z0-9-]+$/)
+    }
+    // round-trips
+    const cap = nameToSlug.get("CapArena (Cheng et al., 2025)")!
+    expect(slugToName.get(cap)).toBe("CapArena (Cheng et al., 2025)")
+  })
+
+  it("disambiguates colliding base slugs with a numeric suffix", () => {
+    const collide = [
+      evalRow("a", ["Foo Bar!"]),
+      evalRow("b", ["Foo  Bar"]),
+    ]
+    const { slugToName } = buildEvaluatorSlugMap(collide)
+    const slugs = Array.from(slugToName.keys()).sort()
+    expect(new Set(slugs).size).toBe(2)
+    expect(slugs.some((s) => /-2$/.test(s))).toBe(true)
+  })
+})
+
+describe("getEvalsForEvaluator", () => {
+  it("resolves a slug to the org's evals", () => {
+    const { nameToSlug } = buildEvaluatorSlugMap(corpus)
+    const slug = nameToSlug.get("OpenAI")!
+    const { name, evals, isVerified } = getEvalsForEvaluator(corpus, slug)
+    expect(name).toBe("OpenAI")
+    expect(evals.map((e) => e.evaluation_id).sort()).toEqual(["e2", "e3"])
+    expect(isVerified).toBe(false)
+  })
+
+  it("restricts to verified evals when verifiedOnly", () => {
+    const { nameToSlug } = buildEvaluatorSlugMap(corpus)
+    const slug = nameToSlug.get("Stanford CRFM")!
+    const { evals } = getEvalsForEvaluator(corpus, slug, { verifiedOnly: true })
+    expect(evals.map((e) => e.evaluation_id).sort()).toEqual(["e1", "e2"])
+  })
+
+  it("returns null name for an unknown slug", () => {
+    const { name, evals } = getEvalsForEvaluator(corpus, "does-not-exist")
+    expect(name).toBeNull()
+    expect(evals).toEqual([])
+  })
+})
+
+describe("verifiedEvalIds", () => {
+  it("collects ids with at least one verified evaluator", () => {
+    const ids = verifiedEvalIds(corpus)
+    expect(Array.from(ids).sort()).toEqual(["e1", "e2", "e4"])
+  })
+})

tests/view-data.test.ts

@@ -46,6 +46,7 @@ async function writeSyntheticStageJSnapshot(snapshotDir: string) {
         1::INTEGER AS variant_count,
         1::BIGINT AS evaluator_count,
         ['OpenAI']::VARCHAR[] AS evaluator_names,
+        ['OpenAI']::VARCHAR[] AS verified_evaluator_names,
         1::INTEGER AS source_type_count,
         ['documentation']::VARCHAR[] AS source_types,
         0::BIGINT AS third_party_eval_count,
@@ -126,6 +127,7 @@ async function writeSyntheticStageJSnapshot(snapshotDir: string) {
         ) AS metric_config,
         1::BIGINT AS models_count,
         ['OpenAI']::VARCHAR[] AS evaluator_names,
+        ['OpenAI']::VARCHAR[] AS verified_evaluator_names,
         ['documentation']::VARCHAR[] AS source_types,
         'OpenAI' AS latest_source_name,
         0.0 AS third_party_ratio,
@@ -288,7 +290,8 @@ async function writeSyntheticStageJSnapshot(snapshotDir: string) {
         NULL AS evalcards_annotations,
         NULL::VARCHAR AS instance_file_path,
         NULL::VARCHAR AS instance_file_format,
-        0::INTEGER AS instance_rows
+        0::INTEGER AS instance_rows,
+        true AS is_verified_evaluator
     `,
     path.join(snapshotDir, "eval_results_view.parquet")
   )
@@ -447,7 +450,7 @@ describe("Stage J view-layer backend", () => {
       expect(evalSummary?.model_results[0]).toMatchObject({
         model_route_id: "openai%2Fgpt-5",
         score: 0.8,
-        result: { metric_summary_id: "mmlu%3Aaccuracy" },
+        result: { metric_summary_id: "mmlu%3Aaccuracy", is_verified_evaluator: true },
       })
       expect(evalSummary?.model_results[0]?.result.generation_config).toMatchObject({
         temperature: 0.2,