Surogate Rune

Chat models excel at conversation. But software usually needs something else: a clear, typed decision that is fast enough for every request and cheap enough for every row.

Asking a general model for simple decisions means paying for prose you throw away, parsing what comes back, and validating it in case the model invented a category that does not exist.

Today we are releasing an open-weights decision model under a permissive license: Surogate Rune.

What it does

Give it text, structured data, or an image with text, along with a question and a set of options. It returns a single answer with a calibrated probability:

• Choice (choice): select one option from a set
• Truth (noul): estimate how likely a statement is to be true
• Ordinal (score): place something on a defined scale

It is a 26-billion-parameter mixture of experts with 4 billion parameters active per token, with a 262,000-token context.

Key capabilities

Fixed answer set. A choice returns one of the keys you supplied. A noul returns a number between 0 and 1. A score returns a position on the list you provided. The response contains no free text and no categories you did not define, so there is nothing to parse or validate.

Full probability distribution. Every choice and score answer includes probabilities for all the options you offered, not only the selected one. A close decision and a clear one look different in the response.

Calibrated confidence. Higher confidence corresponds to higher accuracy, so a threshold is meaningful. Decisions above your threshold can be applied automatically, and those below it sent for review. The proportion in each group is something you can measure.

Multiple questions per request. A workflow is usually more than one decision. All questions in a request are answered together against the same input, and each one can be changed without affecting the others.

Structured input. state accepts a string, an object or an array, so you send the record you already have: fields, a document or a payload.

Thinking when it's unsure. Thinking is off by default. Turn it on for a request and Rune reasons for up to 512 tokens before it answers any question it is less than 70% sure of. Every other question keeps its one-pass answer.

Benchmark results

On par with Jev. The Decision Index is a public leaderboard for decision models: 38 benchmarks in five areas, with each benchmark's score adjusted so that guessing scores zero. On its current edition, 0.2.1, Surogate Rune scores 57.44. Jev 1.13, the hosted API that leads the board, scores 57.91.

Rune is ahead of Jev in three of the five areas: Language, Retrieval & Classification, and Arts & Human Taste.

With thinking turned on, our own run of the suite puts Rune about 1.3 points ahead of Jev. That result is not on the leaderboard yet.

Scores as published on the leaderboard on 28 September 2026.

Decisions in milliseconds

On one NVIDIA RTX PRO 6000, served by Surogate, Rune returns a decision in 90 to 180 ms, with no network round trip and no remote API in the path.

Only questions Rune is unsure of think, so with thinking on, most answers stay as fast as without it.

A decision this fast, running on a single card in your own rack, can sit directly inside a request, a pipeline or a loop, and run on every row without a per-call bill.

Typical use cases

Here are some example decisions. Each one is a POST request to /api/alpha/decisions: the input goes in state, and every question names its type, its instruction and the criteria the model decides against.

Routing and classification. A customer complaint, a support ticket or a medical referral arrives as free text, and the model picks the team that should handle it. A choice question returns the selected option, a confidence, and the probability it gave every option you offered.

{
  "questions": {
    "team": {
      "type": "choice",
      "instructions": "Which team should handle this complaint?",
      "criteria": {
        "cards": "Card payments, chargebacks and disputed transactions.",
        "lending": "Loans, mortgages and credit decisions.",
        "accounts": "Account opening, closing, statements and access."
      }
    }
  },
  "state": {
    "channel": "web form",
    "complaint": "I was charged twice for the same purchase on 14 March and the second charge has still not been reversed."
  }
}

{
  "answers": {
    "team": {
      "type": "choice",
      "choice": "cards",
      "confidence": 0.93,
      "probabilities": { "cards": 0.93, "lending": 0.01, "accounts": 0.06 }
    }
  }
}

Validation checks. Does this invoice match the purchase order? Does this reply answer the customer's question? Is this identity document still valid? A noul question takes criteria for true and for false, and answers with a single probability.

{
  "questions": {
    "matches_po": {
      "type": "noul",
      "instructions": "Does the invoice match the purchase order?",
      "criteria": {
        "true": "Supplier, line items and total agree with the purchase order.",
        "false": "Any supplier, line item or total differs from the purchase order."
      }
    }
  },
  "state": {
    "purchase_order": { "supplier": "Nordkraft AS", "total_eur": 12400.00, "lines": 3 },
    "invoice": { "supplier": "Nordkraft AS", "total_eur": 12400.00, "lines": 3 }
  }
}

{
  "answers": {
    "matches_po": { "type": "noul", "noul": 0.97 }
  }
}

Scoring and prioritisation. Incident severity, transaction risk, ticket urgency, placed on a scale you define. A score question takes an ordered list and returns a position on it, plus a legend so you can read the number back.

{
  "questions": {
    "severity": {
      "type": "score",
      "instructions": "How severe is this incident?",
      "criteria": [
        "Cosmetic, no customer impact",
        "Degraded for some customers",
        "Service down for everyone"
      ]
    }
  },
  "state": {
    "report": "Payments have been failing for all customers in the Nordics since 09:12. Retries are not succeeding."
  }
}

{
  "answers": {
    "severity": {
      "type": "score",
      "score": 1.94,
      "confidence": 0.96,
      "probabilities": { "0": 0, "1": 0.06, "2": 0.94 },
      "legend": {
        "0": "Cosmetic, no customer impact",
        "1": "Degraded for some customers",
        "2": "Service down for everyone"
      }
    }
  }
}

Documents and images. Scanned forms, photographs of meters, screenshots attached to a bug report. The same questions work on an image.

Nothing stops you asking all three at once about the same document. One request, one forward pass, three answers.

Other applications

The same three question types cover work well outside document handling.

Inside an agent loop. Choosing the next tool, the next step, or which sub-agent should take over. At a tenth of a second or so per decision the model can sit in the loop itself, rather than being something the loop stops to call.

Batch classification. Several attributes of one document, such as category, priority, sentiment and completeness, asked in a single request and run across an entire archive. With no per-call fee, a pass over a corpus costs GPU time and nothing else.

Screening and fraud checks. Is this claim consistent with the policy? Is this transaction anomalous? Is this message a phishing attempt? A noul answer against a threshold, with the borderline cases passed to a person.

Grading another system's output. Scoring a generated reply for accuracy, tone or policy compliance before it reaches a customer, on a scale you define and apply consistently.

Extraction with a fixed vocabulary. Pulling a field out of a document when the permitted values are known in advance: supplier from an invoice, product line from an order, department from a form.

Deployment options

You can use Surogate Rune in two ways.

Through our hosted API. Send your decisions to our endpoint and start without setting up a GPU.

On your own hardware. A hosted API means sending your data somewhere else. For many organizations, especially in banking, healthcare, insurance and other regulated environments, that rules it out before accuracy even enters the conversation. Run Rune yourself and your data stays inside your environment. The model can run entirely offline.

The weights are Apache 2.0 licensed: yours to keep, inspect, fine-tune, and deploy. No per-token fees. No rate limits. No dependency on a hosted provider. Nothing needs to leave your infrastructure.

Trained and served with Surogate. Rune was trained with Surogate, our open-source training engine, a native C++/CUDA stack with FP8 and NVFP4 recipes built for NVIDIA Blackwell. The same engine serves it, and on Blackwell cards (the RTX 50 series and RTX PRO series), it is the fastest way to run the model. The engine also runs on earlier NVIDIA architectures: Hopper (H100, H200), Ada Lovelace (RTX 40 series, L40S) and Ampere (A100, RTX 30 series).

The weights are bf16 and take 51.6 GB, so they need a GPU with room for them and the KV cache. We serve them on 96 GB RTX PRO 6000 cards:

hf download surogate/rune-26b-a4b-GGUF --local-dir rune
surogate serve ./rune --host 0.0.0.0 --port 8000 \
  --max-model-len 32768 --max-num-seqs 8 --kv-capacity auto --decision-temperature 2

--decision-temperature 2 makes the confidence scores match accuracy. It never changes which option Rune picks.

Why we built it

Models that can run on European infrastructure, operate under European law, and keep sensitive customer data out of foreign APIs. Models whose weights can be inspected, deployed, adapted, and kept without asking permission from a provider.

The weights are on Hugging Face.

If you want help putting one into a real decision path, talk to us.