Acknowledge the Apertus Acceptable Use Policy
Votum-8B is a LoRA adapter and decision head for swiss-ai/Apertus-v1.5-8B. This repository also holds the adapter merged into the Apertus weights, so it contains modified Apertus weights, which are distributed under the Apache-2.0 licence and the Apertus Acceptable Use Policy (AUP) v1.5. By requesting access you agree to use Votum-8B in accordance with that policy and to pass the same obligations on to anyone you share it with.
Apertus Acceptable Use Policy v1.5: https://github.com/swiss-ai/apertus-legal/blob/main/apertus_1.5/USAGE_POLICY.pdf
Log in or Sign Up to review the conditions and access this model content.
Votum-8B
A decision model on a fully open LLM backbone.
Quickstart · Request and response · Speed · Evaluation · How it works · Training · Limitations · License
Votum-8B turns Apertus-1.5-8B into a decision model. You give it some context (an email, a document, a JSON record, a photo), a question about it and the possible answers. It gives back a probability for each answer.
It does not write text. It reads the prompt once and scores the answers, so a short decision takes under 100 ms, the result is always one of your options, and the probabilities always sum to one.

Votum-8B adds a LoRA adapter and a pointer head to Apertus-1.5-8B, trained for seven GPU-hours on public data. Its server provides a
Jev-compatible endpoint (/v1/systemone).
| Input | a state (text or JSON, optionally with images) and up to 8 questions about it |
| Question types | pick one option · yes/no · rate on a scale |
| Longest prompt | 8,192 tokens per question |
| Languages | built for English, German, French and Italian; 73 languages appear in the training data |
| Speed | about 40 ms per decision for a 450-token prompt, on one NVIDIA RTX 4090 |
| Hardware | a 24 GB GPU; for 16 GB, use Votum-8B-FP8, with FP8-quantized weights, which gives the same answer 96 to 99 % of the time |
| License | Apache-2.0, plus the Apertus Acceptable Use Policy |
Quickstart
You need Python 3.11 or newer and an NVIDIA GPU with 24 GB of memory.
1. Install the package.
pip install votum
2. Get access. Signed in to Hugging Face, open votum-ai/Votum-8B and accept the Apertus Acceptable Use Policy in the access form above the model card; access is granted at once. Then connect your machine to your account with an access token (huggingface.co/settings/tokens, read access is enough):
hf auth login
3. Run a request. The email from the figure, with its three questions:
from votum import Votum
vm = Votum.from_pretrained("votum-ai/Votum-8B")
request = {
"state": "Hi, I was charged twice for my October invoice (INV-4411). Could you refund one of the two payments?",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should handle this ticket?",
"criteria": {
"billing": "Billing and payments",
"tech": "Technical support",
"sales": "Sales",
"hr": "Human resources",
},
},
"refund": {
"type": "noul",
"instructions": "Does the customer ask for money back?",
},
"urgency": {
"type": "score",
"instructions": "How urgent is this ticket?",
"criteria": ["low", "medium", "high"],
},
},
}
out = vm.decide(request)
print(out["answers"])
{
"team": {
"type": "choice",
"choice": "billing",
"confidence": 0.9619,
"probabilities": {
"billing": 0.9619,
"tech": 0.0079,
"sales": 0.0243,
"hr": 0.0059,
},
},
"refund": {
"type": "noul",
"noul": 0.8994,
},
"urgency": {
"type": "score",
"score": 0.9621,
"confidence": 0.4133,
"legend": {
"0": "low",
"1": "medium",
"2": "high",
},
"probabilities": {
"0": 0.3123,
"1": 0.4133,
"2": 0.2744,
},
},
}
Votum returns probabilities, not just a label, so high-confidence answers can be acted on and the rest escalated.
Run this model with the
votumPython package (pip install votum). Plain transformers or vLLM lack its attention mask and pointer head, and give meaningless answers.
Request and response
A request has two parts:
state: the context to decide on. A string, or any JSON object.questions: up to 8 questions about that state, keyed by an id. They are answered together.
Every question has instructions (the question text), a type and, depending on the type, criteria:
type |
Use | criteria |
|---|---|---|
choice |
one of several options | the options: {id: description}, or a list of ids |
noul |
a yes/no question | optional: {"true": description, "false": description} |
score |
a rating on a scale | the levels, lowest first |
The answer to a question holds its type and these fields:
| Field | Returned for | Value |
|---|---|---|
choice |
choice |
id of the most likely option |
noul |
noul |
probability that the answer is yes |
score |
score |
expected level, counting from 0 (0.96 is close to level 1, the second one) |
confidence |
choice, score |
probability of the most likely option or level |
probabilities |
choice, score |
probability of every option or level |
legend |
score |
level index to level text |
The request format (noul, instructions, criteria) is that of Jev and Jeff, so their clients
work unchanged.
Images. A state can hold images: put one anywhere in it as {"image": "photo.jpg"} and install
votum[vision]. In Python, the image can be a file path, raw bytes, a PIL image or a base64 string. Over HTTP it must
be base64-encoded, either plain or as a data URL ("data:image/png;base64,..."): the server never opens files or URLs
named in a request. Image support is a preview. Votum-8B was never trained on images: everyday photos work well, text inside
scanned documents does not yet. The images guide has examples and the measured accuracy.
As a server. votum serve starts an HTTP server built on vLLM, which batches concurrent requests. The endpoint
follows Jev's System One API:
pip install "votum[vllm]"
votum serve --model votum-ai/Votum-8B --port 8011
curl -s localhost:8011/v1/systemone -H 'content-type: application/json' -d '{
"state": "The printer on floor 3 is jammed again.",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team?",
"criteria": {
"it": "IT support",
"fac": "Facilities"
}
}
}
}'
The serving guide covers the API key, memory and the other settings.
For advanced use: raw scores and the separate adapter
- JSON states are written into the prompt with their keys sorted.
- Raw rows.
vm.decide_rows(rows)takes pre-built rows ({"type", "state", "question", "options": [{"id", "text"}]}) and returns raw scores and probabilities. - Usage. The server's response carries
usage.output_tokens = 0, because nothing is generated. - The separate adapter. The weights at the top of this repository have the LoRA adapter already merged into the
Apertus weights, so there is one download. The form the model was trained in, the adapter and the pointer head on
their own, is in
adapter/;Votum.from_pretrained(repo, exact=True)applies it to the original Apertus model, which it downloads fromswiss-ai. The two forms give the same scores on every evaluation set. Merging the adapter changes about 2 % of individual answers, in both directions, and makes serving about 10 % faster.
Speed
Measured on one NVIDIA RTX 4090 (24 GB) with this model, running as a server:
| Request | Prompt tokens | Latency | Decisions/s, many requests at once |
|---|---|---|---|
| 1 question about a short text | ~450 | ~40 ms | 23.5 |
| 1 question about a long document | ~3,000 | ~320 ms | 3.1 |
| 8 questions about a long document | ~3,300 | ~470 ms | 15.8 |
Asking several questions about the same state at once is cheaper than asking them one by one, because the state is read only once. With eight questions per request, the long document gives 5 times as many decisions per second as with one.
For comparison, Apertus-1.5-8B generating its answer, for the short text:
| Model | Output | Tokens written | Latency | Requests/s, many requests at once |
|---|---|---|---|---|
| Votum-8B | single-pass decision | 0 | ~40 ms | 23.5 |
| Apertus-1.5-8B | structured output: choice | 8 | ~210 ms | 21.0 |
| Apertus-1.5-8B | structured output: choice and probabilities | 54 | ~1.1 s | 10.9 |
How these were measured, and more workloads
Setup. One NVIDIA RTX 4090 (24 GB), 16-bit weights, votum serve. "Latency" is the median with
requests sent one at a time. "When many arrive at once" means 256 requests sent together for the short text,
and 64, 32 and 32 requests for the long documents with 1, 4 and 8 questions.
Short text. Items of the OpenDecisions benchmark: one question per request, about 445 prompt tokens each. The Votum row is this model on vLLM 0.33, with the time taken over 50 requests. The two Apertus rows were measured earlier on the same card, with vLLM 0.12 and a different sample of 256 OpenDecisions items, so the comparison is close but not exactly like for like.
Long documents. States of about 3,000 tokens with 1, 4 or 8 questions of up to 8 options each (3,042, 3,190 and 3,330 prompt tokens per question). This model on vLLM 0.33, no reuse of results between requests.
More workloads. The first three rows are our original measurements, taken with vLLM 0.12 and the adapter not yet merged; what we ship is a little faster (on OpenDecisions the median is now 39 ms, not 49).
| Workload | Prompt tokens per question | Decisions/s | Median latency | p95 latency |
|---|---|---|---|---|
| Validation mix, one question per request | 400 | 24.8 | 28 ms | 363 ms |
| OpenDecisions, one question per request | 445 | 22.6 | 49 ms | 100 ms |
| CLINC, 151 intents in each prompt | 1,635 | 11.1 | 98 ms | 100 ms |
| Long documents, 1 question per request | 3,042 | 3.1 | 323 ms | 334 ms |
| Long documents, 4 questions per request | 3,190 | 9.7 | 392 ms | 719 ms |
| Long documents, 8 questions per request | 3,330 | 15.8 | 465 ms | 808 ms |
Do the Python and server implementations agree? Yes, to within numerical noise:
- Python against the server, separate adapter: the same answer on 97.7 to 99.1 % of items. The median largest score difference is 0.11, the same as scoring an item in a batch instead of alone.
- The shipped weights on the server against that reference: 97.3 to 98.7 %, median difference 0.15 to 0.19. This includes the effect of merging the adapter.
- Merged against separate adapter on the same server (vLLM 0.33): 97.6 to 98.7 % of answers, and the same scores: OpenDecisions Capability 59.5 against 59.5, JevBench-Open 56.3 against 55.5, validation accuracy 63.0 against 62.9.
The evaluation tables below come from the original runs; the differences are run-to-run noise.
Evaluation
Votum-8B was measured on three decision benchmarks, on held-out sources in German, French and Italian, and on eleven public datasets that are not in its training data.
Decision benchmarks.
| Benchmark | Capability | Intelligence | Calibration |
|---|---|---|---|
| OpenDecisions | 59.4 | 39.8 | 79.0 |
| JevBench-Open | 55.1 | 40.3 | 69.8 |
Intelligence is chance-corrected accuracy, 100 · (acc − chance) / (1 − chance). Capability is the mean of Intelligence and Calibration.
| Benchmark | Requests | Index |
|---|---|---|
| Jev Decision Index 0.3 (public suite) | 140,620 | 36.92 |
Against Apertus-1.5-8B.
| Test | Metric | Votum-8B | Apertus-1.5-8B |
|---|---|---|---|
| Held-out German, French and Italian sources (7,261 rows) | Accuracy | 66.7 % | 62.2 % |
| BBQ social bias, ambiguous contexts | Share of "unknown" answers (the correct one) | 80.2 % | 57.1 % |
| BBQ social bias, ambiguous contexts | Bias score (0 is unbiased) | +2.0 | +3.6 |
Public sets outside the training pool. Accuracy on all items, and on the half the model is most confident about. The gap between the two columns is what the probabilities are for: accuracy is much higher on high-confidence answers, so the low-confidence half can be escalated to a person or a larger model.
| Set | n | Accuracy | ECE | Most confident half |
|---|---|---|---|---|
| BoolQ | 1,000 | 88.9 | 0.042 | 98.2 |
| SIB-200 (topics, 12 languages) | 2,448 | 82.4 | 0.108 | 97.4 |
| PubMedQA | 1,000 | 76.1 | 0.094 | 89.4 |
| CLINC-150 (with out-of-scope) | 2,000 | 76.4 | 0.328 | 86.7 |
| HellaSwag | 1,000 | 71.5 | 0.159 | 87.0 |
| BANKING77 (77-way) | 3,080 | 70.4 | 0.259 | 85.3 |
| TruthfulQA (MC1) | 817 | 64.7 | 0.128 | 85.0 |
| WinoGrande | 1,267 | 62.9 | 0.081 | 70.5 |
| Belebele | 2,400 | 61.4 | 0.063 | 87.3 |
| MMLU | 2,000 | 60.4 | 0.064 | 82.1 |
| Climate-FEVER | 1,535 | 52.6 | 0.051 | 71.7 |
ECE is the expected calibration error: the average gap between the stated confidence and the share of answers that are right (0 is perfect).
Stress tests.
- Option order. The answer is the same under all four rotations of the options for 97.8 % of MMLU items.
- Many options. On a BANKING77 sample, accuracy goes from 94 % with 4 intents shown to 68 % with all 77; the full 77-way test set reaches 70.4 %.
- Long context. A BoolQ passage hidden among about 7,000 tokens keeps 83.3 % accuracy (87.0 without the padding).
- "None of the above". When it is the right answer, the model picks it only 14.5 % of the time.
How these were measured
- Checkpoint. All numbers are for this checkpoint and were measured by us.
- Noise. The 95 % intervals come from resampling items only. In our development runs, scores moved between runs, and between checkpoints of one run, by about 1 point on OpenDecisions and about 5 on JevBench-Open Intelligence.
- Temperatures. Yes/no and score use the served temperatures. Choice uses 1.473, refit on the evaluation run (the served value is 1.516).
- Out-of-pool sets. These are fixed subsets rendered as decisions, not lm-evaluation-harness numbers.
- Jev Decision Index. Run with its public harness, unchanged. 2,322 requests longer than 8,192 tokens count as missing.
How it works
Votum is Apertus-1.5-8B with a LoRA adapter (rank 16, all 32 layers), a custom attention mask and a pointer head. The language-model head is not used: nothing is generated.

1. One prompt. A request is rendered as a single prompt: a header that lists its questions, then the state, then each question with its options. Every option ends with an end token.
2. Custom attention mask. Eight of the 32 layers (3, 7, …, 31) attend in both directions; the other 24 are causal. On top of that, a block mask isolates the parts of the prompt:
- the header does not attend to the state, and the state does not attend to the questions, so both are the same for every question of a request and are computed once;
- an option attends to the header, the state and its own question, never to another option, and nothing outside an option attends to it;
- all options of a question start at the same position id, so their order carries no signal.
The mask buys two things: answers that do not depend on the order of the options, and a header and state that are
computed once and shared by every question of a request. It costs two: options cannot be
weighed against each other (the model rarely picks "none of the above" when it is right), and the model only works
with the votum loader, not with plain transformers or vLLM.
3. Pointer head. Option j gets a score zj from the final hidden state hj at its end token, and a softmax over the options of a question gives the probabilities pj (formula in the figure). q0 is a learned 256-dimensional query, Wo a 256 × 4096 projection, LN a layer norm, and T a temperature per question type, which can be recalibrated on your own data.
Exact definition
| Part | What it is |
|---|---|
| Backbone | swiss-ai/Apertus-v1.5-8B text stack at revision ef4bbc54d6fe658bc782280ff9f3b53a10a9758f |
| Adapter | LoRA r 16, α 32 on q/k/v/o_proj and up/down_proj in all 32 layers; merged into the weights (bf16), exact fp32 form in adapter/ |
| Pointer head | score_j = ⟨q₀, W_o · LN(h_j)⟩ / 16, where h_j is the final state at option j's <|fim_end|> token, q₀ a learned 256-d query and W_o a 256 × 4096 projection |
| Attention | causal in 24 layers, bidirectional in layers 3, 7, …, 31 |
| Isolation | options never see each other, and nothing outside an option reads it; the state never reads the question; the header never reads the state |
| Positions | every option starts at the same position id |
| Header | each prompt starts with "Questions in this request:", listing the request's questions (choice options sorted) |
| Probabilities | softmax(scores / T), with T = 1.516 for choice, 1.310 for yes/no and 1.182 for score, fitted on validation data |
| Context | 8,192 tokens, set by max_tokens in the checkpoint and --max-model-len on the server. Votum was evaluated on prompts up to about 8,000 tokens (a BoolQ passage hidden among 7,000 tokens keeps 83 % accuracy). The prompt holds every option twice (once in the header), so a long state leaves fewer tokens for options; the largest case evaluated is 151 intents in one prompt. Beyond 8 questions, the extra ones are answered without the others listed |
| Training vs serving | when serving, the header lists options in sorted order and the prompt's last line break counts as part of the last option; in training the order was shuffled and the line break sat outside. Neither moves accuracy beyond noise |
Training
Data. 405,547 rows from 217 public sources, in the three question formats; 73 language codes, 41 % English. The sources are under CC-BY, Apache/MIT, CC0/PDDL, CC-BY-SA and government open-data licences. The cleaned successor of this data is published as votum-ai/Votum-Pool.
Run. A LoRA adapter and the pointer head, trained for about 7 hours on one 96 GB GPU (an estimated 6 to 7 kWh). The exact command is in the GitHub repository.
Fine-tuning. The same repository has a guide and scripts to fine-tune this checkpoint on your own decision rows. A 24 GB GPU is enough for prompts up to 3,072 tokens, or 2,048 if it also drives a display.
Recipe
- Learning rate 1e-4 (1e-3 for the head), 25 warm-up steps, then constant, with a cosine decay over steps 500–600.
- 65,536 tokens per step, 600 steps, seed 2, on one RTX PRO 6000 (96 GB).
- Options shuffled every step, and request headers of up to 8 questions.
- 21 % of rows carry no language code. No non-commercial or research-only sources.
Limitations
What it is weaker at
- Knowledge. It is an 8B model. On knowledge-heavy sets (MMLU, HellaSwag, Belebele, TruthfulQA) it is 13 to 18 points behind a frozen Qwen3.5-9B scored the same way.
- Abstention. It rarely picks "none of the above", "maybe" or "not enough information" when they are right.
- Calibration. It is under-confident on ordinary out-of-pool data and about right on hard decision benchmarks. If the probabilities themselves matter to you, refit the temperatures on a few hundred labelled requests of your own.
- Bias. BBQ shows a small residual bias in ambiguous contexts. Keep a person in the loop for decisions that affect people.
Size limits
- Context: 8,192 tokens per question. This is how far the model was trained and tested, not a limit of the architecture. A longer prompt is refused, not truncated. The limit can be raised, but answers beyond it are unverified; for longer documents, fine-tune on longer rows and measure.
- Options: no fixed number, but accuracy falls as they grow. Several hundred fit beside a short state. On BANKING77 accuracy goes from 94 % with 4 intents shown to 68 % with all 77. A short fine-tune on the target set recovers much of that (see the training guide).
- Questions: no limit in the architecture. Each question is scored in its own pass over the shared state, so
only a single question's prompt has to fit in 8,192 tokens. The server accepts 64 per request by default
(
VOTUM_MAX_QUESTIONS). - Questions listed together: 8, a setting. Each prompt starts with a header listing the request's questions, so
every question is read alongside the others. The header holds at most 8 (
decision_header.max_qinvotum_config.json). This is a choice, not a limit of the model, but more was never trained or measured: in the training data 96 % of states carried one question, 4 % two to four, and the few with more were shown 8 at a time. In a larger request, each question beyond the eighth gets a header of its own (itself and the first seven), so the state is read again for each of them; up to 8 questions per request is therefore the fastest per decision.VOTUM_HEADER_CHUNK=1instead splits the request into groups of 8, each sharing one reading of the state (not measured on labelled data).
Stress test. On synthetic lookup tasks in PyTorch, accuracy held with up to 1,024 questions per request and with 400 options in one question, and a fact hidden anywhere in an 8,192-token prompt was found every time, with confidence falling as the prompt grew (0.99 at 160 tokens, 0.64 to 0.87 at 7,900).
License
Votum-8B is released under Apache-2.0 (LICENSE, NOTICE).
It contains modified weights of swiss-ai/Apertus-v1.5-8B (the LoRA adapter merged into the text stack). Those are
distributed under Apache-2.0 and the
Apertus Acceptable Use Policy v1.5, and
access to this repository requires accepting that policy. If you redistribute Votum, make the policy available and
pass its obligations on.
Apertus ships no output filter, and Swiss AI advises updating the base weights every six months. Votum pins the base
revision in votum_config.json.
Votum is an independent project, not affiliated with or endorsed by the Swiss AI Initiative, EPFL, ETH Zurich or CSCS.
Acknowledgements
Votum builds on other people's work:
- Apertus, by the Swiss AI Initiative (EPFL, ETH Zurich, CSCS): the open model underneath Votum.
- Jev: the original decision models. Votum uses their request format (
choice,noul,score). - Jeff, by Jonathan Geuter, Andrew Cheng and David Alvarez-Melis
(Releasing the Inner Jev): the open recipe for turning a language model into a
decision model. Our evaluation pipeline was checked against their published numbers, and the code that reads
requests is derived from theirs (see
NOTICE). - JevPertus (code): an earlier decision model on the same Apertus-1.5-8B backbone, also a LoRA adapter with a pointer head.
- JevBench and the Jev Decision Index: independent public benchmarks for decision models, on which Votum is measured.
Citation
@misc{votum2026,
title = {Votum: a single-pass decision model on a fully open backbone},
author = {Claudio Vieira},
year = {2026},
url = {https://huggingface.co/votum-ai/Votum-8B}
}
Please also cite Apertus:
@techreport{apertus2026,
title = {Apertus 1.5: From Open Text Models to Open Multimodal Reasoners},
author = {{Project Apertus} and
Yixuan Xu and
Yassine Turki and
Vinko Sabolčec and
Valentina Pyatkin and
Tommy Chu and
Sven Najem-Meyer and
Sean F. Carroll and
Robert Smith and
Raphael Kreft and
Oscar Alessandro Tazza and
Oleg Lavrovsky and
Nicola Irmiger and
Matteo Santelmo and
Marian Schneider and
Juan García Giraldo and
Hanna Yukhymenko and
Eduard Ďurech and
Davit Melikidze and
Dani Tamayo and
Bettina Messmer and
Aryan Ahadinia and
Anunay Yadav and
Allen Huang and
Ahmad Fraij and
Alessandro Bombarda and
Alex Padula and
Alexander Hägele and
Alexander Sternfeld and
Anna Hedström and
Anna Kosovskaia and
Arthur Wuhrmann and
Arundhati Balasubramaniam and
Badr Al Mahouri and
Barna Pasztor and
Bartosz Szostakiewicz and
Bich Ngoc Doan and
Bryan Schmid and
Burak Sezen and
Camille Challier and
Clément Charmillot and
Dana Shayakhmetova and
Daniel Perruchoud and
David Brüggemann and
David Isztl and
Elia Palme and
Emma Anastassova and
Fabian Bösch and
Faruk Zahiragić and
Fawzi Roberto Mohamed and
Fiona Panicali and
Florian Kolly and
Flynn Guerra and
Francesco Monti and
Frederike Lübeck and
Gennaro Oliva and
Haofeng Yang and
Haoliang Shang and
Helen El Khoury and
Henrique Mendonça and
Jannis Vamvas and
Jérome Landolt and
Jessica Lam and
Jingchun Xiao and
Jonathan Coles and
Joshua Oyebanji and
Khanh Nguyen and
Konstantinos Pitas and
Lasse B. Strand and
Li Mi and
Loïc Deslarzes and
Lorenzo Baggi and
Lorenzo Noci and
Luca Baumann and
Luca Sartori and
Lukas Drescher and
Marco De Negri and
Marco Passerini and
Mark Klein and
Marko Stojanovic and
Martin Majsec and
Matin Ansaripour and
Mattea Busato and
Mauro Pellonara and
Max Neuwinger and
Michael Graber and
Michal Tešnar and
Michelle Wastl and
Miguel Gila and
Mikolaj Boronski and
Morgane Magnin and
Moritz Reihs and
Mukhammadali Sayfiddinov and
Nathan Ranchin and
Nicolas Cuveillier and
Oscar Wohlfahrt and
Qianqian Zou and
Rada Kamysheva and
Rita Sevastjanova and
Roman Machacek and
Sebastian Keller and
Simon Matrenok and
Simon Pierre and
Stefano Schuppli and
Suei-Wen Chen and
Szabina Horváth-Mikulas and
Taliesin Perez and
Thilo Spinner and
Thomas Kleine Buening and
Tim Robinson and
Tymoteusz Kwiecinski and
Vilém Zouhar and
Vinzenz Thoma and
Xiaozhe Yao and
Yannick Metz and
Yuhei Fukuhara and
Yusif Askari and
Zixuan Chen and
Alexander Ilic and
Ana Klimovic and
Andreas Krause and
Andrei Kucharavy and
Elliott Ash and
Joost VandeVondele and
Martin Rajman and
Mennatallah El-Assady and
Thomas Schulthess and
Timo Kehrer and
Torsten Hoefler and
Antoine Bosselut and
Martin Jaggi and
Imanol Schlag},
institution = {Swiss AI Initiative},
type = {Technical Report},
year = {2026},
eprint = {2610.15542},
archivePrefix = {arXiv},
primaryClass = {cs.CL},
url = {https://arxiv.org/abs/2610.15542},
}
- Downloads last month
- 2