Nordic Customer Impact (Qwen3.5-4B)

Reads one message a customer sent to a business — an email, a chat, an SMS, a web form, a social media post, a public review, an app store review, a note from a phone call or a letter — and answers 18 questions about it in one call, each with a calibrated probability: what the sender wants, what it is about, how they feel, whether something is broken and for whom, how urgent it is, and which risks and opportunities the message carries for the business.

Works for any kind of business. Languages: Norwegian (Bokmål and Nynorsk), Swedish, Danish, Finnish and English.

{"message_type": {"answer": "problem", "p": 0.94}, "urgency": {"answer": "immediate", "p": 0.88},
 "safety": 0.97, "churn": 0.81, "legal": 0.12, "loyalty": 0.03, ...}

It is a decision model: each answer is a probability read from the model, not generated text, so every call is well-formed and the probabilities can be used directly as confidence.

How it fits together

The structure follows the OMG Business Motivation Model. The customer's message is an Influencer; the model's answers are the Assessment; the risk and reward questions are the Potential Impact, with the model's probability as the likelihood. The model only describes the message. Severity, response times and escalation are Business Rules you own: customer_impact.py contains reference rules (below) meant to be changed.

Questions

Seven choice questions:

Question Answers
message_type — What does the sender mainly want? problem, complaint, question, request, account, billing, cancellation, feedback, praise, privacy, spam, unclear
topic — What is the message mainly about? quality, delivery, staff, price, communication, digital, safety, premises, terms, other
sentiment — What is the overall sentiment of the message? very_negative, negative, neutral, positive, very_positive
emotion — Which emotion dominates the message? calm, confused, frustrated, angry, worried, happy
service_state — Is something the customer needs not working? down, degraded, working, unknown
scope — Who is affected? individual, group, organisation, unknown
urgency — How urgent is the matter? immediate, soon, none

Eleven yes/no questions (asked as two-answer choice questions, yes / no):

Group Question
Risk legal — a legal or regulatory issue (data protection, consumer rights, safety rules, discrimination, breach of contract)
Risk liability — holds the business responsible for a loss or damage and claims or threatens compensation or legal action
Risk safety — a risk to people's health, safety or security
Risk reputation_risk — exposes the business publicly, or threatens to (media, reviews, social media, authorities)
Risk churn — signals leaving, cancelling, not renewing or switching
Risk revenue_loss — a refund, compensation, chargeback, discount demand or lost sale
Reward loyalty — satisfaction, praise or an intention to stay
Reward revenue_gain — interest in buying, booking, upgrading or expanding
Reward advocacy — recommends the business or praises it publicly
Reward improvement — a concrete suggestion that could improve the product or service
Care vulnerable — serious illness, bereavement, financial hardship, disability or great difficulty understanding

The exact wording is in questions.json. Send it unchanged: the model was trained on those strings. You can send a subset of the questions.

Use

Files: nordic-customer-impact-qwen3.5-4b.Q8_0.gguf, questions.json and customer_impact.py.

The model runs on the System One endpoint, POST /v1/systemone (tested with Ollama 0.40.2; Unsloth Studio also serves it). The GGUF uses Ollama's decision-model layout: the Qwen3.5 backbone with the decision head stored as qwen35.decision.*.

ollama pull hf.co/unified-analytics/nordic-customer-impact-qwen3.5-4b:Q8_0
ollama cp hf.co/unified-analytics/nordic-customer-impact-qwen3.5-4b:Q8_0 nordic-customer-impact

The request

The state is the channel and the message, exactly in this form, and the questions come from questions.json:

{"model": "nordic-customer-impact",
 "state": "Channel: email\nMessage: Tredje gang denne måneden at pakken ikke kommer. ...",
 "questions": {"message_type": {"type": "choice", "instructions": "What does the sender mainly want?",
                                "criteria": {"problem": "Reports something that does not work or went wrong", "...": "..."}},
               "...": "..."}}

Channels used in training: email, chat, web form, SMS, social media post, public review, app store review, phone call note, letter. The channel matters: a public review or post that criticises the business is a reputation risk by itself.

With curl and jq:

jq -n --arg state $'Channel: email\nMessage: Tredje gang denne måneden at pakken ikke kommer. Jeg har betalt for ekspress og vil ha pengene tilbake, ellers bytter jeg til en annen nettbutikk.' \
      --slurpfile q questions.json \
      '{model: "nordic-customer-impact", state: $state, questions: $q[0].questions}' \
  | curl -s http://localhost:11434/v1/systemone -d @-

The response

Each answer has the most likely choice and the full probabilities (shortened here). For a yes/no question, probabilities.yes is the probability of yes. Ollama also returns a confidence value; the results on this card use probabilities.

{"model": "nordic-customer-impact",
 "answers": {
   "message_type": {"type": "choice", "choice": "billing",
                    "probabilities": {"billing": 0.842, "problem": 0.140, "complaint": 0.009, "...": "..."}},
   "urgency":      {"type": "choice", "choice": "none",
                    "probabilities": {"immediate": 0.007, "soon": 0.291, "none": 0.702}},
   "churn":        {"type": "choice", "choice": "yes", "probabilities": {"yes": 0.999, "no": 0.001}},
   "...": "..."},
 "usage": {"input_tokens": 2230, "output_tokens": 0}}

Python helper

customer_impact.py (standard library only) makes the call, flattens the answers and applies the reference rules:

python customer_impact.py --model nordic-customer-impact --channel email \
  "Tredje gang denne måneden at pakken ikke kommer. Jeg har betalt for ekspress og vil ha pengene tilbake, ellers bytter jeg til en annen nettbutikk."
{"answers": {"message_type": {"answer": "billing", "p": 0.842}, "topic": {"answer": "delivery", "p": 0.997},
             "sentiment": {"answer": "negative", "p": 0.994}, "emotion": {"answer": "frustrated", "p": 0.984},
             "service_state": {"answer": "degraded", "p": 0.979}, "scope": {"answer": "individual", "p": 0.999},
             "urgency": {"answer": "none", "p": 0.702},
             "legal": 0.429, "liability": 0.003, "safety": 0.0, "reputation_risk": 0.003, "churn": 0.999,
             "revenue_loss": 0.962, "loyalty": 0.001, "revenue_gain": 0.001, "advocacy": 0.0, "improvement": 0.0,
             "vulnerable": 0.001},
 "rules": {"severity": "major", "assessment": "threat", "net_impact": -3.81, "actions": ["Alert the account owner"]}}

As a library:

import json
from customer_impact import assess, rules

questions = json.load(open("questions.json", encoding="utf-8"))["questions"]
answers = assess("http://localhost:11434", "nordic-customer-impact", "chat",
                 "Hei! Appen logger meg ut hele tiden, og jeg får ikke betalt regningen som forfaller i dag.", questions)
print(answers["urgency"], answers["churn"], rules(answers)["severity"])

Routing with confidence

The probabilities are calibrated, so they can decide when to act automatically and when to ask a person:

QUEUES = {"billing": "finance", "cancellation": "retention", "privacy": "data-protection",
          "account": "support", "problem": "support", "spam": "archive"}

def route(answers):
    severity = rules(answers)["severity"]
    kind = answers["message_type"]
    if severity in ("crisis", "blocker") or answers["vulnerable"] >= 0.5:
        return "priority-human"            # serious or sensitive: a person, now
    if kind["p"] >= 0.8:
        return QUEUES.get(kind["answer"], "customer-service")
    return "triage"                        # the model is unsure: let a person decide

Batch

Assess a JSONL file of {"channel": ..., "text": ...} lines, four requests at a time:

import json
from concurrent.futures import ThreadPoolExecutor
from customer_impact import assess, rules

questions = json.load(open("questions.json", encoding="utf-8"))["questions"]

def one(line):
    m = json.loads(line)
    a = assess("http://localhost:11434", "nordic-customer-impact", m.get("channel", "email"), m["text"], questions)
    return {**m, "answers": a, "rules": rules(a)}

with open("messages.jsonl", encoding="utf-8") as src, open("assessed.jsonl", "w", encoding="utf-8") as out, \
        ThreadPoolExecutor(4) as pool:
    for result in pool.map(one, (l for l in src if l.strip())):
        out.write(json.dumps(result, ensure_ascii=False) + "\n")

A subset of the questions

You can send only the questions you need; the input gets shorter (each question adds roughly 120 tokens). The reference rules need the full set.

risk_questions = {k: questions[k] for k in ("safety", "legal", "liability", "reputation_risk", "churn")}
risks = assess("http://localhost:11434", "nordic-customer-impact", "public review", text, risk_questions)

C# (.NET)

using System.Net.Http.Json;
using System.Text.Json.Nodes;

var questions = JsonNode.Parse(File.ReadAllText("questions.json"))!["questions"]!;
var http = new HttpClient { BaseAddress = new Uri("http://localhost:11434"), Timeout = TimeSpan.FromMinutes(2) };

async Task<JsonObject> AssessAsync(string channel, string text)
{
    var request = new JsonObject
    {
        ["model"] = "nordic-customer-impact",
        ["state"] = $"Channel: {channel}\nMessage: {text}",
        ["questions"] = questions.DeepClone(),
    };
    using var response = await http.PostAsJsonAsync("/v1/systemone", request);
    response.EnsureSuccessStatusCode();
    return (await response.Content.ReadFromJsonAsync<JsonObject>())!["answers"]!.AsObject();
}

var answers = await AssessAsync("web form", "Vi har ikke hatt varmtvann i hele blokka siden i går kveld.");
foreach (var (name, answer) in answers)
{
    var probabilities = answer!["probabilities"]!.AsObject();
    var choice = answer["choice"]!.GetValue<string>();
    Console.WriteLine(probabilities.ContainsKey("yes")
        ? $"{name}: P(yes) = {probabilities["yes"]!.GetValue<double>():0.000}"
        : $"{name}: {choice} ({probabilities[choice]!.GetValue<double>():0.000})");
}

JavaScript (Node 18+)

Save as assess.mjs:

import { readFile } from "node:fs/promises";

const { questions } = JSON.parse(await readFile("questions.json", "utf8"));

async function assess(text, channel = "email") {
  const res = await fetch("http://localhost:11434/v1/systemone", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ model: "nordic-customer-impact", state: `Channel: ${channel}\nMessage: ${text}`, questions }),
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  const { answers } = await res.json();
  return Object.fromEntries(Object.entries(answers).map(([name, a]) =>
    [name, "yes" in a.probabilities ? a.probabilities.yes : { answer: a.choice, p: a.probabilities[a.choice] }]));
}

console.log(await assess("Tusen takk til Ahmed i kassa, han hjalp mamma med alt!", "public review"));

Reference rules

Read at a threshold of 0.5 unless a rule says otherwise. All of it lives in customer_impact.py, to be adapted.

Severity, first match:

  1. crisis: safety and urgency immediate; or service down for a whole organisation.
  2. blocker: service down; or safety; or legal and liability together.
  3. major: service degraded; or any of legal, liability, reputation_risk, churn; or vulnerable.
  4. minor: everything else.

Raise one level when reputation_risk ≥ 0.8 and scope is organisation.

Assessment: threat when any risk is yes, opportunity when any reward is yes, both, or neutral.

Net impact = Σ reward weight × p − Σ risk weight × p, with weights loyalty 1, revenue_gain 1.5, advocacy 1.5, improvement 1; legal 2, liability 2, safety 3, reputation_risk 2, churn 1.5, revenue_loss 1.5.

Suggested actions: safety → stop the harm, on-call; personal data with a legal issue → data protection officer (72-hour breach notification); liability → management, and the reply must not admit fault; churn → account owner; revenue_gain → sales; improvement → product owner; vulnerable → a person, not an automated reply; spam → archive.

Results

Test: 600 messages from whole batches that training never saw (80–160 per language, all channels). Accuracy and macro-F1 over the answers; ECE is the calibration error (0 = the probabilities match the observed rates).

Question Accuracy Macro-F1 ECE Yes: precision / recall
message_type 0.810 0.785 0.028
topic 0.812 0.781 0.036
sentiment 0.867 0.823 0.026
emotion 0.872 0.832 0.030
service_state 0.890 0.814 0.019
scope 0.878 0.768 0.026
urgency 0.888 0.863 0.035
legal 0.942 0.921 0.020 0.92 / 0.84
liability 0.988 0.957 0.007 0.98 / 0.87
safety 0.978 0.934 0.010 0.96 / 0.81
reputation_risk 0.978 0.971 0.007 0.95 / 0.96
churn 0.958 0.913 0.023 0.95 / 0.77
revenue_loss 0.937 0.910 0.025 0.89 / 0.84
loyalty 0.972 0.960 0.010 0.91 / 0.97
revenue_gain 0.957 0.930 0.008 0.86 / 0.92
advocacy 0.982 0.942 0.007 0.89 / 0.90
improvement 0.985 0.977 0.009 0.96 / 0.97
vulnerable 0.967 0.938 0.007 0.85 / 0.95

Mean accuracy over the 18 questions by language: Swedish 0.935, English 0.938, Bokmål 0.925, Danish 0.921, Nynorsk 0.919, Finnish 0.913; all 0.926. A Qwen3.5-0.8B model trained the same way reached 0.874.

Some questions are hard by nature. Before the final labelling pass, two independent labellers agreed on the message type of only 64% of the messages, mostly on problem versus complaint versus billing. Use the probabilities: for routing, act on a confident answer and send the rest to a person.

Checked on Ollama 0.40.2 with the published GGUF: the same answer as Unsloth Studio on 10,754 of the 10,800 test answers (median probability difference 0.0003), and a mean accuracy of 0.925 (Studio: 0.926). Speed: about 1.5 s per message for all 18 answers with six requests in parallel on one RTX PRO 6000 (Studio), about 1.9 s with four in parallel on a production Ollama server. The 18 questions take about 2,200 tokens ahead of the message, so a server that caches the prompt prefix answers faster.

Training data

Synthetic, no real companies, people or customer messages.

  • 6,000 messages in 150 batches of 40, one language per batch: Bokmål 1,800, Swedish 1,320, Danish 880, Finnish 800, Nynorsk 600, English 600.
  • Each message follows a sampled brief: one of 116 kinds of business in 19 sectors (retail, grocery, hospitality, food, telecom, energy, finance, health, public services, travel, B2B IT, facility services, property, logistics, education, automotive, leisure, trades and other services), a channel, one of 38 sender personas (from a teenager typing in slang to a lawyer citing terms, a non-native speaker, a voice-to-text user, a person in a difficult life situation), a length from a few words to a long letter, an intended type and sentiment, required risks or rewards, and sometimes a twist (sarcasm, a veiled threat, a false alarm, mixed praise and complaint, a sender who is wrong about the facts, a message written in English by a Nordic speaker).
  • Labelled three times: by the writer, then blind by a second labeller who saw only the channel and the text, and every disagreement was settled by a third judge under the final label guide.
  • Validation and test are whole batches (about 10% each per language) that training never saw.

The dataset itself is not released.

Training

Qwen3.5-4B trained as a decision model with Unsloth (Unsloth Studio): LoRA r16, α16 on bf16 weights, two epochs over 4,800 messages × 18 questions, learning rate 2e-4 with cosine decay, batch 32, maximum length 3,072 tokens. Studio's held-out accuracy went from 0.39 to 0.93 with a calibration error of 0.00. Exported to GGUF Q8_0.

Limits

  • Trained on synthetic messages. Real customer messages are messier: measure on a sample of your own before relying on it, and keep a person in the loop where a miss matters.
  • The yes/no questions favour precision: churn, safety and legal are found in 77–84% of the test messages that have them. Lower the threshold where a miss costs more than a false alarm.
  • One message at a time: no thread history, attachments or customer records.
  • The labels describe the message from the business's point of view; they are not legal advice, and legal means "worth a closer look", not a legal finding.
  • Six languages only.

License

Apache 2.0, like the base model.

Downloads last month
84
GGUF
Model size
5B params
Architecture
qwen35
Hardware compatibility
Log In to add your hardware

8-bit

Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for unified-analytics/nordic-customer-impact-qwen3.5-4b

Finetuned
Qwen/Qwen3.5-4B
Quantized
(676)
this model