GAVEL: Multi-domain Verification & Evaluation

• GAVEL is a recurrent acronym in computational research denoting tools for structured verification, explicit constraint enforcement, and systematic exploration across various domains.
• It spans multiple applications—including LLM safety, vision-language caption verification, legal summarization, ontology integration, software categorization, game generation, and cluster scheduling—with unique methodologies and performance metrics.
• The significance of GAVEL lies in its ability to render complex model behaviors more interpretable and controllable through rule-based mechanisms and structured evaluations.

GAVEL is a recurrent acronym in contemporary computational research rather than a single method or framework. In recent arXiv usage, it denotes systems for rule-based activation safety in LLMs, grounded verification and localization of caption errors in vision-language settings, evaluation and agentic extraction for long-context legal summarization, integration of first-order annotations into OWL ontologies, automatic categorization of GitHub Actions, evolutionary generation of board games, and heterogeneity-aware scheduling for deep learning clusters (Rozenfeld et al., 27 Jan 2026, Gao et al., 25 Jun 2026, Dou et al., 7 Jan 2026, Flügel et al., 2022, Nguyen et al., 2024, Todd et al., 2024, Narayanan et al., 2020). The shared name masks substantial divergence in problem formulation, formal apparatus, and deployment context; what unifies these works is an emphasis on structured verification, explicit constraints, or systematic search over complex spaces.

1. Scope and recurring uses of the name

Across the papers considered here, “GAVEL” expands into multiple domain-specific names and refers to distinct technical artifacts: a safety framework, a benchmark, an evaluator-agent pair, an ontology tool, a classifier, a generative design system, and a scheduler. This multiplicity is itself notable because the acronym is attached to projects concerned with governance, verification, evaluation, localization, and controlled exploration.

Expansion	Domain	Core role
Governance via Activation-based Verification and Extensible Logic	LLM safety	Rule-based activation monitoring
Grounded Caption Error Verification and Localization	Vision-language	Verification, explanation, and box localization
Gavel-Ref / Gavel-Agent	Legal NLP	Evaluation and checklist extraction
Gavel / Gavel-OWL	Ontology engineering	OWL + FOL integration and reasoning
Gavel	Software engineering	GitHub Actions categorization
Generating Games Via Evolution and LLMs	Game generation	LLM-guided evolutionary design
Gavel	Cluster systems	Heterogeneity-aware scheduling

A plausible implication is that the name has become associated, informally, with mechanisms that render complex model behavior more inspectable or more tractable through explicit structure. In the surveyed literature, however, these projects are methodologically independent.

2. Rule-based activation safety for LLMs

“GAVEL: Towards rule-based safety through activation monitoring” defines GAVEL as “Governance via Activation-based Verification and Extensible Logic,” a rule-based safety framework for LLMs that monitors internal activations rather than surface text (Rozenfeld et al., 27 Jan 2026). Its motivation is framed around three limitations of existing activation-based detectors: poor precision, limited flexibility, and lack of interpretability. By analogy to rule-sharing practices in cybersecurity, including Snort and YARA, the framework introduces modular “Cognitive Elements” (CEs), which are fine-grained, human-interpretable factors such as “making a threat” and “payment processing.”

Formally, if $f_\theta$ is the protected LLM, then at generation step $t$ the framework extracts a per-token activation vector

$$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$

where the concatenation is taken over selected attention-output slices from layers in $\Lambda$. It then defines $K$ CEs via functions $g_k:\mathbb{R}^D\to[0,1]$, producing

$g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$

Each CE may equivalently be treated as a thresholded predicate,

$CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$

with $\tau_k$ calibrated on held-out excitation data. Rules are Boolean predicates over CE presence within a sliding window $W_t=\{t-N+1,\dots,t\}$, with binary presence vector

$t$0

A phishing rule is given explicitly as

$t$1

where $t$2 “Create Content,” $t$3 “Click/Enter,” $t$4 “Provide/Give,” and $t$5 “Personal Information.”

The runtime pipeline is token-synchronous. For each generated token, GAVEL extracts $t$6, computes CE probabilities $t$7, updates a sliding buffer, forms the presence vector via window maxima and thresholds, then evaluates each rule $t$8. When a rule fires, the enforcement action may “stop generation, refuse, steer.” Each rule is evaluated in $t$9 time, and the CE detector is described as a lightweight multi-label classifier, with a 3-layer GRU given as an example. The reported end-to-end overhead is less than $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$0 per token.

The framework emphasizes configurability and auditability. Rules are stored in a human-readable format such as YAML or Snort-style syntax, so practitioners can add, remove, or modify $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$1 without retraining either $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$2 or $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$3. Each CE is documented with its excitation dataset and threshold $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$4, and when a rule fires the system logs the specific tokens, CE labels, and detection probabilities $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$5 that satisfied the Boolean condition. The paper also describes an automated rule-creation pipeline: from a natural-language description such as “detect automated romance-scam dialogues,” it proposes CEs, excitation datasets, and a corresponding ruleset; it cross-references a community CE library, uses GPT-4.1 for generation and GPT-5 as a judge, and outputs text-only YAML files.

Empirically, the system is evaluated on nine misuse categories across three domains—cybercrime, psychological harm, and scam automation—using Mistral-7B. Reported aggregate results are AUC $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$6, Balanced Accuracy $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$7, False Positive Rate $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$8 on challenging benign and background dialogues, and True Positive Rate $$r_t = \mathrm{concat}(\{a_t^{(\ell)}\}_{\ell\in\Lambda}) \in \mathbb{R}^D,$$9 across all categories. In the averaged baseline table, GAVEL attains AUC $\Lambda$0, b-ACC $\Lambda$1, TPR $\Lambda$2, and FPR $\Lambda$3, outperforming an activation-classifier on coarse misuse labels, RepBending, CircuitBreakers, and CAST. The CE and rule descriptions are text-only and model-agnostic, and the paper reports reuse across LLaMA-8B, Mistral-7B, Qwen3-8B, and Gemma-4B with minimal variation in CE detection quality. This suggests that GAVEL’s principal abstraction is the decoupling of activation engineering from policy specification.

3. Grounded caption error verification and localization

“GAVEL: Grounded Caption Error Verification and Localization” introduces a vision-language task, dataset, and benchmark for jointly identifying whether a caption is faithful to an image, explaining any discrepancy, and localizing its visual evidence (Gao et al., 25 Jun 2026). For an image-caption pair $\Lambda$4, the model must output a verification label $\Lambda$5, a free-form explanation $\Lambda$6, and one or more bounding boxes $\Lambda$7. The benchmark is explicitly framed around hallucinated or inconsistent outputs of vision-LLMs.

In supervised form, the task can be written with decomposed loss

$\Lambda$8

with binary cross-entropy for verification, autoregressive cross-entropy for explanation, and either $\Lambda$9 or SmoothL1 for localization. The published baseline, however, uses a unified autoregressive decoder within the VisionLLM framework: the assistant first emits “HALLUCINATION” or “NO_HALLUCINATION,” then a rationale, then a special <BBX> placeholder replaced by four discrete coordinate tokens. The tokenizer is expanded by

$K$0

and normalized coordinates are quantized via

$K$1

Training is performed with standard token-level cross-entropy over the entire assistant response, with system and user prompt tokens masked from the loss.

The dataset construction pipeline has four stages: candidate generation through both image-to-text and text-to-image routes; automatic filtering by GPT-5-mini scores; human annotation of incorrectness, explanation, and boxes; and reviewer-based quality control. The reported splits are 35,249 training caption-image pairs with 30,309 distinct images, and 5,606 test pairs with 2,569 images. Summary statistics include average caption length 24.82 words, vocabulary size 27,173 unique tokens, average boxes per image 1.32, a train “No hallucination” ratio of 7.3%, and hallucination types including Activity, Attribute, Color, Location, Object, Quantity, State, Size, “No hall.” and Others.

Evaluation is tri-partite. Verification uses Accuracy and optionally AUC. Explanation is judged through an LLM-as-judge protocol in which an external GPT-5 rater assigns a score in $K$2 scaled to $K$3. Localization is measured by IoU and thresholded accuracy

$K$4

with common thresholds $K$5.

The experimental results emphasize the difficulty of the benchmark. Among zero-shot baselines, GPT-5 reaches $K$6 at $K$7, $K$8 at $K$9, $g_k:\mathbb{R}^D\to[0,1]$0 at $g_k:\mathbb{R}^D\to[0,1]$1, and explanation average $g_k:\mathbb{R}^D\to[0,1]$2, while Qwen3-VL 30B attains $g_k:\mathbb{R}^D\to[0,1]$3, $g_k:\mathbb{R}^D\to[0,1]$4, $g_k:\mathbb{R}^D\to[0,1]$5, and $g_k:\mathbb{R}^D\to[0,1]$6 respectively. None of the six reported models exceed roughly $g_k:\mathbb{R}^D\to[0,1]$7 at $g_k:\mathbb{R}^D\to[0,1]$8. A supervised VisionLLM baseline fine-tuned on the GAVEL train split improves from a zero-shot base of $g_k:\mathbb{R}^D\to[0,1]$9 at $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$0 and explanation average $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$1 to $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$2 and explanation average $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$3 at epoch 7. The paper further reports box-size bias analysis via the distribution of $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$4, noting that GPT-5-mini tends to over-size boxes, Qwen3-VL-8B clusters tightly, and all models suffer substantial localization errors beyond mere size bias. In the paper’s own summary, GAVEL is presented as the first benchmark that simultaneously requires verification, explanation, and localization for image-caption faithfulness.

4. Legal summarization evaluation and agentic checklist extraction

“Gavel: Agent Meets Checklist for Evaluating LLMs on Long-Context Legal Summarization” uses the name Gavel for a paired evaluation framework and agent scaffold: Gavel-Ref and Gavel-Agent (Dou et al., 7 Jan 2026). The task is multi-document legal case summarization, with cases spanning 100K–500K tokens. Gavel-Ref is a reference-based evaluator built around a multi-value checklist of 26 items covering nine groups of case information: Basic Case Information, Legal Foundation, Judge Information, Related Cases, Filings & Proceedings, Decrees, Settlements, Monitoring, and Context.

The checklist formulation is explicitly multi-valued. For summary $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$5 and reference $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$6, an item $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$7 may produce a set

$g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$8

where each extracted value is paired with supporting text. Single-value items use exact or containment matching, while multi-value items are scored by list-wise $g(r_t) = (g_1(r_t),\dots,g_K(r_t)) \in [0,1]^K.$9. Gavel-Ref further adds residual fact evaluation for facts not covered by the 26 checklist items, and writing-style evaluation on five dimensions: readability/jargon, narrative order, sentence structure, formatting, and citation style. The aggregate score is

$CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$0

with $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$1 and $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$2 the residual-content ratio in the reference. The reported checklist score is

$CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$3

where $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$4 is the set of applicable items.

The evaluation corpus comprises 100 civil-rights litigation cases binned at 32K, 64K, 128K, 256K, and 512K tokens, with 20 cases per bin and 83% filed in 2025 to avoid data contamination. Twelve frontier LLMs are evaluated, including GPT-4.1, GPT-5, Claude Opus 4.1, Claude Sonnet 4, Gemini 2.5 Flash, Gemini 2.5 Pro, GPT-oss 20B, multiple Qwen3 variants, and Gemma3 variants. Reported overall performance on $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$5 is led by Gemini 2.5 Pro at 51.0, followed by Claude Sonnet 4 at approximately 49, Gemini 2.5 Flash at approximately 48, GPT-4.1 at approximately 47, GPT-5 at approximately 45, and Opus 4.1 at approximately 44; the best open-source model, GPT-oss 20B, scores 45.9. All models degrade as input grows, with even 1M-token systems dropping roughly 5–8 points between 32K and 512K. At the checklist-group level, models are strong on single-value basics such as filing date, cause of action, and judge name, but very weak on rare or multi-value groups such as Related Cases and Settlements. For Gemini 2.5 Pro, item-level scores range from Filing Date at 0.97 to Settlement Terms–Date–Duration below 0.12.

Gavel-Agent addresses extraction directly from source documents rather than from reference summaries. The paper describes three approaches: End-to-End extraction with a long-context LLM, Chunk-by-Chunk iteration over 16K-token segments, and Gavel-Agent, an LLM agent equipped with six tools: list_documents(), read_document(doc, start, end), search_document_regex(pattern, doc, top_k, context), get_checklist(item/items), append_checklist(patch), and update_checklist(patch). After each action, the agent receives refreshed task and checklist definitions, a document catalog with viewed-token tracking, current checklist state, and recent action history. It stops when all items are completed or explicitly marked Not Applicable.

In meta-evaluation on 40 cases, End-to-End extraction with GPT-4.1 achieves $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$6 with total tokens approximately $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$7 million. Gavel-Agent, using a Qwen3 30B-A3B 26-agent setup, obtains $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$8, described as a 7% drop relative to End-to-End, while using approximately $CE_k(r_t)=1 \iff g_k(r_t)\ge \tau_k,$9 million total tokens, a 36% reduction. Chunk-by-Chunk with Qwen3 30B-A3B reaches $\tau_k$0 and approximately $\tau_k$1 million tokens. The paper positions these results as evidence that long-context legal summarization remains difficult even for frontier models, and that structured extraction can trade modest accuracy loss for substantial efficiency.

5. Ontology engineering: OWL with first-order annotations

In ontology development, “Gavel” and its OWL-specific extension “Gavel-OWL” refer to a toolchain for heterogeneous “FOWL” ontologies that extend OWL with first-order logic annotations while remaining syntactically valid OWL files (Flügel et al., 2022). The central motivation is the gap between domain ontologies written in OWL and foundational ontologies written in first-order logic or Common Logic. Because ordinary OWL reasoners ignore annotations, richer foundational axioms embedded as annotation text remain inert in standard workflows.

The integration mechanism is explicit. FOL axioms are stored via OWL AnnotationAssertion axioms, for example under properties such as fopl:axiom or gavel:axiom. If $\tau_k$2 is an OWL ontology and $\tau_k$3 are the FOL annotations, the combined FOWL theory is

$\tau_k$4

where $\tau_k$5 maps OWL axioms into FOL sentences. A sample translation is

$\tau_k$6

The resulting unified theory is emitted in TPTP syntax and can be checked by a first-order theorem prover such as Vampire.

The translation pipeline uses a Java server accessed through Py4J and the OWL API to parse the ontology, collect annotation assertions, and obtain the OWL signature. OWL axioms are translated via the Direct Semantics mapping; CLIF-style annotations are converted to TPTP using a modified Macleod parser; symbol alignment uses Levenshtein and suffix heuristics to match FOL names to OWL IRIs or labels. The tool supports OWL consistency checking with HermiT on the OWL slice, and FOL consistency or entailment checking with Vampire on the combined theory.

The case studies are varied. In 12 test cases based on Schneider-Rudolph-Sutcliffe 2013, each involving patterns disallowed by OWL 2 DL global restrictions, Gavel-OWL replaces the illegal OWL axiom by an equivalent FOL annotation and Vampire succeeds on all 12 entailments where standard OWL reasoners fail. In the mereotopology setting based on KGEMT, 15 of 27 axioms are FOL-only; the paper reports 16 FOWL premises and Vampire proves all 16 entailments. In the integration of BFO with the OBI ontology, the authors clean BFO 2.0 OWL, align predicate names, import the resulting FOWL version into OBI, and detect four logical conflicts, including a contradiction involving IndependentContinuant, SpatialRegion, tissue, brain, and the disjointness of ImmaterialEntity and MaterialEntity. The process also uncovers a typo in BFO CLIF axiom [062-002]. For ChEBI, described as having approximately 180,000 classes and weak OWL axiomatisation but SMILES annotations for each class, Gavel automatically generates first-order axioms from SMILES, extracts a fragment with 80 incomplete classes and 6,569 complete ones, and reports 31% time-outs, 10,132 unexpected proofs (0.028%), and 256 unexpected counter-examples (0.0007%), some of which led to fixes by ChEBI maintainers.

The principal significance of this Gavel is infrastructural. It preserves Protégé- and OWL API-based workflows while enabling reasoning over axioms that exceed OWL 2 DL expressivity. Its limitations are equally explicit: reasoning becomes semi-decidable at the FOL level, symbol alignment is heuristic, and the tool does not yet cover higher-order axioms.

6. Software engineering and generative design uses

Two further uses of the name concern automated software metadata assignment and evolutionary design of board games. Both rely on learned representations, but their objectives differ sharply: one classifies existing artifacts, the other explores a large creative search space.

In “Automatic Categorization of GitHub Actions with Transformers and Few-shot Learning,” Gavel is a classifier for assigning one or more of 30 official GitHub Marketplace categories to a GitHub Action from its README.md content (Nguyen et al., 2024). The dataset merges two public collections—958 actions from Decan et al. (2023) and 708 from Kinsman et al. (2021)—into 1,213 unique actions spanning all 30 categories. Each README is parsed by the Marko library into plain prose, code blocks, and in-code comments. The model uses a sentence-Transformer SetFit backbone from Hugging Face, specifically all-MiniLM-L6-v2, mapping inputs of up to 512 sub-word tokens into 384-dimensional sentence embeddings. Multi-label classification is implemented in one-vs-rest form with sigmoid heads,

$\tau_k$7

and the loss is the sum of 30 binary cross-entropies. Few-shot fine-tuning samples approximately 16–32 positive and 16–32 negative examples per category. Evaluation uses stratified 10-fold cross-validation. Across five input configurations, the best result is obtained with plain text only (configuration $\tau_k$8), which reaches overall $\tau_k$9. Against HybridRec’s Complement Naïve Bayes baseline, Gavel improves micro-F1 from 0.66 to 0.75 and macro-F1 from 0.50 to 0.76. The comments-only configuration performs worst, with macro-F1 approximately 0.34. This suggests that prose descriptions in README files carry most of the discriminative signal for category assignment.

In “GAVEL: Generating Games Via Evolution and LLMs,” the acronym expands to “Generating Games Via Evolution and LLMs” and denotes a system for automatic generation of board games in the Ludii Game Description Language (Todd et al., 2024). The representation is L-GDL, an S-expression-based, ludeme-centered language. Ludii computes for each game a concept vector

$W_t=\{t-N+1,\dots,t\}$0

whose dimensions are high-level semantic features; these vectors serve as behavioral characterizations in MAP-Elites. The pipeline has two phases. First, CodeLlama-13b is fine-tuned with fill-in-the-middle capability on 574 Ludii games filtered to at most 1,024 tokens and approximately 50,000 parenthetical nodes extracted via balanced-parentheses parsing, using LoRA, 8-bit quantization, one epoch, AdamW, and learning rate $W_t=\{t-N+1,\dots,t\}$1. Second, evolutionary search maintains a $W_t=\{t-N+1,\dots,t\}$2 MAP-Elites archive over the first two PCA dimensions of $W_t=\{t-N+1,\dots,t\}$3.

At each generation $W_t=\{t-N+1,\dots,t\}$4 with $W_t=\{t-N+1,\dots,t\}$5, the system samples archive games, blanks out random parenthetical sub-expressions, asks the fine-tuned LLM to fill them, filters duplicates or unchanged offspring, evaluates fitness and concept vector, then inserts the child into the corresponding archive cell if it improves fitness. Fitness is hierarchical. If the game fails to compile, $W_t=\{t-N+1,\dots,t\}$6; if it compiles but has no legal moves, $W_t=\{t-N+1,\dots,t\}$7; if random playouts reveal balance or agency failures, $W_t=\{t-N+1,\dots,t\}$8. Otherwise, the framework gathers six metrics from self-play and random-play comparisons—balance, decisiveness, completion, agency, coverage, and strategic depth—and combines them with a harmonic mean:

$W_t=\{t-N+1,\dots,t\}$9

Across three seeds, GAVEL reports a Quality-Diversity Score of $t$00 versus $t$01 for GAVEL-UCB, with $t$02. It also reports $t$03 playable cells with $t$04, $t$05 novel cells with playable games, $t$06 cells with $t$07, and $t$08 novel cells with $t$09. Qualitative examples include YavaGo, Havabu, and HopThrough. The paper’s interpretation is that a domain-specific code LLM and quality-diversity search can jointly explore regions of the Ludii rules space not covered by the existing dataset.

7. Heterogeneity-aware cluster scheduling for deep learning workloads

In systems research, “Gavel” denotes a heterogeneity-aware scheduler for clusters of specialized accelerators such as GPUs, TPUs, FPGAs, and custom ASICs (Narayanan et al., 2020). Its central claim is not merely that heterogeneity matters, but that a wide class of scheduling policies can be systematically recast in heterogeneity-aware form by expressing them as optimization problems over machine-specific throughputs.

The formal model uses a throughput matrix $t$10, where $t$11 is job $t$12’s iterations per second on accelerator type $t$13, and an allocation matrix $t$14, where $t$15 is the fraction of wall-clock time job $t$16 should spend on type $t$17. Effective throughput is

$t$18

The basic feasibility constraints require $t$19, $t$20, and

$t$21

for each accelerator type. On top of this substrate, Gavel expresses throughput maximization, heterogeneity-aware max-min fairness, makespan minimization, finish-time fairness in the style of Themis, FIFO, shortest-job-first, cost minimization with optional SLO constraints, and hierarchical policies. The paper’s overarching design principle is that scalar allocations and scalar throughputs can be replaced by machine-type-indexed matrices without changing the general optimization pattern.

A second contribution is an enforcement mechanism. Once an ideal allocation $t$22 is computed, Gavel enforces it through preemptive rounds, with 6 minutes given as an example. At the end of each round, it measures the empirical fraction of time each job or co-located job combination has received on each accelerator type and computes a priority score that is high when a job has under-received service relative to $t$23. The scheduler then greedily selects the highest-priority job-type pairs subject to worker-count and conflict constraints. Tasks are managed through a checkpoint/lease interface so that preempted jobs can resume at iteration boundaries. The paper states that empirical fractions track the target allocation closely and that average job completion time remains within less than 5% of an ideal oracle allocator.

The system also incorporates two performance-modeling components. First, it profiles new jobs on different accelerator types to populate $t$24. Second, for space sharing, it uses a Quasar-style profiling and matrix-completion estimator to predict co-located throughputs. Gavel supports space sharing of up to two jobs per device type by extending the job set to include viable combinations and redefining effective per-job throughput as a linear combination of singleton and combination entries.

The evaluation covers a physical cluster with 48 GPUs—8 V100, 16 P100, and 24 K80—and a simulated cluster with 108 GPUs, 36 of each type. Workloads include ResNet-50, ResNet-18, A3C, an LSTM LLM, Transformer translation, CycleGAN, and a Recoder auto-encoder, with both static and continuous arrival traces. Relative to heterogeneity-agnostic baselines, Gavel reports up to 3.5× reduction in average job completion time under LAS for single-GPU jobs, 2.2× for multi-GPU jobs, 2.8× improvement in average stretch versus Themis, 2.5× speedup in makespan versus FIFO, 1.4× speedup versus Gandiva packing, up to 3.8× average-JCT improvement for FIFO at high load, 1.4× lower dollar cost versus a throughput maximizer, less than 1.0% SLO violations in the SLO-aware variant, and 17% higher total throughput than static partitioning in multi-level fairness experiments. In this formulation, Gavel is a unifying scheduler architecture rather than a single policy: it provides an optimization layer for defining target allocations and a round-based mechanism for realizing them on heterogeneous clusters.