What is Darwin-27B-ZTC? Probability-based decisions with 54 GB BF16

The model card says Darwin processes a state and typed question in one forward pass. It returns a probability distribution by applying softmax to option scores; it generates no tokens². It is therefore not a model to evaluate with chat-style tok/s or answer length.

The three question types serve different purposes. noul makes a yes/no decision, choice selects one labeled option, and score rates an ordered rubric. Including a description for each option makes the comparison criteria explicit in the input.

The model card lists about 54 GB of GPU³ memory for BF16 weights. That figure covers weights, so leave additional room for the operating system, CUDA⁴ context, and input length. If the device cannot provide that capacity, do not assume this example will run unchanged; first check the model card for an official quantized or distributed option.

The model card's local example downloads a Hugging Face snapshot and imports autojev.model.DecisionModel. Listed dependencies are PyTorch⁵, Transformers with Qwen3.5 support, safetensors, and Pillow. The decision code and weights are both required, including readout.safetensors and decision_config.json alongside the backbone files.

pip install torch transformers safetensors pillow huggingface_hub

The card example combines state and question in one row and passes it to model.predict([row]). A choice question includes its type, instructions, and descriptions by option. Save the code as decide.py and run python decide.py; verify option names and probability indexes with a fixed case before wiring it into a service.

import sys
from huggingface_hub import snapshot_download

path = snapshot_download("FINAL-Bench/Darwin-27B-ZTC")
sys.path.insert(0, path)
from autojev.model import DecisionModel
model = DecisionModel(checkpoint=path)

row = {
    "state": {"ticket": "Customer was charged twice for the same order."},
    "question": {
        "type": "choice",
        "instructions": "What should support do?",
        "criteria": {
            "refund": "Refund the duplicate charge.",
            "escalate": "Send to billing.",
            "close": "No action.",
        },
    },
}
probabilities = model.predict([row])[0]
for label, probability in zip(row["question"]["criteria"], probabilities):
    print(label, float(probability))

The example below follows the model card's duplicate-charge classification. No output probability values are stated here because they depend on the hardware and package version used. Check that the option probabilities form a distribution near 1 and preserve input order before connecting them to application policy.

On the model card's Typed Decisions evaluation, the test split contains 400 cases and 2,000 decisions, with reported overall accuracy of 0.743. This is a result on that evaluation set, not a guarantee for your business data. The card also describes the difference between two runs, 0.741 and 0.743 accuracy, as run-to-run variation from request batching.

Compare representative cases with real labels to evaluate classification errors and probability calibration. If BF16 memory is unavailable or the task needs free-form explanations, another decision or generative path may fit better.