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.

Benchmark results

The highest-scoring decision model you can run on your own hardware. On the Decision Index — 132,000 requests across 37 benchmarks — Surogate Rune scores 57.24. That is 96% of the leading hosted API, and ahead of every other model on the board with open weights.

Three of those open entries take a different route to the same goal: they wrap an untrained general model in decision-specific decoding. One is exactly Rune's size, a 26B mixture of experts with 4B parameters active; the others are a 27B dense model and a 4B one. Rune, trained for the task, scores above all three.

Inside the numbers:

• Language: 63.1, ahead of the leading hosted API at 62.3
• Tools & Automation: 72.7, within a point of it
• Every request answered. A declined request is scored as wrong, and two models on the board did not answer them all

For vision, we ran the 2,017-question ScienceQA test set, scoring 92.22% accuracy with images included.

Decisions in milliseconds

Surogate Rune can return a decision in as little as 42ms, with no network round trip and no remote API in the path.

Even image-based decisions complete in just 169ms to 195ms median, depending on quantisation.

42 milliseconds changes the economics of inference. 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/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 tens of milliseconds 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 — category, priority, sentiment, 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

Hosted decision APIs require sending your data somewhere else. For many organizations—especially in banking, healthcare, insurance, and other regulated environments—that can be a constraint before accuracy even enters the conversation.

Surogate Rune runs on your hardware. Your data stays inside your environment, and 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, using int8 tensor cores directly, 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).

docker run --gpus all -p 8000:8000 -v $PWD:/models \
  ghcr.io/invergent-ai/surogate:1.5.1 \
  serve /models/rune-26b-a4b-JD-Q4_K_M.gguf --host 0.0.0.0 --port 8000

Because the weights are GGUF, Rune also runs anywhere GGUF does — llama.cpp, LM Studio, Ollama or Jan — on whatever hardware you already have.

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.