fix bugs

app/api/benchmark-metadata/route.ts

@@ -0,0 +1,7 @@
+import { NextResponse } from "next/server"
+import { getAllBenchmarkCards } from "@/lib/benchmark-metadata"
+
+export async function GET() {
+  const cards = await getAllBenchmarkCards()
+  return NextResponse.json(cards)
+}

app/benchmarks/page.tsx

@@ -1,5 +1,5 @@
 import { redirect } from "next/navigation"
 
-export default function BenchmarksRedirectPage() {
-  redirect("/models")
+export default function BenchmarksPage() {
+  redirect("/evals")
 }

app/developers/[id]/page.tsx

@@ -2,7 +2,7 @@
 
 import { useCallback, useEffect, useMemo, useState } from "react"
 import { useParams, useRouter } from "next/navigation"
-import { ArrowLeft, ArrowUpDown, Search } from "lucide-react"
+import { ArrowLeft, ArrowUpDown, Search, Tag } from "lucide-react"
 
 import { BenchmarkEvaluationCard, type BenchmarkEvaluationCardData } from "@/components/benchmark-evaluation-card"
 import { ListPagination } from "@/components/list-pagination"
@@ -11,7 +11,9 @@ import { PageHeader } from "@/components/page-header"
 import { Button } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
-import { fetchDeveloperSummary } from "@/lib/dashboard-data-client"
+import type { BenchmarkCard } from "@/lib/benchmark-schema"
+import { lookupBenchmarkCard } from "@/lib/benchmark-metadata-utils"
+import { fetchDeveloperSummary, fetchBenchmarkMetadata } from "@/lib/dashboard-data-client"
 
 const PAGE_SIZE = 40
 
@@ -20,6 +22,7 @@ export default function DeveloperDetailPage() {
   const router = useRouter()
   const [developer, setDeveloper] = useState<string>("")
   const [models, setModels] = useState<BenchmarkEvaluationCardData[]>([])
+  const [benchmarkCards, setBenchmarkCards] = useState<Record<string, BenchmarkCard>>({})
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
   const [searchQuery, setSearchQuery] = useState("")
@@ -33,10 +36,14 @@ export default function DeveloperDetailPage() {
   }, [router])
 
   useEffect(() => {
-    fetchDeveloperSummary(routeId)
-      .then((summary) => {
+    Promise.all([
+      fetchDeveloperSummary(routeId),
+      fetchBenchmarkMetadata(),
+    ])
+      .then(([summary, cards]) => {
         setDeveloper(summary.developer)
         setModels(summary.models)
+        setBenchmarkCards(cards)
       })
       .catch((err) => {
         console.error(err)
@@ -45,6 +52,24 @@ export default function DeveloperDetailPage() {
       .finally(() => setLoading(false))
   }, [routeId])
 
+  // Collect all unique domains from benchmarks this developer's models are evaluated on
+  const domainCoverage = useMemo(() => {
+    const domainMap = new Map<string, Set<string>>() // domain → set of benchmark names
+    for (const model of models) {
+      for (const { benchmark } of model.top_scores) {
+        const card = lookupBenchmarkCard(benchmarkCards, benchmark)
+        for (const domain of card?.benchmark_details?.domains ?? []) {
+          const existing = domainMap.get(domain) ?? new Set()
+          existing.add(benchmark)
+          domainMap.set(domain, existing)
+        }
+      }
+    }
+    return Array.from(domainMap.entries())
+      .map(([domain, benchmarks]) => ({ domain, count: benchmarks.size }))
+      .sort((a, b) => b.count - a.count)
+  }, [models, benchmarkCards])
+
   const filteredModels = useMemo(() => {
     const query = searchQuery.trim().toLowerCase()
     const filtered = query
@@ -125,13 +150,16 @@ export default function DeveloperDetailPage() {
         <PageHeader
           eyebrow="Developer"
           title={developer}
-          description="Model cards loaded from this developer’s index and detail files, without scanning the entire corpus."
+          description={`Evaluation coverage across ${models.length} model${models.length !== 1 ? "s" : ""} from this developer, including benchmark domain coverage where metadata is available.`}
           metaItems={[
             { label: "Models", value: models.length.toString() },
             {
               label: "Reported Results",
               value: models.reduce((sum, model) => sum + model.evaluations_count, 0).toString(),
             },
+            ...(domainCoverage.length > 0
+              ? [{ label: "Domains covered", value: domainCoverage.length.toString() }]
+              : []),
           ]}
         >
           <Button variant="outline" onClick={handleBack}>
@@ -140,6 +168,29 @@ export default function DeveloperDetailPage() {
           </Button>
         </PageHeader>
 
+        {/* Domain coverage strip */}
+        {domainCoverage.length > 0 && (
+          <div className="mb-4 mt-6 rounded-[1.5rem] border border-border/70 bg-muted/10 p-4">
+            <div className="mb-2 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+              <Tag className="h-3.5 w-3.5" />
+              Benchmark domain coverage
+            </div>
+            <div className="flex flex-wrap gap-2">
+              {domainCoverage.map(({ domain, count }) => (
+                <span
+                  key={domain}
+                  className="inline-flex items-center gap-1.5 rounded-full border border-border/60 bg-background px-3 py-1 text-xs font-medium capitalize"
+                >
+                  {domain}
+                  <span className="rounded-full bg-muted px-1.5 py-0.5 text-[10px] font-semibold text-muted-foreground">
+                    {count}
+                  </span>
+                </span>
+              ))}
+            </div>
+          </div>
+        )}
+
         <div className="mb-8 mt-8 flex flex-col gap-4 border-b border-border/50 pb-6 sm:flex-row">
           <div className="relative w-full sm:max-w-sm">
             <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
@@ -173,6 +224,7 @@ export default function DeveloperDetailPage() {
               <BenchmarkEvaluationCard
                 key={model.id}
                 data={model}
+                benchmarkCards={benchmarkCards}
                 delayMs={Math.min(index * 45, 240)}
               />
             ))}

app/evals/page.tsx

@@ -1,111 +1,256 @@
 "use client"
 
-import { useState, useMemo, useEffect } from "react"
+import { useEffect, useMemo, useState } from "react"
+import Link from "next/link"
+import { useSearchParams } from "next/navigation"
+import { Search, X } from "lucide-react"
+
 import { useAudienceMode } from "@/components/audience-mode-provider"
-import { Input } from "@/components/ui/input"
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
-import { ArrowUpDown, Search } from "lucide-react"
+import { ListPagination } from "@/components/list-pagination"
 import { Navigation } from "@/components/navigation"
 import { PageHeader } from "@/components/page-header"
-import { EvalCard } from "@/components/eval-card"
-import { ListPagination } from "@/components/list-pagination"
+import { Input } from "@/components/ui/input"
+import type { BenchmarkCard, CategoryType } from "@/lib/benchmark-schema"
 import type { BenchmarkEvalListItem } from "@/lib/eval-processing"
-import { fetchEvalList } from "@/lib/dashboard-data-client"
+import { fetchBenchmarkMetadata, fetchEvalList } from "@/lib/dashboard-data-client"
+import { getCategoryColor } from "@/lib/benchmark-schema"
+import { lookupBenchmarkCard, normalizeBenchmarkKey } from "@/lib/benchmark-metadata-utils"
+import { cn } from "@/lib/utils"
 
 const PAGE_SIZE = 40
 
+function shortenLicense(license: string): string {
+  if (!license || license === "Not specified") return ""
+  if (license.toLowerCase().includes("creative commons attribution 4")) return "CC BY 4.0"
+  if (license.toLowerCase().includes("creative commons zero")) return "CC0"
+  if (license.toLowerCase().includes("apache license 2") || license.toLowerCase().includes("apache 2")) return "Apache 2.0"
+  if (license.toLowerCase().includes("mit license")) return "MIT"
+  if (license.toLowerCase().includes("cc-by-sa")) return "CC BY-SA"
+  if (license.length > 24) return `${license.slice(0, 22)}…`
+  return license
+}
+
+const LICENSE_COLORS: Record<string, string> = {
+  mit: "bg-emerald-100 text-emerald-800 border-emerald-200 dark:bg-emerald-950/40 dark:text-emerald-200",
+  apache: "bg-sky-100 text-sky-800 border-sky-200 dark:bg-sky-950/40 dark:text-sky-200",
+  "cc by": "bg-violet-100 text-violet-800 border-violet-200 dark:bg-violet-950/40 dark:text-violet-200",
+  cc0: "bg-teal-100 text-teal-800 border-teal-200 dark:bg-teal-950/40 dark:text-teal-200",
+  "cc-by-sa": "bg-indigo-100 text-indigo-800 border-indigo-200 dark:bg-indigo-950/40 dark:text-indigo-200",
+}
+
+function licenseBadgeClass(license: string): string {
+  const normalized = license.toLowerCase()
+  for (const [key, className] of Object.entries(LICENSE_COLORS)) {
+    if (normalized.includes(key)) return className
+  }
+  return "bg-muted text-muted-foreground border-border"
+}
+
+function slugifyAggregateId(value: string) {
+  return `aggregate__${value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "")}`
+}
+
 export default function EvalsPage() {
   const { mode } = useAudienceMode()
+  const searchParams = useSearchParams()
+
   const [summaries, setSummaries] = useState<BenchmarkEvalListItem[]>([])
+  const [benchmarkCards, setBenchmarkCards] = useState<Record<string, BenchmarkCard>>({})
   const [loading, setLoading] = useState(true)
   const [totalModels, setTotalModels] = useState(0)
-  const [sortBy, setSortBy] = useState<"name" | "models" | "score">("name")
-  const [groupByComposite, setGroupByComposite] = useState(true)
   const [searchQuery, setSearchQuery] = useState("")
+  const [selectedDomain, setSelectedDomain] = useState<string | null>(null)
+  const [selectedCategory, setSelectedCategory] = useState<string | null>(null)
+  const [showWithoutMetadata, setShowWithoutMetadata] = useState(false)
   const [page, setPage] = useState(1)
 
   useEffect(() => {
-    fetchEvalList()
-      .then((data) => {
+    Promise.all([fetchEvalList(), fetchBenchmarkMetadata()])
+      .then(([data, cards]) => {
         setSummaries(data.evals)
         setTotalModels(data.totalModels)
+        setBenchmarkCards(cards)
       })
       .catch(console.error)
       .finally(() => setLoading(false))
   }, [])
 
+  useEffect(() => {
+    const incomingSearch = searchParams.get("search") ?? ""
+    if (incomingSearch) {
+      setSearchQuery(incomingSearch)
+    }
+  }, [searchParams])
+
+  const summariesWithCards = useMemo(() => {
+    return summaries.map((summary) => {
+      if (summary.benchmark_card) {
+        return summary
+      }
+
+      const fallbackCard =
+        lookupBenchmarkCard(benchmarkCards, summary.evaluation_name) ??
+        lookupBenchmarkCard(benchmarkCards, summary.composite_benchmark_name) ??
+        lookupBenchmarkCard(benchmarkCards, summary.composite_benchmark_key)
+
+      return fallbackCard ? { ...summary, benchmark_card: fallbackCard } : summary
+    })
+  }, [benchmarkCards, summaries])
+
+  const aggregatedSummaries = useMemo(() => {
+    const grouped = new Map<string, BenchmarkEvalListItem[]>()
+    const passthrough: BenchmarkEvalListItem[] = []
+
+    for (const summary of summariesWithCards) {
+      const cardName = summary.benchmark_card?.benchmark_details?.name
+
+      if (!cardName) {
+        passthrough.push(summary)
+        continue
+      }
+
+      const groupKey = normalizeBenchmarkKey(cardName)
+      const existing = grouped.get(groupKey) ?? []
+      existing.push(summary)
+      grouped.set(groupKey, existing)
+    }
+
+    const merged = Array.from(grouped.entries()).map(([groupKey, items]) => {
+      if (items.length === 1) {
+        return items[0]
+      }
+
+      const first = items[0]
+      const aggregateSources = Array.from(
+        new Map(
+          items.map((item) => [
+            item.evaluation_id,
+            {
+              evaluation_id: item.evaluation_id,
+              composite_benchmark_key: item.composite_benchmark_key,
+              composite_benchmark_name: item.composite_benchmark_name,
+              models_count: item.models_count,
+              avg_score_norm: item.avg_score_norm,
+            },
+          ])
+        ).values()
+      ).sort((a, b) => a.composite_benchmark_name.localeCompare(b.composite_benchmark_name))
+
+      const dominantCategory =
+        Object.entries(
+          items.reduce<Record<string, number>>((counts, item) => {
+            counts[item.category] = (counts[item.category] ?? 0) + 1
+            return counts
+          }, {})
+        ).sort((a, b) => b[1] - a[1])[0]?.[0] ?? first.category
+
+      return {
+        ...first,
+        evaluation_name: first.benchmark_card?.benchmark_details?.name ?? first.evaluation_name,
+        evaluation_id: slugifyAggregateId(groupKey),
+        composite_benchmark_key: aggregateSources.length === 1 ? aggregateSources[0].composite_benchmark_key : "multiple",
+        composite_benchmark_name:
+          aggregateSources.length === 1
+            ? aggregateSources[0].composite_benchmark_name
+            : `${aggregateSources.length} composite benchmarks`,
+        category: dominantCategory as CategoryType,
+        models_count: Math.max(...items.map((item) => item.models_count)),
+        evaluator_names: Array.from(new Set(items.flatMap((item) => item.evaluator_names))).sort((a, b) => a.localeCompare(b)),
+        source_types: Array.from(new Set(items.flatMap((item) => item.source_types))).sort((a, b) => a.localeCompare(b)),
+        latest_source_name:
+          aggregateSources.length === 1 ? aggregateSources[0].composite_benchmark_name : "Multiple sources",
+        third_party_ratio:
+          items.reduce((sum, item) => sum + item.third_party_ratio, 0) / items.length,
+        missing_generation_config_count: items.reduce(
+          (sum, item) => sum + item.missing_generation_config_count,
+          0
+        ),
+        avg_score:
+          items.reduce((sum, item) => sum + item.avg_score_norm, 0) / items.length,
+        avg_score_norm:
+          items.reduce((sum, item) => sum + item.avg_score_norm, 0) / items.length,
+        best_model: null,
+        worst_model: null,
+        is_aggregated: true,
+        aggregate_sources: aggregateSources,
+      }
+    })
+
+    return [...merged, ...passthrough]
+  }, [summariesWithCards])
+
+  const allDomains = useMemo(() => {
+    const domainSet = new Set<string>()
+    for (const summary of aggregatedSummaries.filter((entry) => entry.benchmark_card)) {
+      for (const domain of summary.benchmark_card?.benchmark_details?.domains ?? []) {
+        domainSet.add(domain)
+      }
+    }
+    return Array.from(domainSet).sort((a, b) => a.localeCompare(b))
+  }, [aggregatedSummaries])
+
+  const allCategories = useMemo(() => {
+    const categorySet = new Set<string>()
+    for (const summary of aggregatedSummaries.filter((entry) => entry.benchmark_card)) {
+      if (summary.category) {
+        categorySet.add(summary.category)
+      }
+    }
+    return Array.from(categorySet).sort((a, b) => a.localeCompare(b))
+  }, [aggregatedSummaries])
+
+  const metadataRichCount = useMemo(
+    () => aggregatedSummaries.filter((summary) => summary.benchmark_card).length,
+    [aggregatedSummaries]
+  )
+
+  const metadataPoorCount = aggregatedSummaries.length - metadataRichCount
+
   const filtered = useMemo(() => {
     const query = searchQuery.trim().toLowerCase()
-    let list = [...summaries]
+    let list = showWithoutMetadata
+      ? [...aggregatedSummaries]
+      : aggregatedSummaries.filter((summary) => summary.benchmark_card)
 
     if (query) {
       list = list.filter((summary) => {
         const haystacks = [
-          summary.composite_benchmark_name,
           summary.evaluation_name,
+          summary.composite_benchmark_name,
           summary.metric_config.evaluation_description,
-          summary.latest_source_name,
-          summary.factsheet?.purpose,
-          summary.factsheet?.principles_tested,
-          ...summary.evaluator_names,
-          ...summary.source_types,
+          summary.benchmark_card?.benchmark_details?.overview,
+          ...(summary.benchmark_card?.benchmark_details?.domains ?? []),
         ]
 
         return haystacks.some((value) => value?.toLowerCase().includes(query))
       })
     }
 
-    switch (sortBy) {
-      case "name":
-        list.sort((a, b) => a.evaluation_name.localeCompare(b.evaluation_name))
-        break
-      case "models":
-        list.sort((a, b) => b.models_count - a.models_count)
-        break
-      case "score":
-        list.sort((a, b) => b.avg_score_norm - a.avg_score_norm)
-        break
+    if (selectedDomain) {
+      list = list.filter((summary) =>
+        (summary.benchmark_card?.benchmark_details?.domains ?? []).some(
+          (domain) => domain.toLowerCase() === selectedDomain.toLowerCase()
+        )
+      )
     }
-    return list
-  }, [searchQuery, summaries, sortBy])
-
-  const groupedSummaries = useMemo(() => {
-    const groups = new Map<
-      string,
-      {
-        key: string
-        name: string
-        items: BenchmarkEvalListItem[]
-      }
-    >()
 
-    for (const summary of filtered) {
-      const existing = groups.get(summary.composite_benchmark_key) ?? {
-        key: summary.composite_benchmark_key,
-        name: summary.composite_benchmark_name,
-        items: [],
-      }
-      existing.items.push(summary)
-      groups.set(summary.composite_benchmark_key, existing)
+    if (selectedCategory) {
+      list = list.filter((summary) => summary.category === selectedCategory)
     }
 
-    return Array.from(groups.values()).sort((a, b) => a.name.localeCompare(b.name))
-  }, [filtered])
+    list.sort((a, b) => a.evaluation_name.localeCompare(b.evaluation_name))
+    return list
+  }, [aggregatedSummaries, searchQuery, selectedCategory, selectedDomain, showWithoutMetadata])
 
   useEffect(() => {
     setPage(1)
-  }, [groupByComposite, sortBy, searchQuery])
+  }, [searchQuery, selectedCategory, selectedDomain, showWithoutMetadata])
 
   const pagedSummaries = useMemo(
     () => filtered.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE),
     [filtered, page]
   )
 
-  const pagedGroups = useMemo(
-    () => groupedSummaries.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE),
-    [groupedSummaries, page]
-  )
-
   if (loading) {
     return (
       <div className="min-h-screen bg-background">
@@ -124,133 +269,234 @@ export default function EvalsPage() {
       <Navigation />
       <PageHeader
         eyebrow="Evaluations"
-        title="Explore Evaluations"
+        title="Browse Evaluations"
         description={
           mode === "research"
-            ? "Compare benchmark behavior, methodological framing, and performance spread, or group single benchmarks under their composite leaderboards."
-            : "Review evaluation reporting with emphasis on coverage, evidence, and accountable documentation, including how single benchmarks roll up into composite leaderboards."
-        }
-        metaItems={
-          groupByComposite
-            ? [
-                { label: "Composite Benchmarks", value: groupedSummaries.length.toString() },
-                { label: "Single Benchmarks", value: filtered.length.toString() },
-                { label: "Models", value: totalModels.toString() },
-                { label: "View", value: mode === "research" ? "Research" : "Policy" },
-              ]
-            : [
-                { label: "Single Benchmarks", value: summaries.length.toString() },
-                { label: "Models", value: totalModels.toString() },
-                { label: "View", value: mode === "research" ? "Research" : "Policy" },
-              ]
+            ? "Scan single-benchmark evaluations with the benchmark context first, then open the detail page when you need methodology, provenance, or ranking depth."
+            : "Scan single-benchmark evaluations with the benchmark context first, then open the detail page when you need accountability, source, or reporting detail."
         }
+        metaItems={[
+          { label: "Evaluations", value: filtered.length.toString() },
+          { label: "Rich cards", value: metadataRichCount.toString() },
+          { label: "Models", value: totalModels.toString() },
+          { label: "Domains", value: allDomains.length.toString() },
+          ...(selectedDomain ? [{ label: "Domain filter", value: selectedDomain }] : []),
+          ...(selectedCategory ? [{ label: "Category filter", value: selectedCategory }] : []),
+        ]}
       />
+
       <main className="container mx-auto px-4 py-8">
-        <div className="mb-8 flex flex-col gap-3 border-b border-border/50 pb-6 sm:flex-row sm:flex-wrap sm:items-center">
-          <div className="relative w-full sm:max-w-sm">
-            <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
-            <Input
-              value={searchQuery}
-              onChange={(event) => setSearchQuery(event.target.value)}
-              placeholder={
-                groupByComposite
-                  ? "Search composite benchmarks, single benchmarks, purpose, or source"
-                  : "Search single benchmarks, purpose, or source"
-              }
-              className="pl-9"
-            />
-          </div>
-          <div className="inline-flex w-fit rounded-full border bg-muted/20 p-1">
-            <button
-              type="button"
-              onClick={() => setGroupByComposite(false)}
-              className={`inline-flex items-center rounded-full px-3 py-1.5 text-sm font-medium transition-colors ${
-                !groupByComposite
-                  ? "bg-background text-foreground shadow-sm"
-                  : "text-muted-foreground hover:text-foreground"
-              }`}
-            >
-              Flat list
-            </button>
-            <button
-              type="button"
-              onClick={() => setGroupByComposite(true)}
-              className={`inline-flex items-center rounded-full px-3 py-1.5 text-sm font-medium transition-colors ${
-                groupByComposite
-                  ? "bg-background text-foreground shadow-sm"
-                  : "text-muted-foreground hover:text-foreground"
-              }`}
-            >
-              Group by composite benchmark
-            </button>
+        <div className="mb-8 flex flex-col gap-3 border-b border-border/50 pb-6">
+          <div className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center">
+            <div className="relative w-full sm:max-w-sm">
+              <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+              <Input
+                value={searchQuery}
+                onChange={(event) => setSearchQuery(event.target.value)}
+                placeholder="Search by name, domain, or overview"
+                className="pl-9"
+              />
+            </div>
+            <label className="inline-flex w-fit items-center gap-2 rounded-full border border-border/70 bg-muted/20 px-3 py-2 text-sm text-muted-foreground">
+              <input
+                type="checkbox"
+                checked={showWithoutMetadata}
+                onChange={(event) => setShowWithoutMetadata(event.target.checked)}
+                className="h-4 w-4 rounded border-border text-primary focus:ring-primary"
+              />
+              <span>Show benchmarks that don't have rich metadata</span>
+              {metadataPoorCount > 0 ? (
+                <span className="rounded-full border border-border/60 bg-background px-2 py-0.5 text-[10px] font-semibold uppercase tracking-[0.14em] text-muted-foreground">
+                  +{metadataPoorCount}
+                </span>
+              ) : null}
+            </label>
           </div>
-          <Select value={sortBy} onValueChange={v => setSortBy(v as any)}>
-            <SelectTrigger className="w-[200px]">
-              <ArrowUpDown className="h-4 w-4 mr-2" />
-              <SelectValue placeholder="Sort" />
-            </SelectTrigger>
-            <SelectContent>
-              <SelectItem value="name">Single Benchmark (A-Z)</SelectItem>
-              <SelectItem value="models">Most Models</SelectItem>
-              <SelectItem value="score">Highest Avg Score</SelectItem>
-            </SelectContent>
-          </Select>
-        </div>
 
-        {groupByComposite ? (
-          <div className="space-y-8">
-            {pagedGroups.map((group, groupIndex) => (
-              <section
-                key={group.key}
-                className="rounded-[1.5rem] border border-border/70 bg-muted/10 p-5"
+          {allDomains.length > 0 && (
+            <div className="flex flex-wrap items-center gap-1.5">
+              <span className="mr-1 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                Domain
+              </span>
+              <button
+                type="button"
+                onClick={() => setSelectedDomain(null)}
+                className={cn(
+                  "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
+                  selectedDomain === null
+                    ? "border-primary bg-primary text-primary-foreground"
+                    : "border-border/60 bg-background text-muted-foreground hover:text-foreground"
+                )}
               >
-                <div className="mb-4 flex flex-col gap-2 sm:flex-row sm:items-end sm:justify-between">
-                  <div>
-                    <div className="text-[11px] font-semibold uppercase tracking-[0.22em] text-muted-foreground">
-                      Composite Benchmark
-                    </div>
-                    <h2 className="mt-1 text-xl font-bold tracking-tight">{group.name}</h2>
-                    <p className="mt-1 text-sm text-muted-foreground">
-                      {group.items.length} single benchmark{group.items.length !== 1 ? "s" : ""} grouped under this composite benchmark.
-                    </p>
-                  </div>
-                </div>
-
-                <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
-                  {group.items.map((summary, index) => (
-                    <EvalCard
-                      key={summary.evaluation_id}
-                      summary={summary}
-                      delayMs={Math.min((groupIndex * 2 + index) * 35, 240)}
-                    />
-                  ))}
-                </div>
-              </section>
-            ))}
+                All
+              </button>
+              {allDomains.map((domain) => (
+                <button
+                  key={domain}
+                  type="button"
+                  onClick={() => setSelectedDomain(selectedDomain === domain ? null : domain)}
+                  className={cn(
+                    "rounded-full border px-3 py-1 text-xs font-medium capitalize transition-colors",
+                    selectedDomain === domain
+                      ? "border-primary bg-primary text-primary-foreground"
+                      : "border-border/60 bg-background text-muted-foreground hover:text-foreground"
+                  )}
+                >
+                  {domain}
+                </button>
+              ))}
+              {selectedDomain && (
+                <button
+                  type="button"
+                  onClick={() => setSelectedDomain(null)}
+                  className="ml-1 flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground"
+                >
+                  <X className="h-3 w-3" />
+                  Clear
+                </button>
+              )}
+            </div>
+          )}
+
+          {allCategories.length > 0 && (
+            <div className="flex flex-wrap items-center gap-1.5">
+              <span className="mr-1 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                Category
+              </span>
+              <button
+                type="button"
+                onClick={() => setSelectedCategory(null)}
+                className={cn(
+                  "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
+                  selectedCategory === null
+                    ? "border-primary bg-primary text-primary-foreground"
+                    : "border-border/60 bg-background text-muted-foreground hover:text-foreground"
+                )}
+              >
+                All
+              </button>
+              {allCategories.map((category) => (
+                <button
+                  key={category}
+                  type="button"
+                  onClick={() => setSelectedCategory(selectedCategory === category ? null : category)}
+                  className={cn(
+                    "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
+                    selectedCategory === category
+                      ? `${getCategoryColor(category as CategoryType)} border-2`
+                      : "border-border/60 bg-background text-muted-foreground hover:text-foreground"
+                  )}
+                >
+                  {category}
+                </button>
+              ))}
+              {selectedCategory && (
+                <button
+                  type="button"
+                  onClick={() => setSelectedCategory(null)}
+                  className="ml-1 flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground"
+                >
+                  <X className="h-3 w-3" />
+                  Clear
+                </button>
+              )}
+            </div>
+          )}
+        </div>
+
+        {filtered.length === 0 ? (
+          <div className="py-12 text-center text-muted-foreground">
+            No evaluations found.
           </div>
         ) : (
-          <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
-            {pagedSummaries.map((summary, index) => (
-              <EvalCard
-                key={summary.evaluation_id}
-                summary={summary}
-                delayMs={Math.min(index * 45, 240)}
-              />
-            ))}
-          </div>
-        )}
+          <div className="grid grid-cols-1 gap-6 md:grid-cols-2 lg:grid-cols-3">
+            {pagedSummaries.map((summary) => {
+              const card = summary.benchmark_card
+              const title = card?.benchmark_details?.name ?? summary.evaluation_name
+              const overview =
+                card?.benchmark_details?.overview ?? summary.metric_config.evaluation_description
+              const domains = card?.benchmark_details?.domains ?? []
+              const dataType = card?.benchmark_details?.data_type ?? ""
+              const license = card?.ethical_and_legal_considerations?.data_licensing ?? ""
+              const shortLicense = shortenLicense(license)
+              const showCompositeLabel =
+                summary.composite_benchmark_name &&
+                summary.composite_benchmark_name.toLowerCase() !== title.toLowerCase()
+              const compositeLabel = summary.is_aggregated
+                ? summary.aggregate_sources?.map((source) => source.composite_benchmark_name).join(", ")
+                : summary.composite_benchmark_name
 
-        {(groupByComposite ? groupedSummaries.length === 0 : filtered.length === 0) && (
-          <div className="text-center py-12 text-muted-foreground">
-            No evaluations found.
+              return (
+                <Link
+                  key={summary.evaluation_id}
+                  href={`/evals/${summary.evaluation_id}`}
+                  className="group flex flex-col rounded-[1.75rem] border border-border/70 bg-card p-5 shadow-[0_10px_30px_-22px_rgba(15,23,42,0.35)] transition-all hover:-translate-y-0.5 hover:shadow-[0_18px_40px_-24px_rgba(15,23,42,0.45)] motion-academic-enter motion-academic-surface motion-academic-hover"
+                >
+                  <div className="mb-4 flex items-start justify-between gap-3">
+                    <div className="text-[10px] font-semibold uppercase tracking-[0.28em] text-muted-foreground">
+                      {card ? "Benchmark" : "Benchmark without rich metadata"}
+                    </div>
+                    <div className="flex flex-wrap justify-end gap-1.5">
+                      {dataType && (
+                        <span className="rounded-full border border-border/60 bg-muted/40 px-2.5 py-0.5 text-[10px] font-medium text-muted-foreground">
+                          {dataType}
+                        </span>
+                      )}
+                      {shortLicense && (
+                        <span className={`rounded-full border px-2.5 py-0.5 text-[10px] font-semibold ${licenseBadgeClass(license)}`}>
+                          {shortLicense}
+                        </span>
+                      )}
+                      <span className="rounded-full border border-border/60 bg-background px-2.5 py-0.5 text-[10px] font-semibold text-muted-foreground">
+                        {summary.models_count.toLocaleString()} models
+                      </span>
+                    </div>
+                  </div>
+
+                  <h3 className="mb-2 text-base font-bold tracking-tight transition-colors group-hover:text-primary sm:text-lg">
+                    {title}
+                  </h3>
+
+                  {showCompositeLabel && compositeLabel && (
+                    <div className="mb-2 text-xs font-medium uppercase tracking-[0.18em] text-muted-foreground">
+                      {compositeLabel}
+                    </div>
+                  )}
+
+                  {overview && (
+                    <p className="mb-4 flex-1 text-sm leading-6 text-muted-foreground line-clamp-4">
+                      {overview}
+                    </p>
+                  )}
+
+                  {domains.length > 0 && (
+                    <div className="mt-auto flex flex-wrap gap-2 pt-1">
+                      {domains.slice(0, 5).map((domain) => (
+                        <span
+                          key={domain}
+                          className="rounded-full border border-border/60 bg-muted/30 px-3 py-1 text-[11px] font-medium capitalize text-muted-foreground"
+                        >
+                          {domain}
+                        </span>
+                      ))}
+                      {domains.length > 5 && (
+                        <span className="rounded-full border border-border/60 bg-muted/30 px-3 py-1 text-[11px] font-medium text-muted-foreground">
+                          +{domains.length - 5}
+                        </span>
+                      )}
+                    </div>
+                  )}
+                </Link>
+              )
+            })}
           </div>
         )}
 
         <ListPagination
           page={page}
           pageSize={PAGE_SIZE}
-          totalItems={groupByComposite ? groupedSummaries.length : filtered.length}
-          itemLabel={groupByComposite ? "composite benchmarks" : "single benchmarks"}
+          totalItems={filtered.length}
+          itemLabel="evaluations"
           onPageChange={setPage}
         />
       </main>

app/models/[id]/page.tsx

@@ -6,8 +6,8 @@ import { Button } from "@/components/ui/button"
 import { ArrowLeft } from "lucide-react"
 import { Navigation } from "@/components/navigation"
 import { BenchmarkDetail } from "@/components/benchmark-detail"
-import type { ModelEvaluationSummary } from "@/lib/eval-processing"
-import { fetchModelSummary } from "@/lib/dashboard-data-client"
+import type { BenchmarkCard, ModelEvaluationSummary } from "@/lib/eval-processing"
+import { fetchBenchmarkMetadata, fetchModelSummary } from "@/lib/dashboard-data-client"
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs"
 
 export default function ModelDetailPage() {
@@ -15,6 +15,7 @@ export default function ModelDetailPage() {
   const router = useRouter()
   const searchParams = useSearchParams()
   const [summary, setSummary] = useState<ModelEvaluationSummary | null>(null)
+  const [benchmarkCards, setBenchmarkCards] = useState<Record<string, BenchmarkCard>>({})
   const [selectedVariantId, setSelectedVariantId] = useState<string | null>(null)
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
@@ -95,12 +96,16 @@ export default function ModelDetailPage() {
 
     const loadData = async () => {
       try {
-        const modelSummary = await fetchModelSummary(routeId)
+        const [modelSummary, cards] = await Promise.all([
+          fetchModelSummary(routeId),
+          fetchBenchmarkMetadata(),
+        ])
         if (isCancelled) {
           return
         }
 
         setSummary(modelSummary)
+        setBenchmarkCards(cards)
         setSelectedVariantId((current) => current ?? modelSummary.variants[0]?.variant_id ?? null)
       } catch (err) {
         if (isCancelled) {
@@ -259,7 +264,7 @@ export default function ModelDetailPage() {
         </div>
       </div>
       <main className="container mx-auto px-4 py-8">
-        <BenchmarkDetail summary={detailSummary} />
+        <BenchmarkDetail summary={detailSummary} benchmarkCards={benchmarkCards} />
       </main>
     </div>
   )

app/models/page.tsx

@@ -13,7 +13,10 @@ import { ModelCompareDialog } from "@/components/model-compare-dialog"
 import { Navigation } from "@/components/navigation"
 import { PageHeader } from "@/components/page-header"
 import { Badge } from "@/components/ui/badge"
-import { fetchDevelopers, fetchModelCards, type DeveloperListItem } from "@/lib/dashboard-data-client"
+import { fetchDevelopers, fetchModelCards, fetchBenchmarkMetadata, type DeveloperListItem } from "@/lib/dashboard-data-client"
+import type { BenchmarkCard } from "@/lib/benchmark-schema"
+import { getCategoryColor, type CategoryType } from "@/lib/benchmark-schema"
+import { cn } from "@/lib/utils"
 
 const PAGE_SIZE = 40
 const MAX_COMPARE_MODELS = 4
@@ -57,6 +60,7 @@ export default function ModelsPage() {
   const { mode } = useAudienceMode()
   const [evaluations, setEvaluations] = useState<BenchmarkEvaluationCardData[]>([])
   const [developers, setDevelopers] = useState<DeveloperListItem[]>([])
+  const [benchmarkCards, setBenchmarkCards] = useState<Record<string, BenchmarkCard>>({})
   const [loadingModels, setLoadingModels] = useState(true)
   const [loadingDevelopers, setLoadingDevelopers] = useState(true)
   const [groupByDeveloper, setGroupByDeveloper] = useState(false)
@@ -66,12 +70,16 @@ export default function ModelsPage() {
   const [minParamStep, setMinParamStep] = useState(0)
   const [maxParamStep, setMaxParamStep] = useState(PARAM_RANGE_VALUES.length - 1)
   const [selectedModelIds, setSelectedModelIds] = useState<string[]>([])
+  const [selectedCategories, setSelectedCategories] = useState<string[]>([])
   const [compareOpen, setCompareOpen] = useState(false)
   const [page, setPage] = useState(1)
 
   useEffect(() => {
-    fetchModelCards()
-      .then(setEvaluations)
+    Promise.all([fetchModelCards(), fetchBenchmarkMetadata()])
+      .then(([cards, metadata]) => {
+        setEvaluations(cards)
+        setBenchmarkCards(metadata)
+      })
       .catch((error) => {
         console.error("Failed to load evaluations:", error)
       })
@@ -116,6 +124,16 @@ export default function ModelsPage() {
     return PARAM_RANGE_VALUES[maxParamStep] ?? null
   }, [maxParamStep])
 
+  const allCategories = useMemo(() => {
+    const catSet = new Set<string>()
+    for (const evaluation of evaluations) {
+      for (const cat of evaluation.categories ?? []) {
+        catSet.add(cat)
+      }
+    }
+    return Array.from(catSet).sort((a, b) => a.localeCompare(b))
+  }, [evaluations])
+
   const filteredEvaluations = useMemo(() => {
     const query = searchQuery.trim().toLowerCase()
 
@@ -132,6 +150,12 @@ export default function ModelsPage() {
         }
       }
 
+      if (selectedCategories.length > 0) {
+        if (!evaluation.categories.some((c) => selectedCategories.includes(c))) {
+          return false
+        }
+      }
+
       if (!query) {
         return true
       }
@@ -149,7 +173,7 @@ export default function ModelsPage() {
 
       return haystacks.some((value) => value?.toLowerCase().includes(query))
     })
-  }, [evaluations, numericMaxParams, numericMinParams, searchQuery])
+  }, [evaluations, numericMaxParams, numericMinParams, searchQuery, selectedCategories])
 
   const sortedEvaluations = useMemo(() => {
     const sorted = [...filteredEvaluations]
@@ -247,7 +271,7 @@ export default function ModelsPage() {
 
   useEffect(() => {
     setPage(1)
-  }, [developerSortBy, groupByDeveloper, maxParamStep, minParamStep, modelSortBy, searchQuery])
+  }, [developerSortBy, groupByDeveloper, maxParamStep, minParamStep, modelSortBy, searchQuery, selectedCategories])
 
   const pagedEvaluations = useMemo(
     () => sortedEvaluations.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE),
@@ -343,6 +367,7 @@ export default function ModelsPage() {
             !groupByDeveloper
               ? { label: "Compare tray", value: selectedModels.length.toString() }
               : { label: "View", value: "Developer" },
+            ...(selectedCategories.length > 0 ? [{ label: "Category filter", value: selectedCategories.join(", ") }] : []),
           ]}
         />
 
@@ -367,20 +392,21 @@ export default function ModelsPage() {
           </div>
         ) : null}
 
-        <div className="mb-8 flex flex-col gap-4 border-b border-border/50 pb-6 sm:flex-row sm:flex-wrap sm:items-center">
-          <div className="relative w-full sm:max-w-sm">
-            <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
-            <Input
-              value={searchQuery}
-              onChange={(event) => setSearchQuery(event.target.value)}
-              placeholder={
-                groupByDeveloper
-                  ? "Search developers or popular evals"
-                  : "Search models, developers, or benchmarks"
-              }
-              className="pl-9"
-            />
-          </div>
+        <div className="mb-8 flex flex-col gap-4 border-b border-border/50 pb-6">
+          <div className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center">
+            <div className="relative w-full sm:max-w-sm">
+              <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+              <Input
+                value={searchQuery}
+                onChange={(event) => setSearchQuery(event.target.value)}
+                placeholder={
+                  groupByDeveloper
+                    ? "Search developers or popular evals"
+                    : "Search models, developers, or benchmarks"
+                }
+                className="pl-9"
+              />
+            </div>
           {!groupByDeveloper ? (
             <div className="rounded-xl border border-border/70 bg-muted/15 px-4 py-2">
               <div className="flex items-center gap-3">
@@ -524,6 +550,48 @@ export default function ModelsPage() {
               )}
             </SelectContent>
           </Select>
+          </div>
+
+          {/* Category filter chips — only shown for model view */}
+          {!groupByDeveloper && allCategories.length > 0 && (
+            <div className="flex flex-wrap items-center gap-1.5">
+              <span className="text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground mr-1">
+                Category
+              </span>
+              {allCategories.map((cat) => {
+                const isActive = selectedCategories.includes(cat)
+                return (
+                  <button
+                    key={cat}
+                    type="button"
+                    onClick={() =>
+                      setSelectedCategories((prev) =>
+                        prev.includes(cat) ? prev.filter((c) => c !== cat) : [...prev, cat]
+                      )
+                    }
+                    className={cn(
+                      "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
+                      isActive
+                        ? getCategoryColor(cat as CategoryType) + " border-2"
+                        : "border-border/60 bg-background text-muted-foreground hover:text-foreground"
+                    )}
+                  >
+                    {cat}
+                  </button>
+                )
+              })}
+              {selectedCategories.length > 0 && (
+                <button
+                  type="button"
+                  onClick={() => setSelectedCategories([])}
+                  className="ml-1 flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground"
+                >
+                  <X className="h-3 w-3" />
+                  Clear
+                </button>
+              )}
+            </div>
+          )}
         </div>
 
         {(groupByDeveloper ? filteredDevelopers.length === 0 : sortedEvaluations.length === 0) ? (
@@ -559,6 +627,7 @@ export default function ModelsPage() {
                   <BenchmarkEvaluationCard
                     key={evaluation.id}
                     data={evaluation}
+                    benchmarkCards={benchmarkCards}
                     onDelete={handleDelete}
                     selectedForCompare={selectedModelIds.includes(evaluation.id)}
                     onToggleCompare={toggleModelSelection}

components/benchmark-detail.tsx

@@ -1,6 +1,7 @@
 "use client"
 
 // Force recompile
+import Link from "next/link"
 import { useAudienceMode } from "@/components/audience-mode-provider"
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
 import { Badge } from "@/components/ui/badge"
@@ -17,14 +18,16 @@ import {
   ChevronDown, ChevronUp, BarChart3, Award, AlertTriangle,
   Cpu, Tag, Globe, Network, Activity, MessageSquare, Clock, Hash, Layers, Search, FlaskConical, Scale, BookOpenText
 } from "lucide-react"
-import type { BenchmarkEvaluation, CategoryType, EvaluationResult } from "@/lib/benchmark-schema"
-import { inferCategoryFromBenchmark } from "@/lib/benchmark-schema"
+import type { BenchmarkCard, BenchmarkEvaluation, CategoryType, EvaluationResult } from "@/lib/benchmark-schema"
+import { getCategoryColor as getCategoryTone, inferCategoryFromBenchmark } from "@/lib/benchmark-schema"
 import { formatScore, getBenchmarkDisplayName } from "@/lib/eval-processing"
 import type { ModelSummaryCore } from "@/lib/benchmark-schema"
+import { lookupBenchmarkCard } from "@/lib/benchmark-metadata-utils"
 import { Fragment, useState, useEffect, useMemo, type CSSProperties } from "react"
 
 interface BenchmarkDetailProps {
   summary: ModelSummaryCore
+  benchmarkCards?: Record<string, BenchmarkCard>
 }
 
 interface BenchmarkVariant {
@@ -41,10 +44,14 @@ interface BenchmarkVariant {
 interface BenchmarkGroup {
   key: string
   title: string
+  evalDetailHref: string
+  category: CategoryType
   description: string
   scoreType: EvaluationResult["metric_config"]["score_type"] | "mixed"
   avgNormalizedScore: number
   avgDisplayScore: string
+  domains: string[]
+  benchmarkCard?: BenchmarkCard
   variants: BenchmarkVariant[]
 }
 
@@ -450,6 +457,16 @@ function normalizeScoreForDisplay(result: EvaluationResult) {
   return Math.max(0, Math.min(1, normalized))
 }
 
+function slugifyEvalSummaryId(value: string) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "")
+}
+
+function getEvalDetailHref(evaluation: BenchmarkEvaluation, result: EvaluationResult) {
+  const benchmarkKey = evaluation.benchmark || getResultBenchmarkName(evaluation, result)
+  const evalSummaryId = slugifyEvalSummaryId(`${benchmarkKey}__${result.evaluation_name}`)
+  return `/evals/${evalSummaryId}`
+}
+
 function formatResultDisplayScore(result: EvaluationResult) {
   return formatScore(
     result.score_details.score,
@@ -492,12 +509,16 @@ function getVariantDedupKey(variant: BenchmarkVariant) {
 }
 
 function buildBenchmarkGroups(
-  entries: Array<{ evaluation: BenchmarkEvaluation; result: EvaluationResult }>
+  entries: Array<{ evaluation: BenchmarkEvaluation; result: EvaluationResult; category: CategoryType }>,
+  benchmarkCards?: Record<string, BenchmarkCard>
 ): BenchmarkGroup[] {
   const groups = new Map<string, BenchmarkGroup>()
 
   for (const entry of entries) {
     const title = getBenchmarkDisplayName(getResultBenchmarkName(entry.evaluation, entry.result))
+    const card = benchmarkCards
+      ? lookupBenchmarkCard(benchmarkCards, getResultBenchmarkName(entry.evaluation, entry.result))
+      : undefined
     const normalizedScore = normalizeScoreForDisplay(entry.result)
     const displayScore = formatResultDisplayScore(entry.result)
     const descriptor = getVariantDescriptor(entry.evaluation, entry.result)
@@ -518,10 +539,14 @@ function buildBenchmarkGroups(
       groups.set(title, {
         key: title,
         title,
+        evalDetailHref: getEvalDetailHref(entry.evaluation, entry.result),
+        category: entry.category,
         description: entry.result.metric_config.evaluation_description,
         scoreType: entry.result.metric_config.score_type,
         avgNormalizedScore: normalizedScore,
         avgDisplayScore: `${(normalizedScore * 100).toFixed(1)}%`,
+        domains: card?.benchmark_details?.domains ?? [],
+        benchmarkCard: card,
         variants: [variant],
       })
       continue
@@ -593,12 +618,14 @@ function getEvaluationVariantLabel(evaluation: BenchmarkEvaluation) {
   return evaluationPrefix.split("/").filter(Boolean).pop() || null
 }
 
-export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
+export function BenchmarkDetail({ summary, benchmarkCards }: BenchmarkDetailProps) {
   const { mode } = useAudienceMode()
   const isResearchView = mode === "research"
   const [benchmarkSearch, setBenchmarkSearch] = useState("")
   const [benchmarkSort, setBenchmarkSort] = useState<"score" | "name" | "variants" | "spread">("score")
+  const [selectedCategories, setSelectedCategories] = useState<CategoryType[]>([])
   const [expandedBenchmarkKey, setExpandedBenchmarkKey] = useState<string | null>(null)
+  const [showWithoutMetadata, setShowWithoutMetadata] = useState(false)
   const allEvaluations = useMemo(
     () => Object.values(summary.evaluations_by_category).flat(),
     [summary.evaluations_by_category]
@@ -655,7 +682,9 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
               }
             }
 
-            return resultCategory === category ? [{ evaluation, result }] : []
+            return resultCategory === category
+              ? [{ evaluation, result, category: category as CategoryType }]
+              : []
           })
         )
       ),
@@ -663,7 +692,7 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
   )
 
   const policyHighlights = useMemo(() => {
-    const groups = buildBenchmarkGroups(allCategoryResults)
+    const groups = buildBenchmarkGroups(allCategoryResults, benchmarkCards)
     const seenLabels = new Set<string>()
 
     return groups
@@ -691,7 +720,7 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
         level,
       }
     })
-  }, [allCategoryResults])
+  }, [allCategoryResults, benchmarkCards])
 
   const policySummary = useMemo(() => {
     const benchmarkCount = new Set(
@@ -751,22 +780,22 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
     summary.total_evaluations,
   ])
 
-  const benchmarkGroups = useMemo(() => buildBenchmarkGroups(allCategoryResults), [allCategoryResults])
-
-  const bestBenchmark = benchmarkGroups[0]
-  const weakestBenchmark = benchmarkGroups[benchmarkGroups.length - 1]
-  const widestBenchmark = [...benchmarkGroups].sort((a, b) => getBenchmarkSpread(b) - getBenchmarkSpread(a))[0]
-  const repeatedBenchmarkCount = benchmarkGroups.filter((group) => group.variants.length > 1).length
-  const setupDrivenBenchmarkCount = benchmarkGroups.filter((group) =>
-    group.variants.some((variant) => variant.variantType === "setup" || variant.variantType === "setup+subtask")
-  ).length
-  const subtaskDrivenBenchmarkCount = benchmarkGroups.filter((group) =>
-    group.variants.some((variant) => variant.variantType === "subtask" || variant.variantType === "setup+subtask")
-  ).length
+  const benchmarkGroups = useMemo(
+    () => buildBenchmarkGroups(allCategoryResults, benchmarkCards),
+    [allCategoryResults, benchmarkCards]
+  )
+  const availableCategories = useMemo(() => {
+    const presentCategories = new Set(benchmarkGroups.map((group) => group.category))
+    return summary.categories_covered.filter((category) => presentCategories.has(category))
+  }, [benchmarkGroups, summary.categories_covered])
 
   const filteredBenchmarkGroups = useMemo(() => {
     const query = benchmarkSearch.trim().toLowerCase()
     const filtered = benchmarkGroups.filter((group) => {
+      if (selectedCategories.length > 0 && !selectedCategories.includes(group.category)) {
+        return false
+      }
+
       if (!query) {
         return true
       }
@@ -778,25 +807,54 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
       )
     })
 
-    const sorted = [...filtered]
-    switch (benchmarkSort) {
-      case "name":
-        sorted.sort((a, b) => a.title.localeCompare(b.title))
-        break
-      case "variants":
-        sorted.sort((a, b) => b.variants.length - a.variants.length || b.avgNormalizedScore - a.avgNormalizedScore)
-        break
-      case "spread":
-        sorted.sort((a, b) => getBenchmarkSpread(b) - getBenchmarkSpread(a) || b.avgNormalizedScore - a.avgNormalizedScore)
-        break
-      case "score":
-      default:
-        sorted.sort((a, b) => b.avgNormalizedScore - a.avgNormalizedScore)
-        break
+    // Metadata-first: always put groups with a benchmarkCard at the top
+    const withCard = filtered.filter((g) => !!g.benchmarkCard)
+    const withoutCard = filtered.filter((g) => !g.benchmarkCard)
+
+    const sortFn = (a: BenchmarkGroup, b: BenchmarkGroup) => {
+      switch (benchmarkSort) {
+        case "name": return a.title.localeCompare(b.title)
+        case "variants": return b.variants.length - a.variants.length || b.avgNormalizedScore - a.avgNormalizedScore
+        case "spread": return getBenchmarkSpread(b) - getBenchmarkSpread(a) || b.avgNormalizedScore - a.avgNormalizedScore
+        default: return b.avgNormalizedScore - a.avgNormalizedScore
+      }
     }
 
-    return sorted
-  }, [benchmarkGroups, benchmarkSearch, benchmarkSort])
+    withCard.sort(sortFn)
+    withoutCard.sort(sortFn)
+
+    return showWithoutMetadata ? [...withCard, ...withoutCard] : withCard
+  }, [benchmarkGroups, benchmarkSearch, benchmarkSort, selectedCategories, showWithoutMetadata])
+
+  const groupedFilteredBenchmarkGroups = useMemo(() => {
+    const order = new Map(summary.categories_covered.map((category, index) => [category, index]))
+    const groups = new Map<CategoryType, BenchmarkGroup[]>()
+
+    for (const benchmarkGroup of filteredBenchmarkGroups) {
+      const bucket = groups.get(benchmarkGroup.category) ?? []
+      bucket.push(benchmarkGroup)
+      groups.set(benchmarkGroup.category, bucket)
+    }
+
+    return Array.from(groups.entries())
+      .sort((a, b) => (order.get(a[0]) ?? 999) - (order.get(b[0]) ?? 999))
+      .map(([category, groups]) => ({ category, groups }))
+  }, [filteredBenchmarkGroups, summary.categories_covered])
+
+  const overviewBenchmarkGroups =
+    selectedCategories.length > 0 || benchmarkSearch.trim()
+      ? filteredBenchmarkGroups
+      : benchmarkGroups
+
+  const bestBenchmark = overviewBenchmarkGroups[0]
+  const widestBenchmark = [...overviewBenchmarkGroups].sort((a, b) => getBenchmarkSpread(b) - getBenchmarkSpread(a))[0]
+  const repeatedBenchmarkCount = overviewBenchmarkGroups.filter((group) => group.variants.length > 1).length
+  const setupDrivenBenchmarkCount = overviewBenchmarkGroups.filter((group) =>
+    group.variants.some((variant) => variant.variantType === "setup" || variant.variantType === "setup+subtask")
+  ).length
+  const subtaskDrivenBenchmarkCount = overviewBenchmarkGroups.filter((group) =>
+    group.variants.some((variant) => variant.variantType === "subtask" || variant.variantType === "setup+subtask")
+  ).length
 
   useEffect(() => {
     if (!expandedBenchmarkKey) {
@@ -809,6 +867,12 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
     }
   }, [expandedBenchmarkKey, filteredBenchmarkGroups])
 
+  useEffect(() => {
+    setSelectedCategories((current) =>
+      current.filter((category) => availableCategories.includes(category))
+    )
+  }, [availableCategories])
+
   const formatDate = (isoString: string) => {
     try {
       return new Date(isoString).toLocaleDateString('en-US', {
@@ -824,11 +888,11 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
   }
   
   return (
-    <div className="space-y-6">
+    <div className="space-y-4">
       <Card className="overflow-hidden">
-        <CardContent className="space-y-5 p-5 sm:p-6">
-          <div className="flex flex-col gap-5 xl:flex-row xl:items-start xl:justify-between">
-            <div className="space-y-3">
+        <CardContent className="space-y-4 p-4 sm:p-5">
+          <div className="flex flex-col gap-4 xl:flex-row xl:items-start xl:justify-between">
+            <div className="space-y-2.5">
               <div className="flex flex-wrap items-center gap-2">
                 <Badge variant="outline" className="border-border/60 bg-background/80 text-[11px] uppercase tracking-[0.18em]">
                   Model Metadata
@@ -858,16 +922,16 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
               )}
             </div>
 
-            <div className="grid w-full gap-3 sm:grid-cols-2 xl:w-[560px] xl:grid-cols-4">
-              <div className="rounded-2xl border border-sky-200/80 bg-sky-50/80 px-4 py-3 shadow-[inset_0_1px_0_rgba(255,255,255,0.45)] dark:border-sky-900/40 dark:bg-sky-950/20 dark:shadow-none">
+            <div className="grid w-full gap-2.5 sm:grid-cols-2 xl:w-[620px] xl:grid-cols-4">
+              <div className="rounded-2xl border border-sky-200/80 bg-sky-50/80 px-3.5 py-2.5 dark:border-sky-900/40 dark:bg-sky-950/20 dark:shadow-none">
                 <div className="text-[10px] font-semibold tracking-[0.12em] text-sky-700 dark:text-sky-200 whitespace-nowrap">Benchmarks</div>
                 <div className="mt-1 text-[1.8rem] font-semibold leading-none text-sky-950 dark:text-sky-50">{benchmarkGroups.length}</div>
               </div>
-              <div className="rounded-2xl border border-border/70 bg-muted/20 px-4 py-3 shadow-[inset_0_1px_0_rgba(255,255,255,0.3)] dark:shadow-none">
+              <div className="rounded-2xl border border-border/70 bg-muted/20 px-3.5 py-2.5 dark:shadow-none">
                 <div className="text-[10px] font-semibold tracking-[0.12em] text-muted-foreground whitespace-nowrap">Results</div>
                 <div className="mt-1 text-[1.8rem] font-semibold leading-none">{summary.total_evaluations}</div>
               </div>
-              <div className="rounded-2xl border border-emerald-200/80 bg-emerald-50/80 px-4 py-3 shadow-[inset_0_1px_0_rgba(255,255,255,0.45)] dark:border-emerald-900/40 dark:bg-emerald-950/20 dark:shadow-none">
+              <div className="rounded-2xl border border-emerald-200/80 bg-emerald-50/80 px-3.5 py-2.5 dark:border-emerald-900/40 dark:bg-emerald-950/20 dark:shadow-none">
                 <div className="text-[10px] font-semibold tracking-[0.12em] text-emerald-700 dark:text-emerald-200 whitespace-nowrap">
                   Reporting orgs
                 </div>
@@ -875,7 +939,7 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
                   {reportingStats.organizationCount}
                 </div>
               </div>
-              <div className="rounded-2xl border border-amber-200/80 bg-amber-50/80 px-4 py-3 shadow-[inset_0_1px_0_rgba(255,255,255,0.45)] dark:border-amber-900/40 dark:bg-amber-950/20 dark:shadow-none">
+              <div className="rounded-2xl border border-amber-200/80 bg-amber-50/80 px-3.5 py-2.5 dark:border-amber-900/40 dark:bg-amber-950/20 dark:shadow-none">
                 <div className="text-[10px] font-semibold tracking-[0.12em] text-amber-700 dark:text-amber-200 whitespace-nowrap">
                   Source types
                 </div>
@@ -886,7 +950,7 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
             </div>
           </div>
 
-          <div className="grid gap-4 xl:grid-cols-[minmax(0,1fr)_minmax(320px,0.92fr)]">
+          <div className="grid gap-3 xl:grid-cols-[minmax(0,1fr)_minmax(320px,0.92fr)]">
             <div className="rounded-[1.5rem] border bg-muted/10 p-4">
               <div className="text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
                 System and evidence context
@@ -974,7 +1038,7 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
                 </div>
               </div>
             ) : (
-              <div className="rounded-[1.5rem] border bg-gradient-to-br from-amber-50/80 via-background to-rose-50/60 p-4 dark:from-amber-950/20 dark:via-background dark:to-rose-950/20">
+              <div className="rounded-[1.5rem] border bg-amber-50/60 p-4 dark:bg-amber-950/20">
                 <div className="flex items-center gap-2">
                   <Scale className="h-4 w-4 text-primary" />
                   <div className="text-sm font-semibold">Public reading</div>
@@ -1013,8 +1077,8 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
         </CardContent>
       </Card>
 
-      <section className="space-y-5">
-        <div className="flex flex-col gap-4 lg:flex-row lg:items-end lg:justify-between">
+      <section className="space-y-4">
+        <div className="flex flex-col gap-3 lg:flex-row lg:items-end lg:justify-between">
           <div className="space-y-1">
             <h3 className="text-xl font-semibold">
               {isResearchView ? "Benchmark Explorer" : "Reported Benchmark Signals"}
@@ -1026,8 +1090,8 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
             </p>
           </div>
 
-          <div className="flex flex-col gap-3 sm:flex-row">
-            <div className="relative w-full sm:w-[280px]">
+          <div className="flex flex-col gap-2.5 sm:flex-row sm:flex-wrap sm:justify-end">
+            <div className="relative w-full sm:w-[260px]">
               <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
               <Input
                 value={benchmarkSearch}
@@ -1038,55 +1102,126 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
             </div>
 
             <Select value={benchmarkSort} onValueChange={(value) => setBenchmarkSort(value as typeof benchmarkSort)}>
-              <SelectTrigger className="w-full sm:w-[220px]">
+              <SelectTrigger className="w-full sm:w-[200px]">
                 <SelectValue placeholder="Sort benchmarks" />
               </SelectTrigger>
               <SelectContent>
                 <SelectItem value="score">Highest score first</SelectItem>
                 <SelectItem value="name">Name (A-Z)</SelectItem>
-                <SelectItem value="variants">Most comparison slices</SelectItem>
+                <SelectItem value="variants">Most subtasks</SelectItem>
                 <SelectItem value="spread">Largest setup swing</SelectItem>
               </SelectContent>
             </Select>
           </div>
         </div>
 
-        <div className={`grid gap-4 ${isResearchView ? "md:grid-cols-3" : "md:grid-cols-2 xl:grid-cols-3"}`}>
+        {availableCategories.length > 0 && (
+          <div className="flex flex-wrap items-center gap-2">
+            <span className="text-[11px] font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+              Category
+            </span>
+            <button
+              type="button"
+              onClick={() => setSelectedCategories([])}
+              className={`inline-flex items-center rounded-full border px-3 py-1 text-sm font-medium transition-colors ${
+                selectedCategories.length === 0
+                  ? "border-foreground bg-foreground text-background"
+                  : "border-border/70 bg-background text-muted-foreground hover:text-foreground"
+              }`}
+            >
+              All
+            </button>
+            {availableCategories.map((category) => {
+              const isSelected = selectedCategories.includes(category)
+
+              return (
+                <button
+                  key={category}
+                  type="button"
+                  onClick={() =>
+                    setSelectedCategories((current) =>
+                      current.includes(category)
+                        ? current.filter((item) => item !== category)
+                        : [...current, category]
+                    )
+                  }
+                  className={`inline-flex items-center rounded-full border px-3 py-1 text-sm font-medium transition-colors ${
+                    isSelected
+                      ? getCategoryTone(category)
+                      : "border-border/70 bg-background text-muted-foreground hover:text-foreground"
+                  }`}
+                >
+                  {category}
+                </button>
+              )
+            })}
+          </div>
+        )}
+
+        {/* Metadata toggle */}
+        {benchmarkGroups.some((g) => !g.benchmarkCard) && (
+          <div className="flex items-center gap-2 text-sm">
+            <label className="flex cursor-pointer items-center gap-2 select-none">
+              <input
+                type="checkbox"
+                checked={showWithoutMetadata}
+                onChange={(e) => setShowWithoutMetadata(e.target.checked)}
+                className="h-4 w-4 rounded border-border accent-primary"
+              />
+              <span className="text-muted-foreground">
+                Show {benchmarkGroups.filter((g) => !g.benchmarkCard).length} benchmarks without rich metadata
+              </span>
+            </label>
+            <span className="rounded-full border border-border/60 bg-muted/30 px-2 py-0.5 text-[10px] font-medium text-muted-foreground">
+              {benchmarkGroups.filter((g) => !!g.benchmarkCard).length} with metadata
+            </span>
+          </div>
+        )}
+
+        <div className={`grid gap-3 ${isResearchView ? "md:grid-cols-3" : "md:grid-cols-2 xl:grid-cols-3"}`}>
           {bestBenchmark && (
-            <div className="rounded-[1.5rem] border bg-emerald-50/70 p-4 dark:bg-emerald-950/20">
+            <div className="rounded-2xl border bg-emerald-50/70 p-3.5 dark:bg-emerald-950/20">
               <div className="text-[10px] font-semibold uppercase tracking-[0.16em] text-emerald-700/90 dark:text-emerald-300">
                 Strongest Reported Benchmark
               </div>
-              <div className="mt-2 text-base font-semibold tracking-tight">{bestBenchmark.title}</div>
-              <div className="mt-1 text-[13px] leading-5 text-muted-foreground">{bestBenchmark.description}</div>
-              <div className="mt-3 text-[1.75rem] font-semibold tracking-tight text-emerald-700 dark:text-emerald-300">{bestBenchmark.avgDisplayScore}</div>
+              <div className="mt-1.5 text-sm font-semibold tracking-tight">
+                <Link href={bestBenchmark.evalDetailHref} className="underline decoration-dotted underline-offset-4 hover:text-primary">
+                  {bestBenchmark.title}
+                </Link>
+              </div>
+              <div className="mt-1 text-xs leading-5 text-muted-foreground">{bestBenchmark.description}</div>
+              <div className="mt-2 text-[1.45rem] font-semibold tracking-tight text-emerald-700 dark:text-emerald-300">{bestBenchmark.avgDisplayScore}</div>
             </div>
           )}
 
           {widestBenchmark && (
-            <div className="rounded-[1.5rem] border bg-amber-50/70 p-4 dark:bg-amber-950/20">
+            <div className="rounded-2xl border bg-amber-50/70 p-3.5 dark:bg-amber-950/20">
               <div className="text-[10px] font-semibold uppercase tracking-[0.16em] text-amber-700/90 dark:text-amber-300">
                 Widest score gap
               </div>
-              <div className="mt-2 text-base font-semibold tracking-tight">{widestBenchmark.title}</div>
-              <div className="mt-1 text-[13px] leading-5 text-muted-foreground">
-                {widestBenchmark.variants.length} reported slice{widestBenchmark.variants.length === 1 ? "" : "s"} with the biggest spread between highest and lowest scores
+              <div className="mt-1.5 text-sm font-semibold tracking-tight">
+                <Link href={widestBenchmark.evalDetailHref} className="underline decoration-dotted underline-offset-4 hover:text-primary">
+                  {widestBenchmark.title}
+                </Link>
+              </div>
+              <div className="mt-1 text-xs leading-5 text-muted-foreground">
+                {widestBenchmark.variants.length} subtask{widestBenchmark.variants.length === 1 ? "" : "s"} with the biggest spread between highest and lowest scores
               </div>
-              <div className="mt-3 text-[1.75rem] font-semibold tracking-tight text-amber-700 dark:text-amber-300">
+              <div className="mt-2 text-[1.45rem] font-semibold tracking-tight text-amber-700 dark:text-amber-300">
                 {(getBenchmarkSpread(widestBenchmark) * 100).toFixed(1)} pts
               </div>
             </div>
           )}
 
-              <div className="rounded-[1.5rem] border bg-sky-50/70 p-4 dark:bg-sky-950/20">
+              <div className="rounded-2xl border bg-sky-50/70 p-3.5 dark:bg-sky-950/20">
             <div className="text-[10px] font-semibold uppercase tracking-[0.16em] text-sky-700/90 dark:text-sky-300">
               Coverage Snapshot
             </div>
-            <div className="mt-2 text-base font-semibold tracking-tight">{benchmarkGroups.length} benchmarks</div>
-                <div className="mt-1 text-[13px] leading-5 text-muted-foreground">
-              {repeatedBenchmarkCount} benchmark{repeatedBenchmarkCount === 1 ? "" : "s"} include multiple comparison slices.
+            <div className="mt-1.5 text-sm font-semibold tracking-tight">{benchmarkGroups.length} benchmarks</div>
+                <div className="mt-1 text-xs leading-5 text-muted-foreground">
+              {repeatedBenchmarkCount} benchmark{repeatedBenchmarkCount === 1 ? "" : "s"} include multiple subtasks.
                 </div>
-            <div className="mt-3 text-[13px] font-medium text-sky-700 dark:text-sky-300">
+            <div className="mt-2 text-xs font-medium text-sky-700 dark:text-sky-300">
               {filteredBenchmarkGroups.length} shown after filters
             </div>
           </div>
@@ -1094,26 +1229,41 @@ export function BenchmarkDetail({ summary }: BenchmarkDetailProps) {
 
         {filteredBenchmarkGroups.length === 0 ? (
           <div className="rounded-2xl border border-dashed p-8 text-center text-sm text-muted-foreground">
-            No benchmarks match the current search.
+            No benchmarks match the current search or category filters.
           </div>
         ) : (
-          <div className="grid gap-4 xl:grid-cols-2">
-            {filteredBenchmarkGroups.map((group, index) => (
-              <AggregatedBenchmarkCard
-                key={group.key}
-                group={group}
-                isOpen={expandedBenchmarkKey === group.key}
-                motionIndex={index}
-                onOpenChange={(open) =>
-                  setExpandedBenchmarkKey((current) => {
-                    if (open) {
-                      return group.key
-                    }
-
-                    return current === group.key ? null : current
-                  })
-                }
-              />
+          <div className="space-y-5">
+            {groupedFilteredBenchmarkGroups.map(({ category, groups }, sectionIndex) => (
+              <section key={category} className="space-y-3">
+                <div className="flex items-center gap-3">
+                  <span className={`inline-flex items-center rounded-full border px-3 py-1 text-xs font-semibold ${getCategoryTone(category)}`}>
+                    {category}
+                  </span>
+                  <div className="text-sm text-muted-foreground">
+                    {groups.length} benchmark{groups.length === 1 ? "" : "s"}
+                  </div>
+                </div>
+
+                <div className="space-y-2.5">
+                  {groups.map((group, index) => (
+                    <AggregatedBenchmarkCard
+                      key={`${category}-${group.key}`}
+                      group={group}
+                      isOpen={expandedBenchmarkKey === group.key}
+                      motionIndex={sectionIndex * 6 + index}
+                      onOpenChange={(open) =>
+                        setExpandedBenchmarkKey((current) => {
+                          if (open) {
+                            return group.key
+                          }
+
+                          return current === group.key ? null : current
+                        })
+                      }
+                    />
+                  ))}
+                </div>
+              </section>
             ))}
           </div>
         )}
@@ -1861,6 +2011,8 @@ function AggregatedBenchmarkCard({
   }, Number.NEGATIVE_INFINITY)
   const latestReportedLabel =
     Number.isFinite(latestTimestamp) ? formatCompactDate(String(latestTimestamp)) : formatCompactDate(group.variants[0]?.evaluation.retrieved_timestamp ?? "")
+  const compactDomains = group.domains.slice(0, 2)
+  const progressWidth = Math.max(4, Math.min(100, group.avgNormalizedScore * 100))
 
   const toggleRow = (rowKey: string) => {
     setExpandedRows((current) => ({
@@ -1871,118 +2023,150 @@ function AggregatedBenchmarkCard({
 
   return (
     <div
-      className={`motion-academic-enter ${isOpen ? "xl:col-span-2" : ""}`}
+      className="motion-academic-enter"
       style={{ "--enter-delay": `${Math.min(motionIndex * 55, 260)}ms` } as CSSProperties}
     >
       <Collapsible open={isOpen} onOpenChange={onOpenChange}>
-      <Card className="motion-academic-surface overflow-hidden border border-border/70 bg-card shadow-[0_1px_0_rgba(255,255,255,0.3),0_12px_30px_rgba(15,23,42,0.04)] dark:shadow-[0_1px_0_rgba(255,255,255,0.02)]">
-        <div className="p-5 sm:p-6">
-          <div className="flex flex-col gap-5 lg:flex-row lg:items-start lg:justify-between">
-            <div className="min-w-0 flex-1 space-y-3">
-              <div className="flex flex-wrap items-center gap-2">
-                <Badge variant="outline" className="border-border/60 bg-background/70 text-[11px] font-medium text-foreground/85 shadow-none">
-                  Benchmark summary
-                </Badge>
-                <Badge variant="outline" className="border-border/60 bg-background/70 text-[11px] font-normal text-muted-foreground">
-                  {group.scoreType}
-                </Badge>
-                <Badge variant="secondary" className="bg-muted/60 text-[11px] font-normal text-muted-foreground">
-                  {group.variants.length > 1
-                    ? `${group.variants.length} comparison slices`
-                    : "1 reported result"}
-                </Badge>
-                {sourceOrganizations.size > 1 && (
-                  <Badge variant="outline" className="border-border/60 bg-background/70 text-[11px] font-normal text-muted-foreground">
-                    {sourceOrganizations.size} reporting orgs
-                  </Badge>
-                )}
+      <Card className="motion-academic-surface overflow-hidden border border-border/70 bg-card shadow-[0_1px_0_rgba(255,255,255,0.3),0_8px_24px_rgba(15,23,42,0.04)] dark:shadow-[0_1px_0_rgba(255,255,255,0.02)]">
+        <div
+          role="button"
+          tabIndex={0}
+          onClick={() => onOpenChange(!isOpen)}
+          onKeyDown={(event) => {
+            if (event.key === "Enter" || event.key === " ") {
+              event.preventDefault()
+              onOpenChange(!isOpen)
+            }
+          }}
+          className="block w-full cursor-pointer px-3.5 py-2.5 text-left transition-colors hover:bg-muted/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+        >
+            {/* Compact single-row layout */}
+            <div className="flex items-center gap-3">
+              {/* Category dot */}
+              <span className={`shrink-0 inline-flex items-center rounded-full border px-2 py-0.5 text-[10px] font-semibold ${getCategoryTone(group.category)}`}>
+                {group.category}
+              </span>
+
+              {/* Name + domains */}
+              <div className="min-w-0 flex-1">
+                <div className="flex flex-wrap items-center gap-2">
+                  <Link
+                    href={group.evalDetailHref}
+                    onClick={(event) => event.stopPropagation()}
+                    className="text-sm font-semibold tracking-tight text-foreground/95 underline decoration-dotted underline-offset-4 hover:text-primary"
+                  >
+                    {group.title}
+                  </Link>
+                  {group.benchmarkCard && (
+                    <span className="shrink-0 rounded-full border border-border/50 bg-muted/30 px-1.5 py-0.5 text-[9px] font-semibold uppercase tracking-[0.12em] text-muted-foreground">
+                      card
+                    </span>
+                  )}
+                  {compactDomains.map((domain) => (
+                    <span
+                      key={`${group.key}-${domain}`}
+                      className="hidden sm:inline-flex items-center rounded-full border border-border/50 bg-background/60 px-2 py-0.5 text-[10px] font-medium capitalize text-muted-foreground"
+                    >
+                      {domain}
+                    </span>
+                  ))}
+                  {group.domains.length > compactDomains.length && (
+                    <span className="hidden sm:inline text-[10px] text-muted-foreground/70">+{group.domains.length - compactDomains.length}</span>
+                  )}
+                </div>
               </div>
 
-              <div>
-                <h3 className="text-[1.35rem] font-semibold tracking-tight text-foreground/95 sm:text-[1.45rem]">{group.title}</h3>
-                <p className="mt-1 max-w-3xl text-[13px] leading-5 text-muted-foreground">{group.description}</p>
+              {/* Score bar + score — right side */}
+              <div className="hidden md:flex shrink-0 items-center gap-2.5 w-[180px] lg:w-[190px]">
+                <div className="flex-1 h-1.5 overflow-hidden rounded-full bg-muted/60">
+                  <div
+                    className="h-full rounded-full bg-foreground/70 transition-[width] duration-300"
+                    style={{ width: `${progressWidth}%` }}
+                  />
+                </div>
+                <span className="w-12 shrink-0 text-right text-sm font-semibold tabular-nums text-foreground/90">
+                  {group.avgDisplayScore}
+                </span>
               </div>
 
-              <div className="rounded-2xl border border-border/60 bg-muted/[0.22] p-3 shadow-[inset_0_1px_0_rgba(255,255,255,0.45)] dark:bg-muted/10 dark:shadow-none">
-                <div className="grid gap-3 md:grid-cols-[minmax(0,1.6fr)_minmax(140px,.8fr)_minmax(140px,.85fr)]">
-                  <div>
-                    <div className="text-[10px] font-semibold uppercase tracking-[0.14em] text-muted-foreground">
-                      {group.variants.length > 1
-                        ? isResearchView
-                          ? "Top comparison slice"
-                          : "Top reported slice"
-                        : "Reported result"}
+              {/* Subtask count */}
+              <span className="shrink-0 text-[11px] text-muted-foreground w-16 text-right hidden sm:block">
+                {group.variants.length} {group.variants.length === 1 ? "subtask" : "subtasks"}
+              </span>
+
+              {/* Expand toggle */}
+              <div className="shrink-0 text-muted-foreground">
+                {isOpen ? <ChevronUp className="h-4 w-4" /> : <ChevronDown className="h-4 w-4" />}
+              </div>
+          </div>
+        </div>
+
+        <CollapsibleContent>
+          <Separator />
+          <CardContent className="bg-muted/5 p-4 sm:p-5">
+            <div className="space-y-2.5">
+              {group.benchmarkCard && (
+                <div className="rounded-2xl border border-border/70 bg-background/90 p-3.5">
+                  <div className="flex flex-wrap items-start justify-between gap-3">
+                    <div className="min-w-0 space-y-1">
+                      <div className="text-xs font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                        Benchmark context
+                      </div>
+                      <div className="text-base font-semibold">
+                        {group.benchmarkCard.benchmark_details.name}
+                      </div>
+                      <p className="max-w-3xl text-sm leading-6 text-muted-foreground">
+                        {group.benchmarkCard.benchmark_details.overview}
+                      </p>
                     </div>
-                    <div className="mt-1 flex flex-wrap items-center gap-2">
-                      <span className="min-w-0 truncate text-[13px] font-medium text-foreground/90">
-                        {group.variants[0]?.label ?? "Default run"}
-                      </span>
-                      {group.variants[0] && (
-                        <Badge className={`${getVariantTypeTone(group.variants[0].variantType)} shadow-none`}>
-                          {getVariantTypeLabel(group.variants[0].variantType)}
+                    <div className="flex flex-wrap gap-1.5">
+                      <Badge variant="outline" className="font-normal">
+                        {group.benchmarkCard.benchmark_details.data_type}
+                      </Badge>
+                      {group.benchmarkCard.methodology.metrics.slice(0, 2).map((metric) => (
+                        <Badge key={`${group.key}-${metric}`} variant="secondary" className="font-normal">
+                          {metric}
                         </Badge>
-                      )}
+                      ))}
                     </div>
                   </div>
-                  <div className="md:border-l md:border-border/50 md:pl-3">
-                    <div className="text-[10px] font-semibold uppercase tracking-[0.14em] text-muted-foreground">
-                      {group.variants.length > 1
-                        ? isResearchView
-                          ? "Cross-slice spread"
-                          : "Score spread"
-                        : "Comparison status"}
+                  <div className="mt-3 grid gap-3 lg:grid-cols-3">
+                    <div className="rounded-xl border bg-muted/10 p-3">
+                      <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                        Goal
+                      </div>
+                      <div className="mt-1 text-sm text-foreground/90">
+                        {group.benchmarkCard.purpose_and_intended_users.goal}
+                      </div>
                     </div>
-                    <div className="mt-1 text-[13px] font-medium text-foreground/90">
-                      {group.variants.length > 1 ? `${(spread * 100).toFixed(1)} pts` : "No comparison set"}
+                    <div className="rounded-xl border bg-muted/10 p-3">
+                      <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                        Methods
+                      </div>
+                      <div className="mt-1 text-sm text-foreground/90">
+                        {group.benchmarkCard.methodology.methods.slice(0, 2).join(", ") || "Not specified"}
+                      </div>
                     </div>
-                  </div>
-                  <div className="md:border-l md:border-border/50 md:pl-3">
-                    <div className="text-[10px] font-semibold uppercase tracking-[0.14em] text-muted-foreground">
-                      Latest report
+                    <div className="rounded-xl border bg-muted/10 p-3">
+                      <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                        Caveat
+                      </div>
+                      <div className="mt-1 text-sm text-foreground/90">
+                        {group.benchmarkCard.purpose_and_intended_users.limitations}
+                      </div>
                     </div>
-                    <div className="mt-1 text-[13px] font-medium text-foreground/90">{latestReportedLabel}</div>
                   </div>
                 </div>
-              </div>
-            </div>
-
-            <div className="flex items-center gap-3 lg:min-w-[210px] lg:justify-end lg:pl-4">
-              <div className="min-w-[152px] text-right">
-                <div className="text-[2rem] font-semibold tracking-tight text-foreground/95">{group.avgDisplayScore}</div>
-                <div className="mt-1 text-[12px] text-muted-foreground">
-                  {isResearchView ? "Average normalized score" : "Average reported score"}
-                </div>
-                <div className="mt-3 flex justify-end">
-                  <div className="h-1.5 w-28 overflow-hidden rounded-full bg-muted">
-                    <div
-                      className="h-full rounded-full bg-foreground/90 transition-[width] duration-300"
-                      style={{ width: `${Math.max(0, Math.min(100, group.avgNormalizedScore * 100))}%` }}
-                    />
-                  </div>
-                </div>
-              </div>
-              <CollapsibleTrigger asChild>
-                <Button variant="ghost" size="sm" className="motion-academic-button h-9 w-9 rounded-full border border-border/60 bg-background/80 p-0 shadow-sm">
-                  {isOpen ? <ChevronUp className="h-4 w-4" /> : <ChevronDown className="h-4 w-4" />}
-                  <span className="sr-only">Toggle benchmark details</span>
-                </Button>
-              </CollapsibleTrigger>
-            </div>
-          </div>
-        </div>
+              )}
 
-        <CollapsibleContent>
-          <Separator />
-          <CardContent className="p-6 bg-muted/5">
-            <div className="space-y-3">
               <div>
                 <div className="text-xs font-semibold text-muted-foreground uppercase tracking-wider">
-                  Comparison Slices
+                  Subtasks
                 </div>
                 <div className="text-xs text-muted-foreground mt-1">
                   {isResearchView
                     ? "Setup changes and benchmark subtasks are shown separately so you can tell methodological differences from benchmark decomposition."
-                    : "Different setups and benchmark subtasks are visually separated so policy review does not confuse reporting choices with task slices."}
+                    : "Different setups and benchmark subtasks are visually separated so policy review does not confuse reporting choices with benchmark decomposition."}
                 </div>
               </div>
 
@@ -2073,7 +2257,11 @@ function AggregatedBenchmarkCard({
                         className="motion-academic-enter-soft overflow-hidden rounded-xl border bg-background"
                         style={{ "--enter-delay": `${Math.min(index * 40, 180)}ms` } as CSSProperties}
                       >
-                        <div className="p-4">
+                        <button
+                          type="button"
+                          className="block w-full p-4 text-left transition-colors hover:bg-muted/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+                          onClick={() => toggleRow(rowKey)}
+                        >
                           <div className="flex flex-col gap-3">
                             <div className="flex items-start justify-between gap-3">
                               <div className="flex min-w-0 items-start gap-3">
@@ -2096,76 +2284,69 @@ function AggregatedBenchmarkCard({
                                 </div>
                               </div>
 
-                              <Button
-                                variant="ghost"
-                                size="sm"
-                                className="h-9 w-9 shrink-0 p-0"
-                                onClick={() => toggleRow(rowKey)}
-                              >
+                              <span className="inline-flex h-9 w-9 shrink-0 items-center justify-center rounded-full border border-border/60 bg-background/80">
                                 {isRowOpen ? <ChevronUp className="h-4 w-4" /> : <ChevronDown className="h-4 w-4" />}
                                 <span className="sr-only">Toggle variant details</span>
-                              </Button>
+                              </span>
                             </div>
 
-                            <div className="grid gap-2 border-t border-border/50 pt-3 md:grid-cols-4">
-                              <SummaryRailItem
-                                label={isResearchView ? "Config" : "Setup"}
-                                tone="bg-sky-50/80 border-sky-200/70 shadow-[inset_0_1px_0_rgba(255,255,255,0.7)] dark:bg-sky-950/20 dark:border-sky-900/40"
-                              >
-                                <Badge
-                                  variant="outline"
-                                  className="max-w-full truncate border-sky-200/70 bg-background/90 px-2 py-0.5 font-normal dark:border-sky-900/40 dark:bg-background/70"
-                                  title={getTableConfigLabel(row)}
-                                >
+                            <div className="grid gap-3 border-t border-border/50 pt-3 lg:grid-cols-[minmax(0,1.1fr)_minmax(180px,1fr)_110px_150px]">
+                              <div className="min-w-0">
+                                <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                                  {isResearchView ? "Config" : "Setup"}
+                                </div>
+                                <div className="mt-1 text-sm font-medium text-foreground/90" title={getTableConfigLabel(row)}>
                                   {getConfigDisplayValue(getTableConfigLabel(row))}
-                                </Badge>
-                              </SummaryRailItem>
+                                </div>
+                              </div>
 
-                              <SummaryRailItem
-                                label={isResearchView ? "Gap" : "Relationship"}
-                                tone="bg-stone-100/80 border-stone-200/80 shadow-[inset_0_1px_0_rgba(255,255,255,0.7)] dark:bg-stone-900/35 dark:border-stone-800/70"
-                              >
+                              <div className="min-w-0">
+                                <div className="flex items-center justify-between text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                                  <span>{isResearchView ? "Relative score" : "Evidence context"}</span>
+                                  <span>{index === 0 ? "Leader" : `-${(gapToLeader * 100).toFixed(1)} pts`}</span>
+                                </div>
                                 {isResearchView ? (
-                                  <div className="flex items-center gap-2">
-                                    <div className="min-w-0 text-sm font-semibold">
-                                      {index === 0 ? "Leader" : `-${(gapToLeader * 100).toFixed(1)} pts`}
+                                  <>
+                                    <div className="mt-2 h-2 overflow-hidden rounded-full bg-muted">
+                                      <div
+                                        className="h-full rounded-full bg-foreground/70"
+                                        style={{
+                                          width: `${leaderNormalizedScore > 0 ? Math.max(4, (variant.normalizedScore / leaderNormalizedScore) * 100) : 100}%`,
+                                        }}
+                                      />
                                     </div>
-                                    <Progress
-                                      value={leaderNormalizedScore > 0 ? (variant.normalizedScore / leaderNormalizedScore) * 100 : 100}
-                                      className="h-2 w-14 shrink-0"
-                                    />
-                                  </div>
+                                    <div className="mt-1 text-[12px] text-muted-foreground">
+                                      {variant.evaluation.source_metadata.evaluator_relationship.replace(/_/g, " ")}
+                                    </div>
+                                  </>
                                 ) : (
-                                  <div className="text-sm capitalize text-muted-foreground">
+                                  <div className="mt-1 text-sm capitalize text-muted-foreground">
                                     {variant.evaluation.source_metadata.evaluator_relationship.replace(/_/g, " ")}
                                   </div>
                                 )}
-                              </SummaryRailItem>
-
-                              <SummaryRailItem
-                                label="Score"
-                                tone="bg-amber-50/85 border-amber-200/70 shadow-[inset_0_1px_0_rgba(255,255,255,0.7)] dark:bg-amber-950/20 dark:border-amber-900/40"
-                              >
-                                <span className="text-base font-semibold">{variant.displayScore}</span>
-                              </SummaryRailItem>
-
-                              <SummaryRailItem
-                                label={isResearchView ? "Source" : "Evidence"}
-                                tone="bg-emerald-50/80 border-emerald-200/70 shadow-[inset_0_1px_0_rgba(255,255,255,0.7)] dark:bg-emerald-950/20 dark:border-emerald-900/40"
-                              >
-                                <div className="flex items-center gap-1.5 whitespace-nowrap text-sm text-muted-foreground">
-                                  <span className="min-w-0 max-w-[6.25rem] truncate">
-                                    {variant.evaluation.source_metadata.source_organization_name}
-                                  </span>
-                                  <span className="text-border">/</span>
-                                  <span className="shrink-0">
-                                    {evidenceStatus}
-                                  </span>
+                              </div>
+
+                              <div>
+                                <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                                  Score
+                                </div>
+                                <div className="mt-1 text-lg font-semibold tracking-tight">{variant.displayScore}</div>
+                              </div>
+
+                              <div className="min-w-0">
+                                <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
+                                  {isResearchView ? "Source" : "Evidence"}
+                                </div>
+                                <div className="mt-1 truncate text-sm font-medium text-foreground/90">
+                                  {variant.evaluation.source_metadata.source_organization_name}
+                                </div>
+                                <div className="text-[12px] text-muted-foreground">
+                                  {evidenceStatus}
                                 </div>
-                              </SummaryRailItem>
+                              </div>
                             </div>
                           </div>
-                        </div>
+                        </button>
 
                         {isRowOpen && (
                           <div className="border-t bg-muted/10 p-4">
@@ -2182,7 +2363,7 @@ function AggregatedBenchmarkCard({
 
                   {filteredRows.length === 0 && (
                     <div className="rounded-xl border bg-background p-6 text-center text-sm text-muted-foreground">
-                      No comparison slices match the current filters.
+                      No subtasks match the current filters.
                     </div>
                   )}
                 </div>
@@ -2376,25 +2557,6 @@ function InlineMeta({ label, value }: { label: string; value: React.ReactNode })
   )
 }
 
-function SummaryRailItem({
-  label,
-  tone,
-  children,
-}: {
-  label: string
-  tone: string
-  children: React.ReactNode
-}) {
-  return (
-    <div className={`min-w-0 rounded-2xl border px-3 py-2.5 ${tone}`}>
-      <div className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
-        {label}
-      </div>
-      <div className="mt-1.5 min-w-0 overflow-hidden">{children}</div>
-    </div>
-  )
-}
-
 function AllEvaluationsView({ evaluations }: { evaluations: BenchmarkEvaluation[] }) {
   return (
     <div className="space-y-6">

components/benchmark-evaluation-card.tsx

@@ -1,11 +1,11 @@
 "use client"
 
 import type { CSSProperties } from "react"
+import { useMemo } from "react"
 import { useAudienceMode } from "@/components/audience-mode-provider"
 import { useRouter } from "next/navigation"
 import {
   Award,
-  BookOpenText,
   ChevronDown,
   CheckCircle2,
   ExternalLink,
@@ -18,12 +18,14 @@ import {
 } from "lucide-react"
 
 import type { CategoryType } from "@/lib/benchmark-schema"
+import { getCategoryColor } from "@/lib/benchmark-schema"
+import type { BenchmarkCard } from "@/lib/benchmark-schema"
+import { lookupBenchmarkCard } from "@/lib/benchmark-metadata-utils"
 import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible"
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu"
-import { Progress } from "@/components/ui/progress"
 
 export type BenchmarkEvaluationCardData = {
   id: string
@@ -76,6 +78,7 @@ export type BenchmarkEvaluationCardData = {
 
 interface BenchmarkEvaluationCardProps {
   data: BenchmarkEvaluationCardData
+  benchmarkCards?: Record<string, BenchmarkCard>
   onDelete?: (id: string) => void
   delayMs?: number
   selectedForCompare?: boolean
@@ -100,32 +103,6 @@ function formatDate(isoString: string) {
   }
 }
 
-function formatHighlightScore(score: number, unit?: string) {
-  if (unit === "accuracy" || unit === "pass@1" || (!unit && score >= 0 && score <= 1)) {
-    return `${(score * 100).toFixed(1)}%`
-  }
-  if (unit === "points") return score.toFixed(1)
-  return score.toFixed(2)
-}
-
-function scoreToPercent(score: number, unit?: string): number {
-  if (score >= 0 && score <= 1) return score * 100
-  return Math.min(Math.max(score, 0), 100)
-}
-
-function getPolicyBenchmarkLabel(name: string) {
-  const value = name.toLowerCase()
-  if (value.includes("ifeval")) return "Following instructions"
-  if (value.includes("bbh")) return "Reasoning and logic"
-  if (value.includes("math")) return "Advanced mathematics"
-  if (value.includes("gpqa")) return "Expert knowledge"
-  if (value.includes("musr")) return "Narrative reasoning"
-  if (value.includes("mmlu")) return "Broad knowledge"
-  if (value.includes("tau-bench")) return "Agentic task completion"
-  if (value.includes("swe-bench")) return "Software engineering"
-  return name
-}
-
 function formatParamsBillions(value: number | null | undefined) {
   if (value == null || Number.isNaN(value)) return null
   if (value >= 100) return `${Math.round(value)}B`
@@ -181,8 +158,84 @@ function getIndependentSummary(data: BenchmarkEvaluationCardData) {
   return "Self-reported only"
 }
 
+const CATEGORY_PLOT_COLORS: Record<string, string> = {
+  "Core Performance": "#2563eb",
+  "Core Quality Dimensions": "#7c3aed",
+  "Robustness": "#0f766e",
+  "Calibration": "#0891b2",
+  "Adversarial": "#dc2626",
+  "Memorization": "#9333ea",
+  "Fairness": "#ea580c",
+  "Safety": "#16a34a",
+  "Leakage/Contamination": "#be123c",
+  "Privacy": "#0d9488",
+  "Interpretability": "#6366f1",
+  "Efficiency": "#ca8a04",
+  "Retrainability": "#1d4ed8",
+  "Meta-Learning": "#9333ea",
+}
+
+function getCategoryPlotColor(category: string) {
+  return CATEGORY_PLOT_COLORS[category] ?? "#64748b"
+}
+
+function CategoryCoveragePlot({
+  coverage,
+}: {
+  coverage: Array<{ category: CategoryType; count: number }>
+}) {
+  if (coverage.length === 0) {
+    return (
+      <div className="rounded-xl border border-dashed border-border/60 px-3 py-4 text-sm text-muted-foreground">
+        No category coverage recorded.
+      </div>
+    )
+  }
+
+  const totalCount = coverage.reduce((sum, item) => sum + item.count, 0)
+
+  return (
+    <div className="space-y-2">
+      <div
+        className="flex h-3 w-full items-stretch gap-1 rounded-full bg-muted/70"
+        aria-label="Category coverage distribution"
+        role="img"
+      >
+        {coverage.map((item) => (
+          <div
+            key={item.category}
+            className="min-w-2 rounded-full"
+            style={{
+              width: `${(item.count / totalCount) * 100}%`,
+              backgroundColor: getCategoryPlotColor(item.category),
+            }}
+            title={`${item.category}: ${item.count} benchmark${item.count !== 1 ? "s" : ""}`}
+          />
+        ))}
+      </div>
+
+      <div className="flex flex-wrap gap-1.5">
+        {coverage.slice(0, 4).map((item) => (
+          <span
+            key={item.category}
+            className={`inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-[10px] font-semibold ${getCategoryColor(item.category)}`}
+          >
+            <span
+              className="h-1.5 w-1.5 rounded-full"
+              style={{ backgroundColor: getCategoryPlotColor(item.category) }}
+            />
+            {item.category}
+            <span className="opacity-70">{item.count}</span>
+          </span>
+        ))}
+      </div>
+    </div>
+  )
+}
+
 export function BenchmarkEvaluationCard({
   data,
+  benchmarkCards,
   onDelete,
   delayMs = 0,
   selectedForCompare = false,
@@ -191,7 +244,32 @@ export function BenchmarkEvaluationCard({
   const router = useRouter()
   const { mode } = useAudienceMode()
   const isResearchView = mode === "research"
-  const highlights = data.top_scores.slice(0, 3)
+
+  // Collect unique domains from this model's benchmarks using metadata cards
+  const modelDomains = useMemo(() => {
+    if (!benchmarkCards) return []
+    const domainCounts = new Map<string, number>()
+    for (const { benchmark } of data.top_scores) {
+      const card = lookupBenchmarkCard(benchmarkCards, benchmark)
+      for (const domain of card?.benchmark_details?.domains ?? []) {
+        domainCounts.set(domain, (domainCounts.get(domain) ?? 0) + 1)
+      }
+    }
+    return Array.from(domainCounts.entries())
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([domain]) => domain)
+  }, [benchmarkCards, data.top_scores])
+  const categoryCoverage = useMemo(
+    () =>
+      Object.entries(data.category_stats)
+        .filter(([, count]) => count > 0)
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([category, count]) => ({
+          category: category as CategoryType,
+          count,
+        })),
+    [data.category_stats]
+  )
   const library = data.eval_libraries[0]
   const paramsBillions = formatParamsBillions(data.params_billions)
   const reportingSummaryLabel = getReportingSummaryLabel(data)
@@ -291,74 +369,49 @@ export function BenchmarkEvaluationCard({
       </CardHeader>
 
       <CardContent className="space-y-4 pt-4">
-        <div className="grid grid-cols-3 gap-2">
-          <CompactStat
-            label={isResearchView ? "Benchmarks" : "Coverage"}
-            value={data.benchmarks_count.toString()}
-            tone="bg-sky-50 text-sky-900 ring-1 ring-sky-200/70 dark:bg-sky-950/25 dark:text-sky-100 dark:ring-sky-900/50"
-          />
-          <CompactStat
-            label={isResearchView ? "Results" : "Reported"}
-            value={data.evaluations_count.toString()}
-            tone="bg-stone-100 text-stone-900 ring-1 ring-stone-200/80 dark:bg-stone-900/40 dark:text-stone-100 dark:ring-stone-800/70"
-          />
-          <CompactStat
-            label="Reporting Orgs"
-            value={data.evaluator_count.toString()}
-            tone="bg-emerald-50 text-emerald-900 ring-1 ring-emerald-200/70 dark:bg-emerald-950/25 dark:text-emerald-100 dark:ring-emerald-900/50"
-          />
-        </div>
-
         <div className="rounded-2xl border border-border/70 bg-muted/10 px-4 py-3">
-          <div className="flex flex-wrap items-center gap-2">
-            <Badge variant="outline">{reportingSummaryLabel}</Badge>
-            <Badge variant={reproducibility.tone}>
-              <reproducibility.icon className="h-3.5 w-3.5" />
-              {reproducibility.label}
-            </Badge>
-            <Badge variant={data.independent_verification_ratio > 0 ? "secondary" : "outline"}>
-              <ShieldCheck className="h-3.5 w-3.5" />
-              {independentSummary}
-            </Badge>
+          <div className="flex flex-wrap items-center justify-between gap-3">
+            <div>
+              <div className="text-[11px] font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+                Category coverage
+              </div>
+              <div className="mt-1 text-sm text-muted-foreground">
+                {categoryCoverage.length} {categoryCoverage.length === 1 ? "category" : "categories"}
+              </div>
+            </div>
+            <div className="text-right">
+              <div className="text-lg font-semibold tabular-nums text-foreground">{data.evaluator_count}</div>
+              <div className="text-[11px] uppercase tracking-[0.18em] text-muted-foreground">reporting orgs</div>
+            </div>
           </div>
-          <div className="mt-2 text-sm text-muted-foreground">
-            {isResearchView
-              ? "Most useful signals first: benchmark coverage, reproducibility, and benchmark-level performance. Open the details panel only when you need methodology or provenance."
-              : "Most useful signals first: benchmark coverage, reporting posture, and what was actually tested. Open the details panel if you need source or methodology context."}
+
+          <div className="mt-3">
+            <CategoryCoveragePlot coverage={categoryCoverage} />
           </div>
         </div>
 
-        {highlights.length > 0 ? (
-          <section className="space-y-3">
-            <div className="flex items-center gap-2 text-[11px] font-semibold uppercase tracking-[0.18em] text-muted-foreground">
-              {isResearchView ? (
-                <FlaskConical className="h-3.5 w-3.5" />
-              ) : (
-                <BookOpenText className="h-3.5 w-3.5" />
-              )}
-              {isResearchView ? "Most Relevant Benchmarks" : "What Was Tested"}
+        {modelDomains.length > 0 && (
+          <div className="space-y-2">
+            <div className="text-[11px] font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+              Top domain coverage
             </div>
-            <div className="overflow-hidden rounded-2xl border border-border/70">
-              {highlights.map((item, index) => (
-                <SignalRow
-                  key={item.benchmark}
-                  rank={index + 1}
-                  label={isResearchView ? item.benchmark : getPolicyBenchmarkLabel(item.benchmark)}
-                  rawLabel={
-                    isResearchView
-                      ? item.metric !== item.benchmark
-                        ? item.metric
-                        : undefined
-                      : item.benchmark
-                  }
-                  scoreLabel={formatHighlightScore(item.score, item.unit)}
-                  scorePercent={scoreToPercent(item.score, item.unit)}
-                  isLast={index === highlights.length - 1}
-                />
-              ))}
+            <div className="flex flex-wrap gap-1.5">
+            {modelDomains.slice(0, 5).map((domain) => (
+              <span
+                key={domain}
+                className="inline-flex items-center rounded-full border border-border/50 bg-muted/40 px-2.5 py-0.5 text-[11px] font-medium capitalize text-muted-foreground"
+              >
+                {domain}
+              </span>
+            ))}
+            {modelDomains.length > 5 && (
+              <span className="inline-flex items-center rounded-full border border-border/50 bg-muted/40 px-2.5 py-0.5 text-[11px] font-medium text-muted-foreground">
+                +{modelDomains.length - 5} more
+              </span>
+            )}
             </div>
-          </section>
-        ) : null}
+          </div>
+        )}
 
         <Collapsible className="rounded-2xl border border-border/70 bg-background">
           <CollapsibleTrigger asChild>
@@ -372,7 +425,7 @@ export function BenchmarkEvaluationCard({
                   Dive Deeper
                 </div>
                 <div className="mt-1 text-sm font-semibold text-foreground">
-                  Show reporting and methodology details
+                  {isResearchView ? "Methodology & provenance details" : "Reporting & accountability details"}
                 </div>
               </div>
               <ChevronDown className="h-4 w-4 text-muted-foreground" />
@@ -380,28 +433,51 @@ export function BenchmarkEvaluationCard({
           </CollapsibleTrigger>
           <CollapsibleContent onClick={(event) => event.stopPropagation()} className="border-t border-border/60 px-4 py-4">
             <div className="space-y-0 text-sm">
-              <KeyValueRow label="Reporting sources" value={reportingSummaryLabel} />
-              {library && (
-                <KeyValueRow label="Library" value={`${library.name}${library.version ? ` ${library.version}` : ""}`} />
-              )}
-              {data.latest_source_name && (
-                <KeyValueRow label="Latest report" value={data.latest_source_name} />
-              )}
-              <KeyValueRow label="Updated" value={formatDate(data.latest_timestamp)} />
-              <KeyValueRow label="Reproducibility" value={reproducibility.label} />
-              <KeyValueRow label="Independence" value={independentSummary} />
-              {data.source_types.length > 0 && (
-                <KeyValueRow label="Source types" value={data.source_types.map((s) => s.replace(/_/g, " ")).join(", ")} />
-              )}
-              {data.architecture && <KeyValueRow label="Architecture" value={data.architecture} />}
-              {data.missing_generation_config_count > 0 && (
-                <KeyValueRow label="Missing config" value={`${data.missing_generation_config_count} result${data.missing_generation_config_count !== 1 ? "s" : ""}`} />
-              )}
-              {library?.fork && (
-                <div className="mt-3 flex items-start gap-2 rounded-xl bg-amber-50/80 px-3 py-2 text-xs text-amber-900 dark:bg-amber-950/20 dark:text-amber-200">
-                  <LibraryBig className="mt-0.5 h-3.5 w-3.5 shrink-0 text-amber-600 dark:text-amber-300" />
-                  <span>Non-standard eval library fork</span>
-                </div>
+              {isResearchView ? (
+                <>
+                  <KeyValueRow label="Reporting sources" value={reportingSummaryLabel} />
+                  {library && (
+                    <KeyValueRow label="Library" value={`${library.name}${library.version ? ` ${library.version}` : ""}`} />
+                  )}
+                  {data.latest_source_name && (
+                    <KeyValueRow label="Latest report" value={data.latest_source_name} />
+                  )}
+                  <KeyValueRow label="Updated" value={formatDate(data.latest_timestamp)} />
+                  <KeyValueRow label="Reproducibility" value={reproducibility.label} />
+                  <KeyValueRow label="Independence" value={independentSummary} />
+                  {data.source_types.length > 0 && (
+                    <KeyValueRow label="Source types" value={data.source_types.map((s) => s.replace(/_/g, " ")).join(", ")} />
+                  )}
+                  {data.architecture && <KeyValueRow label="Architecture" value={data.architecture} />}
+                  {data.missing_generation_config_count > 0 && (
+                    <KeyValueRow label="Missing config" value={`${data.missing_generation_config_count} result${data.missing_generation_config_count !== 1 ? "s" : ""}`} />
+                  )}
+                  {library?.fork && (
+                    <div className="mt-3 flex items-start gap-2 rounded-xl bg-amber-50/80 px-3 py-2 text-xs text-amber-900 dark:bg-amber-950/20 dark:text-amber-200">
+                      <LibraryBig className="mt-0.5 h-3.5 w-3.5 shrink-0 text-amber-600 dark:text-amber-300" />
+                      <span>Non-standard eval library fork</span>
+                    </div>
+                  )}
+                </>
+              ) : (
+                <>
+                  <KeyValueRow label="Who reported" value={reportingSummaryLabel} />
+                  <KeyValueRow label="Independence" value={independentSummary} />
+                  <KeyValueRow label="Reproducibility" value={reproducibility.label} />
+                  {data.latest_source_name && (
+                    <KeyValueRow label="Latest source" value={data.latest_source_name} />
+                  )}
+                  <KeyValueRow label="Updated" value={formatDate(data.latest_timestamp)} />
+                  {data.source_types.length > 0 && (
+                    <KeyValueRow label="Evidence types" value={data.source_types.map((s) => s.replace(/_/g, " ")).join(", ")} />
+                  )}
+                  {data.missing_generation_config_count > 0 && (
+                    <div className="mt-3 flex items-start gap-2 rounded-xl bg-amber-50/80 px-3 py-2 text-xs text-amber-900 dark:bg-amber-950/20 dark:text-amber-200">
+                      <LibraryBig className="mt-0.5 h-3.5 w-3.5 shrink-0 text-amber-600 dark:text-amber-300" />
+                      <span>{data.missing_generation_config_count} result{data.missing_generation_config_count !== 1 ? "s" : ""} lack documented generation settings — comparisons should be read with care.</span>
+                    </div>
+                  )}
+                </>
               )}
             </div>
           </CollapsibleContent>
@@ -411,23 +487,6 @@ export function BenchmarkEvaluationCard({
   )
 }
 
-function CompactStat({
-  label,
-  value,
-  tone,
-}: {
-  label: string
-  value: string
-  tone: string
-}) {
-  return (
-    <div className={`rounded-2xl px-3 py-2.5 ${tone}`}>
-      <div className="text-[10px] font-semibold uppercase tracking-[0.2em] opacity-80">{label}</div>
-      <div className="mt-1 text-base font-bold tabular-nums">{value}</div>
-    </div>
-  )
-}
-
 function KeyValueRow({ label, value }: { label: string; value: string }) {
   return (
     <div className="grid grid-cols-[7rem_minmax(0,1fr)] items-start gap-x-3 border-b border-border/40 py-2 last:border-b-0 last:pb-0 first:pt-0">
@@ -438,39 +497,3 @@ function KeyValueRow({ label, value }: { label: string; value: string }) {
     </div>
   )
 }
-
-function SignalRow({
-  rank,
-  label,
-  rawLabel,
-  scoreLabel,
-  scorePercent,
-  isLast,
-}: {
-  rank: number
-  label: string
-  rawLabel?: string
-  scoreLabel: string
-  scorePercent: number
-  isLast?: boolean
-}) {
-  return (
-    <div className={`px-3 py-3 ${isLast ? "" : "border-b border-border/60"}`}>
-      <div className="flex items-start gap-3">
-        <div className="flex h-6 w-6 shrink-0 items-center justify-center rounded-full bg-muted text-[11px] font-semibold text-muted-foreground">
-          {rank}
-        </div>
-        <div className="min-w-0 flex-1">
-          <div className="flex items-start justify-between gap-3">
-            <div className="min-w-0">
-              <div className="truncate text-sm font-semibold">{label}</div>
-              {rawLabel && <div className="truncate text-xs text-muted-foreground">{rawLabel}</div>}
-            </div>
-            <div className="shrink-0 text-sm font-semibold tabular-nums">{scoreLabel}</div>
-          </div>
-          <Progress value={scorePercent} className="mt-2 h-1.5" />
-        </div>
-      </div>
-    </div>
-  )
-}

components/eval-card.tsx

@@ -15,6 +15,35 @@ import {
   Users,
 } from "lucide-react"
 import type { BenchmarkEvalListItem } from "@/lib/eval-processing"
+import { getCategoryColor } from "@/lib/benchmark-schema"
+
+const LICENSE_COLORS: Record<string, string> = {
+  "mit": "bg-emerald-100 text-emerald-800 border-emerald-200 dark:bg-emerald-950/40 dark:text-emerald-200",
+  "apache": "bg-sky-100 text-sky-800 border-sky-200 dark:bg-sky-950/40 dark:text-sky-200",
+  "cc by": "bg-violet-100 text-violet-800 border-violet-200 dark:bg-violet-950/40 dark:text-violet-200",
+  "cc0": "bg-teal-100 text-teal-800 border-teal-200 dark:bg-teal-950/40 dark:text-teal-200",
+  "cc-by-sa": "bg-indigo-100 text-indigo-800 border-indigo-200 dark:bg-indigo-950/40 dark:text-indigo-200",
+}
+
+function licenseBadgeClass(license: string): string {
+  const l = license.toLowerCase()
+  for (const [key, cls] of Object.entries(LICENSE_COLORS)) {
+    if (l.includes(key)) return cls
+  }
+  return "bg-muted text-muted-foreground border-border"
+}
+
+function shortenLicense(license: string): string {
+  if (!license || license === "Not specified") return ""
+  // Shorten known verbose license names
+  if (license.toLowerCase().includes("creative commons attribution 4")) return "CC BY 4.0"
+  if (license.toLowerCase().includes("creative commons zero")) return "CC0"
+  if (license.toLowerCase().includes("apache license 2") || license.toLowerCase().includes("apache 2")) return "Apache 2.0"
+  if (license.toLowerCase().includes("mit license")) return "MIT"
+  if (license.toLowerCase().includes("cc-by-sa")) return "CC BY-SA"
+  if (license.length > 24) return license.slice(0, 22) + "…"
+  return license
+}
 
 interface EvalCardProps {
   summary: BenchmarkEvalListItem
@@ -27,6 +56,25 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
   const isResearchView = mode === "research"
   const scorePercent = `${Math.round(summary.avg_score_norm * 100)}%`
   const purpose = summary.factsheet?.purpose ?? "General single-benchmark evaluation"
+  const card = summary.benchmark_card
+  const domains: string[] = card?.benchmark_details?.domains ?? []
+  const license = card?.ethical_and_legal_considerations?.data_licensing ?? ""
+  const shortLicense = shortenLicense(license)
+  // Use the benchmark overview as a richer description when available
+  const overviewText = card?.benchmark_details?.overview
+  // Policy: rich context from metadata card
+  const policyGoal = card?.purpose_and_intended_users?.goal
+  const policyLimitations = card?.purpose_and_intended_users?.limitations
+  const policyAudience = card?.purpose_and_intended_users?.audience
+  const audienceText = Array.isArray(policyAudience)
+    ? policyAudience.slice(0, 2).join("; ")
+    : typeof policyAudience === "string"
+    ? policyAudience
+    : null
+  // Research: score interpretation + similar benchmarks
+  const scoreInterpretation = card?.methodology?.interpretation
+  const rawSimilar = card?.benchmark_details?.similar_benchmarks
+  const similarBenchmarks: string[] = Array.isArray(rawSimilar) ? rawSimilar : rawSimilar ? [rawSimilar] : []
 
   return (
     <Card
@@ -35,8 +83,22 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
       onClick={() => router.push(`/evals/${summary.evaluation_id}`)}
     >
       <CardHeader className="space-y-3 border-b border-border/60 pb-4">
-        <div className="text-[10px] font-semibold uppercase tracking-[0.24em] text-muted-foreground">
-          Single Benchmark
+        <div className="flex items-center justify-between gap-2">
+          <div className="flex items-center gap-2">
+            <div className="text-[10px] font-semibold uppercase tracking-[0.24em] text-muted-foreground">
+              Single Benchmark
+            </div>
+            {summary.category && (
+              <span className={`rounded-full border px-2 py-0.5 text-[10px] font-semibold ${getCategoryColor(summary.category)}`}>
+                {summary.category}
+              </span>
+            )}
+          </div>
+          {shortLicense && (
+            <span className={`rounded-full border px-2 py-0.5 text-[10px] font-semibold ${licenseBadgeClass(license)}`}>
+              {shortLicense}
+            </span>
+          )}
         </div>
 
         <div className="min-w-0">
@@ -45,10 +107,28 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
             Composite benchmark: {summary.composite_benchmark_name}
           </div>
           <div className="mt-1 text-sm text-muted-foreground line-clamp-2">
-            {summary.metric_config.evaluation_description}
+            {overviewText ?? summary.metric_config.evaluation_description}
           </div>
         </div>
 
+        {domains.length > 0 && (
+          <div className="flex flex-wrap gap-1.5">
+            {domains.slice(0, 5).map((d) => (
+              <span
+                key={d}
+                className="rounded-full border border-border/60 bg-muted/40 px-2 py-0.5 text-[10px] font-medium capitalize text-muted-foreground"
+              >
+                {d}
+              </span>
+            ))}
+            {domains.length > 5 && (
+              <span className="rounded-full border border-border/60 bg-muted/40 px-2 py-0.5 text-[10px] font-medium text-muted-foreground">
+                +{domains.length - 5}
+              </span>
+            )}
+          </div>
+        )}
+
         <div className="flex flex-wrap gap-2">
           {summary.third_party_ratio > 0 && (
             <Badge className="bg-emerald-600 text-white hover:bg-emerald-600">
@@ -74,6 +154,14 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
               <MetricPill icon={Users} label="Evaluators" value={summary.evaluator_names.length.toLocaleString()} tone="bg-emerald-100/80 text-emerald-900 dark:bg-emerald-950/40 dark:text-emerald-100" />
             </div>
 
+            {/* Research: score interpretation from metadata */}
+            {scoreInterpretation && (
+              <div className="rounded-xl border border-sky-200/60 bg-sky-50/40 p-3 text-sm dark:border-sky-900/40 dark:bg-sky-950/10">
+                <div className="mb-1 text-[10px] font-semibold uppercase tracking-[0.18em] text-sky-700 dark:text-sky-300">Score interpretation</div>
+                <p className="text-muted-foreground line-clamp-2">{scoreInterpretation}</p>
+              </div>
+            )}
+
             <div className="rounded-xl border bg-muted/10 p-3">
               <div className="mb-2 text-xs font-semibold uppercase tracking-wider text-muted-foreground">Methodology</div>
               <div className="space-y-1.5 text-sm">
@@ -91,25 +179,46 @@ export function EvalCard({ summary, delayMs = 0 }: EvalCardProps) {
                       : "Fully documented"
                   }
                 />
-                <DataRow
-                  label="Third-party"
-                  value={`${Math.round(summary.third_party_ratio * 100)}%`}
-                />
+                <DataRow label="Third-party" value={`${Math.round(summary.third_party_ratio * 100)}%`} />
+                {similarBenchmarks.length > 0 && (
+                  <DataRow label="See also" value={similarBenchmarks.slice(0, 3).join(", ")} />
+                )}
               </div>
             </div>
           </>
         ) : (
           <>
+            {/* Policy: goal (from metadata card if available, otherwise factsheet purpose) */}
             <div className="rounded-xl border border-amber-200/70 bg-amber-50/75 p-3 dark:border-amber-900/40 dark:bg-amber-950/15">
               <div className="flex items-start gap-2">
                 <Scale className="mt-0.5 h-4 w-4 shrink-0 text-amber-600" />
                 <div>
                   <div className="text-sm font-semibold">Purpose</div>
-                  <div className="text-sm text-muted-foreground">{purpose}</div>
+                  <div className="text-sm text-muted-foreground line-clamp-3">
+                    {policyGoal ?? purpose}
+                  </div>
                 </div>
               </div>
             </div>
 
+            {/* Policy: audience + limitations from metadata */}
+            {(audienceText || policyLimitations) && (
+              <div className="space-y-2">
+                {audienceText && (
+                  <div className="rounded-xl border border-sky-200/60 bg-sky-50/50 p-3 text-sm dark:border-sky-900/40 dark:bg-sky-950/15">
+                    <span className="font-semibold text-sky-800 dark:text-sky-200">Intended for: </span>
+                    <span className="text-muted-foreground">{audienceText}</span>
+                  </div>
+                )}
+                {policyLimitations && (
+                  <div className="rounded-xl border border-rose-200/60 bg-rose-50/50 p-3 text-sm dark:border-rose-900/40 dark:bg-rose-950/15">
+                    <span className="font-semibold text-rose-800 dark:text-rose-200">Known limitation: </span>
+                    <span className="text-muted-foreground line-clamp-2">{policyLimitations}</span>
+                  </div>
+                )}
+              </div>
+            )}
+
             <div className="grid gap-2 sm:grid-cols-2">
               <MetricPill icon={BadgeCheck} label="Independent" value={`${Math.round(summary.third_party_ratio * 100)}%`} tone="bg-emerald-100/80 text-emerald-900 dark:bg-emerald-950/40 dark:text-emerald-100" />
               <MetricPill icon={BookOpenText} label="Models" value={summary.models_count.toLocaleString()} tone="bg-sky-100/80 text-sky-900 dark:bg-sky-950/40 dark:text-sky-100" />
@@ -117,14 +226,8 @@ 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"}
-                />
+                <DataRow label="Avg score" value={scorePercent} />
+                <DataRow label="Reported by" value={summary.evaluator_names.join(", ") || "Unknown"} />
                 {summary.missing_generation_config_count > 0 && (
                   <p className="pt-1 text-xs text-muted-foreground">
                     Some results lack documented generation settings — direct score comparisons should be read with care.

components/eval-detail.tsx

@@ -2,21 +2,31 @@
 
 import { useAudienceMode } from "@/components/audience-mode-provider"
 import { Fragment, useMemo, useState } from "react"
+import Link from "next/link"
 import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible"
 import { Progress } from "@/components/ui/progress"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
+import { getModelFamilyRouteId } from "@/lib/model-family"
 import { cn } from "@/lib/utils"
 import {
+  AlertTriangle,
   BarChart3,
+  BookOpen,
   ChevronDown,
   ChevronUp,
   Database,
   ExternalLink,
+  FileText,
   Globe,
   Medal,
+  Scale,
+  Shield,
+  Tag,
 } from "lucide-react"
+import type { BenchmarkCard } from "@/lib/benchmark-schema"
 import type { BenchmarkEvalSummary, ModelResultForBenchmark } from "@/lib/eval-processing"
 
 interface EvalDetailProps {
@@ -30,6 +40,136 @@ interface LeaderboardRow {
   normalizedScore: number
 }
 
+const PARAM_RANGE_VALUES = [1, 2, 3, 4, 6, 8, 10, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 500] as const
+const PARAM_RANGE_MARKERS = [
+  { label: "< 1B", step: 0 },
+  { label: "6B", step: PARAM_RANGE_VALUES.indexOf(6) },
+  { label: "12B", step: PARAM_RANGE_VALUES.indexOf(12) },
+  { label: "32B", step: PARAM_RANGE_VALUES.indexOf(32) },
+  { label: "128B", step: PARAM_RANGE_VALUES.indexOf(128) },
+  { label: "> 500B", step: PARAM_RANGE_VALUES.length - 1 },
+] as const
+
+function formatParamBoundLabel(step: number, bound: "min" | "max") {
+  const maxStepIndex = PARAM_RANGE_VALUES.length - 1
+
+  if (bound === "min" && step <= 0) {
+    return "< 1B"
+  }
+
+  if (bound === "max" && step >= maxStepIndex) {
+    return "> 500B"
+  }
+
+  const value = PARAM_RANGE_VALUES[step]
+  return value != null ? `${value}B` : "Not reported"
+}
+
+function parseParamsBillionsFromText(value: string | null | undefined) {
+  if (!value) {
+    return null
+  }
+
+  const normalized = value.trim().toLowerCase()
+  if (!normalized) {
+    return null
+  }
+
+  const compact = normalized.replace(/,/g, "")
+  const tokenMatch = compact.match(/(\d+(?:\.\d+)?)\s*(trillion|tn|t|billion|bn|b|million|mn|m|thousand|k)\b/)
+  if (tokenMatch) {
+    const amount = Number.parseFloat(tokenMatch[1])
+    if (!Number.isFinite(amount)) {
+      return null
+    }
+
+    const unit = tokenMatch[2]
+    if (unit === "trillion" || unit === "tn" || unit === "t") {
+      return amount * 1000
+    }
+
+    if (unit === "billion" || unit === "bn" || unit === "b") {
+      return amount
+    }
+
+    if (unit === "million" || unit === "mn" || unit === "m") {
+      return amount / 1000
+    }
+
+    if (unit === "thousand" || unit === "k") {
+      return amount / 1_000_000
+    }
+  }
+
+  const numeric = Number.parseFloat(compact)
+  return Number.isFinite(numeric) ? numeric : null
+}
+
+function parseParamsBillionsFromModelName(modelName: string | null | undefined) {
+  if (!modelName) {
+    return null
+  }
+
+  const sizeTokens = Array.from(modelName.matchAll(/\b(\d+(?:\.\d+)?)\s*([tmbk])\b/gi))
+  if (sizeTokens.length === 0) {
+    return null
+  }
+
+  const lastToken = sizeTokens[sizeTokens.length - 1]
+  const numericValue = Number.parseFloat(lastToken[1])
+  if (!Number.isFinite(numericValue)) {
+    return null
+  }
+
+  const unit = lastToken[2].toLowerCase()
+  if (unit === "t") {
+    return numericValue * 1000
+  }
+
+  if (unit === "b") {
+    return numericValue
+  }
+
+  if (unit === "m") {
+    return numericValue / 1000
+  }
+
+  if (unit === "k") {
+    return numericValue / 1_000_000
+  }
+
+  return null
+}
+
+function getParamsBillions(modelResult: ModelResultForBenchmark) {
+  const additionalDetails = modelResult.model_info.additional_details
+  const rawParamsBillions =
+    additionalDetails?.params_billions ??
+    additionalDetails?.parameter_count ??
+    additionalDetails?.num_parameters ??
+    additionalDetails?.params
+
+  if (typeof rawParamsBillions === "number") {
+    return rawParamsBillions
+  }
+
+  if (typeof rawParamsBillions === "string") {
+    const parsed = parseParamsBillionsFromText(rawParamsBillions)
+    if (Number.isFinite(parsed)) {
+      return parsed
+    }
+  }
+
+  if (typeof modelResult.model_info.parameter_count === "string") {
+    const parsed = parseParamsBillionsFromText(modelResult.model_info.parameter_count)
+    if (Number.isFinite(parsed)) {
+      return parsed
+    }
+  }
+
+  return parseParamsBillionsFromModelName(modelResult.model_info.name)
+}
+
 function formatMetadataValue(value: unknown): string {
   if (value == null) {
     return "N/A"
@@ -98,6 +238,9 @@ export function EvalDetail({ summary }: EvalDetailProps) {
   const { mode } = useAudienceMode()
   const isResearchView = mode === "research"
   const [expandedRows, setExpandedRows] = useState<Record<string, boolean>>({})
+  const [leaderboardPage, setLeaderboardPage] = useState(1)
+  const [minParamStep, setMinParamStep] = useState(0)
+  const [maxParamStep, setMaxParamStep] = useState(PARAM_RANGE_VALUES.length - 1)
 
   const maxScore = summary.metric_config.max_score ?? 1
   const minScore = summary.metric_config.min_score ?? 0
@@ -105,6 +248,25 @@ export function EvalDetail({ summary }: EvalDetailProps) {
 
   const normalizeScore = (raw: number) => (range > 0 ? (raw - minScore) / range : raw)
   const formatPercent = (normalized: number) => `${(normalized * 100).toFixed(1)}%`
+  const maxParamStepIndex = PARAM_RANGE_VALUES.length - 1
+  const minHandlePercent = (minParamStep / maxParamStepIndex) * 100
+  const maxHandlePercent = (maxParamStep / maxParamStepIndex) * 100
+
+  const numericMinParams = useMemo(() => {
+    if (minParamStep <= 0) {
+      return null
+    }
+
+    return PARAM_RANGE_VALUES[minParamStep] ?? null
+  }, [minParamStep])
+
+  const numericMaxParams = useMemo(() => {
+    if (maxParamStep >= PARAM_RANGE_VALUES.length - 1) {
+      return null
+    }
+
+    return PARAM_RANGE_VALUES[maxParamStep] ?? null
+  }, [maxParamStep])
 
   const sortedResults = useMemo(
     () =>
@@ -114,11 +276,32 @@ export function EvalDetail({ summary }: EvalDetailProps) {
     [summary.model_results, summary.metric_config.lower_is_better]
   )
 
+  const hasParameterData = useMemo(
+    () => sortedResults.some((result) => getParamsBillions(result) != null),
+    [sortedResults]
+  )
+
+  const filteredResults = useMemo(() => {
+    return sortedResults.filter((modelResult) => {
+      const paramsBillions = getParamsBillions(modelResult)
+
+      if (numericMinParams != null && (paramsBillions == null || paramsBillions < numericMinParams)) {
+        return false
+      }
+
+      if (numericMaxParams != null && (paramsBillions == null || paramsBillions > numericMaxParams)) {
+        return false
+      }
+
+      return true
+    })
+  }, [numericMaxParams, numericMinParams, sortedResults])
+
   const leaderboardRows = useMemo<LeaderboardRow[]>(() => {
     let currentRank = 0
     let previousScore: number | null = null
 
-    return sortedResults.map((modelResult, index) => {
+    return filteredResults.map((modelResult, index) => {
       if (previousScore === null || Math.abs(modelResult.score - previousScore) > 1e-9) {
         currentRank = index + 1
         previousScore = modelResult.score
@@ -131,14 +314,24 @@ export function EvalDetail({ summary }: EvalDetailProps) {
         normalizedScore: normalizeScore(modelResult.score),
       }
     })
-  }, [sortedResults])
+  }, [filteredResults])
+
+  const LEADERBOARD_PAGE_SIZE = 50
+  const pagedLeaderboardRows = useMemo(
+    () => leaderboardRows.slice(0, leaderboardPage * LEADERBOARD_PAGE_SIZE),
+    [leaderboardRows, leaderboardPage]
+  )
 
   const avgNorm = formatPercent(summary.avg_score_norm)
   const scoreDirectionLabel = summary.metric_config.lower_is_better ? "Lower scores rank higher" : "Higher scores rank higher"
   const leaderboardTitle = isResearchView ? "Leaderboard" : "Reporting Comparison"
   const leaderboardDescription = isResearchView
-    ? "Models ranked by normalized score for this benchmark."
-    : "Model results with stronger emphasis on reporting context and evaluator provenance."
+    ? summary.is_aggregated
+      ? "Models ranked by average normalized score across the contributing composite benchmarks."
+      : "Models ranked by normalized score for this benchmark."
+    : summary.is_aggregated
+      ? "Averaged model results across the contributing composite benchmarks, with drill-down to each component score."
+      : "Model results with stronger emphasis on reporting context and evaluator provenance."
 
   const toggleRow = (key: string) =>
     setExpandedRows((current) => ({
@@ -154,11 +347,17 @@ export function EvalDetail({ summary }: EvalDetailProps) {
             <div className="space-y-3">
               <div className="flex flex-wrap items-center gap-2">
                 <Badge variant="outline" className="border-border/60 bg-background/80 text-[11px] uppercase tracking-[0.18em]">
-                  Single Benchmark
-                </Badge>
-                <Badge variant="secondary" className="font-normal">
-                  Composite: {summary.composite_benchmark_name}
+                  {summary.is_aggregated ? "Merged Benchmark" : "Single Benchmark"}
                 </Badge>
+                {summary.is_aggregated ? (
+                  <Badge variant="secondary" className="font-normal">
+                    {summary.aggregate_sources?.length ?? 0} composite benchmarks
+                  </Badge>
+                ) : (
+                  <Badge variant="secondary" className="font-normal">
+                    Composite: {summary.composite_benchmark_name}
+                  </Badge>
+                )}
                 <Badge variant="secondary" className="font-normal capitalize">
                   {summary.metric_config.score_type}
                 </Badge>
@@ -235,14 +434,22 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                 <dt className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
                   Composite benchmark
                 </dt>
-                <dd className="mt-1 break-words font-medium">{summary.composite_benchmark_name}</dd>
+                <dd className="mt-1 break-words font-medium">
+                  {summary.is_aggregated
+                    ? summary.aggregate_sources?.map((source) => source.composite_benchmark_name).join(", ") || "Multiple composite benchmarks"
+                    : summary.composite_benchmark_name}
+                </dd>
               </div>
               <div>
                 <dt className="text-[11px] font-semibold uppercase tracking-[0.16em] text-muted-foreground">
                   {isResearchView ? "Single benchmark ID" : "What this covers"}
                 </dt>
                 <dd className="mt-1 break-words font-medium">
-                  {isResearchView ? summary.evaluation_id : summary.metric_config.evaluation_description}
+                  {isResearchView
+                    ? summary.evaluation_id
+                    : summary.is_aggregated
+                      ? summary.metric_config.evaluation_description
+                      : summary.metric_config.evaluation_description}
                 </dd>
               </div>
               <div>
@@ -286,6 +493,11 @@ export function EvalDetail({ summary }: EvalDetailProps) {
         </CardContent>
       </Card>
 
+      {/* Policy: benchmark context BEFORE the leaderboard (context first, numbers second) */}
+      {!isResearchView && summary.benchmark_card && (
+        <BenchmarkCardPanel card={summary.benchmark_card} isResearchView={false} defaultRisksOpen />
+      )}
+
       <Card className="overflow-hidden">
         <CardHeader className="border-b bg-muted/10">
           <div className="flex flex-col gap-3 lg:flex-row lg:items-end lg:justify-between">
@@ -298,8 +510,17 @@ export function EvalDetail({ summary }: EvalDetailProps) {
             </div>
 
             <div className="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
-              <Badge variant="secondary">{summary.models_count} models</Badge>
+              <Badge variant="secondary">
+                {leaderboardRows.length === summary.models_count
+                  ? `${summary.models_count} models`
+                  : `${leaderboardRows.length} of ${summary.models_count} models`}
+              </Badge>
               <Badge variant="outline">{scoreDirectionLabel}</Badge>
+              {hasParameterData && (numericMinParams != null || numericMaxParams != null) && (
+                <Badge variant="outline">
+                  Params {formatParamBoundLabel(minParamStep, "min")} to {formatParamBoundLabel(maxParamStep, "max")}
+                </Badge>
+              )}
               {isResearchView && (
                 <Badge variant="outline">
                   Scale {summary.metric_config.min_score ?? 0} - {summary.metric_config.max_score ?? 1}
@@ -310,6 +531,89 @@ export function EvalDetail({ summary }: EvalDetailProps) {
         </CardHeader>
 
         <CardContent className="p-0">
+          {hasParameterData && (
+            <div className="border-b bg-background px-5 py-4 sm:px-6">
+              <div className="flex flex-col gap-3 lg:flex-row lg:items-center lg:justify-between">
+                <div className="space-y-1">
+                  <div className="text-[11px] font-semibold uppercase tracking-[0.18em] text-muted-foreground">
+                    Parameter range
+                  </div>
+                  <div className="text-sm text-muted-foreground">
+                    Narrow the leaderboard to comparable model sizes.
+                  </div>
+                </div>
+
+                <div className="flex min-w-0 flex-1 items-center gap-4 lg:max-w-[40rem]">
+                  <div className="min-w-0 flex-1">
+                    <div className="mb-2 flex items-center justify-between text-[10px] font-medium uppercase tracking-[0.14em] text-muted-foreground">
+                      {PARAM_RANGE_MARKERS.map((marker) => (
+                        <span key={marker.label} className="text-center">
+                          {marker.label}
+                        </span>
+                      ))}
+                    </div>
+
+                    <div className="relative h-4">
+                      <div className="absolute inset-x-1.5 top-1/2 h-[3px] -translate-y-1/2 rounded-full bg-border/80" />
+                      <div className="absolute inset-x-1.5 top-1/2 h-[3px] -translate-y-1/2">
+                        <div
+                          className="absolute inset-y-0 rounded-full bg-foreground transition-[left,right] duration-300 ease-[var(--ease-out-quint)]"
+                          style={{
+                            left: `${minHandlePercent}%`,
+                            right: `${Math.max(100 - maxHandlePercent, 0)}%`,
+                          }}
+                        />
+                      </div>
+
+                      <div className="absolute inset-x-1.5 top-1/2 -translate-y-1/2">
+                        {PARAM_RANGE_VALUES.map((_, stepIndex) => (
+                          <span
+                            key={`param-tick-${stepIndex}`}
+                            className="absolute top-0 h-2 w-px -translate-x-1/2 rounded-full bg-border"
+                            style={{ left: `${(stepIndex / maxParamStepIndex) * 100}%` }}
+                            aria-hidden="true"
+                          />
+                        ))}
+                      </div>
+
+                      <input
+                        type="range"
+                        min={0}
+                        max={maxParamStepIndex}
+                        step={1}
+                        value={minParamStep}
+                        onChange={(event) => {
+                          const nextMin = Number(event.target.value)
+                          setMinParamStep(Math.min(nextMin, maxParamStep))
+                        }}
+                        className="param-range-input"
+                        aria-label="Minimum parameter filter"
+                      />
+
+                      <input
+                        type="range"
+                        min={0}
+                        max={maxParamStepIndex}
+                        step={1}
+                        value={maxParamStep}
+                        onChange={(event) => {
+                          const nextMax = Number(event.target.value)
+                          setMaxParamStep(Math.max(nextMax, minParamStep))
+                        }}
+                        className="param-range-input"
+                        aria-label="Maximum parameter filter"
+                      />
+                    </div>
+                  </div>
+
+                  <span className="shrink-0 text-[11px] text-muted-foreground">
+                    {formatParamBoundLabel(minParamStep, "min")} to {formatParamBoundLabel(maxParamStep, "max")}
+                  </span>
+                </div>
+              </div>
+            </div>
+          )}
+
           <Table className="min-w-[980px]">
             <TableHeader>
               <TableRow className="hover:bg-transparent">
@@ -332,11 +636,14 @@ export function EvalDetail({ summary }: EvalDetailProps) {
               </TableRow>
             </TableHeader>
             <TableBody>
-              {leaderboardRows.map(({ key, rank, modelResult, normalizedScore }) => {
+              {pagedLeaderboardRows.map(({ key, rank, modelResult, normalizedScore }) => {
                 const isExpanded = expandedRows[key] ?? false
                 const subtasks = modelResult.score_details.details
                   ? Object.entries(modelResult.score_details.details).filter(([, value]) => typeof value === "number")
                   : []
+                const hasExpandableDetails =
+                  (modelResult.aggregate_components && modelResult.aggregate_components.length > 1) ||
+                  subtasks.length > 1
 
                 const datasetName = Array.isArray(modelResult.source_data)
                   ? undefined
@@ -362,7 +669,14 @@ export function EvalDetail({ summary }: EvalDetailProps) {
 
                       <TableCell className="whitespace-normal">
                         <div className="space-y-1">
-                          <div className="font-semibold leading-tight">{modelResult.model_info.name}</div>
+                          <div className="font-semibold leading-tight">
+                            <Link
+                              href={`/models/${getModelFamilyRouteId(modelResult.model_info)}`}
+                              className="underline decoration-dotted underline-offset-4 hover:text-primary"
+                            >
+                              {modelResult.model_info.name}
+                            </Link>
+                          </div>
                           <div className="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
                             {modelResult.model_info.parameter_count && (
                               <Badge variant="secondary" className="font-normal">
@@ -377,6 +691,11 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                             <span className="lg:hidden">
                               {modelResult.model_info.developer ?? "Unknown developer"}
                             </span>
+                            {modelResult.aggregate_components && modelResult.aggregate_components.length > 1 && (
+                              <Badge variant="outline" className="font-normal">
+                                Avg of {modelResult.aggregate_components.length}
+                              </Badge>
+                            )}
                           </div>
                         </div>
                       </TableCell>
@@ -408,18 +727,33 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                       ) : (
                         <TableCell className="hidden md:table-cell">
                           <div className="text-sm text-muted-foreground capitalize">
-                            {modelResult.source_metadata.evaluator_relationship.replace(/_/g, " ")}
+                            {modelResult.aggregate_components && modelResult.aggregate_components.length > 1
+                              ? `average of ${modelResult.aggregate_components.length} composite scores`
+                              : modelResult.source_metadata.evaluator_relationship.replace(/_/g, " ")}
                           </div>
                         </TableCell>
                       )}
 
                       <TableCell className="hidden whitespace-normal xl:table-cell">
-                        <div className="space-y-1">
-                          <div className="font-medium">{modelResult.source_metadata.source_organization_name}</div>
-                          <div className="text-xs text-muted-foreground">
-                            {modelResult.source_metadata.evaluator_relationship.replace(/_/g, " ")}
+                        {modelResult.aggregate_components && modelResult.aggregate_components.length > 1 ? (
+                          <div className="space-y-1">
+                            <div className="font-medium">
+                              {Array.from(new Set(modelResult.aggregate_components.map((component) => component.source_organization_name))).join(", ")}
+                            </div>
+                            <div className="text-xs text-muted-foreground">
+                              {modelResult.aggregate_components
+                                .map((component) => component.composite_benchmark_name)
+                                .join(", ")}
+                            </div>
                           </div>
-                        </div>
+                        ) : (
+                          <div className="space-y-1">
+                            <div className="font-medium">{modelResult.source_metadata.source_organization_name}</div>
+                            <div className="text-xs text-muted-foreground">
+                              {modelResult.source_metadata.evaluator_relationship.replace(/_/g, " ")}
+                            </div>
+                          </div>
+                        )}
                       </TableCell>
 
                       <TableCell className="hidden lg:table-cell">
@@ -427,14 +761,16 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                       </TableCell>
 
                       <TableCell className="px-4 text-right">
-                        <Button
-                          variant="ghost"
-                          size="icon"
-                          aria-label={isExpanded ? "Collapse details" : "Expand details"}
-                          onClick={() => toggleRow(key)}
-                        >
-                          {isExpanded ? <ChevronUp className="h-4 w-4" /> : <ChevronDown className="h-4 w-4" />}
-                        </Button>
+                        {hasExpandableDetails && (
+                          <Button
+                            variant="ghost"
+                            size="icon"
+                            aria-label={isExpanded ? "Collapse details" : "Expand details"}
+                            onClick={() => toggleRow(key)}
+                          >
+                            {isExpanded ? <ChevronUp className="h-4 w-4" /> : <ChevronDown className="h-4 w-4" />}
+                          </Button>
+                        )}
                       </TableCell>
                     </TableRow>
 
@@ -515,9 +851,12 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                                     : "Normalized performance plus uncertainty and sample details."
                                 }
                               >
-                                <MetaRow label="Normalized Score" value={formatPercent(normalizedScore)} />
                                 <MetaRow
-                                  label="Raw Score"
+                                  label={modelResult.aggregate_components ? "Average Score" : "Normalized Score"}
+                                  value={formatPercent(normalizedScore)}
+                                />
+                                <MetaRow
+                                  label={modelResult.aggregate_components ? "Average Raw Value" : "Raw Score"}
                                   value={formatRawScore(modelResult.score, summary.metric_config.unit)}
                                 />
                                 <MetaRow label="Score Type" value={modelResult.result.metric_config.score_type} />
@@ -539,41 +878,64 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                               </DetailPanel>
                             </div>
 
-                            {subtasks.length > 0 && (
-                              <div className="space-y-3">
-                                <div>
-                                  <div className="text-xs font-semibold uppercase tracking-[0.2em] text-muted-foreground">
-                                    Subtask Distribution
-                                  </div>
-                                  <div className="text-sm text-muted-foreground">
-                                    Detailed sub-metric scores for this model run.
-                                  </div>
+                            {modelResult.aggregate_components && modelResult.aggregate_components.length > 1 && (
+                              <div className="space-y-2">
+                                <div className="text-xs font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                                  Composite Score Breakdown
                                 </div>
+                                <div className="overflow-hidden rounded-xl border">
+                                  <table className="w-full text-sm">
+                                    <thead>
+                                      <tr className="border-b bg-muted/30">
+                                        <th className="px-3 py-2 text-left text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Benchmark</th>
+                                        <th className="px-3 py-2 text-left text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Source</th>
+                                        <th className="px-3 py-2 text-right text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Raw</th>
+                                        <th className="px-3 py-2 text-right text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Score</th>
+                                      </tr>
+                                    </thead>
+                                    <tbody>
+                                      {modelResult.aggregate_components.map((component, i) => (
+                                        <tr key={`${component.evaluation_id}-${i}`} className="border-b last:border-0 hover:bg-muted/10">
+                                          <td className="px-3 py-2 font-medium">{component.composite_benchmark_name}</td>
+                                          <td className="px-3 py-2 text-muted-foreground">{component.source_organization_name}</td>
+                                          <td className="px-3 py-2 text-right tabular-nums text-muted-foreground">{formatRawScore(component.score)}</td>
+                                          <td className="px-3 py-2 text-right font-semibold tabular-nums">{formatPercent(component.normalized_score)}</td>
+                                        </tr>
+                                      ))}
+                                    </tbody>
+                                  </table>
+                                </div>
+                              </div>
+                            )}
 
-                                <div className="grid gap-3 md:grid-cols-2 xl:grid-cols-3">
-                                  {subtasks.map(([subtaskName, value]) => {
-                                    const numericValue = value as number
-                                    const normalizedSubtaskScore = range > 0 ? (numericValue - minScore) / range : numericValue
-
-                                    return (
-                                      <div key={subtaskName} className="rounded-xl border bg-background/70 p-4">
-                                        <div className="mb-3 flex items-start justify-between gap-4">
-                                          <div className="min-w-0">
-                                            <div className="text-sm font-medium capitalize">
-                                              {subtaskName.replace(/_/g, " ")}
-                                            </div>
-                                            <div className="text-xs text-muted-foreground">
-                                              {formatRawScore(numericValue, summary.metric_config.unit)}
-                                            </div>
-                                          </div>
-                                          <div className="text-sm font-semibold tabular-nums">
-                                            {formatPercent(normalizedSubtaskScore)}
-                                          </div>
-                                        </div>
-                                        <Progress value={normalizedSubtaskScore * 100} className="h-2" />
-                                      </div>
-                                    )
-                                  })}
+                            {subtasks.length > 1 && (
+                              <div className="space-y-2">
+                                <div className="text-xs font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                                  Subtask Breakdown
+                                </div>
+                                <div className="overflow-hidden rounded-xl border">
+                                  <table className="w-full text-sm">
+                                    <thead>
+                                      <tr className="border-b bg-muted/30">
+                                        <th className="px-3 py-2 text-left text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Subtask</th>
+                                        <th className="px-3 py-2 text-right text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Raw</th>
+                                        <th className="px-3 py-2 text-right text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">Score</th>
+                                      </tr>
+                                    </thead>
+                                    <tbody>
+                                      {subtasks.map(([subtaskName, value]) => {
+                                        const numericValue = value as number
+                                        const normalizedSubtaskScore = range > 0 ? (numericValue - minScore) / range : numericValue
+                                        return (
+                                          <tr key={subtaskName} className="border-b last:border-0 hover:bg-muted/10">
+                                            <td className="px-3 py-2 font-medium capitalize">{subtaskName.replace(/_/g, " ")}</td>
+                                            <td className="px-3 py-2 text-right tabular-nums text-muted-foreground">{formatRawScore(numericValue, summary.metric_config.unit)}</td>
+                                            <td className="px-3 py-2 text-right font-semibold tabular-nums">{formatPercent(normalizedSubtaskScore)}</td>
+                                          </tr>
+                                        )
+                                      })}
+                                    </tbody>
+                                  </table>
                                 </div>
                               </div>
                             )}
@@ -633,14 +995,68 @@ export function EvalDetail({ summary }: EvalDetailProps) {
                   </Fragment>
                 )
               })}
+              {leaderboardRows.length === 0 && (
+                <TableRow>
+                  <TableCell colSpan={8} className="px-6 py-12 text-center text-sm text-muted-foreground">
+                    No leaderboard entries match the selected parameter range.
+                  </TableCell>
+                </TableRow>
+              )}
             </TableBody>
           </Table>
+
+          {/* Load more */}
+          {pagedLeaderboardRows.length < leaderboardRows.length && (
+            <div className="border-t px-6 py-4 text-center">
+              <Button
+                variant="outline"
+                onClick={() => setLeaderboardPage((p) => p + 1)}
+              >
+                Load more ({leaderboardRows.length - pagedLeaderboardRows.length} remaining)
+              </Button>
+            </div>
+          )}
         </CardContent>
       </Card>
+
+      {/* Research: benchmark card details AFTER the leaderboard, collapsed by default */}
+      {isResearchView && summary.benchmark_card && (
+        <ResearchBenchmarkCardCollapsible card={summary.benchmark_card} />
+      )}
     </div>
   )
 }
 
+function ResearchBenchmarkCardCollapsible({ card }: { card: BenchmarkCard }) {
+  const [open, setOpen] = useState(false)
+  return (
+    <Collapsible open={open} onOpenChange={setOpen}>
+      <CollapsibleTrigger asChild>
+        <button
+          type="button"
+          className="flex w-full items-center justify-between rounded-[1.5rem] border border-border/70 bg-muted/10 px-5 py-4 text-left transition-colors hover:bg-muted/20"
+        >
+          <div className="flex items-center gap-2">
+            <BookOpen className="h-4 w-4 text-muted-foreground" />
+            <span className="text-sm font-semibold">Benchmark card details</span>
+            <span className="text-xs text-muted-foreground">
+              — dataset, methodology, risks, resources
+            </span>
+          </div>
+          {open ? (
+            <ChevronUp className="h-4 w-4 text-muted-foreground" />
+          ) : (
+            <ChevronDown className="h-4 w-4 text-muted-foreground" />
+          )}
+        </button>
+      </CollapsibleTrigger>
+      <CollapsibleContent className="mt-2">
+        <BenchmarkCardPanel card={card} isResearchView defaultRisksOpen={false} />
+      </CollapsibleContent>
+    </Collapsible>
+  )
+}
+
 function DetailPanel({
   title,
   subtitle,
@@ -675,3 +1091,305 @@ function MetaRow({
     </div>
   )
 }
+
+function toStringArray(value: string[] | string | undefined): string[] {
+  if (!value) return []
+  if (Array.isArray(value)) return value.filter(Boolean)
+  if (value === "Not specified") return []
+  return [value]
+}
+
+function BenchmarkCardPanel({
+  card,
+  isResearchView,
+  defaultRisksOpen = false,
+}: {
+  card: BenchmarkCard
+  isResearchView: boolean
+  defaultRisksOpen?: boolean
+}) {
+  const [risksOpen, setRisksOpen] = useState(defaultRisksOpen)
+  const details = card.benchmark_details
+  const purpose = card.purpose_and_intended_users
+  const methodology = card.methodology
+  const data = card.data
+  const ethical = card.ethical_and_legal_considerations
+  const risks = card.possible_risks ?? []
+  const flaggedFields = Object.entries(card.flagged_fields ?? {})
+  const missingFields = card.missing_fields ?? []
+
+  const domains = details.domains ?? []
+  const languages = details.languages ?? []
+  const resources = (details.resources ?? []).filter(Boolean)
+  const tasks = toStringArray(purpose.tasks)
+  const audience = toStringArray(purpose.audience)
+
+  const license = ethical.data_licensing ?? ""
+  const shortLicense = license && license !== "Not specified" ? license : null
+
+  return (
+    <Card className="overflow-hidden">
+      <CardHeader className="border-b bg-muted/10">
+        <div className="flex flex-wrap items-center gap-3">
+          <BookOpen className="h-5 w-5 text-primary" />
+          <CardTitle className="text-xl">Benchmark Card</CardTitle>
+          {shortLicense && (
+            <Badge variant="outline" className="font-normal">
+              {shortLicense}
+            </Badge>
+          )}
+          {(flaggedFields.length > 0 || missingFields.length > 0) && (
+            <Badge className="bg-amber-500 text-amber-950 hover:bg-amber-500">
+              <AlertTriangle className="mr-1 h-3 w-3" />
+              {flaggedFields.length} flagged · {missingFields.length} missing
+            </Badge>
+          )}
+        </div>
+        <CardDescription>
+          Structured metadata about this benchmark — what it measures, how it was built, and known limitations.
+          {card.card_info?.llm && (
+            <span className="ml-1 text-muted-foreground/70">
+              Card generated by {card.card_info.llm}.
+            </span>
+          )}
+        </CardDescription>
+      </CardHeader>
+
+      <CardContent className="space-y-6 p-5 sm:p-6">
+        {/* Overview + domains */}
+        <div className="space-y-3">
+          <p className="text-sm leading-6 text-muted-foreground">{details.overview}</p>
+
+          <div className="flex flex-wrap gap-2">
+            {domains.map((d) => (
+              <span
+                key={d}
+                className="inline-flex items-center gap-1 rounded-full border border-border/60 bg-muted/30 px-2.5 py-1 text-xs font-medium capitalize"
+              >
+                <Tag className="h-3 w-3 shrink-0 text-muted-foreground" />
+                {d}
+              </span>
+            ))}
+            {languages.map((l) => (
+              <span
+                key={l}
+                className="inline-flex items-center gap-1 rounded-full border border-sky-200/70 bg-sky-50/60 px-2.5 py-1 text-xs font-medium dark:border-sky-900/40 dark:bg-sky-950/20"
+              >
+                <Globe className="h-3 w-3 shrink-0 text-sky-600" />
+                {l}
+              </span>
+            ))}
+          </div>
+        </div>
+
+        <div className="grid gap-4 sm:grid-cols-2 xl:grid-cols-3">
+          {/* Goal */}
+          <div className="rounded-[1.25rem] border border-border/70 bg-muted/10 p-4">
+            <div className="mb-2 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+              <Scale className="h-3.5 w-3.5" /> Goal
+            </div>
+            <p className="text-sm leading-5 text-foreground">{purpose.goal}</p>
+          </div>
+
+          {/* Metric interpretation */}
+          <div className="rounded-[1.25rem] border border-border/70 bg-muted/10 p-4">
+            <div className="mb-2 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+              <BarChart3 className="h-3.5 w-3.5" /> Score interpretation
+            </div>
+            <p className="text-sm leading-5 text-foreground">{methodology.interpretation}</p>
+          </div>
+
+          {/* Limitations */}
+          <div className="rounded-[1.25rem] border border-amber-200/60 bg-amber-50/60 p-4 dark:border-amber-900/40 dark:bg-amber-950/15">
+            <div className="mb-2 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-[0.2em] text-amber-700 dark:text-amber-300">
+              <AlertTriangle className="h-3.5 w-3.5" /> Limitations
+            </div>
+            <p className="text-sm leading-5 text-amber-900/90 dark:text-amber-100/90">{purpose.limitations}</p>
+          </div>
+        </div>
+
+        {/* Research-only: methodology + dataset details */}
+        {isResearchView && (
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="rounded-[1.25rem] border border-border/70 bg-muted/10 p-4">
+              <div className="mb-3 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                Dataset
+              </div>
+              <dl className="space-y-2 text-sm">
+                <div className="flex gap-2">
+                  <dt className="w-20 shrink-0 text-muted-foreground">Size</dt>
+                  <dd className="font-medium">{data.size}</dd>
+                </div>
+                <div className="flex gap-2">
+                  <dt className="w-20 shrink-0 text-muted-foreground">Format</dt>
+                  <dd className="font-medium capitalize">{data.format}</dd>
+                </div>
+                <div className="flex gap-2">
+                  <dt className="w-20 shrink-0 text-muted-foreground">Source</dt>
+                  <dd className="font-medium">{data.source}</dd>
+                </div>
+              </dl>
+            </div>
+
+            <div className="rounded-[1.25rem] border border-border/70 bg-muted/10 p-4">
+              <div className="mb-3 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+                Methodology
+              </div>
+              <dl className="space-y-2 text-sm">
+                {methodology.metrics.length > 0 && (
+                  <div className="flex gap-2">
+                    <dt className="w-20 shrink-0 text-muted-foreground">Metrics</dt>
+                    <dd className="font-medium">{methodology.metrics.join(", ")}</dd>
+                  </div>
+                )}
+                {tasks.length > 0 && (
+                  <div className="flex gap-2">
+                    <dt className="w-20 shrink-0 text-muted-foreground">Tasks</dt>
+                    <dd className="font-medium">{tasks.join(", ")}</dd>
+                  </div>
+                )}
+                {audience.length > 0 && (
+                  <div className="flex gap-2">
+                    <dt className="w-20 shrink-0 text-muted-foreground">Audience</dt>
+                    <dd className="font-medium">{audience.join("; ")}</dd>
+                  </div>
+                )}
+              </dl>
+            </div>
+          </div>
+        )}
+
+        {/* Risks (collapsible) */}
+        {risks.length > 0 && (
+          <Collapsible open={risksOpen} onOpenChange={setRisksOpen}>
+            <CollapsibleTrigger asChild>
+              <button
+                type="button"
+                className="flex w-full items-center justify-between rounded-[1.25rem] border border-border/70 bg-muted/10 p-4 text-left transition-colors hover:bg-muted/20"
+              >
+                <div className="flex items-center gap-2">
+                  <Shield className="h-4 w-4 text-muted-foreground" />
+                  <span className="text-sm font-semibold">
+                    Risk considerations ({risks.length})
+                  </span>
+                </div>
+                {risksOpen ? (
+                  <ChevronUp className="h-4 w-4 text-muted-foreground" />
+                ) : (
+                  <ChevronDown className="h-4 w-4 text-muted-foreground" />
+                )}
+              </button>
+            </CollapsibleTrigger>
+            <CollapsibleContent>
+              <div className="mt-2 grid gap-3 sm:grid-cols-2">
+                {risks.map((risk, i) => (
+                  <div
+                    key={i}
+                    className="rounded-[1.25rem] border border-border/60 bg-background p-4"
+                  >
+                    <div className="mb-1.5 flex items-start justify-between gap-2">
+                      <span className="text-sm font-semibold">{risk.category}</span>
+                      {risk.url && (
+                        <a
+                          href={risk.url}
+                          target="_blank"
+                          rel="noreferrer"
+                          onClick={(e) => e.stopPropagation()}
+                          className="shrink-0 text-muted-foreground hover:text-primary"
+                        >
+                          <ExternalLink className="h-3.5 w-3.5" />
+                        </a>
+                      )}
+                    </div>
+                    {risk.description?.[0] && (
+                      <p className="text-xs leading-5 text-muted-foreground line-clamp-3">
+                        {risk.description[0]}
+                      </p>
+                    )}
+                  </div>
+                ))}
+              </div>
+            </CollapsibleContent>
+          </Collapsible>
+        )}
+
+        {/* Compliance / ethical notes (policy view emphasis) */}
+        {!isResearchView && (
+          <div className="rounded-[1.25rem] border border-border/70 bg-muted/10 p-4">
+            <div className="mb-3 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+              Ethical &amp; legal
+            </div>
+            <dl className="grid gap-x-6 gap-y-2 text-sm sm:grid-cols-2">
+              {shortLicense && (
+                <div className="flex gap-2">
+                  <dt className="w-28 shrink-0 text-muted-foreground">License</dt>
+                  <dd className="font-medium">{license}</dd>
+                </div>
+              )}
+              {ethical.compliance_with_regulations && ethical.compliance_with_regulations !== "Not specified" && (
+                <div className="flex gap-2">
+                  <dt className="w-28 shrink-0 text-muted-foreground">Compliance</dt>
+                  <dd className="font-medium">{ethical.compliance_with_regulations}</dd>
+                </div>
+              )}
+              {ethical.privacy_and_anonymity && ethical.privacy_and_anonymity !== "Not specified" && (
+                <div className="col-span-full flex gap-2">
+                  <dt className="w-28 shrink-0 text-muted-foreground">Privacy</dt>
+                  <dd className="font-medium">{ethical.privacy_and_anonymity}</dd>
+                </div>
+              )}
+            </dl>
+          </div>
+        )}
+
+        {/* Flagged / missing fields warning */}
+        {(flaggedFields.length > 0 || missingFields.length > 0) && isResearchView && (
+          <div className="rounded-[1.25rem] border border-amber-200/60 bg-amber-50/50 p-4 dark:border-amber-900/40 dark:bg-amber-950/15">
+            <div className="mb-2 text-[11px] font-semibold uppercase tracking-[0.2em] text-amber-700 dark:text-amber-300">
+              Card quality notes
+            </div>
+            {flaggedFields.length > 0 && (
+              <ul className="space-y-1 text-xs text-amber-900/80 dark:text-amber-100/80">
+                {flaggedFields.map(([field, note]) => (
+                  <li key={field}>
+                    <span className="font-semibold">{field}:</span> {note}
+                  </li>
+                ))}
+              </ul>
+            )}
+            {missingFields.length > 0 && (
+              <p className="mt-1 text-xs text-amber-900/70 dark:text-amber-100/70">
+                Missing: {missingFields.join(", ")}
+              </p>
+            )}
+          </div>
+        )}
+
+        {/* External resources */}
+        {resources.length > 0 && (
+          <div>
+            <div className="mb-2 text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-foreground">
+              Resources
+            </div>
+            <div className="flex flex-wrap gap-2">
+              {resources.map((url) => (
+                <a
+                  key={url}
+                  href={url}
+                  target="_blank"
+                  rel="noreferrer"
+                  onClick={(e) => e.stopPropagation()}
+                  className="inline-flex items-center gap-1 rounded-full border border-border/60 bg-background px-3 py-1.5 text-xs font-medium text-muted-foreground hover:text-primary hover:border-primary/40 transition-colors"
+                >
+                  <FileText className="h-3 w-3 shrink-0" />
+                  {url.replace(/^https?:\/\//, "").replace(/\/.+/, "")}
+                  <ExternalLink className="h-3 w-3 shrink-0" />
+                </a>
+              ))}
+            </div>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  )
+}

data/benchmarks/helm_capabilities.json

@@ -1,4 +1,233 @@
 {
+  "benchmark_cards": {
+    "Omni-MATH": {
+      "benchmark_details": {
+        "name": "Omni-MATH",
+        "overview": "Omni-MATH is a benchmark designed to measure the mathematical reasoning capabilities of large language models at the Olympiad competition level. It comprises 4,428 challenging problems, categorized into over 33 sub-domains and more than 10 distinct difficulty levels. It was created because existing mathematical benchmarks are nearing saturation and are inadequate for assessing models on truly difficult tasks.",
+        "data_type": "text",
+        "domains": [
+          "math",
+          "olympiads"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "GSM8K",
+          "MATH"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2410.07985",
+          "https://huggingface.co/datasets/KbsdJames/Omni-MATH",
+          "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To provide a challenging benchmark for assessing and advancing the mathematical reasoning capabilities of large language models at the Olympiad and competition level, as existing benchmarks have become less challenging. It enables a nuanced analysis of performance across various mathematical disciplines and complexity levels.",
+        "audience": [
+          "Researchers evaluating large language models"
+        ],
+        "tasks": [
+          "Solving Olympiad-level mathematical problems",
+          "Solving competition-level mathematical problems",
+          "Rule-based evaluation on a filtered subset of problems (Omni-MATH-Rule)"
+        ],
+        "limitations": "Some problems are not suitable for reliable rule-based evaluation, leading to a filtered 'testable' set and an 'untestable' set.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The data is sourced from contest pages, the AoPS Wiki, and the AoPS Forum. Initial raw counts from these sources were filtered to create the final dataset.",
+        "size": "4,428 problems. A subset of 2,821 problems (Omni-MATH-Rule) is suitable for rule-based evaluation, and a separate subset of 100 samples was used for meta-evaluation.",
+        "format": "JSON",
+        "annotation": "Problems underwent rigorous human annotation by a team including PhD and Master's students. Each problem was reviewed by two annotators for cross-validation, achieving high agreement rates."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated by generating solutions to the mathematical problems.",
+          "Evaluation is conducted using both model-based judgment (e.g., GPT-4o or the open-source Omni-Judge) and rule-based evaluation for a specific subset of problems (Omni-MATH-Rule)."
+        ],
+        "metrics": [
+          "Accuracy (Acc)"
+        ],
+        "calculation": "The overall score is the accuracy percentage, calculated as the number of correct solutions divided by the total number of problems.",
+        "interpretation": "Higher accuracy indicates stronger performance. The benchmark is considered challenging, as even advanced models achieve only moderate accuracy.",
+        "baseline_results": "Paper baselines (accuracy on full Omni-MATH / Omni-MATH-Rule subset): o1-mini (60.54% / 62.2%), o1-preview (52.55% / 51.7%), qwen2.5-MATH-72b-Instruct (36.20% / 35.7%), qwen2.5-MATH-7b-Instruct (33.22% / 32.3%), GPT-4o (30.49% / 29.2%), NuminaMATH-72b-cot (28.45% / 27.1%), DeepseekMATH-7b-RL (16.12% / 14.9%). EEE results: OLMo 2 32B Instruct March 2025 scored 0.161 (16.1%).",
+        "validation": "For the Omni-MATH-Rule subset, two PhD students annotated problems to determine suitability for rule-based evaluation, achieving 98% cross-validation accuracy. A meta-evaluation compared model-generated judgments against human gold-standard annotations on a 100-sample subset to assess reliability."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "Apache License 2.0",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T13:34:44.331592",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "WildBench": {
+      "benchmark_details": {
+        "name": "WildBench",
+        "overview": "WildBench is a benchmark that measures the performance of large language models on challenging, open-ended tasks derived from real-world user queries. It consists of 1,024 tasks selected from human-chatbot conversation logs. Its distinctive features include using a natural distribution of real user queries and employing automated evaluation with two novel metrics, WB-Reward and WB-Score, which utilize task-specific checklists and structured explanations.",
+        "data_type": "tabular, text",
+        "domains": [
+          "Info Seeking",
+          "Math & Data",
+          "Reasoning & Planning",
+          "Creative Tasks"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "AlpacaEval",
+          "ArenaHard",
+          "MT-bench",
+          "Chatbot Arena"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2406.04770",
+          "https://huggingface.co/datasets/allenai/WildBench",
+          "https://huggingface.co/spaces/allenai/WildBench",
+          "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To provide a realistic, automated, and cost-effective evaluation framework for large language models that reflects their capabilities on challenging, real-world user tasks. It aims to be contamination-resilient and dynamically updated.",
+        "audience": [
+          "Researchers and practitioners evaluating large language models"
+        ],
+        "tasks": [
+          "Open-ended text generation in response to diverse user queries"
+        ],
+        "limitations": "The benchmark acknowledges a common issue in LLM-as-a-judge evaluations: bias towards longer outputs. It introduces a length-penalty method to mitigate this.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The data is derived from real user-chatbot conversation logs collected by the AI2 WildChat project. Over one million logs were filtered to create the benchmark.",
+        "size": "The benchmark contains 1,024 tasks. A separate 'v2-hard' configuration contains 256 examples. The dataset falls into the size category of 1K to 10K examples.",
+        "format": "The data is stored in Parquet format.",
+        "annotation": "Human annotation was used for quality control. GPT-4-Turbo assisted by summarizing query intents to help human reviewers filter out nonsensical tasks. Human reviewers manually assessed tasks to ensure they were challenging, diverse, and that associated checklist questions were clear. The final set of tasks was retained after this process. Each example includes fine-grained annotations such as task types and checklists for evaluating response quality."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated automatically using LLM-as-a-judge, with GPT-4-turbo as the evaluator. The evaluation is not fine-tuning-based and appears to be zero-shot or prompted.",
+          "The evaluation uses length-penalized pairwise comparisons and individual scoring to prevent bias towards longer outputs."
+        ],
+        "metrics": [
+          "WB-Reward (for pairwise comparisons)",
+          "WB-Score (for individual scoring)",
+          "WB-Elo (for leaderboard ranking, merging WB-Reward and WB-Score)"
+        ],
+        "calculation": "WB-Reward compares a test model against three baseline models of varying performance, producing outcomes of 'much better', 'slightly better', 'tie', 'slightly worse', or 'much worse'. A length penalty converts 'slightly better/worse' to 'tie' if the winner's response is excessively longer. WB-Score evaluates individual model outputs. WB-Elo merges the pairwise comparisons from WB-Reward and WB-Score to perform Elo rating updates.",
+        "interpretation": "Higher scores on WB-Reward and WB-Score indicate better performance. Strong performance is validated by a high correlation with human-voted Elo ratings from Chatbot Arena, with WB-Reward achieving a Pearson correlation of 0.98 and WB-Score reaching 0.95.",
+        "baseline_results": "Paper baselines: The paper reports results for 40 LLMs but does not list specific scores. It notes that using Haiku as a baseline yields the best correlation with human ratings. EEE results: OLMo 2 32B Instruct March 2025 scored 0.7340 on WildBench.",
+        "validation": "The evaluation metrics are validated by their strong correlation with human-voted Elo ratings from Chatbot Arena on hard tasks. Checklist questions used in the evaluation were manually verified for clarity and relevance."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "The dataset is made available under a CC BY license, intended for research and educational use in accordance with AI2's Responsible Use Guidelines.",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Data contamination",
+          "description": [
+            "Data contamination occurs when incorrect data is used for training. For example, data that is not aligned with model's purpose or data that is already set aside for other development tasks such as testing and evaluation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-contamination.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T13:56:24.159440",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    }
+  },
   "models": [
     {
       "model_id": "allenai/OLMo-2-1124-7B-Instruct",
@@ -794,4 +1023,4 @@
       }
     }
   ]
-}
+}

data/benchmarks/helm_classic.json

@@ -1,4 +1,556 @@
 {
+  "benchmark_cards": {
+    "BoolQ": {
+      "benchmark_details": {
+        "name": "BoolQ",
+        "overview": "BoolQ is a benchmark that measures a model's ability to answer naturally occurring yes/no questions, framed as a reading comprehension task. The questions are generated in unprompted and unconstrained settings, often querying complex, non-factoid information and requiring difficult entailment-like inference. The dataset consists of a single task: answering yes/no questions given a supporting passage.",
+        "data_type": "text",
+        "domains": [
+          "natural language understanding",
+          "reading comprehension",
+          "natural language inference"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "MultiNLI",
+          "SNLI",
+          "QNLI",
+          "SQuAD 2.0",
+          "Natural Questions (NQ)",
+          "QQP",
+          "MS MARCO",
+          "RACE",
+          "bAbI stories"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/1905.10044",
+          "https://huggingface.co/datasets/google/boolq",
+          "https://goo.gl/boolq",
+          "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To test models on their ability to answer naturally occurring yes/no questions, which are challenging and require complex inferential abilities beyond surface-level reasoning.",
+        "audience": [
+          "Researchers in natural language understanding and reading comprehension"
+        ],
+        "tasks": [
+          "Yes/no question answering",
+          "Text-pair classification"
+        ],
+        "limitations": "Annotation involved some errors and ambiguous cases. The use of singly-annotated examples is a trade-off for dataset size. Potential concerns about annotation artifacts are acknowledged.",
+        "out_of_scope_uses": "The paper does not explicitly state what the benchmark is not designed for."
+      },
+      "data": {
+        "source": "The data consists of naturally occurring yes/no questions authored by people who were not prompted to write specific question types and did not know the answers. The passages are excerpts from sources like Wikipedia.",
+        "size": "15,942 examples total, with 9,427 in the train split and 3,270 in the validation split. The dataset size category is between 10,000 and 100,000 examples.",
+        "format": "parquet",
+        "annotation": "Questions were answered by human annotators. A quality check on a subset showed the main annotation process achieved 90% accuracy against a gold-standard set labeled by three authors. The training, development, and test sets use singly-annotated examples."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated by fine-tuning on the BoolQ training set, potentially after transfer learning from other datasets or unsupervised pre-training. Zero-shot or direct use of pre-trained models without fine-tuning did not outperform the majority baseline.",
+          "The task requires providing a yes/no (boolean) answer to a question based on a given passage."
+        ],
+        "metrics": [
+          "Accuracy"
+        ],
+        "calculation": "The overall score is the accuracy percentage on the test set.",
+        "interpretation": "Higher accuracy indicates better performance. Human accuracy is 90%, and the majority baseline is approximately 62%.",
+        "baseline_results": "Paper baselines: Majority baseline: 62.17% dev, 62.31% test; Recurrent model baseline: 69.6%; Best model (BERT large pre-trained on MultiNLI then fine-tuned on BoolQ): 80.4% accuracy; Human accuracy: 90%. EEE results: Anthropic-LM v4-s3 52B: 81.5%.",
+        "validation": "Quality assurance involved author-led gold-standard annotation on a subset, showing 90% agreement. The development set was used for model selection, such as choosing the best model from five seeds based on its performance."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "cc-by-sa-3.0",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Uncertain data provenance",
+          "description": [
+            "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T15:08:51.830946",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "CNN/DailyMail": {
+      "benchmark_details": {
+        "name": "CNN/DailyMail",
+        "overview": "CNN/DailyMail is a benchmark for evaluating abstractive and extractive summarization models using news articles. It contains over 300,000 unique articles written by journalists from CNN and the Daily Mail. The dataset was originally created for machine reading and question answering, but later versions were restructured specifically for summarization tasks.",
+        "data_type": "text",
+        "domains": [
+          "summarization",
+          "journalism",
+          "news media"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": "No facts provided about similar benchmarks.",
+        "resources": [
+          "https://huggingface.co/datasets/abisee/cnn_dailymail",
+          "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To help develop models that can summarize long paragraphs of text into one or two sentences, aiding in the efficient presentation of information from large quantities of text.",
+        "audience": [
+          "NLP researchers",
+          "Summarization model developers"
+        ],
+        "tasks": [
+          "Summarization"
+        ],
+        "limitations": "News articles often place important information in the first third, which may affect summarization. A manual study found 25% of samples in an earlier version were difficult for humans due to ambiguity and coreference errors. Also, machine-generated summaries may differ in truth values from the original articles.",
+        "out_of_scope_uses": "No facts provided about out-of-scope uses."
+      },
+      "data": {
+        "source": "The dataset consists of news articles and highlight sentences written by journalists at CNN and the Daily Mail. The CNN articles were collected from April 2007 to April 2015, and the Daily Mail articles from June 2010 to April 2015, sourced from archives on the Wayback Machine.",
+        "size": "Over 300,000 unique articles, with 287,113 training examples, 13,368 validation examples, and 11,490 test examples.",
+        "format": "parquet",
+        "annotation": "The dataset does not contain additional annotations. The highlights are the original summaries written by the article authors and are used as the target for summarization."
+      },
+      "methodology": {
+        "methods": [
+          "Models generate a summary for a given news article, which is then compared to the author-written highlights."
+        ],
+        "metrics": [
+          "ROUGE-2"
+        ],
+        "calculation": "The ROUGE-2 score measures the overlap of bigrams between the generated summary and the reference highlights.",
+        "interpretation": "Higher scores indicate better performance, as they reflect greater overlap with the reference summaries.",
+        "baseline_results": "Paper baseline (Zhong et al., 2020): ROUGE-1 score of 44.41 for an extractive summarization model. Evaluation suite result (Anthropic-LM v4-s3 52B): ROUGE-2 score of 0.154.",
+        "validation": "No facts provided about validation procedures."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "The dataset (version 3.0.0) is not anonymized, meaning individuals' names are present in the text.",
+        "data_licensing": "Apache License 2.0",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Data contamination",
+          "description": [
+            "Data contamination occurs when incorrect data is used for training. For example, data that is not aligned with model's purpose or data that is already set aside for other development tasks such as testing and evaluation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-contamination.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T15:15:47.316103",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "CivilComments": {
+      "benchmark_details": {
+        "name": "CivilComments",
+        "overview": "CivilComments is a benchmark designed to measure unintended identity-based bias in toxicity classification models. It uses a large, real-world dataset of online comments from the Civil Comments platform, extended with crowd-sourced annotations for toxicity and demographic identity references. This provides a nuanced evaluation of bias beyond synthetic datasets.",
+        "data_type": "tabular, text",
+        "domains": [
+          "machine learning fairness",
+          "bias measurement",
+          "toxic comment classification",
+          "text classification"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": "The paper does not name other specific benchmark datasets, only referencing prior work using synthetic test sets.",
+        "resources": [
+          "https://arxiv.org/abs/1903.04561",
+          "https://huggingface.co/datasets/google/civil_comments",
+          "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To evaluate unintended identity-based bias in toxicity classification models using real data and nuanced metrics.",
+        "audience": [
+          "Machine learning researchers and practitioners working on fairness, bias measurement, and mitigation, particularly in toxic comment classification."
+        ],
+        "tasks": [
+          "Binary toxicity classification (toxic vs. non-toxic)",
+          "Analysis of performance across identity subgroups"
+        ],
+        "limitations": "The labeled set of identities is not comprehensive and does not provide universal coverage, representing a balance between coverage, annotator accuracy, and example count. The real-world data is potentially noisier than synthetic alternatives.",
+        "out_of_scope_uses": [
+          "Developing effective strategies for choosing optimal thresholds to minimize bias"
+        ]
+      },
+      "data": {
+        "source": "The data consists of online comments sourced from the Civil Comments platform, a commenting plugin for independent English-language news sites. The comments were publicly posted between 2015 and 2017.",
+        "size": "The dataset contains approximately 1.8 million comments for training, with separate validation and test sets of approximately 97,320 examples each. All comments were labeled for toxicity, and a subset of 450,000 comments was additionally labeled for identity references.",
+        "format": "parquet",
+        "annotation": "Labeling was performed by crowd raters. Toxicity labels were applied using guidelines consistent with the Perspective API. For the identity-labeled subset, raters were shown comments and selected referenced identities (e.g., genders, races, ethnicities) from a provided list. Some comments for identity labeling were pre-selected by models to increase the frequency of identity content."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated by applying a suite of bias metrics to their predictions on the test set. The original paper demonstrates this using publicly accessible toxicity classifiers on the dataset."
+        ],
+        "metrics": [
+          "Subgroup AUC",
+          "BPSN AUC",
+          "BNSP AUC",
+          "Negative Average Equality Gap (AEG)",
+          "Positive Average Equality Gap (AEG)"
+        ],
+        "calculation": "The evaluation calculates five metrics for each identity subgroup to provide a multi-faceted view of bias. There is no single aggregated overall score.",
+        "interpretation": "For the AUC metrics (Subgroup, BPSN, BNSP), higher values indicate better separability (fewer mis-orderings). For the Average Equality Gaps (Negative and Positive), lower values indicate better separability (more similar score distributions).",
+        "baseline_results": "Paper baselines: Results for TOXICITY@1 and TOXICITY@6 from the Perspective API are reported, showing their Subgroup AUC, BPSN AUC, BNSP AUC, Negative AEG, and Positive AEG on a synthetic dataset for the lowest performing 20 subgroups. They are also compared on short comments within the human-labeled dataset for specific identities. EEE results: Anthropic-LM v4-s3 52B scored 0.6100 on the CivilComments metric.",
+        "validation": "The evaluation assumes the human-provided labels are reliable. The identity labeling set was designed to balance coverage, crowd rater accuracy, and ensure sufficient examples per identity for meaningful results."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "The paper does not discuss how personally identifiable information (PII) in the online comments was handled or if data was anonymized.",
+        "data_licensing": "Creative Commons Zero v1.0 Universal",
+        "consent_procedures": "The paper does not describe compensation for crowdworkers or the specific platform used for annotation.",
+        "compliance_with_regulations": "The paper does not mention IRB approval, GDPR compliance, or any other ethical review process."
+      },
+      "possible_risks": [
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Uncertain data provenance",
+          "description": [
+            "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Output bias",
+          "description": [
+            "Generated content might unfairly represent certain groups or individuals."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/output-bias.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [],
+      "card_info": {
+        "created_at": "2026-03-17T12:38:43.250822",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "HellaSwag": {
+      "benchmark_details": {
+        "name": "HellaSwag",
+        "overview": "HellaSwag is a benchmark designed to measure commonsense natural language inference by testing a model's ability to select the most plausible follow-up event from four multiple-choice options. It is adversarially constructed to be challenging for state-of-the-art models, using a method called Adversarial Filtering to create difficult wrong answers that are obvious to humans but often misclassified by models.",
+        "data_type": "text",
+        "domains": [
+          "commonsense reasoning",
+          "natural language inference"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "SWAG",
+          "SNLI"
+        ],
+        "resources": [
+          "https://rowanzellers.com/hellaswag",
+          "https://arxiv.org/abs/1905.07830",
+          "https://huggingface.co/datasets/Rowan/hellaswag",
+          "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To create a challenge dataset that reveals the difficulty of commonsense inference for state-of-the-art models, demonstrating their lack of robustness and reliance on dataset biases rather than genuine reasoning. It aims to evaluate a model's ability to select the most plausible continuation of a given event description.",
+        "audience": [
+          "NLP researchers"
+        ],
+        "tasks": [
+          "Four-way multiple-choice selection for event continuation",
+          "Commonsense inference"
+        ],
+        "limitations": "The adversarial filtering process used to create the dataset, while effective at making it difficult for models, may also select examples where the ground truth answer is not the one preferred by human annotators, necessitating manual filtering to retain the best examples.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "Contexts are sourced from WikiHow instructional articles and ActivityNet video descriptions. Incorrect answer choices are generated by machines and then adversarially filtered.",
+        "size": "The dataset contains 70,000 examples in total, with 5,001 in-domain validation examples and 5,000 zero-shot validation examples. The training set comprises 39,905 examples.",
+        "format": "Parquet",
+        "annotation": "Human crowd workers on Amazon Mechanical Turk validated the endings. They were presented with a context and six endings (one true, five machine-generated) and rated their plausibility. The process involved iterative filtering and replacement of unrealistic endings. Worker quality was ensured via an autograded test and fair pay. A gold standard check by three authors on a random sample showed 90% agreement with crowd annotations."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated via fine-tuning on the dataset.",
+          "The benchmark also includes zero-shot evaluation on held-out categories."
+        ],
+        "metrics": [
+          "HellaSwag accuracy"
+        ],
+        "calculation": "The overall score is the accuracy percentage on the full validation or test sets. Performance is also broken down by subsets, such as in-domain versus zero-shot and by data source.",
+        "interpretation": "Higher scores indicate better performance. Human performance is over 95%, which is considered strong. Model performance below 50% is reported, indicating a struggle, with a gap of over 45% from human performance on in-domain data.",
+        "baseline_results": "Paper baselines: BERT-Large achieves 47.3% accuracy overall. ESIM + ELMo gets 33.3% accuracy. A BERT-Base model with a frozen encoder and an added LSTM performs 4.3% worse than fine-tuned BERT-Base. Evaluation suite results: Anthropic-LM v4-s3 52B achieves 0.807 (80.7%) accuracy.",
+        "validation": "Human validation involved giving five crowd workers the same multiple-choice task and combining their answers via majority vote to establish a human performance baseline. The adversarial filtering process used iterative human ratings to ensure wrong answers were implausible."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "Not specified",
+        "consent_procedures": "Crowdworkers on Amazon Mechanical Turk participated voluntarily and were compensated, with pay described as fair. A qualification task was used to filter workers, and those who consistently preferred generated endings over real ones were disqualified.",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {
+        "baseline_results": "[Possible Hallucination], no supporting evidence found in source material"
+      },
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.data_licensing",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T15:47:07.561060",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "QuAC": {
+      "benchmark_details": {
+        "name": "QuAC",
+        "overview": "QuAC (Question Answering in Context) is a benchmark that measures a model's ability to answer questions within an information-seeking dialogue. It contains 14,000 dialogues comprising 100,000 question-answer pairs. The dataset is distinctive because questions are often open-ended, context-dependent, unanswerable, or only meaningful within the dialog flow, presenting challenges not found in standard machine comprehension datasets.",
+        "data_type": "text",
+        "domains": [
+          "question answering",
+          "dialogue modeling",
+          "text generation"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "SQuAD"
+        ],
+        "resources": [
+          "http://quac.ai",
+          "https://arxiv.org/abs/1808.07036",
+          "https://huggingface.co/datasets/allenai/quac",
+          "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To enable models to learn from and participate in information-seeking dialog, handling context-dependent, elliptical, and sometimes unanswerable questions.",
+        "audience": [
+          "Not specified"
+        ],
+        "tasks": [
+          "Extractive question answering",
+          "Text generation",
+          "Fill mask"
+        ],
+        "limitations": "Some questions have lower quality annotations; the dataset filters out the noisiest ~10% of annotations where human F1 is below 40. Questions can be open-ended, unanswerable, or only meaningful within the dialog context, posing inherent challenges.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The data is crowdsourced via an interactive dialog between two crowd workers: one acting as a student asking questions to learn about a hidden Wikipedia text, and the other acting as a teacher who answers using short excerpts from that text. The source data comes from Wikipedia.",
+        "size": "The dataset contains 98,407 question-answer pairs from 13,594 dialogs, based on 8,854 unique sections from 3,611 unique Wikipedia articles. The training set has 83,568 questions (11,567 dialogs), the validation set has 7,354 questions (1,000 dialogs), and the test set has 7,353 questions (1,002 dialogs). The dataset size is between 10,000 and 100,000 examples.",
+        "format": "Each dialog is a sequence of question-answer pairs centered around a Wikipedia section. The teacher's response includes a text span, a 'yes/no' indication, a 'no answer' indication, and an encouragement for follow-up questions.",
+        "annotation": "Questions are answered by a teacher selecting short excerpts (spans) from the Wikipedia text. The training set has one reference answer per question, while the validation and test sets each have five reference answers per question to improve evaluation reliability. For evaluation, questions with a human F1 score lower than 40 are not used, as manual inspection revealed lower quality below this threshold."
+      },
+      "methodology": {
+        "methods": [
+          "Models predict a text span to answer a question about a Wikipedia section, given a dialog history of previous questions and answers.",
+          "The evaluation uses a reading comprehension architecture extended to model dialog context."
+        ],
+        "metrics": [
+          "Word-level F1"
+        ],
+        "calculation": "Precision and recall are computed over overlapping words after removing stopwords. For 'no answer' questions, F1 is 1 if correctly predicted and 0 otherwise. The maximum F1 among all references is computed for each question.",
+        "interpretation": "Higher F1 scores indicate better performance. The best model underperforms humans by 20 F1, indicating significant room for improvement.",
+        "baseline_results": "Paper baselines: The best model underperforms humans by 20 F1, but specific model names and scores are not provided. EEE results: Anthropic-LM v4-s3 52B achieves an F1 score of 0.431.",
+        "validation": "Quality assurance includes using multiple references for development and test questions, filtering out questions with low human F1 scores, and manual inspection of low-quality annotations."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "MIT License",
+        "consent_procedures": "Dialogs were created by two crowd workers, but the specific compensation or platform details are not provided in the paper.",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Uncertain data provenance",
+          "description": [
+            "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.audience",
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T13:45:24.009083",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    }
+  },
   "models": [
     {
       "model_id": "Anthropic-LM-v4-s3-52B",
@@ -14,7 +566,7 @@
         "HellaSwag": 0.807,
         "OpenbookQA": 0.558,
         "TruthfulQA": 0.368,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.154,
         "XSUM": 0.134,
         "IMDB": 0.934,
@@ -33,12 +585,12 @@
         "NarrativeQA": 0.596,
         "NaturalQuestions (open-book)": 0.581,
         "QuAC": 0.313,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.177,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.931,
         "CivilComments": 0.531,
         "RAFT": 0.514
@@ -55,12 +607,12 @@
         "NarrativeQA": 0.528,
         "NaturalQuestions (open-book)": 0.539,
         "QuAC": 0.296,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.213,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.928,
         "CivilComments": 0.511,
         "RAFT": 0.502
@@ -206,9 +758,9 @@
         "Mean win rate": 0.553,
         "MMLU": 0.339,
         "BoolQ": 0.742,
-        "NarrativeQA": -1.0,
+        "NarrativeQA": -1,
         "NaturalQuestions (open-book)": 0.589,
-        "QuAC": -1.0,
+        "QuAC": -1,
         "HellaSwag": 0.729,
         "OpenbookQA": 0.53,
         "TruthfulQA": 0.245,
@@ -231,10 +783,10 @@
         "NarrativeQA": 0.605,
         "NaturalQuestions (open-book)": 0.568,
         "QuAC": 0.334,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.182,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.11,
         "XSUM": 0.105,
         "IMDB": 0.939,
@@ -253,10 +805,10 @@
         "NarrativeQA": 0.665,
         "NaturalQuestions (open-book)": 0.609,
         "QuAC": 0.349,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.221,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.139,
         "XSUM": 0.124,
         "IMDB": 0.947,
@@ -275,10 +827,10 @@
         "NarrativeQA": 0.711,
         "NaturalQuestions (open-book)": 0.649,
         "QuAC": 0.37,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.222,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.15,
         "XSUM": 0.136,
         "IMDB": 0.959,
@@ -315,14 +867,14 @@
       "scores": {
         "Mean win rate": 0.197,
         "MMLU": 0.407,
-        "BoolQ": 0.0,
+        "BoolQ": 0,
         "NarrativeQA": 0.151,
         "NaturalQuestions (open-book)": 0.19,
         "QuAC": 0.121,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.377,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.122,
         "XSUM": 0.09,
         "IMDB": 0.207,
@@ -515,12 +1067,12 @@
         "MMLU": 0.609,
         "BoolQ": 0.896,
         "NarrativeQA": 0.742,
-        "NaturalQuestions (open-book)": -1.0,
+        "NaturalQuestions (open-book)": -1,
         "QuAC": 0.473,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.616,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.049,
         "XSUM": 0.149,
         "IMDB": 0.935,
@@ -539,10 +1091,10 @@
         "NarrativeQA": 0.086,
         "NaturalQuestions (open-book)": 0.477,
         "QuAC": 0.116,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.133,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.043,
         "XSUM": 0.015,
         "IMDB": 0.379,
@@ -561,10 +1113,10 @@
         "NarrativeQA": 0.083,
         "NaturalQuestions (open-book)": 0.349,
         "QuAC": 0.144,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.193,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.03,
         "XSUM": 0.058,
         "IMDB": 0.337,
@@ -583,12 +1135,12 @@
         "NarrativeQA": 0.691,
         "NaturalQuestions (open-book)": 0.686,
         "QuAC": 0.403,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.385,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.762,
         "CivilComments": 0.645,
         "RAFT": 0.657
@@ -605,12 +1157,12 @@
         "NarrativeQA": 0.643,
         "NaturalQuestions (open-book)": 0.634,
         "QuAC": 0.392,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.292,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.916,
         "CivilComments": 0.62,
         "RAFT": 0.693
@@ -627,12 +1179,12 @@
         "NarrativeQA": 0.711,
         "NaturalQuestions (open-book)": 0.614,
         "QuAC": 0.347,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.324,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.928,
         "CivilComments": 0.6,
         "RAFT": 0.643
@@ -649,12 +1201,12 @@
         "NarrativeQA": 0.752,
         "NaturalQuestions (open-book)": 0.666,
         "QuAC": 0.39,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.344,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.927,
         "CivilComments": 0.549,
         "RAFT": 0.752
@@ -671,12 +1223,12 @@
         "NarrativeQA": 0.755,
         "NaturalQuestions (open-book)": 0.672,
         "QuAC": 0.401,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.508,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.962,
         "CivilComments": 0.655,
         "RAFT": 0.702
@@ -693,12 +1245,12 @@
         "NarrativeQA": 0.669,
         "NaturalQuestions (open-book)": 0.589,
         "QuAC": 0.338,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.28,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.947,
         "CivilComments": 0.563,
         "RAFT": 0.573
@@ -759,12 +1311,12 @@
         "NarrativeQA": 0.744,
         "NaturalQuestions (open-book)": 0.637,
         "QuAC": 0.424,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.33,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.962,
         "CivilComments": 0.588,
         "RAFT": 0.707
@@ -781,12 +1333,12 @@
         "NarrativeQA": 0.77,
         "NaturalQuestions (open-book)": 0.674,
         "QuAC": 0.484,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.554,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.961,
         "CivilComments": 0.652,
         "RAFT": 0.727
@@ -803,12 +1355,12 @@
         "NarrativeQA": 0.691,
         "NaturalQuestions (open-book)": 0.611,
         "QuAC": 0.406,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.272,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.907,
         "CivilComments": 0.562,
         "RAFT": 0.643
@@ -869,12 +1421,12 @@
         "NarrativeQA": 0.716,
         "NaturalQuestions (open-book)": 0.687,
         "QuAC": 0.423,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.422,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.962,
         "CivilComments": 0.624,
         "RAFT": 0.707
@@ -891,12 +1443,12 @@
         "NarrativeQA": 0.732,
         "NaturalQuestions (open-book)": 0.673,
         "QuAC": 0.393,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.231,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.959,
         "CivilComments": 0.599,
         "RAFT": 0.723
@@ -913,12 +1465,12 @@
         "NarrativeQA": 0.733,
         "NaturalQuestions (open-book)": 0.697,
         "QuAC": 0.327,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.234,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.956,
         "CivilComments": 0.573,
         "RAFT": 0.68
@@ -1067,12 +1619,12 @@
         "NarrativeQA": 0.663,
         "NaturalQuestions (open-book)": 0.624,
         "QuAC": 0.512,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.609,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.899,
         "CivilComments": 0.674,
         "RAFT": 0.768
@@ -1089,12 +1641,12 @@
         "NarrativeQA": 0.625,
         "NaturalQuestions (open-book)": 0.675,
         "QuAC": 0.485,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.339,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.943,
         "CivilComments": 0.696,
         "RAFT": 0.748
@@ -1221,12 +1773,12 @@
         "NarrativeQA": 0.396,
         "NaturalQuestions (open-book)": 0.592,
         "QuAC": 0.27,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.243,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.738,
         "CivilComments": 0.566,
         "RAFT": 0.486
@@ -1243,12 +1795,12 @@
         "NarrativeQA": 0.625,
         "NaturalQuestions (open-book)": 0.666,
         "QuAC": 0.371,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.384,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.959,
         "CivilComments": 0.603,
         "RAFT": 0.586
@@ -1265,12 +1817,12 @@
         "NarrativeQA": 0.476,
         "NaturalQuestions (open-book)": 0.449,
         "QuAC": 0.311,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.213,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.852,
         "CivilComments": 0.511,
         "RAFT": 0.523
@@ -1287,12 +1839,12 @@
         "NarrativeQA": 0.673,
         "NaturalQuestions (open-book)": 0.675,
         "QuAC": 0.307,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.353,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.959,
         "CivilComments": 0.552,
         "RAFT": 0.661
@@ -1309,12 +1861,12 @@
         "NarrativeQA": 0.621,
         "NaturalQuestions (open-book)": 0.579,
         "QuAC": 0.332,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.234,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.836,
         "CivilComments": 0.514,
         "RAFT": 0.602
@@ -1331,12 +1883,12 @@
         "NarrativeQA": 0.617,
         "NaturalQuestions (open-book)": 0.586,
         "QuAC": 0.336,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.205,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.752,
         "CivilComments": 0.547,
         "RAFT": 0.648
@@ -1353,12 +1905,12 @@
         "NarrativeQA": 0.555,
         "NaturalQuestions (open-book)": 0.52,
         "QuAC": 0.309,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.277,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.907,
         "CivilComments": 0.549,
         "RAFT": 0.502
@@ -1375,12 +1927,12 @@
         "NarrativeQA": 0.638,
         "NaturalQuestions (open-book)": 0.659,
         "QuAC": 0.26,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.243,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.927,
         "CivilComments": 0.664,
         "RAFT": 0.695
@@ -1397,12 +1949,12 @@
         "NarrativeQA": 0.638,
         "NaturalQuestions (open-book)": 0.637,
         "QuAC": 0.259,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.208,
-        "MS MARCO (TREC)": -1.0,
-        "CNN/DailyMail": -1.0,
-        "XSUM": -1.0,
+        "MS MARCO (TREC)": -1,
+        "CNN/DailyMail": -1,
+        "XSUM": -1,
         "IMDB": 0.894,
         "CivilComments": 0.549,
         "RAFT": 0.661
@@ -1419,10 +1971,10 @@
         "NarrativeQA": 0.496,
         "NaturalQuestions (open-book)": 0.682,
         "QuAC": 0.433,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.185,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.152,
         "XSUM": 0.104,
         "IMDB": 0.94,
@@ -1441,10 +1993,10 @@
         "NarrativeQA": 0.252,
         "NaturalQuestions (open-book)": 0.227,
         "QuAC": 0.162,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.202,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.017,
         "XSUM": 0.021,
         "IMDB": 0.836,
@@ -1463,10 +2015,10 @@
         "NarrativeQA": 0.706,
         "NaturalQuestions (open-book)": 0.642,
         "QuAC": 0.272,
-        "HellaSwag": -1.0,
-        "OpenbookQA": -1.0,
+        "HellaSwag": -1,
+        "OpenbookQA": -1,
         "TruthfulQA": 0.218,
-        "MS MARCO (TREC)": -1.0,
+        "MS MARCO (TREC)": -1,
         "CNN/DailyMail": 0.154,
         "XSUM": 0.132,
         "IMDB": 0.955,
@@ -1475,4 +2027,4 @@
       }
     }
   ]
-}
+}

data/benchmarks/helm_lite.json

@@ -1,4 +1,346 @@
 {
+  "benchmark_cards": {
+    "GSM8K": {
+      "benchmark_details": {
+        "name": "GSM8K",
+        "overview": "GSM8K is a benchmark that measures the ability of language models to perform multi-step mathematical reasoning. It consists of 8.5K high-quality, linguistically diverse grade school math word problems. The problems are distinctive because they require 2 to 8 steps to solve using basic arithmetic, and even the largest transformer models struggle to achieve high test performance on them. Solutions are provided in natural language with step-by-step reasoning.",
+        "data_type": "text",
+        "domains": [
+          "grade school mathematics",
+          "math word problems"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "Not specified"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2110.14168",
+          "https://huggingface.co/datasets/openai/gsm8k",
+          "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To diagnose the failures of current language models in robust multi-step mathematical reasoning and to support research, particularly in methods like training verifiers to judge solution correctness. It also aims to shed light on the properties of large language models' reasoning processes.",
+        "audience": [
+          "Researchers working on language model capabilities and mathematical reasoning"
+        ],
+        "tasks": [
+          "Solving grade school math word problems",
+          "Text generation for question answering"
+        ],
+        "limitations": "Even the largest models struggle with high test performance on this dataset, and autoregressive models have no mechanism to correct their own errors during solution generation.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The dataset was created by hiring freelance contractors via Upwork and then scaled using the NLP data labeling platform Surge AI. Problems and solutions were written by these contractors.",
+        "size": "8.5K (8,500) problems, with a size category of 10K<n<100K. The training set contains 7,473 examples and the test set contains 1,319 examples.",
+        "format": "parquet. The data is structured with a 'Problem:' field followed by a 'Solution:' field, where the solution includes step-by-step reasoning with intermediate calculations in special tags (e.g., `<<4*2=8>>`) and ends with a 'Final Answer:'.",
+        "annotation": "Contractors wrote the problems and solutions. For verification, different workers re-solved all problems to check agreement with the original solutions; problematic problems were either repaired or discarded. The annotators were from Surge AI."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated by generating step-by-step solutions to math word problems. The dataset provides two answer formats: a standard step-by-step solution and a solution structured with Socratic sub-questions.",
+          "The paper proposes a verification method where a separate verifier model is trained to judge the correctness of generated solutions. At test time, multiple candidate solutions are generated, and the one ranked highest by the verifier is selected."
+        ],
+        "metrics": [
+          "GSM8K"
+        ],
+        "calculation": "The GSM8K metric is a continuous score where higher values are better. It is described as 'EM on GSM8K', indicating it measures exact match accuracy.",
+        "interpretation": "Higher scores indicate better performance. The score is not bounded, but typical model performance ranges from low to high, with the highest reported score being 75.2.",
+        "baseline_results": "Paper baselines: The paper notes that even the largest transformer models fail to achieve high test performance, but does not report specific scores. EEE results: Llama 3.1 8B Instruct scored 75.2, and Yi 34B scored 0.648 on GSM8K.",
+        "validation": "The paper provides empirical evidence that the verification method scales more effectively with data than a finetuning baseline and remains effective even with a verifier much smaller than the generator."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "MIT License",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Reproducibility",
+          "description": [
+            "Replicating agent behavior or output can be impacted by changes or updates made to external services and tools. This impact is increased if the agent is built with generative AI."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/reproducibility-agentic.html"
+        },
+        {
+          "category": "Incomplete advice",
+          "description": [
+            "When a model provides advice without having enough information, resulting in possible harm if the advice is followed."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/incomplete-advice.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "benchmark_details.similar_benchmarks",
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T15:37:16.459776",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "LegalBench": {
+      "benchmark_details": {
+        "name": "LEGALBENCH",
+        "overview": "LEGALBENCH is a benchmark designed to measure the legal reasoning capabilities of large language models. It comprises 162 tasks collaboratively constructed and hand-crafted by legal professionals, covering six distinct types of legal reasoning.",
+        "data_type": "text",
+        "domains": [
+          "legal",
+          "law",
+          "finance"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "GLUE",
+          "HELM",
+          "BigBench",
+          "RAFT"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2308.11462",
+          "https://huggingface.co/datasets/nguha/legalbench",
+          "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To enable greater study of what types of legal reasoning large language models (LLMs) can perform.",
+        "audience": [
+          "Practitioners (to integrate LLMs into workflows)",
+          "Legal academics",
+          "Computer scientists"
+        ],
+        "tasks": [
+          "Text classification",
+          "Question answering",
+          "Text generation",
+          "Rule-application tasks"
+        ],
+        "limitations": "The tasks do not generalize to all legal reasoning tasks or all types of legal documents, offering only a preliminary understanding of LLM performance.",
+        "out_of_scope_uses": [
+          "Predicting the legality of real-world events",
+          "Predicting the outcome of lawsuits",
+          "Providing legal advice"
+        ]
+      },
+      "data": {
+        "source": "Data is drawn from three categories: existing publicly available datasets and corpora (some reformatted), datasets previously created by legal professionals but not released, and tasks developed specifically for LegalBench. The tasks originate from 36 distinct corpora.",
+        "size": "The benchmark comprises 162 tasks. The distribution of tasks by sample count is: 28 tasks have 50-100 samples, 97 have 100-500 samples, 29 have 500-2000 samples, and 8 have 2000+ samples. The overall dataset falls into the size category of 10,000 to 100,000 examples.",
+        "format": "Examples are presented in a structured format with fields such as 'Task name', 'Question', 'Options', and 'Answer'.",
+        "annotation": "Annotation procedures are task-dependent. For certain tasks, each data point was manually validated by a law-trained expert. Detailed annotation methodology for each task is documented in a separate section of the paper."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated in a few-shot setting. Train splits consist of a small random sample of between 2 to 8 instances to capture a true few-shot learning scenario.",
+          "For rule-application tasks, a law-trained expert manually validates each model generation."
+        ],
+        "metrics": [
+          "LegalBench",
+          "Correctness",
+          "Analysis"
+        ],
+        "calculation": "The primary benchmark metric is Exact Match (EM) on LegalBench. For rule-application tasks, two separate metrics are computed: 'correctness' (the proportion of generations without errors) and 'analysis'.",
+        "interpretation": "Higher scores on the LegalBench metric indicate better performance. The metric is continuous and lower scores are not better.",
+        "baseline_results": "The original paper evaluated 20 LLMs from 11 different families but did not provide specific scores. In a separate evaluation suite, the Yi 34B model achieved a score of 0.618.",
+        "validation": "For rule-application tasks, a law-trained expert manually validated each model generation. For datasets reused or adapted from other sources, the original data sheets document any redactions or missing data."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "For tasks that reuse or adapt existing datasets, the benchmark refers to the original data sheets for details on any data redactions or missing information.",
+        "data_licensing": "other",
+        "consent_procedures": "Not specified.",
+        "compliance_with_regulations": "The benchmark includes a section for each task intended to provide information relevant to ethical review processes, but specific details are not provided in the available facts."
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "ethical_and_legal_considerations.consent_procedures"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T12:59:10.203815",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "MedQA": {
+      "benchmark_details": {
+        "name": "MEDQA",
+        "overview": "MEDQA is a free-form multiple-choice open-domain question answering (OpenQA) benchmark designed to measure a model's ability to solve medical problems. It is distinctive as the first such dataset sourced from professional medical board exams, covering multiple languages and presenting a challenging real-world scenario.",
+        "data_type": "text",
+        "domains": [
+          "medical knowledge",
+          "professional medical exams"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "ARC",
+          "OpenBookQA"
+        ],
+        "resources": [
+          "https://github.com/jind11/MedQA",
+          "https://arxiv.org/abs/2009.13081",
+          "https://huggingface.co/datasets/GBaker/MedQA-USMLE-4-options",
+          "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To present a challenging open-domain question answering dataset to promote the development of stronger models capable of handling sophisticated real-world medical scenarios, specifically evaluating performance on medical knowledge as tested in professional exams.",
+        "audience": [
+          "The natural language processing (NLP) community"
+        ],
+        "tasks": [
+          "Free-form multiple-choice question answering",
+          "Open-domain question answering"
+        ],
+        "limitations": "Even the best current methods achieve relatively low accuracy (36.7% to 70.1% across languages), indicating the benchmark's difficulty and the limitations of existing models.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The data is collected from professional medical board exams.",
+        "size": "The dataset contains 12,723 questions in English, 34,251 in simplified Chinese, and 14,123 in traditional Chinese. The total number of examples falls within the 10K to 100K range.",
+        "format": "JSON",
+        "annotation": "The answer labels are the correct answers from the professional exams. No additional annotation process is described."
+      },
+      "methodology": {
+        "methods": [
+          "The benchmark uses a sequential combination of a document retriever and a machine comprehension model. It includes both rule-based and neural methods.",
+          "The evaluation is a standard question-answering task, though the specific learning setting (e.g., zero-shot, few-shot, fine-tuning) is not explicitly defined."
+        ],
+        "metrics": [
+          "Accuracy"
+        ],
+        "calculation": "The overall score is the accuracy on the test set.",
+        "interpretation": "Higher accuracy indicates better performance. The best reported accuracies are 36.7% for English, 42.0% for traditional Chinese, and 70.1% for simplified Chinese questions.",
+        "baseline_results": "Original paper baselines: The best method reported achieves 36.7% accuracy on English, 42.0% on traditional Chinese, and 70.1% on simplified Chinese questions. Model names are not specified. EEE results: Yi 34B achieves a score of 0.656 (65.6%).",
+        "validation": "Not specified"
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "Creative Commons Attribution 4.0",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Uncertain data provenance",
+          "description": [
+            "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "methodology.validation",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T13:23:29.822123",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    }
+  },
   "models": [
     {
       "model_id": "01-ai/yi-34b",
@@ -980,7 +1322,7 @@
         "OpenbookQA": 0.912,
         "MMLU": 0.659,
         "MATH": 0.703,
-        "GSM8K": -1.0,
+        "GSM8K": -1,
         "LegalBench": 0.584,
         "MedQA": 0.672,
         "WMT 2014": 0.154
@@ -1548,4 +1890,4 @@
       }
     }
   ]
-}
+}

data/benchmarks/helm_mmlu.json

@@ -1,4 +1,117 @@
 {
+  "benchmark_cards": {
+    "MMLU All Subjects": {
+      "benchmark_details": {
+        "name": "Measuring Massive Multitask Language Understanding (MMLU)",
+        "overview": "MMLU is a multiple-choice question-answering benchmark that measures a text model's multitask accuracy across 57 distinct tasks. It is designed to test a wide range of knowledge and problem-solving abilities, covering diverse academic and professional subjects from elementary to advanced levels.",
+        "data_type": "text",
+        "domains": [
+          "STEM",
+          "humanities",
+          "social sciences"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "GLUE",
+          "SuperGLUE"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2009.03300",
+          "https://huggingface.co/datasets/cais/mmlu",
+          "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json",
+          "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To bridge the gap between the wide-ranging knowledge models acquire during pretraining and existing evaluation measures by assessing models across a diverse set of academic and professional subjects.",
+        "audience": [
+          "Researchers analyzing model capabilities and identifying shortcomings"
+        ],
+        "tasks": [
+          "Multiple-choice question answering"
+        ],
+        "limitations": "Models exhibit lopsided performance, frequently do not know when they are wrong, and have near-random accuracy on some socially important subjects like morality and law.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The dataset is an original source with expert-generated questions.",
+        "size": "The dataset contains over 100,000 examples, with a test split of 14,042 examples, a validation split of 1,531 examples, a dev split of 285 examples, and an auxiliary training split of 99,842 examples.",
+        "format": "parquet",
+        "annotation": "The dataset has no additional annotations; each question provides the correct answer as a class label (A, B, C, or D)."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated exclusively in zero-shot and few-shot settings to measure knowledge acquired during pretraining."
+        ],
+        "metrics": [
+          "MMLU (accuracy)"
+        ],
+        "calculation": "The overall score is an average accuracy across the 57 tasks.",
+        "interpretation": "Higher scores indicate better performance. Near random-chance accuracy indicates weak performance. The very largest GPT-3 model improved over random chance by almost 20 percentage points on average, but models still need substantial improvements to reach expert-level accuracy.",
+        "baseline_results": "Paper baselines: Most recent models have near random-chance accuracy. The very largest GPT-3 model improved over random chance by almost 20 percentage points on average. EEE results: Yi 34B scored 0.6500, Anthropic-LM v4-s3 52B scored 0.4810. The mean score across 2 evaluated models is 0.5655.",
+        "validation": "Not specified"
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "MIT License",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "methodology.validation",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T13:14:49.605975",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    }
+  },
   "models": [
     {
       "model_id": "01-ai/yi-34b",
@@ -427,7 +540,7 @@
         "Sociology": 0.846,
         "Virology": 0.524,
         "World Religions": 0.825,
-        "Mean win rate": 1.0
+        "Mean win rate": 1
       }
     },
     {
@@ -3398,4 +3511,4 @@
       }
     }
   ]
-}
+}

data/benchmarks/hfopenllm_v2.json

@@ -1,4 +1,588 @@
 {
+  "benchmark_cards": {
+    "IFEval": {
+      "benchmark_details": {
+        "name": "Instruction-Following Eval (IFEval)",
+        "overview": "IFEval is a benchmark that measures the ability of large language models to follow natural language instructions. It focuses specifically on 'verifiable instructions'—instructions that can be objectively checked, such as word count requirements or keyword mentions. It is distinctive for providing a straightforward, reproducible, and automatic evaluation that avoids the subjectivity of human judgment and the bias of model-based assessment.",
+        "data_type": "text",
+        "domains": [
+          "instruction following"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "Not specified"
+        ],
+        "resources": [
+          "https://github.com/google-research/google-research/tree/master/instruction_following_eval",
+          "https://arxiv.org/abs/2311.07911",
+          "https://huggingface.co/datasets/google/IFEval",
+          "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To provide a standardized, objective, and reproducible method for evaluating the instruction-following capability of large language models.",
+        "audience": [
+          "Researchers evaluating large language models"
+        ],
+        "tasks": [
+          "Text generation",
+          "Following verifiable instructions (e.g., word counts, formatting rules, keyword mentions)"
+        ],
+        "limitations": "The benchmark is limited to verifiable instructions and does not support multi-modal use cases, such as generating images. The current implementation is acknowledged to have room for improvement.",
+        "out_of_scope_uses": [
+          "Evaluating subjective or ambiguous instructions (e.g., 'write with a funny tone')"
+        ]
+      },
+      "data": {
+        "source": "The data consists of constructed prompts, as described in the research paper. The specific source material for the prompt content is not specified.",
+        "size": "Approximately 500 prompts, with a train split containing 541 prompts. No information is provided about development or test splits.",
+        "format": "JSON",
+        "annotation": "The prompts contain verifiable instructions, meaning compliance can be checked automatically via predefined rules (e.g., word counting). No human annotation process is described."
+      },
+      "methodology": {
+        "methods": [
+          "Automatic and objective verification of whether the model's output follows the verifiable instructions in the prompt.",
+          "Zero-shot evaluation setup."
+        ],
+        "metrics": [
+          "IFEval"
+        ],
+        "calculation": "Not specified",
+        "interpretation": "Higher scores indicate better performance.",
+        "baseline_results": "Paper baseline: Results for two widely available LLMs are reported, but specific model names and scores are not provided. EEE results: OLMo 2 32B Instruct March 2025 scored 0.7800; YiSM-blossom5.1-34B-SLERP scored 0.5033. Mean score across 2 models is 0.6417.",
+        "validation": "Quality assurance relies on the objective verifiability of the instructions. No additional validation procedures are described."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "Apache License 2.0",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Reproducibility",
+          "description": [
+            "Replicating agent behavior or output can be impacted by changes or updates made to external services and tools. This impact is increased if the agent is built with generative AI."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/reproducibility-agentic.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "benchmark_details.similar_benchmarks",
+        "methodology.calculation",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T15:55:54.431294",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "GPQA": {
+      "benchmark_details": {
+        "name": "GPQA",
+        "overview": "GPQA (Graduate-Level Google-Proof Q&A Benchmark) is a text-based benchmark that measures the ability to answer extremely difficult, expert-level multiple-choice questions. It contains 448 questions designed to be 'Google-proof,' meaning they are hard to solve even with unrestricted web access. Its distinctiveness lies in its high difficulty for both highly skilled non-experts and state-of-the-art AI, making it suitable for scalable oversight experiments.",
+        "data_type": "tabular, text",
+        "domains": [
+          "biology",
+          "physics",
+          "chemistry",
+          "open domain qa",
+          "open book qa",
+          "multiple choice qa"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "DROP",
+          "Massive Multitask Language Understanding (MMLU)"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2311.12022",
+          "https://huggingface.co/datasets/Idavidrein/gpqa",
+          "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To create a testbed for scalable oversight, enabling the study of methods for humans to reliably supervise and extract truthful information from AI systems on questions that are very difficult for non-experts to answer or verify. It can also be used for general large language model capabilities benchmarking.",
+        "audience": [
+          "Researchers studying scalable oversight and AI alignment",
+          "Researchers interested in supervising AI systems that may surpass human capabilities in specialized domains"
+        ],
+        "tasks": [
+          "Multiple-choice question answering",
+          "Question answering",
+          "Text generation"
+        ],
+        "limitations": "The dataset is small, with 448 examples in the main set. There is a need for scalable oversight methods to overcome existing cognitive or ethical biases supervisors might have.",
+        "out_of_scope_uses": [
+          "Tasks where non-experts can easily find the answer using web search, as the questions are intended to be 'Google-proof'"
+        ]
+      },
+      "data": {
+        "source": "The questions were written and validated by domain experts with or pursuing PhDs in biology, physics, and chemistry, using an annotation pipeline where experts wrote questions and explanations and received detailed feedback from other experts.",
+        "size": "The main set contains 448 multiple-choice questions, with an extended set of 546 questions also mentioned. The dataset falls within the 1K<n<10K size category. The paper does not specify train, development, or test splits.",
+        "format": "The data is provided in CSV format and consists of multiple-choice questions, each with four answer choices, explanations, and references.",
+        "annotation": "Domain experts wrote the questions and explanations. Other expert validators provided feedback and 4-point difficulty ratings. Quality was assessed by comparing a sample to author-created 'gold-standard' labels, achieving 90% accuracy. Validation also involved experts from outside a question's domain attempting them with web access, which confirmed the questions' difficulty through low accuracy scores."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated in both closed-book (no runtime access to external information) and open-book (with access to an internet search tool) settings.",
+          "Prompting methods include zero-shot, few-shot, zero-shot chain-of-thought, and few-shot chain-of-thought."
+        ],
+        "metrics": [
+          "Accuracy (percentage of correct answers)"
+        ],
+        "calculation": "The overall score is the accuracy across the question set. Results are reported separately for the main set, extended set, and a 'Diamond Set'.",
+        "interpretation": "Higher accuracy indicates better performance. Expert human performance is benchmarked at 65% overall accuracy (or 74% when discounting clear mistakes). Non-expert human performance is 34%.",
+        "baseline_results": "PAPER baselines: On the main set, GPT-4 with few-shot chain-of-thought achieved 39.7% accuracy; GPT-4 with search achieved 41.0%; GPT-3.5-turbo-16k (zero-shot) achieved 29.8%; Llama-2-70B-chat (few-shot chain-of-thought) achieved 29.1%. Human expert accuracy was 65%, and non-expert accuracy was 34%. EEE results: YiSM-blossom5.1-34B-SLERP achieved 0.3557; OLMo 2 32B Instruct March 2025 achieved 0.2870.",
+        "validation": "Quality assurance involved expert validation and feedback. Gold-standard labels were created for a sample of 110 questions, achieving 90% annotator agreement. Expert validators also rated question difficulty."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "The dataset includes a canary string to aid in filtering it from training data, and distribution requires users to agree not to reveal examples in plain text or images online to prevent data leakage. No specific anonymization of the question content is described.",
+        "data_licensing": "Creative Commons Attribution 4.0",
+        "consent_procedures": "Non-expert validators were compensated with large bonuses for effort. The use of contractors is mentioned, but the specific platform and detailed compensation procedures for experts are not specified.",
+        "compliance_with_regulations": "No information is provided regarding IRB approval, GDPR compliance, or other ethical review."
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {
+        "methodology.metrics": "[Factuality Score: 0.09], low factual alignment with source material",
+        "methodology.calculation": "[Possible Hallucination], no supporting evidence found in source material",
+        "methodology.baseline_results": "[Possible Hallucination], no supporting evidence found in source material",
+        "methodology.validation": "[Possible Hallucination], no supporting evidence found in source material"
+      },
+      "missing_fields": [],
+      "card_info": {
+        "created_at": "2026-03-17T15:27:14.197081",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "MATH Level 5": {
+      "benchmark_details": {
+        "name": "MATH Level 5",
+        "overview": "MATH Level 5 is a benchmark that measures the mathematical problem-solving ability of machine learning models using challenging competition-level mathematics problems. It contains 12,500 problems, each with a full step-by-step solution, and is specifically focused on the hardest difficulty level (Level 5) within the dataset. Problems are presented in text, with diagrams for subjects like geometry specified using the Asymptote language.",
+        "data_type": "text",
+        "domains": [
+          "mathematics",
+          "explanation generation"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "DeepMind Mathematics Dataset",
+          "Metamath Theorem Proving"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2103.03874",
+          "https://huggingface.co/datasets/DigitalLearningGmbH/MATH-lighteval"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To measure the mathematical problem-solving ability of machine learning models, specifically evaluating their capacity to analyze problems, select appropriate heuristics, and chain them together to produce a final answer. The benchmark also aims to teach models to generate step-by-step derivations and explanations.",
+        "audience": [
+          "Machine learning researchers"
+        ],
+        "tasks": [
+          "Mathematical problem solving",
+          "Step-by-step solution generation",
+          "Final answer generation"
+        ],
+        "limitations": "Accuracy on the benchmark remains relatively low even with large Transformer models, and scaling model size alone appears impractical for achieving strong mathematical reasoning based on current trends, indicating it is a very challenging benchmark.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The data is sourced from high school mathematics competitions, including the AMC 10, AMC 12, and AIME.",
+        "size": "The full dataset contains 12,500 problems, with 7,500 for training and 5,000 for testing. The exact number of examples for the 'Level 5' subset is not specified.",
+        "format": "The data is stored in Parquet format. Each problem includes a full step-by-step solution in LaTeX and natural language, and the final answer is a unique normalized sequence.",
+        "annotation": "Problems are expert-generated, but the specific annotation process and quality control measures are not detailed."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated by generating a final answer for a given problem. The solution must contain the final answer enclosed in a `\\boxed{}` tag."
+        ],
+        "metrics": [
+          "MATH Level 5"
+        ],
+        "calculation": "The metric is an Exact Match score on MATH Level 5. The score is continuous, and higher values indicate better performance.",
+        "interpretation": "Higher scores indicate better performance. The score is continuous, and lower values are not better.",
+        "baseline_results": "Paper baselines: Not specified. Evaluation suite results: YiSM-blossom5.1-34B-SLERP achieved a score of 0.2153.",
+        "validation": "Not specified"
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "MIT License",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Lack of data transparency",
+          "description": [
+            "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation. "
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "methodology.validation",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T16:09:19.958535",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "MMLU-PRO": {
+      "benchmark_details": {
+        "name": "MMLU-Pro",
+        "overview": "MMLU-Pro is an enhanced version of the Massive Multitask Language Understanding benchmark designed to be more challenging and robust. It measures multi-task language understanding and reasoning capabilities by integrating more reasoning-focused questions, expanding answer choices from four to ten, and eliminating trivial or noisy questions found in its predecessor. It covers a broad range of subjects.",
+        "data_type": "tabular, text",
+        "domains": [
+          "STEM",
+          "humanities",
+          "social sciences",
+          "math",
+          "physics",
+          "chemistry",
+          "law",
+          "engineering",
+          "economics",
+          "health",
+          "psychology",
+          "business",
+          "biology",
+          "philosophy",
+          "computer science",
+          "history"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "MMLU"
+        ],
+        "resources": [
+          "https://arxiv.org/abs/2406.01574",
+          "https://huggingface.co/datasets/TIGER-Lab/MMLU-Pro",
+          "https://huggingface.co/spaces/TIGER-Lab/MMLU-Pro",
+          "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To provide a more challenging and discriminative benchmark for tracking progress in language model capabilities, testing deeper cognitive processes and reasoning as models plateau on existing benchmarks.",
+        "audience": [
+          "Researchers evaluating large language models"
+        ],
+        "tasks": [
+          "Multiple-choice question answering across a broad range of subjects"
+        ],
+        "limitations": "The dataset contains some mistakes and formatting inconsistencies, which the maintainers are correcting based on expert feedback.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The dataset is an enhanced version of MMLU, integrating more challenging questions from multiple sources. These include original MMLU questions (with trivial or ambiguous ones removed), hand-picked high-quality STEM problems from the internet, human-annotated questions requiring theorems from TheoremQA, and science questions from college exams via SciBench.",
+        "size": "The test split contains 12,032 examples, placing the dataset in the 10K to 100K size category. The total file size is 8,775,905 bytes.",
+        "format": "The data is stored in Parquet format and consists of multiple-choice questions, expanding the number of answer choices from four (as in MMLU) to ten.",
+        "annotation": "The annotation process involved expert review. Over ten experts scrutinized each question and its options to ensure challenge, comprehensiveness, accuracy, and fairness. Some answers were later corrected based on recommendations from specialists such as medical professionals."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated using multiple-choice question answering, typically with a 5-shot prompting setup, though some models use 0-shot.",
+          "Performance is tested using both direct answering and Chain-of-Thought (CoT) reasoning.",
+          "The benchmark tests performance under 24 different prompt styles."
+        ],
+        "metrics": [
+          "Accuracy (reported as a percentage or score)"
+        ],
+        "calculation": "The overall score is an average accuracy across subjects, but the specific calculation method is not detailed.",
+        "interpretation": "Higher scores indicate better performance. Performance on MMLU-Pro is significantly lower than on MMLU, indicating it is more challenging.",
+        "baseline_results": "PAPER baselines: GPT-4o achieves over 70% accuracy in Math and Physics subjects. Llama-3-70B-Instruct achieves an overall accuracy of 56.2%. Gemma-7B and Mistral-7B-v0.1 have lower performance (e.g., Mistral-7B-v0.1 scores just over 20% in Math and Physics). HF_README baselines: GPT-4o achieves an overall score of 0.7255 with CoT and 0.5346 with direct prompting. Other reported scores include Claude-3-Opus (0.6845), Claude-3-Sonnet (0.5511), Gemini 1.5 Flash (0.5912), and Llama-3-70B-Instruct (0.5620). EEE results: OLMo 2 32B Instruct March 2025 scored 0.4140.",
+        "validation": "The benchmark demonstrates greater stability under varying prompts, with sensitivity to prompt variations decreasing from 4-5% in MMLU to just 2% in MMLU-Pro."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "MIT License",
+        "consent_procedures": "Not specified",
+        "compliance_with_regulations": "Not specified"
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Uncertain data provenance",
+          "description": [
+            "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+        },
+        {
+          "category": "Data bias",
+          "description": [
+            "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {},
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity",
+        "ethical_and_legal_considerations.consent_procedures",
+        "ethical_and_legal_considerations.compliance_with_regulations"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T16:20:31.763989",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    },
+    "MUSR": {
+      "benchmark_details": {
+        "name": "MuSR",
+        "overview": "MuSR (Multistep Soft Reasoning) is a benchmark that measures the ability of language models to perform multistep soft reasoning based on natural language narratives. It combines sophisticated narratives with complex reasoning that requires commonsense knowledge and is not solvable by simple rule-based systems. The benchmark consists of three tasks: murder mysteries, object placements, and team allocations.",
+        "data_type": "text",
+        "domains": [
+          "reasoning",
+          "commonsense reasoning",
+          "planning"
+        ],
+        "languages": [
+          "English"
+        ],
+        "similar_benchmarks": [
+          "bAbI",
+          "BigTOM",
+          "ToMi",
+          "RuleTakers",
+          "ProntoQA",
+          "SocialIQA",
+          "StrategyQA"
+        ],
+        "resources": [
+          "https://github.com/Zayne-Sprague/MuSR",
+          "https://arxiv.org/abs/2310.16049",
+          "https://huggingface.co/datasets/TAUR-Lab/MuSR"
+        ]
+      },
+      "purpose_and_intended_users": {
+        "goal": "To evaluate and characterize the gaps in language models' abilities to perform robust, multistep reasoning in complex natural language settings, particularly testing the limits of techniques like chain-of-thought.",
+        "audience": [
+          "Researchers evaluating language models",
+          "Researchers evaluating neurosymbolic systems on reasoning capabilities"
+        ],
+        "tasks": [
+          "Question answering",
+          "Solving murder mysteries",
+          "Solving object placement problems",
+          "Solving team allocation problems"
+        ],
+        "limitations": "The benchmark instances are generated by GPT-4, which may lead to simple, poor-quality narratives with potential inconsistencies, though the paper argues they are valid test cases if the underlying information is faithfully preserved.",
+        "out_of_scope_uses": [
+          "Not specified"
+        ]
+      },
+      "data": {
+        "source": "The data is synthetically generated using a neurosymbolic synthetic-to-natural generation algorithm that employs GPT-4. The process begins with gold facts, constructs a reasoning tree, and iteratively generates a narrative.",
+        "size": "756 instances across three domains: 250 for Murder Mystery, 256 for Object Placements, and 250 for Team Allocations. The dataset is categorized as containing fewer than 1,000 examples (n<1K).",
+        "format": "CSV, containing free-text narratives (ranging from hundreds to roughly 1000 words in length) followed by a multiple-choice question.",
+        "annotation": "Answers are derived from the underlying gold facts used in generation. For validation, human annotators (7 total) solved instances using a chain-of-thought+ prompt, with instances triply-annotated (34-40 per domain). Human accuracy was very high, with the lowest average annotator score at 90% and majority vote accuracy between 94.1% and 100%."
+      },
+      "methodology": {
+        "methods": [
+          "Models are evaluated in zero-shot and single-shot (1-shot) settings.",
+          "Prompting strategies include single-shot prompting, chain-of-thought (CoT), and an engineered variant called CoT+.",
+          "Neurosymbolic algorithms like Program-Aided Language Models (PAL) and SymbolicTOM are also evaluated on compatible domains."
+        ],
+        "metrics": [
+          "MUSR (Accuracy)"
+        ],
+        "calculation": "Performance is measured as accuracy (percentage correct) for each of the three domains (MM, OP, TA) separately. The paper does not report a single aggregated score.",
+        "interpretation": "Higher accuracy indicates better performance. Human performance sets a high ceiling (ranging from 94.1% to 100% by majority vote), while random baselines are at or near chance (ranging from 24.6% to 50%).",
+        "baseline_results": "Paper baselines: Random baseline (MM: 50%, OP: 24.6%, TA: 33.3%), GPT-4 (80.4%, 60.9%, 68.4%), GPT-3.5 (61.6%, 46.9%, 40.4%), Llama2 70b Chat (48.8%, 42.2%, 44.8%), Llama2 7b Chat (50.8%, 29.3%, 36.8%), Vicuna 7b v1.5 (48.4%, 29.7%, 26.4%), Vicuna 13b v1.5 (50.8%, 34.4%, 32%), Vicuna 33b v1.3 (49.6%, 31.2%, 30%), Human Eval (94.1%, 95%, 100%). PAL results for Team Allocation outperform end-to-end models but are below human performance. EEE results: YiSM-blossom5.1-34B-SLERP achieved an accuracy of 0.4413.",
+        "validation": "The dataset is validated by measuring human annotator performance to ensure the narratives support the intended reasoning. Rule-based baselines (e.g., picking the suspect with the longest chapter) are used as sanity checks and perform near random chance, confirming the tasks are not trivially solvable."
+      },
+      "ethical_and_legal_considerations": {
+        "privacy_and_anonymity": "Not specified",
+        "data_licensing": "Creative Commons Attribution 4.0",
+        "consent_procedures": "Annotation was performed by three hired undergraduate students. No details on compensation or the hiring platform are provided.",
+        "compliance_with_regulations": "The research received support from NSF, DARPA, and the Air Force Research Laboratory. No mention of IRB approval or other specific regulatory compliance is made."
+      },
+      "possible_risks": [
+        {
+          "category": "Over- or under-reliance",
+          "description": [
+            "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+        },
+        {
+          "category": "Unrepresentative data",
+          "description": [
+            "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+        },
+        {
+          "category": "Data contamination",
+          "description": [
+            "Data contamination occurs when incorrect data is used for training. For example, data that is not aligned with model's purpose or data that is already set aside for other development tasks such as testing and evaluation."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-contamination.html"
+        },
+        {
+          "category": "Reproducibility",
+          "description": [
+            "Replicating agent behavior or output can be impacted by changes or updates made to external services and tools. This impact is increased if the agent is built with generative AI."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/reproducibility-agentic.html"
+        },
+        {
+          "category": "Improper usage",
+          "description": [
+            "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+          ],
+          "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+        }
+      ],
+      "flagged_fields": {
+        "methodology.calculation": "[Possible Hallucination], no supporting evidence found in source material",
+        "methodology.baseline_results": "[Possible Hallucination], no supporting evidence found in source material",
+        "methodology.validation": "[Factuality Score: 0.17], low factual alignment with source material"
+      },
+      "missing_fields": [
+        "purpose_and_intended_users.out_of_scope_uses",
+        "ethical_and_legal_considerations.privacy_and_anonymity"
+      ],
+      "card_info": {
+        "created_at": "2026-03-17T12:25:43.235734",
+        "llm": "deepseek-ai/DeepSeek-V3.2"
+      }
+    }
+  },
   "models": [
     {
       "model_id": "0-hero/Matter-0.2-7B-DPO",
@@ -839,7 +1423,7 @@
       "scores": {
         "IFEval": 0.1467,
         "BBH": 0.2704,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2525,
         "MUSR": 0.3605,
         "MMLU-PRO": 0.1123
@@ -878,7 +1462,7 @@
       "scores": {
         "IFEval": 0.1467,
         "BBH": 0.2704,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2525,
         "MUSR": 0.3605,
         "MMLU-PRO": 0.1123
@@ -1138,7 +1722,7 @@
       "scores": {
         "IFEval": 0.1374,
         "BBH": 0.2834,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2458,
         "MUSR": 0.3552,
         "MMLU-PRO": 0.1117
@@ -1671,7 +2255,7 @@
       "scores": {
         "IFEval": 0.1751,
         "BBH": 0.293,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2374,
         "MUSR": 0.3499,
         "MMLU-PRO": 0.1112
@@ -1775,7 +2359,7 @@
       "scores": {
         "IFEval": 0.2049,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1168
@@ -3998,7 +4582,7 @@
       "scores": {
         "IFEval": 0.2497,
         "BBH": 0.2817,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2441,
         "MUSR": 0.3578,
         "MMLU-PRO": 0.1085
@@ -4011,7 +4595,7 @@
       "scores": {
         "IFEval": 0.1507,
         "BBH": 0.293,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2534,
         "MUSR": 0.3565,
         "MMLU-PRO": 0.1125
@@ -5233,7 +5817,7 @@
       "scores": {
         "IFEval": 0.1778,
         "BBH": 0.287,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2475,
         "MUSR": 0.3447,
         "MMLU-PRO": 0.111
@@ -7846,7 +8430,7 @@
       "scores": {
         "IFEval": 0.1592,
         "BBH": 0.2906,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2492,
         "MUSR": 0.3286,
         "MMLU-PRO": 0.1111
@@ -8574,7 +9158,7 @@
       "scores": {
         "IFEval": 0.7628,
         "BBH": 0.5098,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2802,
         "MUSR": 0.4579,
         "MMLU-PRO": 0.4033
@@ -8730,7 +9314,7 @@
       "scores": {
         "IFEval": 0.288,
         "BBH": 0.5154,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3247,
         "MUSR": 0.408,
         "MMLU-PRO": 0.3817
@@ -8899,7 +9483,7 @@
       "scores": {
         "IFEval": 0.1869,
         "BBH": 0.2913,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3738,
         "MMLU-PRO": 0.1123
@@ -8938,7 +9522,7 @@
       "scores": {
         "IFEval": 0.1575,
         "BBH": 0.4196,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2936,
         "MUSR": 0.3116,
         "MMLU-PRO": 0.19
@@ -9224,7 +9808,7 @@
       "scores": {
         "IFEval": 0.1697,
         "BBH": 0.2877,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2492,
         "MUSR": 0.3751,
         "MMLU-PRO": 0.1101
@@ -9235,9 +9819,9 @@
       "name": "BgGPT-Gemma-2-27B-IT-v1.0",
       "developer": "INSAIT-Institute",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1167
@@ -9354,7 +9938,7 @@
       "scores": {
         "IFEval": 0.1409,
         "BBH": 0.2791,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2441,
         "MUSR": 0.3738,
         "MMLU-PRO": 0.1109
@@ -12617,7 +13201,7 @@
       "scores": {
         "IFEval": 0.1351,
         "BBH": 0.2828,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2559,
         "MUSR": 0.3526,
         "MMLU-PRO": 0.1128
@@ -12630,7 +13214,7 @@
       "scores": {
         "IFEval": 0.1354,
         "BBH": 0.2811,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2643,
         "MUSR": 0.3579,
         "MMLU-PRO": 0.1105
@@ -12643,7 +13227,7 @@
       "scores": {
         "IFEval": 0.1354,
         "BBH": 0.2827,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2609,
         "MUSR": 0.3619,
         "MMLU-PRO": 0.1094
@@ -12708,7 +13292,7 @@
       "scores": {
         "IFEval": 0.1395,
         "BBH": 0.2779,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2483,
         "MUSR": 0.3447,
         "MMLU-PRO": 0.1115
@@ -13683,7 +14267,7 @@
       "scores": {
         "IFEval": 0.1153,
         "BBH": 0.2868,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2458,
         "MUSR": 0.3698,
         "MMLU-PRO": 0.1108
@@ -15410,9 +15994,9 @@
       "name": "naps-gemma-2-27b-v-0.1.0",
       "developer": "NAPS-ai",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1168
@@ -15423,9 +16007,9 @@
       "name": "naps-gemma-2-27b-v0.1.0",
       "developer": "NAPS-ai",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1168
@@ -15490,7 +16074,7 @@
       "scores": {
         "IFEval": 0.1845,
         "BBH": 0.3041,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2391,
         "MUSR": 0.3486,
         "MMLU-PRO": 0.1099
@@ -15516,7 +16100,7 @@
       "scores": {
         "IFEval": 0.1881,
         "BBH": 0.2178,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2064,
         "MUSR": 0.3538,
         "MMLU-PRO": 0.1163
@@ -16335,7 +16919,7 @@
       "scores": {
         "IFEval": 0.1808,
         "BBH": 0.2815,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2559,
         "MUSR": 0.375,
         "MMLU-PRO": 0.1143
@@ -16348,7 +16932,7 @@
       "scores": {
         "IFEval": 0.1749,
         "BBH": 0.2602,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2458,
         "MUSR": 0.338,
         "MMLU-PRO": 0.1125
@@ -17089,7 +17673,7 @@
       "scores": {
         "IFEval": 0.0257,
         "BBH": 0.292,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.25,
         "MUSR": 0.3511,
         "MMLU-PRO": 0.1162
@@ -17128,7 +17712,7 @@
       "scores": {
         "IFEval": 0.203,
         "BBH": 0.2936,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2576,
         "MUSR": 0.3619,
         "MMLU-PRO": 0.1111
@@ -17193,7 +17777,7 @@
       "scores": {
         "IFEval": 0.2254,
         "BBH": 0.275,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2576,
         "MUSR": 0.3762,
         "MMLU-PRO": 0.1123
@@ -17219,7 +17803,7 @@
       "scores": {
         "IFEval": 0.0233,
         "BBH": 0.3092,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3314,
         "MMLU-PRO": 0.1138
@@ -18129,7 +18713,7 @@
       "scores": {
         "IFEval": 0.1757,
         "BBH": 0.274,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.25,
         "MUSR": 0.3753,
         "MMLU-PRO": 0.112
@@ -18140,7 +18724,7 @@
       "name": "INTELLECT-1-Instruct",
       "developer": "PrimeIntellect",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.287,
         "MATH Level 5": 0.0227,
         "GPQA": 0.2483,
@@ -18155,7 +18739,7 @@
       "scores": {
         "IFEval": 0.2282,
         "BBH": 0.2877,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3484,
         "MMLU-PRO": 0.1123
@@ -19455,7 +20039,7 @@
       "scores": {
         "IFEval": 0.3071,
         "BBH": 0.3341,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2576,
         "MUSR": 0.3329,
         "MMLU-PRO": 0.1697
@@ -19819,7 +20403,7 @@
       "scores": {
         "IFEval": 0.1897,
         "BBH": 0.2876,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2492,
         "MUSR": 0.3948,
         "MMLU-PRO": 0.1078
@@ -19975,7 +20559,7 @@
       "scores": {
         "IFEval": 0.0932,
         "BBH": 0.2977,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2475,
         "MUSR": 0.3941,
         "MMLU-PRO": 0.1157
@@ -19988,7 +20572,7 @@
       "scores": {
         "IFEval": 0.0858,
         "BBH": 0.2929,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2483,
         "MUSR": 0.3981,
         "MMLU-PRO": 0.1285
@@ -20742,7 +21326,7 @@
       "scores": {
         "IFEval": 0.1545,
         "BBH": 0.2945,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2391,
         "MUSR": 0.3711,
         "MMLU-PRO": 0.116
@@ -20794,7 +21378,7 @@
       "scores": {
         "IFEval": 0.1809,
         "BBH": 0.2881,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2433,
         "MUSR": 0.3872,
         "MMLU-PRO": 0.109
@@ -22211,7 +22795,7 @@
       "scores": {
         "IFEval": 0.208,
         "BBH": 0.292,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3499,
         "MMLU-PRO": 0.1167
@@ -22224,7 +22808,7 @@
       "scores": {
         "IFEval": 0.1407,
         "BBH": 0.2769,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2634,
         "MUSR": 0.3218,
         "MMLU-PRO": 0.1112
@@ -22250,7 +22834,7 @@
       "scores": {
         "IFEval": 0.0656,
         "BBH": 0.3568,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2676,
         "MUSR": 0.3805,
         "MMLU-PRO": 0.1672
@@ -22302,7 +22886,7 @@
       "scores": {
         "IFEval": 0.1828,
         "BBH": 0.2828,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.229,
         "MUSR": 0.31,
         "MMLU-PRO": 0.1144
@@ -22315,7 +22899,7 @@
       "scores": {
         "IFEval": 0.1815,
         "BBH": 0.2297,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2315,
         "MUSR": 0.3445,
         "MMLU-PRO": 0.116
@@ -23056,7 +23640,7 @@
       "scores": {
         "IFEval": 0.1426,
         "BBH": 0.5528,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3163,
         "MUSR": 0.4386,
         "MMLU-PRO": 0.4145
@@ -23067,9 +23651,9 @@
       "name": "glm-4-9b-chat",
       "developer": "THUDM",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.4736,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3138,
         "MUSR": 0.3994,
         "MMLU-PRO": 0.3167
@@ -23080,9 +23664,9 @@
       "name": "glm-4-9b-chat-1m",
       "developer": "THUDM",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.418,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3037,
         "MUSR": 0.3795,
         "MMLU-PRO": 0.3163
@@ -23823,7 +24407,7 @@
       "scores": {
         "IFEval": 0.1751,
         "BBH": 0.2643,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2106,
         "MUSR": 0.3128,
         "MMLU-PRO": 0.1173
@@ -24031,7 +24615,7 @@
       "scores": {
         "IFEval": 0.1879,
         "BBH": 0.3017,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.224,
         "MUSR": 0.3684,
         "MMLU-PRO": 0.1164
@@ -24148,7 +24732,7 @@
       "scores": {
         "IFEval": 0.1879,
         "BBH": 0.4462,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.281,
         "MUSR": 0.3627,
         "MMLU-PRO": 0.2318
@@ -25292,7 +25876,7 @@
       "scores": {
         "IFEval": 0.185,
         "BBH": 0.2913,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.3497,
         "MMLU-PRO": 0.1166
@@ -25435,7 +26019,7 @@
       "scores": {
         "IFEval": 0.1273,
         "BBH": 0.2944,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2408,
         "MUSR": 0.3368,
         "MMLU-PRO": 0.1144
@@ -25838,7 +26422,7 @@
       "scores": {
         "IFEval": 0.1856,
         "BBH": 0.291,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2643,
         "MUSR": 0.3364,
         "MMLU-PRO": 0.1091
@@ -25903,7 +26487,7 @@
       "scores": {
         "IFEval": 0.207,
         "BBH": 0.3011,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2634,
         "MUSR": 0.3219,
         "MMLU-PRO": 0.111
@@ -25916,7 +26500,7 @@
       "scores": {
         "IFEval": 0.207,
         "BBH": 0.3011,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2634,
         "MUSR": 0.3219,
         "MMLU-PRO": 0.111
@@ -25981,7 +26565,7 @@
       "scores": {
         "IFEval": 0.167,
         "BBH": 0.2938,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2517,
         "MUSR": 0.3541,
         "MMLU-PRO": 0.1087
@@ -26046,7 +26630,7 @@
       "scores": {
         "IFEval": 0.1446,
         "BBH": 0.2817,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2433,
         "MUSR": 0.3697,
         "MMLU-PRO": 0.1095
@@ -26592,7 +27176,7 @@
       "scores": {
         "IFEval": 0.1746,
         "BBH": 0.3126,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.245,
         "MUSR": 0.4096,
         "MMLU-PRO": 0.1087
@@ -26735,7 +27319,7 @@
       "scores": {
         "IFEval": 0.1748,
         "BBH": 0.2883,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.3803,
         "MMLU-PRO": 0.1129
@@ -26969,7 +27553,7 @@
       "scores": {
         "IFEval": 0.167,
         "BBH": 0.295,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2567,
         "MUSR": 0.3764,
         "MMLU-PRO": 0.1082
@@ -27320,7 +27904,7 @@
       "scores": {
         "IFEval": 0.1815,
         "BBH": 0.3242,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2945,
         "MUSR": 0.3596,
         "MMLU-PRO": 0.331
@@ -27372,7 +27956,7 @@
       "scores": {
         "IFEval": 0.1943,
         "BBH": 0.6234,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3322,
         "MUSR": 0.4267,
         "MMLU-PRO": 0.4688
@@ -27593,7 +28177,7 @@
       "scores": {
         "IFEval": 0.1773,
         "BBH": 0.2892,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.343,
         "MMLU-PRO": 0.1169
@@ -27684,7 +28268,7 @@
       "scores": {
         "IFEval": 0.1706,
         "BBH": 0.3607,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2911,
         "MUSR": 0.3911,
         "MMLU-PRO": 0.1723
@@ -27697,7 +28281,7 @@
       "scores": {
         "IFEval": 0.1645,
         "BBH": 0.3597,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2852,
         "MUSR": 0.4082,
         "MMLU-PRO": 0.1647
@@ -27762,7 +28346,7 @@
       "scores": {
         "IFEval": 0.1884,
         "BBH": 0.6129,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3196,
         "MUSR": 0.4451,
         "MMLU-PRO": 0.4589
@@ -27775,7 +28359,7 @@
       "scores": {
         "IFEval": 0.1758,
         "BBH": 0.2757,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2357,
         "MUSR": 0.3209,
         "MMLU-PRO": 0.1114
@@ -27788,7 +28372,7 @@
       "scores": {
         "IFEval": 0.1913,
         "BBH": 0.2942,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.362,
         "MMLU-PRO": 0.1168
@@ -28048,7 +28632,7 @@
       "scores": {
         "IFEval": 0.1879,
         "BBH": 0.2969,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2626,
         "MUSR": 0.3633,
         "MMLU-PRO": 0.1168
@@ -28074,7 +28658,7 @@
       "scores": {
         "IFEval": 0.1754,
         "BBH": 0.2874,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2492,
         "MUSR": 0.3524,
         "MMLU-PRO": 0.1128
@@ -28113,7 +28697,7 @@
       "scores": {
         "IFEval": 0.1639,
         "BBH": 0.2827,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2584,
         "MUSR": 0.3857,
         "MMLU-PRO": 0.1095
@@ -28126,7 +28710,7 @@
       "scores": {
         "IFEval": 0.2009,
         "BBH": 0.3215,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2743,
         "MUSR": 0.3843,
         "MMLU-PRO": 0.108
@@ -28152,7 +28736,7 @@
       "scores": {
         "IFEval": 0.1697,
         "BBH": 0.4063,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2827,
         "MUSR": 0.3501,
         "MMLU-PRO": 0.1981
@@ -28217,7 +28801,7 @@
       "scores": {
         "IFEval": 0.1921,
         "BBH": 0.3252,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2374,
         "MUSR": 0.375,
         "MMLU-PRO": 0.1088
@@ -28230,7 +28814,7 @@
       "scores": {
         "IFEval": 0.1742,
         "BBH": 0.3794,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3062,
         "MUSR": 0.394,
         "MMLU-PRO": 0.198
@@ -28943,9 +29527,9 @@
       "name": "GRAG-NEMO-12B-ORPO-HESSIAN-AI",
       "developer": "avemio",
       "scores": {
-        "IFEval": 0.0,
+        "IFEval": 0,
         "BBH": 0.2607,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.3447,
         "MMLU-PRO": 0.1061
@@ -29634,7 +30218,7 @@
       "scores": {
         "IFEval": 0.1813,
         "BBH": 0.336,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.25,
         "MUSR": 0.3497,
         "MMLU-PRO": 0.1445
@@ -30076,7 +30660,7 @@
       "scores": {
         "IFEval": 0.1579,
         "BBH": 0.2962,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2517,
         "MUSR": 0.3846,
         "MMLU-PRO": 0.1146
@@ -30856,7 +31440,7 @@
       "scores": {
         "IFEval": 0.1829,
         "BBH": 0.2874,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.3674,
         "MMLU-PRO": 0.11
@@ -31233,7 +31817,7 @@
       "scores": {
         "IFEval": 0.1123,
         "BBH": 0.2875,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2466,
         "MUSR": 0.3938,
         "MMLU-PRO": 0.1135
@@ -31766,7 +32350,7 @@
       "scores": {
         "IFEval": 0.1706,
         "BBH": 0.2947,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3686,
         "MMLU-PRO": 0.1167
@@ -31779,7 +32363,7 @@
       "scores": {
         "IFEval": 0.1916,
         "BBH": 0.2977,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2685,
         "MUSR": 0.3872,
         "MMLU-PRO": 0.1132
@@ -32806,7 +33390,7 @@
       "scores": {
         "IFEval": 0.1715,
         "BBH": 0.5463,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.3406,
         "MUSR": 0.3555,
         "MMLU-PRO": 0.3947
@@ -33105,7 +33689,7 @@
       "scores": {
         "IFEval": 0.2019,
         "BBH": 0.2868,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3566,
         "MMLU-PRO": 0.1065
@@ -33118,7 +33702,7 @@
       "scores": {
         "IFEval": 0.1979,
         "BBH": 0.2698,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2466,
         "MUSR": 0.3593,
         "MMLU-PRO": 0.1041
@@ -33196,7 +33780,7 @@
       "scores": {
         "IFEval": 0.1752,
         "BBH": 0.2906,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2399,
         "MUSR": 0.3512,
         "MMLU-PRO": 0.1126
@@ -33820,7 +34404,7 @@
       "scores": {
         "IFEval": 0.125,
         "BBH": 0.2867,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2483,
         "MUSR": 0.3487,
         "MMLU-PRO": 0.1098
@@ -33833,7 +34417,7 @@
       "scores": {
         "IFEval": 0.1411,
         "BBH": 0.2924,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2525,
         "MUSR": 0.3541,
         "MMLU-PRO": 0.1101
@@ -33885,7 +34469,7 @@
       "scores": {
         "IFEval": 0.1373,
         "BBH": 0.2949,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2508,
         "MUSR": 0.3698,
         "MMLU-PRO": 0.1118
@@ -34782,7 +35366,7 @@
       "scores": {
         "IFEval": 0.1718,
         "BBH": 0.2766,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2424,
         "MUSR": 0.3857,
         "MMLU-PRO": 0.1123
@@ -34795,7 +35379,7 @@
       "scores": {
         "IFEval": 0.196,
         "BBH": 0.3047,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2643,
         "MUSR": 0.3795,
         "MMLU-PRO": 0.112
@@ -34808,7 +35392,7 @@
       "scores": {
         "IFEval": 0.2358,
         "BBH": 0.2959,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2416,
         "MUSR": 0.3689,
         "MMLU-PRO": 0.1089
@@ -34873,7 +35457,7 @@
       "scores": {
         "IFEval": 0.1585,
         "BBH": 0.2876,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.25,
         "MUSR": 0.3517,
         "MMLU-PRO": 0.1098
@@ -35861,7 +36445,7 @@
       "scores": {
         "IFEval": 0.2049,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1167
@@ -37382,7 +37966,7 @@
       "scores": {
         "IFEval": 0.1028,
         "BBH": 0.2941,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2567,
         "MUSR": 0.3528,
         "MMLU-PRO": 0.1141
@@ -37577,7 +38161,7 @@
       "scores": {
         "IFEval": 0.1572,
         "BBH": 0.2863,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2592,
         "MUSR": 0.3607,
         "MMLU-PRO": 0.1169
@@ -40281,7 +40865,7 @@
       "scores": {
         "IFEval": 0.1416,
         "BBH": 0.2989,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2525,
         "MUSR": 0.3475,
         "MMLU-PRO": 0.1094
@@ -40853,7 +41437,7 @@
       "scores": {
         "IFEval": 0.2145,
         "BBH": 0.4283,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2961,
         "MUSR": 0.4979,
         "MMLU-PRO": 0.2414
@@ -41295,7 +41879,7 @@
       "scores": {
         "IFEval": 0.1778,
         "BBH": 0.3056,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2517,
         "MUSR": 0.3883,
         "MMLU-PRO": 0.1126
@@ -41685,7 +42269,7 @@
       "scores": {
         "IFEval": 0.1564,
         "BBH": 0.2894,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2626,
         "MUSR": 0.3789,
         "MMLU-PRO": 0.1169
@@ -42218,7 +42802,7 @@
       "scores": {
         "IFEval": 0.0705,
         "BBH": 0.3449,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2668,
         "MUSR": 0.3631,
         "MMLU-PRO": 0.1679
@@ -42595,7 +43179,7 @@
       "scores": {
         "IFEval": 0.2018,
         "BBH": 0.3282,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2643,
         "MUSR": 0.4123,
         "MMLU-PRO": 0.1472
@@ -42972,7 +43556,7 @@
       "scores": {
         "IFEval": 0.166,
         "BBH": 0.3068,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2542,
         "MUSR": 0.3538,
         "MMLU-PRO": 0.108
@@ -42998,7 +43582,7 @@
       "scores": {
         "IFEval": 0.1504,
         "BBH": 0.295,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2609,
         "MUSR": 0.4031,
         "MMLU-PRO": 0.1126
@@ -43011,7 +43595,7 @@
       "scores": {
         "IFEval": 0.1597,
         "BBH": 0.31,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2567,
         "MUSR": 0.4017,
         "MMLU-PRO": 0.1157
@@ -43908,7 +44492,7 @@
       "scores": {
         "IFEval": 0.1479,
         "BBH": 0.3014,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2542,
         "MUSR": 0.4287,
         "MMLU-PRO": 0.1119
@@ -44870,7 +45454,7 @@
       "scores": {
         "IFEval": 0.2273,
         "BBH": 0.2865,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2492,
         "MUSR": 0.3445,
         "MMLU-PRO": 0.1168
@@ -45754,7 +46338,7 @@
       "scores": {
         "IFEval": 0.2049,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1167
@@ -46443,7 +47027,7 @@
       "scores": {
         "IFEval": 0.1564,
         "BBH": 0.292,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3792,
         "MMLU-PRO": 0.11
@@ -47132,7 +47716,7 @@
       "scores": {
         "IFEval": 0.1413,
         "BBH": 0.2717,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2341,
         "MUSR": 0.3351,
         "MMLU-PRO": 0.1179
@@ -47158,7 +47742,7 @@
       "scores": {
         "IFEval": 0.1494,
         "BBH": 0.2423,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2458,
         "MUSR": 0.358,
         "MMLU-PRO": 0.1139
@@ -47509,7 +48093,7 @@
       "scores": {
         "IFEval": 0.1763,
         "BBH": 0.3011,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2399,
         "MUSR": 0.342,
         "MMLU-PRO": 0.1066
@@ -47665,7 +48249,7 @@
       "scores": {
         "IFEval": 0.2049,
         "BBH": 0.2912,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3575,
         "MMLU-PRO": 0.1167
@@ -48679,7 +49263,7 @@
       "scores": {
         "IFEval": 0.1492,
         "BBH": 0.313,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2601,
         "MUSR": 0.3911,
         "MMLU-PRO": 0.1147
@@ -50421,7 +51005,7 @@
       "scores": {
         "IFEval": 0.1397,
         "BBH": 0.2824,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.276,
         "MUSR": 0.3724,
         "MMLU-PRO": 0.1123
@@ -51266,7 +51850,7 @@
       "scores": {
         "IFEval": 0.3681,
         "BBH": 0.4726,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2743,
         "MUSR": 0.3524,
         "MMLU-PRO": 0.2247
@@ -52007,7 +52591,7 @@
       "scores": {
         "IFEval": 0.1872,
         "BBH": 0.302,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2768,
         "MUSR": 0.3682,
         "MMLU-PRO": 0.1095
@@ -53801,7 +54385,7 @@
       "scores": {
         "IFEval": 0.2318,
         "BBH": 0.2823,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2534,
         "MUSR": 0.3485,
         "MMLU-PRO": 0.1094
@@ -54048,7 +54632,7 @@
       "scores": {
         "IFEval": 0.1943,
         "BBH": 0.2951,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2576,
         "MUSR": 0.3796,
         "MMLU-PRO": 0.1166
@@ -54113,7 +54697,7 @@
       "scores": {
         "IFEval": 0.0787,
         "BBH": 0.2919,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2643,
         "MUSR": 0.4138,
         "MMLU-PRO": 0.1172
@@ -54178,7 +54762,7 @@
       "scores": {
         "IFEval": 0.1197,
         "BBH": 0.3002,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2525,
         "MUSR": 0.3581,
         "MMLU-PRO": 0.1129
@@ -54282,7 +54866,7 @@
       "scores": {
         "IFEval": 0.1869,
         "BBH": 0.6048,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2701,
         "MUSR": 0.3843,
         "MMLU-PRO": 0.4382
@@ -58247,7 +58831,7 @@
       "scores": {
         "IFEval": 0.1555,
         "BBH": 0.283,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2416,
         "MUSR": 0.367,
         "MMLU-PRO": 0.109
@@ -58260,7 +58844,7 @@
       "scores": {
         "IFEval": 0.1555,
         "BBH": 0.283,
-        "MATH Level 5": 0.0,
+        "MATH Level 5": 0,
         "GPQA": 0.2416,
         "MUSR": 0.367,
         "MMLU-PRO": 0.109
@@ -58410,4 +58994,4 @@
       }
     }
   ]
-}
+}

data/survey/eval-schema-fields.json

@@ -0,0 +1,563 @@
+[
+  {
+    "id": "eee_eval:source_metadata.evaluator_relationship",
+    "source": "eee_eval",
+    "section": "source_metadata",
+    "field": "evaluator_relationship",
+    "schemaPath": "source_metadata.evaluator_relationship",
+    "fullPath": "eee_eval.source_metadata.evaluator_relationship",
+    "type": "string",
+    "description": "Relationship between the evaluator and the model developer (e.g., first-party, third-party, independent).",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:source_metadata.source_organization_name",
+    "source": "eee_eval",
+    "section": "source_metadata",
+    "field": "source_organization_name",
+    "schemaPath": "source_metadata.source_organization_name",
+    "fullPath": "eee_eval.source_metadata.source_organization_name",
+    "type": "string",
+    "description": "Name of the organization that produced or published the evaluation results.",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:source_metadata.source_url",
+    "source": "eee_eval",
+    "section": "source_metadata",
+    "field": "source_url",
+    "schemaPath": "source_metadata.source_url",
+    "fullPath": "eee_eval.source_metadata.source_url",
+    "type": "string",
+    "description": "URL pointing to the original source of the evaluation results.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:source_metadata.publication_date",
+    "source": "eee_eval",
+    "section": "source_metadata",
+    "field": "publication_date",
+    "schemaPath": "source_metadata.publication_date",
+    "fullPath": "eee_eval.source_metadata.publication_date",
+    "type": "string",
+    "description": "Date when the evaluation results were published or made publicly available.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:retrieved_timestamp",
+    "source": "eee_eval",
+    "section": "root",
+    "field": "retrieved_timestamp",
+    "schemaPath": "retrieved_timestamp",
+    "fullPath": "eee_eval.retrieved_timestamp",
+    "type": "string",
+    "description": "ISO 8601 timestamp indicating when the evaluation data was retrieved or ingested.",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:eval_library.name",
+    "source": "eee_eval",
+    "section": "eval_library",
+    "field": "name",
+    "schemaPath": "eval_library.name",
+    "fullPath": "eee_eval.eval_library.name",
+    "type": "string",
+    "description": "Name of the evaluation library or harness used to run the evaluation (e.g., lm-evaluation-harness, HELM).",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:eval_library.version",
+    "source": "eee_eval",
+    "section": "eval_library",
+    "field": "version",
+    "schemaPath": "eval_library.version",
+    "fullPath": "eee_eval.eval_library.version",
+    "type": "string",
+    "description": "Version string of the evaluation library used, enabling reproducibility checks.",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:eval_library.url",
+    "source": "eee_eval",
+    "section": "eval_library",
+    "field": "url",
+    "schemaPath": "eval_library.url",
+    "fullPath": "eee_eval.eval_library.url",
+    "type": "string",
+    "description": "Repository or documentation URL for the evaluation library.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:model_info.model_id",
+    "source": "eee_eval",
+    "section": "model_info",
+    "field": "model_id",
+    "schemaPath": "model_info.model_id",
+    "fullPath": "eee_eval.model_info.model_id",
+    "type": "string",
+    "description": "Unique identifier for the model being evaluated (e.g., HuggingFace model ID).",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:model_info.model_revision",
+    "source": "eee_eval",
+    "section": "model_info",
+    "field": "model_revision",
+    "schemaPath": "model_info.model_revision",
+    "fullPath": "eee_eval.model_info.model_revision",
+    "type": "string",
+    "description": "Git revision or checkpoint hash of the model weights used during evaluation.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:model_info.model_type",
+    "source": "eee_eval",
+    "section": "model_info",
+    "field": "model_type",
+    "schemaPath": "model_info.model_type",
+    "fullPath": "eee_eval.model_info.model_type",
+    "type": "string",
+    "description": "Type or architecture category of the model (e.g., decoder-only, encoder-decoder).",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:evaluation_results.generation_config",
+    "source": "eee_eval",
+    "section": "evaluation_results",
+    "field": "generation_config",
+    "schemaPath": "evaluation_results.generation_config",
+    "fullPath": "eee_eval.evaluation_results.generation_config",
+    "type": "object",
+    "description": "Generation configuration used during evaluation, including temperature, top-p, max tokens, and other sampling parameters.",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:evaluation_results.scores",
+    "source": "eee_eval",
+    "section": "evaluation_results",
+    "field": "scores",
+    "schemaPath": "evaluation_results.scores",
+    "fullPath": "eee_eval.evaluation_results.scores",
+    "type": "object",
+    "description": "Aggregate scores across benchmarks, keyed by benchmark name.",
+    "required": "required"
+  },
+  {
+    "id": "eee_eval:evaluation_results.num_few_shot",
+    "source": "eee_eval",
+    "section": "evaluation_results",
+    "field": "num_few_shot",
+    "schemaPath": "evaluation_results.num_few_shot",
+    "fullPath": "eee_eval.evaluation_results.num_few_shot",
+    "type": "integer",
+    "description": "Number of few-shot examples provided in the prompt during evaluation.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:detailed_evaluation_results.file_path",
+    "source": "eee_eval",
+    "section": "detailed_evaluation_results",
+    "field": "file_path",
+    "schemaPath": "detailed_evaluation_results.file_path",
+    "fullPath": "eee_eval.detailed_evaluation_results.file_path",
+    "type": "string",
+    "description": "Path or URL to files containing per-sample evaluation results for detailed analysis.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:detailed_evaluation_results.format",
+    "source": "eee_eval",
+    "section": "detailed_evaluation_results",
+    "field": "format",
+    "schemaPath": "detailed_evaluation_results.format",
+    "fullPath": "eee_eval.detailed_evaluation_results.format",
+    "type": "string",
+    "description": "File format of the detailed evaluation results (e.g., jsonl, parquet, csv).",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:hardware_info.gpu_type",
+    "source": "eee_eval",
+    "section": "hardware_info",
+    "field": "gpu_type",
+    "schemaPath": "hardware_info.gpu_type",
+    "fullPath": "eee_eval.hardware_info.gpu_type",
+    "type": "string",
+    "description": "Type and model of GPU hardware used during evaluation.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_eval:hardware_info.num_gpus",
+    "source": "eee_eval",
+    "section": "hardware_info",
+    "field": "num_gpus",
+    "schemaPath": "hardware_info.num_gpus",
+    "fullPath": "eee_eval.hardware_info.num_gpus",
+    "type": "integer",
+    "description": "Number of GPUs used during evaluation.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:benchmark_details.overview",
+    "source": "autobenchmarkcard",
+    "section": "benchmark_details",
+    "field": "overview",
+    "schemaPath": "benchmark_details.overview",
+    "fullPath": "autobenchmarkcard.benchmark_details.overview",
+    "type": "string",
+    "description": "High-level summary of the benchmark, its purpose, and the capabilities it is designed to measure.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:benchmark_details.name",
+    "source": "autobenchmarkcard",
+    "section": "benchmark_details",
+    "field": "name",
+    "schemaPath": "benchmark_details.name",
+    "fullPath": "autobenchmarkcard.benchmark_details.name",
+    "type": "string",
+    "description": "Official name of the benchmark.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:benchmark_details.version",
+    "source": "autobenchmarkcard",
+    "section": "benchmark_details",
+    "field": "version",
+    "schemaPath": "benchmark_details.version",
+    "fullPath": "autobenchmarkcard.benchmark_details.version",
+    "type": "string",
+    "description": "Version of the benchmark dataset or task specification.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:benchmark_details.release_date",
+    "source": "autobenchmarkcard",
+    "section": "benchmark_details",
+    "field": "release_date",
+    "schemaPath": "benchmark_details.release_date",
+    "fullPath": "autobenchmarkcard.benchmark_details.release_date",
+    "type": "string",
+    "description": "Date the benchmark was publicly released.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:benchmark_details.citation",
+    "source": "autobenchmarkcard",
+    "section": "benchmark_details",
+    "field": "citation",
+    "schemaPath": "benchmark_details.citation",
+    "fullPath": "autobenchmarkcard.benchmark_details.citation",
+    "type": "string",
+    "description": "BibTeX or APA citation for the benchmark paper or dataset.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:purpose_and_intended_users.intended_use",
+    "source": "autobenchmarkcard",
+    "section": "purpose_and_intended_users",
+    "field": "intended_use",
+    "schemaPath": "purpose_and_intended_users.intended_use",
+    "fullPath": "autobenchmarkcard.purpose_and_intended_users.intended_use",
+    "type": "string",
+    "description": "Description of the intended use cases and audiences for this benchmark.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:purpose_and_intended_users.limitations",
+    "source": "autobenchmarkcard",
+    "section": "purpose_and_intended_users",
+    "field": "limitations",
+    "schemaPath": "purpose_and_intended_users.limitations",
+    "fullPath": "autobenchmarkcard.purpose_and_intended_users.limitations",
+    "type": "string",
+    "description": "Known limitations of the benchmark, including scope restrictions, population coverage gaps, or validity concerns.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:purpose_and_intended_users.out_of_scope",
+    "source": "autobenchmarkcard",
+    "section": "purpose_and_intended_users",
+    "field": "out_of_scope",
+    "schemaPath": "purpose_and_intended_users.out_of_scope",
+    "fullPath": "autobenchmarkcard.purpose_and_intended_users.out_of_scope",
+    "type": "string",
+    "description": "Explicit description of use cases or capabilities the benchmark is not designed to evaluate.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:methodology.metrics",
+    "source": "autobenchmarkcard",
+    "section": "methodology",
+    "field": "metrics",
+    "schemaPath": "methodology.metrics",
+    "fullPath": "autobenchmarkcard.methodology.metrics",
+    "type": "array",
+    "description": "List of evaluation metrics used (e.g., accuracy, F1, BLEU), including their definitions and how they are computed.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:methodology.validation",
+    "source": "autobenchmarkcard",
+    "section": "methodology",
+    "field": "validation",
+    "schemaPath": "methodology.validation",
+    "fullPath": "autobenchmarkcard.methodology.validation",
+    "type": "string",
+    "description": "Description of validation procedures used to ensure benchmark quality, including human review, pilot studies, or inter-annotator agreement.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:methodology.interpretation",
+    "source": "autobenchmarkcard",
+    "section": "methodology",
+    "field": "interpretation",
+    "schemaPath": "methodology.interpretation",
+    "fullPath": "autobenchmarkcard.methodology.interpretation",
+    "type": "string",
+    "description": "Guidance on how to interpret benchmark scores, including what constitutes a meaningful difference and known confounds.",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:methodology.data_collection",
+    "source": "autobenchmarkcard",
+    "section": "methodology",
+    "field": "data_collection",
+    "schemaPath": "methodology.data_collection",
+    "fullPath": "autobenchmarkcard.methodology.data_collection",
+    "type": "string",
+    "description": "Description of how benchmark data was collected, curated, or generated.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:methodology.prompt_format",
+    "source": "autobenchmarkcard",
+    "section": "methodology",
+    "field": "prompt_format",
+    "schemaPath": "methodology.prompt_format",
+    "fullPath": "autobenchmarkcard.methodology.prompt_format",
+    "type": "string",
+    "description": "Specification of the prompt template or format used when querying models.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:ethical_and_legal_considerations.compliance_with_regulations",
+    "source": "autobenchmarkcard",
+    "section": "ethical_and_legal_considerations",
+    "field": "compliance_with_regulations",
+    "schemaPath": "ethical_and_legal_considerations.compliance_with_regulations",
+    "fullPath": "autobenchmarkcard.ethical_and_legal_considerations.compliance_with_regulations",
+    "type": "string",
+    "description": "Statement on compliance with relevant regulations or legal frameworks (e.g., GDPR, EU AI Act, NIST RMF).",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:ethical_and_legal_considerations.data_privacy",
+    "source": "autobenchmarkcard",
+    "section": "ethical_and_legal_considerations",
+    "field": "data_privacy",
+    "schemaPath": "ethical_and_legal_considerations.data_privacy",
+    "fullPath": "autobenchmarkcard.ethical_and_legal_considerations.data_privacy",
+    "type": "string",
+    "description": "Description of how personal data or sensitive information is handled in the benchmark.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:ethical_and_legal_considerations.consent",
+    "source": "autobenchmarkcard",
+    "section": "ethical_and_legal_considerations",
+    "field": "consent",
+    "schemaPath": "ethical_and_legal_considerations.consent",
+    "fullPath": "autobenchmarkcard.ethical_and_legal_considerations.consent",
+    "type": "string",
+    "description": "Information about consent obtained from data subjects or annotators.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:possible_risks.category",
+    "source": "autobenchmarkcard",
+    "section": "possible_risks",
+    "field": "category",
+    "schemaPath": "possible_risks.category",
+    "fullPath": "autobenchmarkcard.possible_risks.category",
+    "type": "array",
+    "description": "Categorized list of potential risks associated with misuse or misinterpretation of benchmark results (e.g., gaming, overfitting, contamination).",
+    "required": "required"
+  },
+  {
+    "id": "autobenchmarkcard:possible_risks.mitigation",
+    "source": "autobenchmarkcard",
+    "section": "possible_risks",
+    "field": "mitigation",
+    "schemaPath": "possible_risks.mitigation",
+    "fullPath": "autobenchmarkcard.possible_risks.mitigation",
+    "type": "string",
+    "description": "Recommended mitigations or safeguards to reduce identified risks.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:dataset_details.size",
+    "source": "autobenchmarkcard",
+    "section": "dataset_details",
+    "field": "size",
+    "schemaPath": "dataset_details.size",
+    "fullPath": "autobenchmarkcard.dataset_details.size",
+    "type": "integer",
+    "description": "Total number of examples or items in the benchmark dataset.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:dataset_details.languages",
+    "source": "autobenchmarkcard",
+    "section": "dataset_details",
+    "field": "languages",
+    "schemaPath": "dataset_details.languages",
+    "fullPath": "autobenchmarkcard.dataset_details.languages",
+    "type": "array",
+    "description": "Languages represented in the benchmark dataset (ISO 639-1 codes).",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:dataset_details.domains",
+    "source": "autobenchmarkcard",
+    "section": "dataset_details",
+    "field": "domains",
+    "schemaPath": "dataset_details.domains",
+    "fullPath": "autobenchmarkcard.dataset_details.domains",
+    "type": "array",
+    "description": "Subject domains covered by the benchmark (e.g., medicine, law, mathematics, code).",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:dataset_details.license",
+    "source": "autobenchmarkcard",
+    "section": "dataset_details",
+    "field": "license",
+    "schemaPath": "dataset_details.license",
+    "fullPath": "autobenchmarkcard.dataset_details.license",
+    "type": "string",
+    "description": "License under which the benchmark dataset is distributed.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:leaderboard_info.url",
+    "source": "autobenchmarkcard",
+    "section": "leaderboard_info",
+    "field": "url",
+    "schemaPath": "leaderboard_info.url",
+    "fullPath": "autobenchmarkcard.leaderboard_info.url",
+    "type": "string",
+    "description": "URL of the official leaderboard or results page for this benchmark.",
+    "required": "optional"
+  },
+  {
+    "id": "autobenchmarkcard:leaderboard_info.submission_requirements",
+    "source": "autobenchmarkcard",
+    "section": "leaderboard_info",
+    "field": "submission_requirements",
+    "schemaPath": "leaderboard_info.submission_requirements",
+    "fullPath": "autobenchmarkcard.leaderboard_info.submission_requirements",
+    "type": "string",
+    "description": "Requirements for submitting model results to the benchmark leaderboard.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_instance_level_eval:instance_id",
+    "source": "eee_instance_level_eval",
+    "section": "root",
+    "field": "instance_id",
+    "schemaPath": "instance_id",
+    "fullPath": "eee_instance_level_eval.instance_id",
+    "type": "string",
+    "description": "Unique identifier for a single evaluation instance or example.",
+    "required": "required"
+  },
+  {
+    "id": "eee_instance_level_eval:model_output",
+    "source": "eee_instance_level_eval",
+    "section": "root",
+    "field": "model_output",
+    "schemaPath": "model_output",
+    "fullPath": "eee_instance_level_eval.model_output",
+    "type": "string",
+    "description": "Raw text output generated by the model for this instance.",
+    "required": "required"
+  },
+  {
+    "id": "eee_instance_level_eval:ground_truth",
+    "source": "eee_instance_level_eval",
+    "section": "root",
+    "field": "ground_truth",
+    "schemaPath": "ground_truth",
+    "fullPath": "eee_instance_level_eval.ground_truth",
+    "type": "string",
+    "description": "Reference answer or ground truth label for this instance.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_instance_level_eval:score",
+    "source": "eee_instance_level_eval",
+    "section": "root",
+    "field": "score",
+    "schemaPath": "score",
+    "fullPath": "eee_instance_level_eval.score",
+    "type": "number",
+    "description": "Numeric score assigned to this instance by the evaluation metric.",
+    "required": "required"
+  },
+  {
+    "id": "eee_instance_level_eval:prompt",
+    "source": "eee_instance_level_eval",
+    "section": "root",
+    "field": "prompt",
+    "schemaPath": "prompt",
+    "fullPath": "eee_instance_level_eval.prompt",
+    "type": "string",
+    "description": "Full prompt text as presented to the model for this instance.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_instance_level_eval:task_name",
+    "source": "eee_instance_level_eval",
+    "section": "root",
+    "field": "task_name",
+    "schemaPath": "task_name",
+    "fullPath": "eee_instance_level_eval.task_name",
+    "type": "string",
+    "description": "Name of the task or benchmark this instance belongs to.",
+    "required": "required"
+  },
+  {
+    "id": "eee_instance_level_eval:metadata.difficulty",
+    "source": "eee_instance_level_eval",
+    "section": "metadata",
+    "field": "difficulty",
+    "schemaPath": "metadata.difficulty",
+    "fullPath": "eee_instance_level_eval.metadata.difficulty",
+    "type": "string",
+    "description": "Difficulty level or category of this instance (e.g., easy, medium, hard).",
+    "required": "optional"
+  },
+  {
+    "id": "eee_instance_level_eval:metadata.subject",
+    "source": "eee_instance_level_eval",
+    "section": "metadata",
+    "field": "subject",
+    "schemaPath": "metadata.subject",
+    "fullPath": "eee_instance_level_eval.metadata.subject",
+    "type": "string",
+    "description": "Subject or topic area of this instance.",
+    "required": "optional"
+  },
+  {
+    "id": "eee_instance_level_eval:metadata.source_dataset",
+    "source": "eee_instance_level_eval",
+    "section": "metadata",
+    "field": "source_dataset",
+    "schemaPath": "metadata.source_dataset",
+    "fullPath": "eee_instance_level_eval.metadata.source_dataset",
+    "type": "string",
+    "description": "Original dataset this instance was sourced from.",
+    "required": "optional"
+  }
+]

lib/benchmark-metadata-utils.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared benchmark name normalization utilities.
+ * This file has NO "server-only" restriction so it can be imported from client components.
+ */
+
+/**
+ * Normalize a benchmark name to a stable lookup key.
+ * Strips composite prefixes like "hfopenllm_v2/", lowercases, collapses whitespace.
+ */
+export function normalizeBenchmarkKey(name: string): string {
+  return name
+    .replace(/^[a-z0-9_]+ ?\//i, "") // strip "hfopenllm_v2/" etc.
+    .toLowerCase()
+    .replace(/[_]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+}
+
+/**
+ * Build multiple candidate lookup keys for a benchmark name.
+ */
+export function candidateBenchmarkKeys(name: string): string[] {
+  const base = normalizeBenchmarkKey(name)
+  return Array.from(
+    new Set([
+      base,
+      base.replace(/-/g, " "),
+      base.replace(/ /g, "-"),
+      base.replace(/[^a-z0-9]/g, ""),
+    ])
+  )
+}
+
+/**
+ * Given a record of BenchmarkCards and a benchmark name, find the matching card.
+ */
+export function lookupBenchmarkCard<T>(
+  cards: Record<string, T>,
+  benchmarkName: string
+): T | undefined {
+  for (const key of candidateBenchmarkKeys(benchmarkName)) {
+    if (cards[key]) return cards[key]
+  }
+  // Fuzzy: check if any card key starts with or contains the name
+  const base = normalizeBenchmarkKey(benchmarkName)
+  for (const [cardKey, card] of Object.entries(cards)) {
+    if (cardKey.includes(base) || base.includes(cardKey)) return card
+  }
+  return undefined
+}

lib/benchmark-metadata.ts

@@ -0,0 +1,98 @@
+import "server-only"
+
+import { promises as fs, type Dirent } from "fs"
+import path from "path"
+
+import type { BenchmarkCard } from "@/lib/benchmark-schema"
+import { normalizeBenchmarkKey, candidateBenchmarkKeys as candidateKeys } from "@/lib/benchmark-metadata-utils"
+
+export { normalizeBenchmarkKey }
+
+interface IndexedBenchmarkDetailFile {
+  benchmark_cards?: Record<string, BenchmarkCard>
+}
+
+function getBenchmarkDataDirectory() {
+  return path.join(process.cwd(), "data", "benchmarks")
+}
+
+async function readEmbeddedBenchmarkCards(): Promise<Map<string, BenchmarkCard>> {
+  const dir = getBenchmarkDataDirectory()
+  const map = new Map<string, BenchmarkCard>()
+
+  let entries: Dirent[]
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true })
+  } catch {
+    return map
+  }
+
+  const jsonFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+
+  await Promise.all(
+    jsonFiles.map(async (entry) => {
+      try {
+        const raw = await fs.readFile(path.join(dir, entry.name), "utf8")
+        const parsed = JSON.parse(raw) as IndexedBenchmarkDetailFile
+        const embeddedCards = parsed.benchmark_cards
+
+        if (!embeddedCards || typeof embeddedCards !== "object") {
+          return
+        }
+
+        for (const [metricName, card] of Object.entries(embeddedCards)) {
+          if (!card?.benchmark_details?.name) {
+            continue
+          }
+
+          for (const key of candidateKeys(metricName)) {
+            if (!map.has(key)) map.set(key, card)
+          }
+
+          for (const key of candidateKeys(card.benchmark_details.name)) {
+            if (!map.has(key)) map.set(key, card)
+          }
+        }
+      } catch (err) {
+        console.warn(`benchmark-metadata: failed to load embedded cards from ${entry.name}:`, err)
+      }
+    })
+  )
+
+  return map
+}
+
+let cachedMapPromise: Promise<Map<string, BenchmarkCard>> | null = null
+
+function getMap(): Promise<Map<string, BenchmarkCard>> {
+  if (process.env.NODE_ENV === "production") {
+    if (!cachedMapPromise) cachedMapPromise = readEmbeddedBenchmarkCards()
+    return cachedMapPromise
+  }
+  return readEmbeddedBenchmarkCards()
+}
+
+/** Look up a BenchmarkCard by any commonly-used benchmark name. Returns null if not found. */
+export async function getBenchmarkCard(benchmarkName: string): Promise<BenchmarkCard | null> {
+  const map = await getMap()
+  for (const key of candidateKeys(benchmarkName)) {
+    const card = map.get(key)
+    if (card) return card
+  }
+  return null
+}
+
+/** Returns all loaded BenchmarkCards keyed by their normalised canonical name. */
+export async function getAllBenchmarkCards(): Promise<Record<string, BenchmarkCard>> {
+  const map = await getMap()
+  // Deduplicate: only emit one entry per card (by canonical name)
+  const seen = new Set<BenchmarkCard>()
+  const result: Record<string, BenchmarkCard> = {}
+  for (const [key, card] of map) {
+    if (!seen.has(card)) {
+      seen.add(card)
+      result[normalizeBenchmarkKey(card.benchmark_details.name)] = card
+    }
+  }
+  return result
+}

lib/benchmark-schema.ts

@@ -167,12 +167,36 @@ export const EVALUATION_CATEGORIES = [
 
 export type CategoryType = typeof EVALUATION_CATEGORIES[number]
 
+/**
+ * Returns Tailwind badge classes for a given category
+ */
+export function getCategoryColor(category: CategoryType): string {
+  switch (category) {
+    case 'Safety':
+      return 'bg-rose-100 text-rose-800 border-rose-200 dark:bg-rose-950/40 dark:text-rose-200'
+    case 'Fairness':
+      return 'bg-amber-100 text-amber-800 border-amber-200 dark:bg-amber-950/40 dark:text-amber-200'
+    case 'Adversarial':
+      return 'bg-orange-100 text-orange-800 border-orange-200 dark:bg-orange-950/40 dark:text-orange-200'
+    case 'Privacy':
+      return 'bg-violet-100 text-violet-800 border-violet-200 dark:bg-violet-950/40 dark:text-violet-200'
+    case 'Robustness':
+      return 'bg-emerald-100 text-emerald-800 border-emerald-200 dark:bg-emerald-950/40 dark:text-emerald-200'
+    case 'Leakage/Contamination':
+      return 'bg-red-100 text-red-800 border-red-200 dark:bg-red-950/40 dark:text-red-200'
+    case 'Core Performance':
+      return 'bg-sky-100 text-sky-800 border-sky-200 dark:bg-sky-950/40 dark:text-sky-200'
+    default:
+      return 'bg-muted text-muted-foreground border-border'
+  }
+}
+
 /**
  * Helper to determine category from benchmark name
  */
 export function inferCategoryFromBenchmark(benchmarkName: string): CategoryType {
   const name = benchmarkName.toLowerCase()
-  
+
   // Category mappings
   if (name.includes('advglue') || name.includes('jailbreak') || name.includes('attack') || name.includes('adversarial') || name.includes('red-team')) {
     return 'Adversarial'
@@ -180,7 +204,9 @@ export function inferCategoryFromBenchmark(benchmarkName: string): CategoryType
   if (name.includes('fairness') || name.includes('bias') || name.includes('stereo') || name.includes('bbq') || name.includes('celeb') || name.includes('winobias')) {
     return 'Fairness'
   }
-  if (name.includes('safety') || name.includes('harmful') || name.includes('toxic') || name.includes('truthful') || name.includes('unsafe')) {
+  // CivilComments is a toxicity/bias classification benchmark → Safety
+  if (name.includes('safety') || name.includes('harmful') || name.includes('toxic') || name.includes('truthful') || name.includes('unsafe')
+      || name === 'civilcomments' || name.includes('civil_comments') || name.includes('civil comments')) {
     return 'Safety'
   }
   if (name.includes('leakage') || name.includes('contamination')) {
@@ -207,10 +233,10 @@ export function inferCategoryFromBenchmark(benchmarkName: string): CategoryType
   if (name.includes('retrain') || name.includes('forgetting')) {
     return 'Retrainability'
   }
-  if (name.includes('meta') || name.includes('few-shot') || name.includes('learning')) {
+  if (name.includes('meta-learning') || name.includes('meta learning') || name.includes('metalearning') || name.includes('few-shot') || name.includes('in-context')) {
     return 'Meta-Learning'
   }
-  if (name.includes('mt-bench') || name.includes('quality') || name.includes('human') || name.includes('fact') || name.includes('hallucination')) {
+  if (name.includes('mt-bench') || name.includes('quality') || name.includes('humaneval') || name.includes('hallucination') || name.includes('factuality') || name.includes('factscore')) {
     return 'Core Quality Dimensions'
   }
   
@@ -314,3 +340,67 @@ export interface EvaluationCardData {
   inference_engine?: string
   inference_platform?: string
 }
+
+// ── Benchmark Card types (from metadata/benchmark_card_*.json) ────────────────
+
+export interface BenchmarkCardDetails {
+  name: string
+  overview: string
+  data_type: string
+  domains: string[]
+  languages: string[]
+  similar_benchmarks: string[] | string
+  resources: string[]
+}
+
+export interface BenchmarkCardPurpose {
+  goal: string
+  audience: string[] | string
+  tasks: string[]
+  limitations: string
+  out_of_scope_uses: string[] | string
+}
+
+export interface BenchmarkCardData {
+  source: string
+  size: string
+  format: string
+  annotation: string
+}
+
+export interface BenchmarkCardMethodology {
+  methods: string[]
+  metrics: string[]
+  calculation: string
+  interpretation: string
+  baseline_results: string
+  validation: string
+}
+
+export interface BenchmarkCardEthical {
+  privacy_and_anonymity: string
+  data_licensing: string
+  consent_procedures: string
+  compliance_with_regulations: string
+}
+
+export interface BenchmarkCardRisk {
+  category: string
+  description: string[]
+  url: string
+}
+
+export interface BenchmarkCard {
+  benchmark_details: BenchmarkCardDetails
+  purpose_and_intended_users: BenchmarkCardPurpose
+  data: BenchmarkCardData
+  methodology: BenchmarkCardMethodology
+  ethical_and_legal_considerations: BenchmarkCardEthical
+  possible_risks: BenchmarkCardRisk[]
+  flagged_fields: Record<string, string>
+  missing_fields: string[]
+  card_info: {
+    created_at: string
+    llm: string
+  }
+}

lib/dashboard-data-client.ts

@@ -1,5 +1,6 @@
 import type { BenchmarkEvaluationCardData } from "@/components/benchmark-evaluation-card"
 import type {
+  BenchmarkCard,
   BenchmarkEvalListItem,
   BenchmarkEvalSummary,
   ModelEvaluationSummary,
@@ -83,3 +84,7 @@ export function fetchDeveloperSummary(developerId: string) {
     `/api/developer-summary?id=${encodeURIComponent(developerId)}`
   )
 }
+
+export function fetchBenchmarkMetadata() {
+  return fetchJson<Record<string, BenchmarkCard>>("/api/benchmark-metadata")
+}

lib/eval-processing.ts

@@ -3,6 +3,7 @@
  */
 
 import type {
+  BenchmarkCard,
   BenchmarkEvaluation,
   EvaluationCardData,
   CategoryType,
@@ -16,6 +17,8 @@ import type {
 import type { ModelEvaluationSummary } from './benchmark-schema'
 import type { ModelSummaryCore } from './benchmark-schema'
 import { inferCategoryFromBenchmark, EVALUATION_CATEGORIES } from './benchmark-schema'
+
+export type { BenchmarkCard }
 import { getCanonicalModelIdentity, getModelFamilyRouteId } from './model-family'
 
 export type { ModelEvaluationSummary }
@@ -111,6 +114,18 @@ export interface ModelResultForBenchmark {
   source_metadata: SourceMetadata
   source_data: BenchmarkEvaluation['source_data']
   result: EvaluationResult
+  aggregate_components?: Array<{
+    evaluation_id: string
+    composite_benchmark_key: string
+    composite_benchmark_name: string
+    score: number
+    normalized_score: number
+    evaluation_timestamp: string
+    source_name?: string
+    source_type: SourceMetadata["source_type"]
+    source_organization_name: string
+    evaluator_relationship: SourceMetadata["evaluator_relationship"]
+  }>
 }
 
 export interface BenchmarkEvalSummary {
@@ -135,6 +150,16 @@ export interface BenchmarkEvalSummary {
   avg_score: number
   /** avg_score normalised to 0-1 using metric_config.min/max_score */
   avg_score_norm: number
+  /** Rich benchmark card from the metadata/ folder, when available */
+  benchmark_card?: BenchmarkCard
+  is_aggregated?: boolean
+  aggregate_sources?: Array<{
+    evaluation_id: string
+    composite_benchmark_key: string
+    composite_benchmark_name: string
+    models_count: number
+    avg_score_norm: number
+  }>
 }
 
 export type BenchmarkEvalListItem = Omit<BenchmarkEvalSummary, "model_results">

lib/model-data.ts

@@ -4,6 +4,7 @@ import { promises as fs } from "fs"
 import path from "path"
 
 import type {
+  BenchmarkCard,
   BenchmarkEvaluation,
   EvalLibrary,
   EvaluationResult,
@@ -15,8 +16,11 @@ import type {
   SourceMetadata,
 } from "@/lib/benchmark-schema"
 import { inferCategoryFromBenchmark } from "@/lib/benchmark-schema"
+import { lookupBenchmarkCard } from "@/lib/benchmark-metadata-utils"
 import {
   type BenchmarkEvalListItem,
+  type BenchmarkEvalSummary,
+  type ModelResultForBenchmark,
   createEvaluationCard,
   createModelFamilySummary,
   groupEvaluationsByBenchmark,
@@ -25,6 +29,7 @@ import {
   toBenchmarkEvalListItem,
 } from "@/lib/eval-processing"
 import { getCanonicalModelIdentity, getModelFamilyRouteId, normalizeModelInfo } from "@/lib/model-family"
+import { getBenchmarkCard, normalizeBenchmarkKey } from "@/lib/benchmark-metadata"
 
 interface RawModelFile {
   model_info: ModelInfo
@@ -48,6 +53,86 @@ interface RawEvaluationResult
   evaluation_timestamp?: string
 }
 
+function getSourceDataSignature(sourceData?: string[] | SourceData) {
+  if (!sourceData) {
+    return ""
+  }
+
+  if (Array.isArray(sourceData)) {
+    return sourceData.join("|")
+  }
+
+  return [
+    sourceData.dataset_name,
+    sourceData.source_type,
+    sourceData.hf_repo,
+    sourceData.external_link,
+  ]
+    .filter(Boolean)
+    .join("|")
+}
+
+function getRawEvaluationResultKey(result: RawEvaluationResult) {
+  return [result.evaluation_name.trim().toLowerCase(), getSourceDataSignature(result.source_data)].join("::")
+}
+
+function mergeRawEvaluationResults(results: RawEvaluationResult[]) {
+  const merged = new Map<string, RawEvaluationResult>()
+
+  for (const result of results) {
+    merged.set(getRawEvaluationResultKey(result), result)
+  }
+
+  return Array.from(merged.values())
+}
+
+function getRawEvaluationKey(evaluation: RawEvaluation) {
+  return [
+    evaluation.evaluation_id,
+    evaluation.retrieved_timestamp,
+    evaluation.benchmark,
+    evaluation.source_metadata.source_name,
+    evaluation.source_metadata.source_type,
+    evaluation.source_metadata.source_organization_name,
+    evaluation.source_metadata.evaluator_relationship,
+  ]
+    .filter(Boolean)
+    .join("::")
+}
+
+function dedupeRawEvaluations(evaluations: RawEvaluation[]) {
+  const merged = new Map<string, RawEvaluation>()
+
+  for (const evaluation of evaluations) {
+    const key = getRawEvaluationKey(evaluation)
+    const existing = merged.get(key)
+
+    if (!existing) {
+      merged.set(key, {
+        ...evaluation,
+        evaluation_results: mergeRawEvaluationResults(evaluation.evaluation_results),
+      })
+      continue
+    }
+
+    merged.set(key, {
+      ...existing,
+      ...evaluation,
+      source_data: evaluation.source_data ?? existing.source_data,
+      eval_library: evaluation.eval_library ?? existing.eval_library,
+      detailed_evaluation_results:
+        evaluation.detailed_evaluation_results ?? existing.detailed_evaluation_results,
+      generation_config: evaluation.generation_config ?? existing.generation_config,
+      evaluation_results: mergeRawEvaluationResults([
+        ...existing.evaluation_results,
+        ...evaluation.evaluation_results,
+      ]),
+    })
+  }
+
+  return Array.from(merged.values())
+}
+
 interface IndexedModelSummary {
   id: string
   name: string
@@ -62,6 +147,7 @@ interface IndexedBenchmarkEntry {
 }
 
 interface IndexedBenchmarkDetail {
+  benchmark_cards?: Record<string, BenchmarkCard>
   models: Array<{
     model_id: string
     name: string
@@ -254,6 +340,223 @@ function slugifyEvalId(value: string) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "")
 }
 
+function getAggregateEvalId(value: string) {
+  return `aggregate__${slugifyEvalId(value)}`
+}
+
+function normalizeEvalTimestamp(value: string) {
+  const numericTimestamp = Number(value)
+  return !Number.isNaN(numericTimestamp) && !value.includes("-")
+    ? numericTimestamp * 1000
+    : new Date(value).getTime()
+}
+
+function normalizeSummaryScore(summary: BenchmarkEvalSummary, score: number) {
+  const maxScore = summary.metric_config.max_score ?? 1
+  const minScore = summary.metric_config.min_score ?? 0
+  const range = maxScore - minScore
+  return range > 0 ? (score - minScore) / range : score
+}
+
+async function attachBenchmarkCardToSummary(summary: BenchmarkEvalSummary): Promise<BenchmarkEvalSummary> {
+  if (summary.benchmark_card) {
+    return summary
+  }
+
+  const cardCandidates = [
+    summary.evaluation_name,
+    summary.composite_benchmark_name,
+    summary.composite_benchmark_key,
+  ]
+
+  for (const candidate of cardCandidates) {
+    const card = await getBenchmarkCard(candidate)
+    if (card) {
+      return { ...summary, benchmark_card: card }
+    }
+  }
+
+  return summary
+}
+
+function aggregateBenchmarkSummaries(
+  summaries: BenchmarkEvalSummary[],
+  aggregationKey: string
+): BenchmarkEvalSummary | null {
+  if (summaries.length === 0) {
+    return null
+  }
+
+  const first = summaries[0]
+  const card = first.benchmark_card
+  const aggregateSources = Array.from(
+    new Map(
+      summaries.map((summary) => [
+        summary.evaluation_id,
+        {
+          evaluation_id: summary.evaluation_id,
+          composite_benchmark_key: summary.composite_benchmark_key,
+          composite_benchmark_name: summary.composite_benchmark_name,
+          models_count: summary.models_count,
+          avg_score_norm: summary.avg_score_norm,
+        },
+      ])
+    ).values()
+  ).sort((a, b) => a.composite_benchmark_name.localeCompare(b.composite_benchmark_name))
+
+  const modelBuckets = new Map<
+    string,
+    {
+      model_info: ModelResultForBenchmark["model_info"]
+      components: Array<{
+        summary: BenchmarkEvalSummary
+        modelResult: ModelResultForBenchmark
+      }>
+    }
+  >()
+
+  for (const summary of summaries) {
+    for (const modelResult of summary.model_results) {
+      const existing = modelBuckets.get(modelResult.model_info.id) ?? {
+        model_info: modelResult.model_info,
+        components: [],
+      }
+      existing.components.push({ summary, modelResult })
+      modelBuckets.set(modelResult.model_info.id, existing)
+    }
+  }
+
+  const aggregateMetricConfig = {
+    ...first.metric_config,
+    evaluation_description:
+      aggregateSources.length > 1
+        ? `Average normalized score across ${aggregateSources
+            .map((source) => source.composite_benchmark_name)
+            .join(", ")}`
+        : first.metric_config.evaluation_description,
+    min_score: 0,
+    max_score: 1,
+    unit: "normalized average",
+  } as const
+
+  const aggregatedModelResults: ModelResultForBenchmark[] = Array.from(modelBuckets.values()).map(
+    ({ model_info, components }) => {
+      const normalizedScores = components.map(({ summary, modelResult }) =>
+        normalizeSummaryScore(summary, modelResult.score)
+      )
+      const avgNormalizedScore =
+        normalizedScores.reduce((sum, score) => sum + score, 0) / normalizedScores.length
+
+      const latestComponent = [...components].sort(
+        (a, b) =>
+          normalizeEvalTimestamp(b.modelResult.evaluation_timestamp) -
+          normalizeEvalTimestamp(a.modelResult.evaluation_timestamp)
+      )[0]
+
+      const aggregateComponents = components
+        .map(({ summary, modelResult }) => ({
+          evaluation_id: summary.evaluation_id,
+          composite_benchmark_key: summary.composite_benchmark_key,
+          composite_benchmark_name: summary.composite_benchmark_name,
+          score: modelResult.score,
+          normalized_score: normalizeSummaryScore(summary, modelResult.score),
+          evaluation_timestamp: modelResult.evaluation_timestamp,
+          source_name: modelResult.source_metadata.source_name,
+          source_type: modelResult.source_metadata.source_type,
+          source_organization_name: modelResult.source_metadata.source_organization_name,
+          evaluator_relationship: modelResult.source_metadata.evaluator_relationship,
+        }))
+        .sort((a, b) => a.composite_benchmark_name.localeCompare(b.composite_benchmark_name))
+
+      return {
+        model_info,
+        score: avgNormalizedScore,
+        score_details: {
+          score: avgNormalizedScore,
+          sample_size: components.reduce(
+            (sum, { modelResult }) => sum + (modelResult.score_details.sample_size ?? 0),
+            0
+          ) || undefined,
+        },
+        evaluation_timestamp: latestComponent.modelResult.evaluation_timestamp,
+        source_metadata: latestComponent.modelResult.source_metadata,
+        source_data: latestComponent.modelResult.source_data,
+        result: {
+          ...latestComponent.modelResult.result,
+          evaluation_name: card?.benchmark_details?.name ?? first.evaluation_name,
+          metric_config: aggregateMetricConfig,
+          score_details: {
+            score: avgNormalizedScore,
+          },
+        },
+        aggregate_components: aggregateComponents,
+      }
+    }
+  )
+
+  const lowerIsBetter = first.metric_config.lower_is_better
+  aggregatedModelResults.sort((a, b) => (lowerIsBetter ? a.score - b.score : b.score - a.score))
+
+  const avgScore =
+    aggregatedModelResults.reduce((sum, modelResult) => sum + modelResult.score, 0) /
+    aggregatedModelResults.length
+
+  const evaluatorNames = Array.from(
+    new Set(summaries.flatMap((summary) => summary.evaluator_names))
+  ).sort((a, b) => a.localeCompare(b))
+
+  const sourceTypes = Array.from(
+    new Set(summaries.flatMap((summary) => summary.source_types))
+  ).sort((a, b) => a.localeCompare(b))
+
+  const totalUnderlyingResults = summaries.reduce((sum, summary) => sum + summary.model_results.length, 0)
+  const totalThirdPartyResults = summaries.reduce(
+    (sum, summary) => sum + summary.model_results.filter((result) => result.source_metadata.evaluator_relationship === "third_party").length,
+    0
+  )
+
+  return {
+    evaluation_name: card?.benchmark_details?.name ?? first.evaluation_name,
+    evaluation_id: getAggregateEvalId(aggregationKey),
+    composite_benchmark_key:
+      aggregateSources.length === 1 ? aggregateSources[0].composite_benchmark_key : "multiple",
+    composite_benchmark_name:
+      aggregateSources.length === 1
+        ? aggregateSources[0].composite_benchmark_name
+        : `${aggregateSources.length} composite benchmarks`,
+    category: first.category,
+    metric_config: aggregateMetricConfig,
+    factsheet: first.factsheet,
+    model_results: aggregatedModelResults,
+    models_count: aggregatedModelResults.length,
+    evaluator_names: evaluatorNames,
+    source_types: sourceTypes,
+    latest_source_name:
+      aggregateSources.length === 1 ? aggregateSources[0].composite_benchmark_name : "Multiple sources",
+    third_party_ratio: totalUnderlyingResults > 0 ? totalThirdPartyResults / totalUnderlyingResults : 0,
+    missing_generation_config_count: summaries.reduce(
+      (sum, summary) => sum + summary.missing_generation_config_count,
+      0
+    ),
+    best_model:
+      aggregatedModelResults.length > 0
+        ? { name: aggregatedModelResults[0].model_info.name, score: aggregatedModelResults[0].score }
+        : null,
+    worst_model:
+      aggregatedModelResults.length > 0
+        ? {
+            name: aggregatedModelResults[aggregatedModelResults.length - 1].model_info.name,
+            score: aggregatedModelResults[aggregatedModelResults.length - 1].score,
+          }
+        : null,
+    avg_score: avgScore,
+    avg_score_norm: avgScore,
+    benchmark_card: card,
+    is_aggregated: true,
+    aggregate_sources: aggregateSources,
+  }
+}
+
 function inferMetricConfig(scores: number[], benchmark: string, metric: string): MetricConfig {
   const finiteScores = scores.filter((score) => Number.isFinite(score))
   const maxScore = finiteScores.length > 0 ? Math.max(...finiteScores) : 1
@@ -343,6 +646,7 @@ async function buildEvalListDataFromBenchmarkIndexes(): Promise<{
         worst_model: null,
         avg_score: avgScore,
         avg_score_norm: range > 0 ? (avgScore - minScore) / range : 0,
+        benchmark_card: lookupBenchmarkCard(detail.benchmark_cards ?? {}, metric),
       })
     }
   }
@@ -420,7 +724,7 @@ async function loadEvaluationsForModelId(modelId: string) {
       continue
     }
 
-    return raw.evaluations.map((evaluation) =>
+    return dedupeRawEvaluations(raw.evaluations).map((evaluation) =>
       normalizeEvaluation(raw.model_info, evaluation)
     )
   }
@@ -591,7 +895,7 @@ async function readAllEvaluationsFromDataDirectory(): Promise<BenchmarkEvaluatio
           return []
         }
 
-        return raw.evaluations.map((evaluation) =>
+        return dedupeRawEvaluations(raw.evaluations).map((evaluation) =>
           normalizeEvaluation(raw.model_info, evaluation)
         )
       } catch (error) {
@@ -630,6 +934,7 @@ export async function getModelCards() {
 
 export async function getEvalListData() {
   const indexed = await buildEvalListDataFromBenchmarkIndexes()
+
   if (indexed) {
     return indexed
   }
@@ -638,10 +943,16 @@ export async function getEvalListData() {
   const summaries = Object.values(groupEvaluationsByBenchmark(evaluations))
   const totalModels = Object.keys(groupEvaluationsByModelFamily(evaluations)).length
 
-  return {
-    evals: summaries.map(toBenchmarkEvalListItem),
-    totalModels,
-  }
+  // Attach benchmark_card to each summary
+  const evalsWithCards = await Promise.all(
+    summaries.map(async (summary) => {
+      const card = await getBenchmarkCard(summary.composite_benchmark_key)
+      const listItem = toBenchmarkEvalListItem(summary)
+      return card ? { ...listItem, benchmark_card: card } : listItem
+    })
+  )
+
+  return { evals: evalsWithCards, totalModels }
 }
 
 export async function getEvalList() {
@@ -758,10 +1069,10 @@ export async function getDeveloperSummaryById(routeId: string) {
     benchmark_scores: Object.fromEntries(
       items.flatMap((evaluation) =>
         evaluation.evaluation_results
-          .map((result) => {
+          .flatMap((result) => {
             const score = result.score_details?.score
             if (!Number.isFinite(score)) {
-              return null
+              return []
             }
 
             const benchmarkName =
@@ -769,9 +1080,8 @@ export async function getDeveloperSummaryById(routeId: string) {
                 ? result.source_data.dataset_name
                 : evaluation.benchmark ?? result.evaluation_name
 
-            return [[`${benchmarkName}/${result.evaluation_name}`, score]] as const
+            return [[`${benchmarkName}/${result.evaluation_name}`, score] as const]
           })
-          .filter((entry): entry is readonly [string, number][] => entry !== null)
       ),
     ),
   }))
@@ -839,6 +1149,23 @@ export async function getModelSummaryById(modelId: string) {
 export async function getEvalSummaryById(evalId: string) {
   const evaluations = await loadAllEvaluationsFromDataDirectory()
   const grouped = groupEvaluationsByBenchmark(evaluations)
+  const summariesWithCards = await Promise.all(
+    Object.values(grouped).map((summary) => attachBenchmarkCardToSummary(summary))
+  )
+
+  if (evalId.startsWith("aggregate__")) {
+    const aggregateKey = evalId.replace(/^aggregate__/, "")
+    const aggregateMembers = summariesWithCards.filter((summary) => {
+      const cardName = summary.benchmark_card?.benchmark_details?.name
+      return cardName ? slugifyEvalId(normalizeBenchmarkKey(cardName)) === aggregateKey : false
+    })
+
+    return aggregateBenchmarkSummaries(aggregateMembers, aggregateKey)
+  }
+
+  const summary = summariesWithCards.find((item) => item.evaluation_id === evalId) ?? null
+
+  if (!summary) return null
 
-  return Object.values(grouped).find((summary) => summary.evaluation_id === evalId) ?? null
+  return summary
 }

metadata/benchmark_card_BoolQ.json

@@ -0,0 +1,118 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "BoolQ",
+      "overview": "BoolQ is a benchmark that measures a model's ability to answer naturally occurring yes/no questions, framed as a reading comprehension task. The questions are generated in unprompted and unconstrained settings, often querying complex, non-factoid information and requiring difficult entailment-like inference. The dataset consists of a single task: answering yes/no questions given a supporting passage.",
+      "data_type": "text",
+      "domains": [
+        "natural language understanding",
+        "reading comprehension",
+        "natural language inference"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "MultiNLI",
+        "SNLI",
+        "QNLI",
+        "SQuAD 2.0",
+        "Natural Questions (NQ)",
+        "QQP",
+        "MS MARCO",
+        "RACE",
+        "bAbI stories"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/1905.10044",
+        "https://huggingface.co/datasets/google/boolq",
+        "https://goo.gl/boolq",
+        "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To test models on their ability to answer naturally occurring yes/no questions, which are challenging and require complex inferential abilities beyond surface-level reasoning.",
+      "audience": [
+        "Researchers in natural language understanding and reading comprehension"
+      ],
+      "tasks": [
+        "Yes/no question answering",
+        "Text-pair classification"
+      ],
+      "limitations": "Annotation involved some errors and ambiguous cases. The use of singly-annotated examples is a trade-off for dataset size. Potential concerns about annotation artifacts are acknowledged.",
+      "out_of_scope_uses": "The paper does not explicitly state what the benchmark is not designed for."
+    },
+    "data": {
+      "source": "The data consists of naturally occurring yes/no questions authored by people who were not prompted to write specific question types and did not know the answers. The passages are excerpts from sources like Wikipedia.",
+      "size": "15,942 examples total, with 9,427 in the train split and 3,270 in the validation split. The dataset size category is between 10,000 and 100,000 examples.",
+      "format": "parquet",
+      "annotation": "Questions were answered by human annotators. A quality check on a subset showed the main annotation process achieved 90% accuracy against a gold-standard set labeled by three authors. The training, development, and test sets use singly-annotated examples."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated by fine-tuning on the BoolQ training set, potentially after transfer learning from other datasets or unsupervised pre-training. Zero-shot or direct use of pre-trained models without fine-tuning did not outperform the majority baseline.",
+        "The task requires providing a yes/no (boolean) answer to a question based on a given passage."
+      ],
+      "metrics": [
+        "Accuracy"
+      ],
+      "calculation": "The overall score is the accuracy percentage on the test set.",
+      "interpretation": "Higher accuracy indicates better performance. Human accuracy is 90%, and the majority baseline is approximately 62%.",
+      "baseline_results": "Paper baselines: Majority baseline: 62.17% dev, 62.31% test; Recurrent model baseline: 69.6%; Best model (BERT large pre-trained on MultiNLI then fine-tuned on BoolQ): 80.4% accuracy; Human accuracy: 90%. EEE results: Anthropic-LM v4-s3 52B: 81.5%.",
+      "validation": "Quality assurance involved author-led gold-standard annotation on a subset, showing 90% agreement. The development set was used for model selection, such as choosing the best model from five seeds based on its performance."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "cc-by-sa-3.0",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Uncertain data provenance",
+        "description": [
+          "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T15:08:51.830946",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_CNN_DailyMail.json

@@ -0,0 +1,104 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "CNN/DailyMail",
+      "overview": "CNN/DailyMail is a benchmark for evaluating abstractive and extractive summarization models using news articles. It contains over 300,000 unique articles written by journalists from CNN and the Daily Mail. The dataset was originally created for machine reading and question answering, but later versions were restructured specifically for summarization tasks.",
+      "data_type": "text",
+      "domains": [
+        "summarization",
+        "journalism",
+        "news media"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": "No facts provided about similar benchmarks.",
+      "resources": [
+        "https://huggingface.co/datasets/abisee/cnn_dailymail",
+        "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To help develop models that can summarize long paragraphs of text into one or two sentences, aiding in the efficient presentation of information from large quantities of text.",
+      "audience": [
+        "NLP researchers",
+        "Summarization model developers"
+      ],
+      "tasks": [
+        "Summarization"
+      ],
+      "limitations": "News articles often place important information in the first third, which may affect summarization. A manual study found 25% of samples in an earlier version were difficult for humans due to ambiguity and coreference errors. Also, machine-generated summaries may differ in truth values from the original articles.",
+      "out_of_scope_uses": "No facts provided about out-of-scope uses."
+    },
+    "data": {
+      "source": "The dataset consists of news articles and highlight sentences written by journalists at CNN and the Daily Mail. The CNN articles were collected from April 2007 to April 2015, and the Daily Mail articles from June 2010 to April 2015, sourced from archives on the Wayback Machine.",
+      "size": "Over 300,000 unique articles, with 287,113 training examples, 13,368 validation examples, and 11,490 test examples.",
+      "format": "parquet",
+      "annotation": "The dataset does not contain additional annotations. The highlights are the original summaries written by the article authors and are used as the target for summarization."
+    },
+    "methodology": {
+      "methods": [
+        "Models generate a summary for a given news article, which is then compared to the author-written highlights."
+      ],
+      "metrics": [
+        "ROUGE-2"
+      ],
+      "calculation": "The ROUGE-2 score measures the overlap of bigrams between the generated summary and the reference highlights.",
+      "interpretation": "Higher scores indicate better performance, as they reflect greater overlap with the reference summaries.",
+      "baseline_results": "Paper baseline (Zhong et al., 2020): ROUGE-1 score of 44.41 for an extractive summarization model. Evaluation suite result (Anthropic-LM v4-s3 52B): ROUGE-2 score of 0.154.",
+      "validation": "No facts provided about validation procedures."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "The dataset (version 3.0.0) is not anonymized, meaning individuals' names are present in the text.",
+      "data_licensing": "Apache License 2.0",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Data contamination",
+        "description": [
+          "Data contamination occurs when incorrect data is used for training. For example, data that is not aligned with model's purpose or data that is already set aside for other development tasks such as testing and evaluation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-contamination.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T15:15:47.316103",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_CivilComments.json

@@ -0,0 +1,109 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "CivilComments",
+      "overview": "CivilComments is a benchmark designed to measure unintended identity-based bias in toxicity classification models. It uses a large, real-world dataset of online comments from the Civil Comments platform, extended with crowd-sourced annotations for toxicity and demographic identity references. This provides a nuanced evaluation of bias beyond synthetic datasets.",
+      "data_type": "tabular, text",
+      "domains": [
+        "machine learning fairness",
+        "bias measurement",
+        "toxic comment classification",
+        "text classification"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": "The paper does not name other specific benchmark datasets, only referencing prior work using synthetic test sets.",
+      "resources": [
+        "https://arxiv.org/abs/1903.04561",
+        "https://huggingface.co/datasets/google/civil_comments",
+        "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To evaluate unintended identity-based bias in toxicity classification models using real data and nuanced metrics.",
+      "audience": [
+        "Machine learning researchers and practitioners working on fairness, bias measurement, and mitigation, particularly in toxic comment classification."
+      ],
+      "tasks": [
+        "Binary toxicity classification (toxic vs. non-toxic)",
+        "Analysis of performance across identity subgroups"
+      ],
+      "limitations": "The labeled set of identities is not comprehensive and does not provide universal coverage, representing a balance between coverage, annotator accuracy, and example count. The real-world data is potentially noisier than synthetic alternatives.",
+      "out_of_scope_uses": [
+        "Developing effective strategies for choosing optimal thresholds to minimize bias"
+      ]
+    },
+    "data": {
+      "source": "The data consists of online comments sourced from the Civil Comments platform, a commenting plugin for independent English-language news sites. The comments were publicly posted between 2015 and 2017.",
+      "size": "The dataset contains approximately 1.8 million comments for training, with separate validation and test sets of approximately 97,320 examples each. All comments were labeled for toxicity, and a subset of 450,000 comments was additionally labeled for identity references.",
+      "format": "parquet",
+      "annotation": "Labeling was performed by crowd raters. Toxicity labels were applied using guidelines consistent with the Perspective API. For the identity-labeled subset, raters were shown comments and selected referenced identities (e.g., genders, races, ethnicities) from a provided list. Some comments for identity labeling were pre-selected by models to increase the frequency of identity content."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated by applying a suite of bias metrics to their predictions on the test set. The original paper demonstrates this using publicly accessible toxicity classifiers on the dataset."
+      ],
+      "metrics": [
+        "Subgroup AUC",
+        "BPSN AUC",
+        "BNSP AUC",
+        "Negative Average Equality Gap (AEG)",
+        "Positive Average Equality Gap (AEG)"
+      ],
+      "calculation": "The evaluation calculates five metrics for each identity subgroup to provide a multi-faceted view of bias. There is no single aggregated overall score.",
+      "interpretation": "For the AUC metrics (Subgroup, BPSN, BNSP), higher values indicate better separability (fewer mis-orderings). For the Average Equality Gaps (Negative and Positive), lower values indicate better separability (more similar score distributions).",
+      "baseline_results": "Paper baselines: Results for TOXICITY@1 and TOXICITY@6 from the Perspective API are reported, showing their Subgroup AUC, BPSN AUC, BNSP AUC, Negative AEG, and Positive AEG on a synthetic dataset for the lowest performing 20 subgroups. They are also compared on short comments within the human-labeled dataset for specific identities. EEE results: Anthropic-LM v4-s3 52B scored 0.6100 on the CivilComments metric.",
+      "validation": "The evaluation assumes the human-provided labels are reliable. The identity labeling set was designed to balance coverage, crowd rater accuracy, and ensure sufficient examples per identity for meaningful results."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "The paper does not discuss how personally identifiable information (PII) in the online comments was handled or if data was anonymized.",
+      "data_licensing": "Creative Commons Zero v1.0 Universal",
+      "consent_procedures": "The paper does not describe compensation for crowdworkers or the specific platform used for annotation.",
+      "compliance_with_regulations": "The paper does not mention IRB approval, GDPR compliance, or any other ethical review process."
+    },
+    "possible_risks": [
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Uncertain data provenance",
+        "description": [
+          "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Output bias",
+        "description": [
+          "Generated content might unfairly represent certain groups or individuals."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/output-bias.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [],
+    "card_info": {
+      "created_at": "2026-03-17T12:38:43.250822",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_GPQA.json

@@ -0,0 +1,118 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "GPQA",
+      "overview": "GPQA (Graduate-Level Google-Proof Q&A Benchmark) is a text-based benchmark that measures the ability to answer extremely difficult, expert-level multiple-choice questions. It contains 448 questions designed to be 'Google-proof,' meaning they are hard to solve even with unrestricted web access. Its distinctiveness lies in its high difficulty for both highly skilled non-experts and state-of-the-art AI, making it suitable for scalable oversight experiments.",
+      "data_type": "tabular, text",
+      "domains": [
+        "biology",
+        "physics",
+        "chemistry",
+        "open domain qa",
+        "open book qa",
+        "multiple choice qa"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "DROP",
+        "Massive Multitask Language Understanding (MMLU)"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2311.12022",
+        "https://huggingface.co/datasets/Idavidrein/gpqa",
+        "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To create a testbed for scalable oversight, enabling the study of methods for humans to reliably supervise and extract truthful information from AI systems on questions that are very difficult for non-experts to answer or verify. It can also be used for general large language model capabilities benchmarking.",
+      "audience": [
+        "Researchers studying scalable oversight and AI alignment",
+        "Researchers interested in supervising AI systems that may surpass human capabilities in specialized domains"
+      ],
+      "tasks": [
+        "Multiple-choice question answering",
+        "Question answering",
+        "Text generation"
+      ],
+      "limitations": "The dataset is small, with 448 examples in the main set. There is a need for scalable oversight methods to overcome existing cognitive or ethical biases supervisors might have.",
+      "out_of_scope_uses": [
+        "Tasks where non-experts can easily find the answer using web search, as the questions are intended to be 'Google-proof'"
+      ]
+    },
+    "data": {
+      "source": "The questions were written and validated by domain experts with or pursuing PhDs in biology, physics, and chemistry, using an annotation pipeline where experts wrote questions and explanations and received detailed feedback from other experts.",
+      "size": "The main set contains 448 multiple-choice questions, with an extended set of 546 questions also mentioned. The dataset falls within the 1K<n<10K size category. The paper does not specify train, development, or test splits.",
+      "format": "The data is provided in CSV format and consists of multiple-choice questions, each with four answer choices, explanations, and references.",
+      "annotation": "Domain experts wrote the questions and explanations. Other expert validators provided feedback and 4-point difficulty ratings. Quality was assessed by comparing a sample to author-created 'gold-standard' labels, achieving 90% accuracy. Validation also involved experts from outside a question's domain attempting them with web access, which confirmed the questions' difficulty through low accuracy scores."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated in both closed-book (no runtime access to external information) and open-book (with access to an internet search tool) settings.",
+        "Prompting methods include zero-shot, few-shot, zero-shot chain-of-thought, and few-shot chain-of-thought."
+      ],
+      "metrics": [
+        "Accuracy (percentage of correct answers)"
+      ],
+      "calculation": "The overall score is the accuracy across the question set. Results are reported separately for the main set, extended set, and a 'Diamond Set'.",
+      "interpretation": "Higher accuracy indicates better performance. Expert human performance is benchmarked at 65% overall accuracy (or 74% when discounting clear mistakes). Non-expert human performance is 34%.",
+      "baseline_results": "PAPER baselines: On the main set, GPT-4 with few-shot chain-of-thought achieved 39.7% accuracy; GPT-4 with search achieved 41.0%; GPT-3.5-turbo-16k (zero-shot) achieved 29.8%; Llama-2-70B-chat (few-shot chain-of-thought) achieved 29.1%. Human expert accuracy was 65%, and non-expert accuracy was 34%. EEE results: YiSM-blossom5.1-34B-SLERP achieved 0.3557; OLMo 2 32B Instruct March 2025 achieved 0.2870.",
+      "validation": "Quality assurance involved expert validation and feedback. Gold-standard labels were created for a sample of 110 questions, achieving 90% annotator agreement. Expert validators also rated question difficulty."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "The dataset includes a canary string to aid in filtering it from training data, and distribution requires users to agree not to reveal examples in plain text or images online to prevent data leakage. No specific anonymization of the question content is described.",
+      "data_licensing": "Creative Commons Attribution 4.0",
+      "consent_procedures": "Non-expert validators were compensated with large bonuses for effort. The use of contractors is mentioned, but the specific platform and detailed compensation procedures for experts are not specified.",
+      "compliance_with_regulations": "No information is provided regarding IRB approval, GDPR compliance, or other ethical review."
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {
+      "methodology.metrics": "[Factuality Score: 0.09], low factual alignment with source material",
+      "methodology.calculation": "[Possible Hallucination], no supporting evidence found in source material",
+      "methodology.baseline_results": "[Possible Hallucination], no supporting evidence found in source material",
+      "methodology.validation": "[Possible Hallucination], no supporting evidence found in source material"
+    },
+    "missing_fields": [],
+    "card_info": {
+      "created_at": "2026-03-17T15:27:14.197081",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_GSM8K.json

@@ -0,0 +1,112 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "GSM8K",
+      "overview": "GSM8K is a benchmark that measures the ability of language models to perform multi-step mathematical reasoning. It consists of 8.5K high-quality, linguistically diverse grade school math word problems. The problems are distinctive because they require 2 to 8 steps to solve using basic arithmetic, and even the largest transformer models struggle to achieve high test performance on them. Solutions are provided in natural language with step-by-step reasoning.",
+      "data_type": "text",
+      "domains": [
+        "grade school mathematics",
+        "math word problems"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "Not specified"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2110.14168",
+        "https://huggingface.co/datasets/openai/gsm8k",
+        "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To diagnose the failures of current language models in robust multi-step mathematical reasoning and to support research, particularly in methods like training verifiers to judge solution correctness. It also aims to shed light on the properties of large language models' reasoning processes.",
+      "audience": [
+        "Researchers working on language model capabilities and mathematical reasoning"
+      ],
+      "tasks": [
+        "Solving grade school math word problems",
+        "Text generation for question answering"
+      ],
+      "limitations": "Even the largest models struggle with high test performance on this dataset, and autoregressive models have no mechanism to correct their own errors during solution generation.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The dataset was created by hiring freelance contractors via Upwork and then scaled using the NLP data labeling platform Surge AI. Problems and solutions were written by these contractors.",
+      "size": "8.5K (8,500) problems, with a size category of 10K<n<100K. The training set contains 7,473 examples and the test set contains 1,319 examples.",
+      "format": "parquet. The data is structured with a 'Problem:' field followed by a 'Solution:' field, where the solution includes step-by-step reasoning with intermediate calculations in special tags (e.g., `<<4*2=8>>`) and ends with a 'Final Answer:'.",
+      "annotation": "Contractors wrote the problems and solutions. For verification, different workers re-solved all problems to check agreement with the original solutions; problematic problems were either repaired or discarded. The annotators were from Surge AI."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated by generating step-by-step solutions to math word problems. The dataset provides two answer formats: a standard step-by-step solution and a solution structured with Socratic sub-questions.",
+        "The paper proposes a verification method where a separate verifier model is trained to judge the correctness of generated solutions. At test time, multiple candidate solutions are generated, and the one ranked highest by the verifier is selected."
+      ],
+      "metrics": [
+        "GSM8K"
+      ],
+      "calculation": "The GSM8K metric is a continuous score where higher values are better. It is described as 'EM on GSM8K', indicating it measures exact match accuracy.",
+      "interpretation": "Higher scores indicate better performance. The score is not bounded, but typical model performance ranges from low to high, with the highest reported score being 75.2.",
+      "baseline_results": "Paper baselines: The paper notes that even the largest transformer models fail to achieve high test performance, but does not report specific scores. EEE results: Llama 3.1 8B Instruct scored 75.2, and Yi 34B scored 0.648 on GSM8K.",
+      "validation": "The paper provides empirical evidence that the verification method scales more effectively with data than a finetuning baseline and remains effective even with a verifier much smaller than the generator."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "MIT License",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Reproducibility",
+        "description": [
+          "Replicating agent behavior or output can be impacted by changes or updates made to external services and tools. This impact is increased if the agent is built with generative AI."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/reproducibility-agentic.html"
+      },
+      {
+        "category": "Incomplete advice",
+        "description": [
+          "When a model provides advice without having enough information, resulting in possible harm if the advice is followed."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/incomplete-advice.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "benchmark_details.similar_benchmarks",
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T15:37:16.459776",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_HellaSwag.json

@@ -0,0 +1,115 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "HellaSwag",
+      "overview": "HellaSwag is a benchmark designed to measure commonsense natural language inference by testing a model's ability to select the most plausible follow-up event from four multiple-choice options. It is adversarially constructed to be challenging for state-of-the-art models, using a method called Adversarial Filtering to create difficult wrong answers that are obvious to humans but often misclassified by models.",
+      "data_type": "text",
+      "domains": [
+        "commonsense reasoning",
+        "natural language inference"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "SWAG",
+        "SNLI"
+      ],
+      "resources": [
+        "https://rowanzellers.com/hellaswag",
+        "https://arxiv.org/abs/1905.07830",
+        "https://huggingface.co/datasets/Rowan/hellaswag",
+        "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To create a challenge dataset that reveals the difficulty of commonsense inference for state-of-the-art models, demonstrating their lack of robustness and reliance on dataset biases rather than genuine reasoning. It aims to evaluate a model's ability to select the most plausible continuation of a given event description.",
+      "audience": [
+        "NLP researchers"
+      ],
+      "tasks": [
+        "Four-way multiple-choice selection for event continuation",
+        "Commonsense inference"
+      ],
+      "limitations": "The adversarial filtering process used to create the dataset, while effective at making it difficult for models, may also select examples where the ground truth answer is not the one preferred by human annotators, necessitating manual filtering to retain the best examples.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "Contexts are sourced from WikiHow instructional articles and ActivityNet video descriptions. Incorrect answer choices are generated by machines and then adversarially filtered.",
+      "size": "The dataset contains 70,000 examples in total, with 5,001 in-domain validation examples and 5,000 zero-shot validation examples. The training set comprises 39,905 examples.",
+      "format": "Parquet",
+      "annotation": "Human crowd workers on Amazon Mechanical Turk validated the endings. They were presented with a context and six endings (one true, five machine-generated) and rated their plausibility. The process involved iterative filtering and replacement of unrealistic endings. Worker quality was ensured via an autograded test and fair pay. A gold standard check by three authors on a random sample showed 90% agreement with crowd annotations."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated via fine-tuning on the dataset.",
+        "The benchmark also includes zero-shot evaluation on held-out categories."
+      ],
+      "metrics": [
+        "HellaSwag accuracy"
+      ],
+      "calculation": "The overall score is the accuracy percentage on the full validation or test sets. Performance is also broken down by subsets, such as in-domain versus zero-shot and by data source.",
+      "interpretation": "Higher scores indicate better performance. Human performance is over 95%, which is considered strong. Model performance below 50% is reported, indicating a struggle, with a gap of over 45% from human performance on in-domain data.",
+      "baseline_results": "Paper baselines: BERT-Large achieves 47.3% accuracy overall. ESIM + ELMo gets 33.3% accuracy. A BERT-Base model with a frozen encoder and an added LSTM performs 4.3% worse than fine-tuned BERT-Base. Evaluation suite results: Anthropic-LM v4-s3 52B achieves 0.807 (80.7%) accuracy.",
+      "validation": "Human validation involved giving five crowd workers the same multiple-choice task and combining their answers via majority vote to establish a human performance baseline. The adversarial filtering process used iterative human ratings to ensure wrong answers were implausible."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "Not specified",
+      "consent_procedures": "Crowdworkers on Amazon Mechanical Turk participated voluntarily and were compensated, with pay described as fair. A qualification task was used to filter workers, and those who consistently preferred generated endings over real ones were disqualified.",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {
+      "baseline_results": "[Possible Hallucination], no supporting evidence found in source material"
+    },
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.data_licensing",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T15:47:07.561060",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_IFEval.json

@@ -0,0 +1,112 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "Instruction-Following Eval (IFEval)",
+      "overview": "IFEval is a benchmark that measures the ability of large language models to follow natural language instructions. It focuses specifically on 'verifiable instructions'\u2014instructions that can be objectively checked, such as word count requirements or keyword mentions. It is distinctive for providing a straightforward, reproducible, and automatic evaluation that avoids the subjectivity of human judgment and the bias of model-based assessment.",
+      "data_type": "text",
+      "domains": [
+        "instruction following"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "Not specified"
+      ],
+      "resources": [
+        "https://github.com/google-research/google-research/tree/master/instruction_following_eval",
+        "https://arxiv.org/abs/2311.07911",
+        "https://huggingface.co/datasets/google/IFEval",
+        "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To provide a standardized, objective, and reproducible method for evaluating the instruction-following capability of large language models.",
+      "audience": [
+        "Researchers evaluating large language models"
+      ],
+      "tasks": [
+        "Text generation",
+        "Following verifiable instructions (e.g., word counts, formatting rules, keyword mentions)"
+      ],
+      "limitations": "The benchmark is limited to verifiable instructions and does not support multi-modal use cases, such as generating images. The current implementation is acknowledged to have room for improvement.",
+      "out_of_scope_uses": [
+        "Evaluating subjective or ambiguous instructions (e.g., 'write with a funny tone')"
+      ]
+    },
+    "data": {
+      "source": "The data consists of constructed prompts, as described in the research paper. The specific source material for the prompt content is not specified.",
+      "size": "Approximately 500 prompts, with a train split containing 541 prompts. No information is provided about development or test splits.",
+      "format": "JSON",
+      "annotation": "The prompts contain verifiable instructions, meaning compliance can be checked automatically via predefined rules (e.g., word counting). No human annotation process is described."
+    },
+    "methodology": {
+      "methods": [
+        "Automatic and objective verification of whether the model's output follows the verifiable instructions in the prompt.",
+        "Zero-shot evaluation setup."
+      ],
+      "metrics": [
+        "IFEval"
+      ],
+      "calculation": "Not specified",
+      "interpretation": "Higher scores indicate better performance.",
+      "baseline_results": "Paper baseline: Results for two widely available LLMs are reported, but specific model names and scores are not provided. EEE results: OLMo 2 32B Instruct March 2025 scored 0.7800; YiSM-blossom5.1-34B-SLERP scored 0.5033. Mean score across 2 models is 0.6417.",
+      "validation": "Quality assurance relies on the objective verifiability of the instructions. No additional validation procedures are described."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "Apache License 2.0",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Reproducibility",
+        "description": [
+          "Replicating agent behavior or output can be impacted by changes or updates made to external services and tools. This impact is increased if the agent is built with generative AI."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/reproducibility-agentic.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "benchmark_details.similar_benchmarks",
+      "methodology.calculation",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T15:55:54.431294",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_LegalBench.json

@@ -0,0 +1,120 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "LEGALBENCH",
+      "overview": "LEGALBENCH is a benchmark designed to measure the legal reasoning capabilities of large language models. It comprises 162 tasks collaboratively constructed and hand-crafted by legal professionals, covering six distinct types of legal reasoning.",
+      "data_type": "text",
+      "domains": [
+        "legal",
+        "law",
+        "finance"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "GLUE",
+        "HELM",
+        "BigBench",
+        "RAFT"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2308.11462",
+        "https://huggingface.co/datasets/nguha/legalbench",
+        "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To enable greater study of what types of legal reasoning large language models (LLMs) can perform.",
+      "audience": [
+        "Practitioners (to integrate LLMs into workflows)",
+        "Legal academics",
+        "Computer scientists"
+      ],
+      "tasks": [
+        "Text classification",
+        "Question answering",
+        "Text generation",
+        "Rule-application tasks"
+      ],
+      "limitations": "The tasks do not generalize to all legal reasoning tasks or all types of legal documents, offering only a preliminary understanding of LLM performance.",
+      "out_of_scope_uses": [
+        "Predicting the legality of real-world events",
+        "Predicting the outcome of lawsuits",
+        "Providing legal advice"
+      ]
+    },
+    "data": {
+      "source": "Data is drawn from three categories: existing publicly available datasets and corpora (some reformatted), datasets previously created by legal professionals but not released, and tasks developed specifically for LegalBench. The tasks originate from 36 distinct corpora.",
+      "size": "The benchmark comprises 162 tasks. The distribution of tasks by sample count is: 28 tasks have 50-100 samples, 97 have 100-500 samples, 29 have 500-2000 samples, and 8 have 2000+ samples. The overall dataset falls into the size category of 10,000 to 100,000 examples.",
+      "format": "Examples are presented in a structured format with fields such as 'Task name', 'Question', 'Options', and 'Answer'.",
+      "annotation": "Annotation procedures are task-dependent. For certain tasks, each data point was manually validated by a law-trained expert. Detailed annotation methodology for each task is documented in a separate section of the paper."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated in a few-shot setting. Train splits consist of a small random sample of between 2 to 8 instances to capture a true few-shot learning scenario.",
+        "For rule-application tasks, a law-trained expert manually validates each model generation."
+      ],
+      "metrics": [
+        "LegalBench",
+        "Correctness",
+        "Analysis"
+      ],
+      "calculation": "The primary benchmark metric is Exact Match (EM) on LegalBench. For rule-application tasks, two separate metrics are computed: 'correctness' (the proportion of generations without errors) and 'analysis'.",
+      "interpretation": "Higher scores on the LegalBench metric indicate better performance. The metric is continuous and lower scores are not better.",
+      "baseline_results": "The original paper evaluated 20 LLMs from 11 different families but did not provide specific scores. In a separate evaluation suite, the Yi 34B model achieved a score of 0.618.",
+      "validation": "For rule-application tasks, a law-trained expert manually validated each model generation. For datasets reused or adapted from other sources, the original data sheets document any redactions or missing data."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "For tasks that reuse or adapt existing datasets, the benchmark refers to the original data sheets for details on any data redactions or missing information.",
+      "data_licensing": "other",
+      "consent_procedures": "Not specified.",
+      "compliance_with_regulations": "The benchmark includes a section for each task intended to provide information relevant to ethical review processes, but specific details are not provided in the available facts."
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "ethical_and_legal_considerations.consent_procedures"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T12:59:10.203815",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_MATH_Level_5.json

@@ -0,0 +1,112 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "MATH Level 5",
+      "overview": "MATH Level 5 is a benchmark that measures the mathematical problem-solving ability of machine learning models using challenging competition-level mathematics problems. It contains 12,500 problems, each with a full step-by-step solution, and is specifically focused on the hardest difficulty level (Level 5) within the dataset. Problems are presented in text, with diagrams for subjects like geometry specified using the Asymptote language.",
+      "data_type": "text",
+      "domains": [
+        "mathematics",
+        "explanation generation"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "DeepMind Mathematics Dataset",
+        "Metamath Theorem Proving"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2103.03874",
+        "https://huggingface.co/datasets/DigitalLearningGmbH/MATH-lighteval"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To measure the mathematical problem-solving ability of machine learning models, specifically evaluating their capacity to analyze problems, select appropriate heuristics, and chain them together to produce a final answer. The benchmark also aims to teach models to generate step-by-step derivations and explanations.",
+      "audience": [
+        "Machine learning researchers"
+      ],
+      "tasks": [
+        "Mathematical problem solving",
+        "Step-by-step solution generation",
+        "Final answer generation"
+      ],
+      "limitations": "Accuracy on the benchmark remains relatively low even with large Transformer models, and scaling model size alone appears impractical for achieving strong mathematical reasoning based on current trends, indicating it is a very challenging benchmark.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The data is sourced from high school mathematics competitions, including the AMC 10, AMC 12, and AIME.",
+      "size": "The full dataset contains 12,500 problems, with 7,500 for training and 5,000 for testing. The exact number of examples for the 'Level 5' subset is not specified.",
+      "format": "The data is stored in Parquet format. Each problem includes a full step-by-step solution in LaTeX and natural language, and the final answer is a unique normalized sequence.",
+      "annotation": "Problems are expert-generated, but the specific annotation process and quality control measures are not detailed."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated by generating a final answer for a given problem. The solution must contain the final answer enclosed in a `\\boxed{}` tag."
+      ],
+      "metrics": [
+        "MATH Level 5"
+      ],
+      "calculation": "The metric is an Exact Match score on MATH Level 5. The score is continuous, and higher values indicate better performance.",
+      "interpretation": "Higher scores indicate better performance. The score is continuous, and lower values are not better.",
+      "baseline_results": "Paper baselines: Not specified. Evaluation suite results: YiSM-blossom5.1-34B-SLERP achieved a score of 0.2153.",
+      "validation": "Not specified"
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "MIT License",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "methodology.validation",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T16:09:19.958535",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_MMLU-Pro.json

@@ -0,0 +1,126 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "MMLU-Pro",
+      "overview": "MMLU-Pro is an enhanced version of the Massive Multitask Language Understanding benchmark designed to be more challenging and robust. It measures multi-task language understanding and reasoning capabilities by integrating more reasoning-focused questions, expanding answer choices from four to ten, and eliminating trivial or noisy questions found in its predecessor. It covers a broad range of subjects.",
+      "data_type": "tabular, text",
+      "domains": [
+        "STEM",
+        "humanities",
+        "social sciences",
+        "math",
+        "physics",
+        "chemistry",
+        "law",
+        "engineering",
+        "economics",
+        "health",
+        "psychology",
+        "business",
+        "biology",
+        "philosophy",
+        "computer science",
+        "history"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "MMLU"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2406.01574",
+        "https://huggingface.co/datasets/TIGER-Lab/MMLU-Pro",
+        "https://huggingface.co/spaces/TIGER-Lab/MMLU-Pro",
+        "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To provide a more challenging and discriminative benchmark for tracking progress in language model capabilities, testing deeper cognitive processes and reasoning as models plateau on existing benchmarks.",
+      "audience": [
+        "Researchers evaluating large language models"
+      ],
+      "tasks": [
+        "Multiple-choice question answering across a broad range of subjects"
+      ],
+      "limitations": "The dataset contains some mistakes and formatting inconsistencies, which the maintainers are correcting based on expert feedback.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The dataset is an enhanced version of MMLU, integrating more challenging questions from multiple sources. These include original MMLU questions (with trivial or ambiguous ones removed), hand-picked high-quality STEM problems from the internet, human-annotated questions requiring theorems from TheoremQA, and science questions from college exams via SciBench.",
+      "size": "The test split contains 12,032 examples, placing the dataset in the 10K to 100K size category. The total file size is 8,775,905 bytes.",
+      "format": "The data is stored in Parquet format and consists of multiple-choice questions, expanding the number of answer choices from four (as in MMLU) to ten.",
+      "annotation": "The annotation process involved expert review. Over ten experts scrutinized each question and its options to ensure challenge, comprehensiveness, accuracy, and fairness. Some answers were later corrected based on recommendations from specialists such as medical professionals."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated using multiple-choice question answering, typically with a 5-shot prompting setup, though some models use 0-shot.",
+        "Performance is tested using both direct answering and Chain-of-Thought (CoT) reasoning.",
+        "The benchmark tests performance under 24 different prompt styles."
+      ],
+      "metrics": [
+        "Accuracy (reported as a percentage or score)"
+      ],
+      "calculation": "The overall score is an average accuracy across subjects, but the specific calculation method is not detailed.",
+      "interpretation": "Higher scores indicate better performance. Performance on MMLU-Pro is significantly lower than on MMLU, indicating it is more challenging.",
+      "baseline_results": "PAPER baselines: GPT-4o achieves over 70% accuracy in Math and Physics subjects. Llama-3-70B-Instruct achieves an overall accuracy of 56.2%. Gemma-7B and Mistral-7B-v0.1 have lower performance (e.g., Mistral-7B-v0.1 scores just over 20% in Math and Physics). HF_README baselines: GPT-4o achieves an overall score of 0.7255 with CoT and 0.5346 with direct prompting. Other reported scores include Claude-3-Opus (0.6845), Claude-3-Sonnet (0.5511), Gemini 1.5 Flash (0.5912), and Llama-3-70B-Instruct (0.5620). EEE results: OLMo 2 32B Instruct March 2025 scored 0.4140.",
+      "validation": "The benchmark demonstrates greater stability under varying prompts, with sensitivity to prompt variations decreasing from 4-5% in MMLU to just 2% in MMLU-Pro."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "MIT License",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Uncertain data provenance",
+        "description": [
+          "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T16:20:31.763989",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_MMLU.json

@@ -0,0 +1,113 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "Measuring Massive Multitask Language Understanding (MMLU)",
+      "overview": "MMLU is a multiple-choice question-answering benchmark that measures a text model's multitask accuracy across 57 distinct tasks. It is designed to test a wide range of knowledge and problem-solving abilities, covering diverse academic and professional subjects from elementary to advanced levels.",
+      "data_type": "text",
+      "domains": [
+        "STEM",
+        "humanities",
+        "social sciences"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "GLUE",
+        "SuperGLUE"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2009.03300",
+        "https://huggingface.co/datasets/cais/mmlu",
+        "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json",
+        "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To bridge the gap between the wide-ranging knowledge models acquire during pretraining and existing evaluation measures by assessing models across a diverse set of academic and professional subjects.",
+      "audience": [
+        "Researchers analyzing model capabilities and identifying shortcomings"
+      ],
+      "tasks": [
+        "Multiple-choice question answering"
+      ],
+      "limitations": "Models exhibit lopsided performance, frequently do not know when they are wrong, and have near-random accuracy on some socially important subjects like morality and law.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The dataset is an original source with expert-generated questions.",
+      "size": "The dataset contains over 100,000 examples, with a test split of 14,042 examples, a validation split of 1,531 examples, a dev split of 285 examples, and an auxiliary training split of 99,842 examples.",
+      "format": "parquet",
+      "annotation": "The dataset has no additional annotations; each question provides the correct answer as a class label (A, B, C, or D)."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated exclusively in zero-shot and few-shot settings to measure knowledge acquired during pretraining."
+      ],
+      "metrics": [
+        "MMLU (accuracy)"
+      ],
+      "calculation": "The overall score is an average accuracy across the 57 tasks.",
+      "interpretation": "Higher scores indicate better performance. Near random-chance accuracy indicates weak performance. The very largest GPT-3 model improved over random chance by almost 20 percentage points on average, but models still need substantial improvements to reach expert-level accuracy.",
+      "baseline_results": "Paper baselines: Most recent models have near random-chance accuracy. The very largest GPT-3 model improved over random chance by almost 20 percentage points on average. EEE results: Yi 34B scored 0.6500, Anthropic-LM v4-s3 52B scored 0.4810. The mean score across 2 evaluated models is 0.5655.",
+      "validation": "Not specified"
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "MIT License",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "methodology.validation",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T13:14:49.605975",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_MUSR.json

@@ -0,0 +1,124 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "MuSR",
+      "overview": "MuSR (Multistep Soft Reasoning) is a benchmark that measures the ability of language models to perform multistep soft reasoning based on natural language narratives. It combines sophisticated narratives with complex reasoning that requires commonsense knowledge and is not solvable by simple rule-based systems. The benchmark consists of three tasks: murder mysteries, object placements, and team allocations.",
+      "data_type": "text",
+      "domains": [
+        "reasoning",
+        "commonsense reasoning",
+        "planning"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "bAbI",
+        "BigTOM",
+        "ToMi",
+        "RuleTakers",
+        "ProntoQA",
+        "SocialIQA",
+        "StrategyQA"
+      ],
+      "resources": [
+        "https://github.com/Zayne-Sprague/MuSR",
+        "https://arxiv.org/abs/2310.16049",
+        "https://huggingface.co/datasets/TAUR-Lab/MuSR"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To evaluate and characterize the gaps in language models' abilities to perform robust, multistep reasoning in complex natural language settings, particularly testing the limits of techniques like chain-of-thought.",
+      "audience": [
+        "Researchers evaluating language models",
+        "Researchers evaluating neurosymbolic systems on reasoning capabilities"
+      ],
+      "tasks": [
+        "Question answering",
+        "Solving murder mysteries",
+        "Solving object placement problems",
+        "Solving team allocation problems"
+      ],
+      "limitations": "The benchmark instances are generated by GPT-4, which may lead to simple, poor-quality narratives with potential inconsistencies, though the paper argues they are valid test cases if the underlying information is faithfully preserved.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The data is synthetically generated using a neurosymbolic synthetic-to-natural generation algorithm that employs GPT-4. The process begins with gold facts, constructs a reasoning tree, and iteratively generates a narrative.",
+      "size": "756 instances across three domains: 250 for Murder Mystery, 256 for Object Placements, and 250 for Team Allocations. The dataset is categorized as containing fewer than 1,000 examples (n<1K).",
+      "format": "CSV, containing free-text narratives (ranging from hundreds to roughly 1000 words in length) followed by a multiple-choice question.",
+      "annotation": "Answers are derived from the underlying gold facts used in generation. For validation, human annotators (7 total) solved instances using a chain-of-thought+ prompt, with instances triply-annotated (34-40 per domain). Human accuracy was very high, with the lowest average annotator score at 90% and majority vote accuracy between 94.1% and 100%."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated in zero-shot and single-shot (1-shot) settings.",
+        "Prompting strategies include single-shot prompting, chain-of-thought (CoT), and an engineered variant called CoT+.",
+        "Neurosymbolic algorithms like Program-Aided Language Models (PAL) and SymbolicTOM are also evaluated on compatible domains."
+      ],
+      "metrics": [
+        "MUSR (Accuracy)"
+      ],
+      "calculation": "Performance is measured as accuracy (percentage correct) for each of the three domains (MM, OP, TA) separately. The paper does not report a single aggregated score.",
+      "interpretation": "Higher accuracy indicates better performance. Human performance sets a high ceiling (ranging from 94.1% to 100% by majority vote), while random baselines are at or near chance (ranging from 24.6% to 50%).",
+      "baseline_results": "Paper baselines: Random baseline (MM: 50%, OP: 24.6%, TA: 33.3%), GPT-4 (80.4%, 60.9%, 68.4%), GPT-3.5 (61.6%, 46.9%, 40.4%), Llama2 70b Chat (48.8%, 42.2%, 44.8%), Llama2 7b Chat (50.8%, 29.3%, 36.8%), Vicuna 7b v1.5 (48.4%, 29.7%, 26.4%), Vicuna 13b v1.5 (50.8%, 34.4%, 32%), Vicuna 33b v1.3 (49.6%, 31.2%, 30%), Human Eval (94.1%, 95%, 100%). PAL results for Team Allocation outperform end-to-end models but are below human performance. EEE results: YiSM-blossom5.1-34B-SLERP achieved an accuracy of 0.4413.",
+      "validation": "The dataset is validated by measuring human annotator performance to ensure the narratives support the intended reasoning. Rule-based baselines (e.g., picking the suspect with the longest chapter) are used as sanity checks and perform near random chance, confirming the tasks are not trivially solvable."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "Creative Commons Attribution 4.0",
+      "consent_procedures": "Annotation was performed by three hired undergraduate students. No details on compensation or the hiring platform are provided.",
+      "compliance_with_regulations": "The research received support from NSF, DARPA, and the Air Force Research Laboratory. No mention of IRB approval or other specific regulatory compliance is made."
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data contamination",
+        "description": [
+          "Data contamination occurs when incorrect data is used for training. For example, data that is not aligned with model's purpose or data that is already set aside for other development tasks such as testing and evaluation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-contamination.html"
+      },
+      {
+        "category": "Reproducibility",
+        "description": [
+          "Replicating agent behavior or output can be impacted by changes or updates made to external services and tools. This impact is increased if the agent is built with generative AI."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/reproducibility-agentic.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {
+      "methodology.calculation": "[Possible Hallucination], no supporting evidence found in source material",
+      "methodology.baseline_results": "[Possible Hallucination], no supporting evidence found in source material",
+      "methodology.validation": "[Factuality Score: 0.17], low factual alignment with source material"
+    },
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T12:25:43.235734",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_MedQA.json

@@ -0,0 +1,114 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "MEDQA",
+      "overview": "MEDQA is a free-form multiple-choice open-domain question answering (OpenQA) benchmark designed to measure a model's ability to solve medical problems. It is distinctive as the first such dataset sourced from professional medical board exams, covering multiple languages and presenting a challenging real-world scenario.",
+      "data_type": "text",
+      "domains": [
+        "medical knowledge",
+        "professional medical exams"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "ARC",
+        "OpenBookQA"
+      ],
+      "resources": [
+        "https://github.com/jind11/MedQA",
+        "https://arxiv.org/abs/2009.13081",
+        "https://huggingface.co/datasets/GBaker/MedQA-USMLE-4-options",
+        "https://storage.googleapis.com/crfm-helm-public/lite/benchmark_output/releases/v1.13.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To present a challenging open-domain question answering dataset to promote the development of stronger models capable of handling sophisticated real-world medical scenarios, specifically evaluating performance on medical knowledge as tested in professional exams.",
+      "audience": [
+        "The natural language processing (NLP) community"
+      ],
+      "tasks": [
+        "Free-form multiple-choice question answering",
+        "Open-domain question answering"
+      ],
+      "limitations": "Even the best current methods achieve relatively low accuracy (36.7% to 70.1% across languages), indicating the benchmark's difficulty and the limitations of existing models.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The data is collected from professional medical board exams.",
+      "size": "The dataset contains 12,723 questions in English, 34,251 in simplified Chinese, and 14,123 in traditional Chinese. The total number of examples falls within the 10K to 100K range.",
+      "format": "JSON",
+      "annotation": "The answer labels are the correct answers from the professional exams. No additional annotation process is described."
+    },
+    "methodology": {
+      "methods": [
+        "The benchmark uses a sequential combination of a document retriever and a machine comprehension model. It includes both rule-based and neural methods.",
+        "The evaluation is a standard question-answering task, though the specific learning setting (e.g., zero-shot, few-shot, fine-tuning) is not explicitly defined."
+      ],
+      "metrics": [
+        "Accuracy"
+      ],
+      "calculation": "The overall score is the accuracy on the test set.",
+      "interpretation": "Higher accuracy indicates better performance. The best reported accuracies are 36.7% for English, 42.0% for traditional Chinese, and 70.1% for simplified Chinese questions.",
+      "baseline_results": "Original paper baselines: The best method reported achieves 36.7% accuracy on English, 42.0% on traditional Chinese, and 70.1% on simplified Chinese questions. Model names are not specified. EEE results: Yi 34B achieves a score of 0.656 (65.6%).",
+      "validation": "Not specified"
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "Creative Commons Attribution 4.0",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Uncertain data provenance",
+        "description": [
+          "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "methodology.validation",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T13:23:29.822123",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_Omni-MATH.json

@@ -0,0 +1,113 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "Omni-MATH",
+      "overview": "Omni-MATH is a benchmark designed to measure the mathematical reasoning capabilities of large language models at the Olympiad competition level. It comprises 4,428 challenging problems, categorized into over 33 sub-domains and more than 10 distinct difficulty levels. It was created because existing mathematical benchmarks are nearing saturation and are inadequate for assessing models on truly difficult tasks.",
+      "data_type": "text",
+      "domains": [
+        "math",
+        "olympiads"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "GSM8K",
+        "MATH"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2410.07985",
+        "https://huggingface.co/datasets/KbsdJames/Omni-MATH",
+        "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To provide a challenging benchmark for assessing and advancing the mathematical reasoning capabilities of large language models at the Olympiad and competition level, as existing benchmarks have become less challenging. It enables a nuanced analysis of performance across various mathematical disciplines and complexity levels.",
+      "audience": [
+        "Researchers evaluating large language models"
+      ],
+      "tasks": [
+        "Solving Olympiad-level mathematical problems",
+        "Solving competition-level mathematical problems",
+        "Rule-based evaluation on a filtered subset of problems (Omni-MATH-Rule)"
+      ],
+      "limitations": "Some problems are not suitable for reliable rule-based evaluation, leading to a filtered 'testable' set and an 'untestable' set.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The data is sourced from contest pages, the AoPS Wiki, and the AoPS Forum. Initial raw counts from these sources were filtered to create the final dataset.",
+      "size": "4,428 problems. A subset of 2,821 problems (Omni-MATH-Rule) is suitable for rule-based evaluation, and a separate subset of 100 samples was used for meta-evaluation.",
+      "format": "JSON",
+      "annotation": "Problems underwent rigorous human annotation by a team including PhD and Master's students. Each problem was reviewed by two annotators for cross-validation, achieving high agreement rates."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated by generating solutions to the mathematical problems.",
+        "Evaluation is conducted using both model-based judgment (e.g., GPT-4o or the open-source Omni-Judge) and rule-based evaluation for a specific subset of problems (Omni-MATH-Rule)."
+      ],
+      "metrics": [
+        "Accuracy (Acc)"
+      ],
+      "calculation": "The overall score is the accuracy percentage, calculated as the number of correct solutions divided by the total number of problems.",
+      "interpretation": "Higher accuracy indicates stronger performance. The benchmark is considered challenging, as even advanced models achieve only moderate accuracy.",
+      "baseline_results": "Paper baselines (accuracy on full Omni-MATH / Omni-MATH-Rule subset): o1-mini (60.54% / 62.2%), o1-preview (52.55% / 51.7%), qwen2.5-MATH-72b-Instruct (36.20% / 35.7%), qwen2.5-MATH-7b-Instruct (33.22% / 32.3%), GPT-4o (30.49% / 29.2%), NuminaMATH-72b-cot (28.45% / 27.1%), DeepseekMATH-7b-RL (16.12% / 14.9%). EEE results: OLMo 2 32B Instruct March 2025 scored 0.161 (16.1%).",
+      "validation": "For the Omni-MATH-Rule subset, two PhD students annotated problems to determine suitability for rule-based evaluation, achieving 98% cross-validation accuracy. A meta-evaluation compared model-generated judgments against human gold-standard annotations on a 100-sample subset to assess reliability."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "Apache License 2.0",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      },
+      {
+        "category": "Improper usage",
+        "description": [
+          "Improper usage occurs when a model is used for a purpose that it was not originally designed for."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/improper-usage.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T13:34:44.331592",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_QuAC.json

@@ -0,0 +1,114 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "QuAC",
+      "overview": "QuAC (Question Answering in Context) is a benchmark that measures a model's ability to answer questions within an information-seeking dialogue. It contains 14,000 dialogues comprising 100,000 question-answer pairs. The dataset is distinctive because questions are often open-ended, context-dependent, unanswerable, or only meaningful within the dialog flow, presenting challenges not found in standard machine comprehension datasets.",
+      "data_type": "text",
+      "domains": [
+        "question answering",
+        "dialogue modeling",
+        "text generation"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "SQuAD"
+      ],
+      "resources": [
+        "http://quac.ai",
+        "https://arxiv.org/abs/1808.07036",
+        "https://huggingface.co/datasets/allenai/quac",
+        "https://storage.googleapis.com/crfm-helm-public/benchmark_output/releases/v0.4.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To enable models to learn from and participate in information-seeking dialog, handling context-dependent, elliptical, and sometimes unanswerable questions.",
+      "audience": [
+        "Not specified"
+      ],
+      "tasks": [
+        "Extractive question answering",
+        "Text generation",
+        "Fill mask"
+      ],
+      "limitations": "Some questions have lower quality annotations; the dataset filters out the noisiest ~10% of annotations where human F1 is below 40. Questions can be open-ended, unanswerable, or only meaningful within the dialog context, posing inherent challenges.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The data is crowdsourced via an interactive dialog between two crowd workers: one acting as a student asking questions to learn about a hidden Wikipedia text, and the other acting as a teacher who answers using short excerpts from that text. The source data comes from Wikipedia.",
+      "size": "The dataset contains 98,407 question-answer pairs from 13,594 dialogs, based on 8,854 unique sections from 3,611 unique Wikipedia articles. The training set has 83,568 questions (11,567 dialogs), the validation set has 7,354 questions (1,000 dialogs), and the test set has 7,353 questions (1,002 dialogs). The dataset size is between 10,000 and 100,000 examples.",
+      "format": "Each dialog is a sequence of question-answer pairs centered around a Wikipedia section. The teacher's response includes a text span, a 'yes/no' indication, a 'no answer' indication, and an encouragement for follow-up questions.",
+      "annotation": "Questions are answered by a teacher selecting short excerpts (spans) from the Wikipedia text. The training set has one reference answer per question, while the validation and test sets each have five reference answers per question to improve evaluation reliability. For evaluation, questions with a human F1 score lower than 40 are not used, as manual inspection revealed lower quality below this threshold."
+    },
+    "methodology": {
+      "methods": [
+        "Models predict a text span to answer a question about a Wikipedia section, given a dialog history of previous questions and answers.",
+        "The evaluation uses a reading comprehension architecture extended to model dialog context."
+      ],
+      "metrics": [
+        "Word-level F1"
+      ],
+      "calculation": "Precision and recall are computed over overlapping words after removing stopwords. For 'no answer' questions, F1 is 1 if correctly predicted and 0 otherwise. The maximum F1 among all references is computed for each question.",
+      "interpretation": "Higher F1 scores indicate better performance. The best model underperforms humans by 20 F1, indicating significant room for improvement.",
+      "baseline_results": "Paper baselines: The best model underperforms humans by 20 F1, but specific model names and scores are not provided. EEE results: Anthropic-LM v4-s3 52B achieves an F1 score of 0.431.",
+      "validation": "Quality assurance includes using multiple references for development and test questions, filtering out questions with low human F1 scores, and manual inspection of low-quality annotations."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "MIT License",
+      "consent_procedures": "Dialogs were created by two crowd workers, but the specific compensation or platform details are not provided in the paper.",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Uncertain data provenance",
+        "description": [
+          "Data provenance refers to the traceability of data (including synthetic data), which includes its ownership, origin, transformations, and generation. Proving that the data is the same as the original source with correct usage terms is difficult without standardized methods for verifying data sources or generation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-provenance.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.audience",
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T13:45:24.009083",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}

metadata/benchmark_card_WildBench.json

@@ -0,0 +1,118 @@
+{
+  "benchmark_card": {
+    "benchmark_details": {
+      "name": "WildBench",
+      "overview": "WildBench is a benchmark that measures the performance of large language models on challenging, open-ended tasks derived from real-world user queries. It consists of 1,024 tasks selected from human-chatbot conversation logs. Its distinctive features include using a natural distribution of real user queries and employing automated evaluation with two novel metrics, WB-Reward and WB-Score, which utilize task-specific checklists and structured explanations.",
+      "data_type": "tabular, text",
+      "domains": [
+        "Info Seeking",
+        "Math & Data",
+        "Reasoning & Planning",
+        "Creative Tasks"
+      ],
+      "languages": [
+        "English"
+      ],
+      "similar_benchmarks": [
+        "AlpacaEval",
+        "ArenaHard",
+        "MT-bench",
+        "Chatbot Arena"
+      ],
+      "resources": [
+        "https://arxiv.org/abs/2406.04770",
+        "https://huggingface.co/datasets/allenai/WildBench",
+        "https://huggingface.co/spaces/allenai/WildBench",
+        "https://storage.googleapis.com/crfm-helm-public/capabilities/benchmark_output/releases/v1.15.0/groups/core_scenarios.json"
+      ]
+    },
+    "purpose_and_intended_users": {
+      "goal": "To provide a realistic, automated, and cost-effective evaluation framework for large language models that reflects their capabilities on challenging, real-world user tasks. It aims to be contamination-resilient and dynamically updated.",
+      "audience": [
+        "Researchers and practitioners evaluating large language models"
+      ],
+      "tasks": [
+        "Open-ended text generation in response to diverse user queries"
+      ],
+      "limitations": "The benchmark acknowledges a common issue in LLM-as-a-judge evaluations: bias towards longer outputs. It introduces a length-penalty method to mitigate this.",
+      "out_of_scope_uses": [
+        "Not specified"
+      ]
+    },
+    "data": {
+      "source": "The data is derived from real user-chatbot conversation logs collected by the AI2 WildChat project. Over one million logs were filtered to create the benchmark.",
+      "size": "The benchmark contains 1,024 tasks. A separate 'v2-hard' configuration contains 256 examples. The dataset falls into the size category of 1K to 10K examples.",
+      "format": "The data is stored in Parquet format.",
+      "annotation": "Human annotation was used for quality control. GPT-4-Turbo assisted by summarizing query intents to help human reviewers filter out nonsensical tasks. Human reviewers manually assessed tasks to ensure they were challenging, diverse, and that associated checklist questions were clear. The final set of tasks was retained after this process. Each example includes fine-grained annotations such as task types and checklists for evaluating response quality."
+    },
+    "methodology": {
+      "methods": [
+        "Models are evaluated automatically using LLM-as-a-judge, with GPT-4-turbo as the evaluator. The evaluation is not fine-tuning-based and appears to be zero-shot or prompted.",
+        "The evaluation uses length-penalized pairwise comparisons and individual scoring to prevent bias towards longer outputs."
+      ],
+      "metrics": [
+        "WB-Reward (for pairwise comparisons)",
+        "WB-Score (for individual scoring)",
+        "WB-Elo (for leaderboard ranking, merging WB-Reward and WB-Score)"
+      ],
+      "calculation": "WB-Reward compares a test model against three baseline models of varying performance, producing outcomes of 'much better', 'slightly better', 'tie', 'slightly worse', or 'much worse'. A length penalty converts 'slightly better/worse' to 'tie' if the winner's response is excessively longer. WB-Score evaluates individual model outputs. WB-Elo merges the pairwise comparisons from WB-Reward and WB-Score to perform Elo rating updates.",
+      "interpretation": "Higher scores on WB-Reward and WB-Score indicate better performance. Strong performance is validated by a high correlation with human-voted Elo ratings from Chatbot Arena, with WB-Reward achieving a Pearson correlation of 0.98 and WB-Score reaching 0.95.",
+      "baseline_results": "Paper baselines: The paper reports results for 40 LLMs but does not list specific scores. It notes that using Haiku as a baseline yields the best correlation with human ratings. EEE results: OLMo 2 32B Instruct March 2025 scored 0.7340 on WildBench.",
+      "validation": "The evaluation metrics are validated by their strong correlation with human-voted Elo ratings from Chatbot Arena on hard tasks. Checklist questions used in the evaluation were manually verified for clarity and relevance."
+    },
+    "ethical_and_legal_considerations": {
+      "privacy_and_anonymity": "Not specified",
+      "data_licensing": "The dataset is made available under a CC BY license, intended for research and educational use in accordance with AI2's Responsible Use Guidelines.",
+      "consent_procedures": "Not specified",
+      "compliance_with_regulations": "Not specified"
+    },
+    "possible_risks": [
+      {
+        "category": "Over- or under-reliance",
+        "description": [
+          "In AI-assisted decision-making tasks, reliance measures how much a person trusts (and potentially acts on) a model's output. Over-reliance occurs when a person puts too much trust in a model, accepting a model's output when the model's output is likely incorrect. Under-reliance is the opposite, where the person doesn't trust the model but should."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/over-or-under-reliance.html"
+      },
+      {
+        "category": "Unrepresentative data",
+        "description": [
+          "Unrepresentative data occurs when the training or fine-tuning data is not sufficiently representative of the underlying population or does not measure the phenomenon of interest. Synthetic data might not fully capture the complexity and nuances of real-world data. Causes include possible limitations in the seed data quality, biases in generation methods, or inadequate domain knowledge. Thus, AI models might struggle to generalize effectively to real-world scenarios."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/unrepresentative-data.html"
+      },
+      {
+        "category": "Data bias",
+        "description": [
+          "Historical and societal biases might be present in data that are used to train and fine-tune models. Biases can also be inherited from seed data or exacerbated by synthetic data generation methods."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-bias.html"
+      },
+      {
+        "category": "Data contamination",
+        "description": [
+          "Data contamination occurs when incorrect data is used for training. For example, data that is not aligned with model's purpose or data that is already set aside for other development tasks such as testing and evaluation."
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/data-contamination.html"
+      },
+      {
+        "category": "Lack of data transparency",
+        "description": [
+          "Lack of data transparency might be due to insufficient documentation of training or tuning dataset details, including synthetic data generation.\u00a0"
+        ],
+        "url": "https://www.ibm.com/docs/en/watsonx/saas?topic=SSYOK8/wsj/ai-risk-atlas/lack-of-data-transparency.html"
+      }
+    ],
+    "flagged_fields": {},
+    "missing_fields": [
+      "purpose_and_intended_users.out_of_scope_uses",
+      "ethical_and_legal_considerations.privacy_and_anonymity",
+      "ethical_and_legal_considerations.consent_procedures",
+      "ethical_and_legal_considerations.compliance_with_regulations"
+    ],
+    "card_info": {
+      "created_at": "2026-03-17T13:56:24.159440",
+      "llm": "deepseek-ai/DeepSeek-V3.2"
+    }
+  }
+}