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.

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.

Code: votum on GitHub Training data: Votum-Pool Built on Apertus-1.5-8B License: Apache-2.0

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.

Four requests answered by Votum-8B: an email about a double charge, a JSON order record, a photo of a derailed locomotive and a photo of a street market. The same answers are listed as text below the figure.

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 votum Python 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 from swiss-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.

One request through the model in three panels: the prompt with header, state, questions and options; the attention mask between those blocks; the pointer-head formula z_j = <q_0, W_o LN(h_j)> / 16 with p_j = softmax(z / T)_j, and the score and probability of each option

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_q in votum_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=1 instead 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
Safetensors
Model size
8B params
Tensor type
BF16
·
F32
·
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for votum-ai/Votum-8B

Adapter
(8)
this model
Quantizations
1 model

Papers for votum-ai/Votum-8B