zime-ai/dwight-4b

Dwight by Zime

Dwight 4B

Straight answers about sales calls. True or false, never "it depends."

Dwight is a 4-billion-parameter model from Zime AI, the AI infrastructure platform for sales teams. It reads a full sales call transcript and does two things:

1. Decides. Answers a typed question about the call (yes/no, a choice, or a 0-10 score) with one token and a calibrated confidence, in about a third of a second.
2. Explains. Writes structured insights for a call (what was said, when, how strong the signal is, with a verbatim quote) as JSON.

It runs on a single GPU, reads up to 32k tokens (about a 90-minute call), answers a question in about 0.1 s on an H100, and costs a small fraction of a cent per question when self-hosted.

At a glance

	Dwight 4B 1.0
Base model	Qwen3-4B-Instruct-2507 (Apache 2.0)
Context	32,768 tokens
Decisions	one-token answers with calibrated probabilities
Insights	JSON with heading, detail, grade, score, timestamp and a verbatim excerpt
Hardware	one 24-80 GB GPU (bf16, ~8 GB of weights); best with vLLM
License	Apache 2.0

Dwight as a classifier

One question in, one token out, with a calibrated confidence. Asked about the same call again, each further question costs a few hundredths of a second.

Accuracy vs Jev (313 questions on 120 held-out calls, labels set by an independent LLM referee; the same questions for both models):

Question	Dwight 4B	Jev 1.13
Next meeting set (High / Medium / Low)	0.79 (macro-F1 0.79)	0.57 (macro-F1 0.39)
Pricing sentiment (low / mid / high)	0.86	0.74
Competitor discussed (High / Medium / Low)	0.66 (macro-F1 0.64)	0.65 (macro-F1 0.57)
Objection raised and unresolved (yes / no)	0.64	0.79

At scale (tens of thousands of questions on sales calls, agreement with a large frontier model's answers on the same calls): next meeting 0.80, competitor 0.76, objections 0.75, pricing 0.76, with calibration error (ECE) 0.02-0.05.

Speed (one NVIDIA H100, vLLM, bf16; Jev and GLM 5 through their APIs):

~20-minute call	Dwight 4B	Jev 1.13	GLM 5
First question	0.13 s	0.34 s (all questions in one request)	1.9 s
Each further question on the same call	0.02 s	(included above)	1.9 s

On longer calls Dwight's first question takes 0.54 s at ~60 minutes (20k tokens) and 1.06 s at ~90 minutes (33k tokens); further questions stay under 0.08 s, because vLLM keeps the transcript cached (enable_prefix_caching=True).

Dwight as an insight model

Structured, quotable insights: what was said, when, how strong the signal is, and the exact words. Compared with GLM 5 on identical inputs (475 call checklists across 40 held-out calls from 4 companies; the reference is a large frontier model's answer on the same calls):

	Dwight 4B	GLM 5
Quotes found verbatim in the transcript	100%	98.7%
Grade agrees with the reference	83%	72%
Its insights the reference also reports	~57%	~44-56%
Reference insights it also finds	~50%	~61%
Median time per checklist	4.2 s (one H100)	12 s (API)

On one H100, 4 checklists at a time, Dwight writes about 2,000 checklists an hour. It is precise and faithful to the transcript, and more conservative than larger models: it reports fewer insights.

Cost at scale

One month at 10,000 calls, each with 10 decision questions and 10 insight checklists (100,000 decisions and 100,000 insights):

Per month	Dwight 4B, self-hosted	GLM 5 (API)	Frontier API model	Jev (API)
100,000 decisions	~$5	~$1,000	~$1,750	~$5-10
100,000 insights	~$200	~$1,970	~$6,940	not offered
Total	~$205	~$2,970	~$8,690	decisions only

How these are built: Dwight on one H100 billed per second at about $3.95 an hour (about 1 GPU hour for the decisions, about 50 for the insights; the GPU is off when idle). GLM 5 and the frontier model at their list prices and the measured per-checklist cost of the comparison run; for decisions each question sends a ~10k-token transcript (sending all questions in one request cuts that cost about tenfold, at the price of one-token answers with confidence). Jev at its measured cost per call. A dedicated always-on H100 costs about $2,900 a month and only pays off at much higher volume.

Quick start: decisions

Dwight answers one question at a time with one token. Put the transcript and the question in this layout (letters A, B, C... map to your options in order):

system: You are a sales decision model. Read the conversation and answer the question with exactly one option token.

user:
<conversation>
[00:00:05] [Maya Brooks]: Can we meet Tuesday at 10?
[00:00:09] [Dan Ruiz]: Tuesday 10 works, I'll send the invite.
</conversation>

<question id="next_meeting_set" type="choice">
Was a concrete next meeting agreed, with a date and time?
</question>
Options:
A) High
B) Medium
C) Low
Answer with exactly one letter.

For a yes/no question use type="boolean" and end with Answer yes or no.; for a 0-10 score use type="score" with options A) 0 ... K) 10. Read the probabilities of the option tokens from the first generated token and renormalize over them: that is the confidence. See examples/decide.py (vLLM, about 40 lines).

Questions are yours to write: any question a reader could answer from the call works best when it is specific and states what counts as each option.

Quick start: insights

Give the transcript after a short description of what to look for, and ask for JSON. See examples/insights.py. Output shape:

{"details": [{"heading": "Next meeting set for Tuesday", "detail": "The buyer agreed to a
  follow-up on Tuesday at 10:00 and the rep will send the invite.", "grade": "High",
  "score": 90, "timestamp": "00:00:09", "excerpt": "Tuesday 10 works, I'll send the invite."}],
 "summary": "A follow-up meeting was agreed for Tuesday at 10:00."}

When nothing qualifies, Dwight answers with a single detail headed "No insights found as per checklist".

Transcript format

One line per turn: [HH:MM:SS] [Speaker name]: text for decisions, [HH:MM:SS] Speaker name: text for insights. Timestamps in the answer refer to these markers. Speaker names can be anything; real names give the most natural output.

Quantized versions

GGUF quantizations for llama.cpp, LM Studio and Ollama, made by bartowski (thank you!): bartowski/zime-ai_dwight-4b-GGUF, from BF16 (8.05 GB) down to IQ2_M (1.49 GB).

ollama run hf.co/bartowski/zime-ai_dwight-4b-GGUF:Q5_K_M

In LM Studio, search for zime-ai_dwight-4b and pick Q5_K_M.

Using the confidence scores? Use Q5_K_M or higher. Decisions read the probabilities of the option tokens, and quantization shifts those probabilities before it changes the answers. The quantizations were calibrated on a general text corpus, not on sales calls. For insights and plain answers without confidence, Q4_K_M (2.59 GB) is a good default.

Training

Fine-tuned from Qwen3-4B-Instruct-2507 with LoRA on 8 NVIDIA H100 GPUs, on about 35,000 sales-call insight examples covering 500+ call behaviors, plus about 8,000 decision questions, from synthetic B2B software sales calls. The training data is not released.

Limitations

• Conservative: finds fewer insights than larger models, most of all objections.
• Weaker on companies and call types unlike its training data.
• English only; trained on B2B software sales calls.
• 32k tokens of context; longer transcripts must be shortened.
• Not a source of truth about people: verify important outputs against the transcript.

Versions

Version	Notes
1.0	First release

License

Apache 2.0. See LICENSE and NOTICE. Built on Qwen3-4B-Instruct-2507 by the Qwen team.

About Zime

Zime is an AI platform for sales teams: it analyzes every sales call, coaches reps and surfaces what moves deals forward. Dwight is built from what Zime learned analyzing real sales conversations. Learn more at zime.ai.

Citation

@misc{dwight4b2026,
  title  = {Dwight 4B: straight answers about sales calls},
  author = {Zime AI},
  year   = {2026},
  url    = {https://huggingface.co/zime-ai/dwight-4b},
  note   = {https://zime.ai}
}