Model card, prompts, NOTICE, infographics and the Thought Hold clip

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/cue-v1-english.png filter=lfs diff=lfs merge=lfs -text
+assets/cue-v1-languages-cutoffs-600ms.png filter=lfs diff=lfs merge=lfs -text
+assets/cue-v1-languages-cutoffs.png filter=lfs diff=lfs merge=lfs -text
+assets/cue-v1-languages-latency-10pct.png filter=lfs diff=lfs merge=lfs -text
+assets/cue-v1-languages-latency.png filter=lfs diff=lfs merge=lfs -text
+assets/cue-v1-thought-hold.mp4 filter=lfs diff=lfs merge=lfs -text

NOTICE

@@ -0,0 +1,8 @@
+Cue v1
+Copyright 2026 Pype
+
+This model is a fine-tune of Gemma 4 E4B (google/gemma-4-E4B-it) by Google, used under the Apache License,
+Version 2.0. Cue v1's weights, adapter, prompts and documentation are released under the same licence.
+
+The benchmark results in this repository were produced with LiveKit's eot-bench harness. The "× √Smart Turn
+v3.2" setup refers to Smart Turn v3.2 by Pipecat (BSD 2-Clause), which is not included here.

README.md

@@ -0,0 +1,371 @@
+---
+license: apache-2.0
+base_model: google/gemma-4-E4B-it
+language:
+- en
+tags:
+- end-of-turn
+- turn-taking
+- endpointing
+- barge-in
+- voice-agents
+- decision-model
+- gguf
+- eot-bench
+- interruptions
+pipeline_tag: text-classification
+---
+
+# Cue v1
+
+**Cue v1 is a turn-taking decision model for voice agents.** It is Gemma 4 E4B, fine-tuned to answer two typed
+questions: *when the caller pauses, are they done, and if not, why not?* and *when the caller speaks over the agent,
+should the agent stop?* Each answer is read from the logits, as probabilities over named states instead of a single
+score, so the agent knows not only *whether* to act but *how long to wait* and *whether it was really interrupted*:
+
+| | Answer | What it means | What the agent does |
+|---|---|---|---|
+| **End of turn** (the caller pauses) | **DONE** | A complete question, answer, request or statement | Reply now |
+| | **LIKELY_DONE** | Probably finished, but it trails off | A short grace, then reply |
+| | **MID_THOUGHT** | The sentence is left hanging: a trailing "and", "so", "my number is", half a number | Wait: more is coming |
+| | **HOLDING** | Telling a story or explaining something: the pause is thinking | Wait longer, don't cut in |
+| **Interruptions** (the caller speaks while the agent talks) | **STOP** | A real interruption: a question, a correction, an objection, "wait", "hello?", or a full answer to the agent's question | Stop talking and listen |
+| | **CONTINUE** | Only listening: "hmm", "okay", "haan", "achha", laughter, noise, a fragment | Keep talking |
+
+Cue is the turn engine in **Shortwire**, Pype's open source voice AI stack, where decision models run the call and
+the main LLM only talks: turns, holds, barge-in, guardrails, dictation and tool calls. In Shortwire, MID_THOUGHT and
+HOLDING are what we call **Thought Hold**, and every answer and its probability shows up in the **Decision Trace**.
+*Knows when to wait. Knows when to stop.*
+
+<video controls playsinline width="100%" src="https://huggingface.co/Pype/cue-v1/resolve/main/assets/cue-v1-thought-hold.mp4"></video>
+
+*Thought Hold on a real call: the caller pauses mid-sentence while giving their details, the end-of-turn decision
+answers MID_THOUGHT (0.68), and the agent holds instead of cutting in. Recorded in Shortwire with the base Gemma
+4 E4B asking this same question, before the fine-tune; Cue v1 is that decision, trained. The phone number is masked.*
+
+## How it decides: logits, not text
+
+Cue v1 never writes an answer. At every pause:
+
+1. **Ask one question.** The decision prompt lists the options as letters, followed by what was said so far.
+   - **End of turn:** A = DONE, B = LIKELY_DONE, C = MID_THOUGHT, D = HOLDING; with what the other side last said,
+     what the speaker has said in this turn, and how the transcript ends.
+   - **Interruptions:** A = STOP, B = CONTINUE; with what the agent is saying, the question it last asked, and what
+     the caller just said over it.
+2. **Let the model compute one token.** `max_tokens: 1`, with the top 20 log-probabilities returned
+   (`logprobs: true`). llama.cpp returns log-probabilities, the normalised form of the logits; for choosing between
+   options they are the same thing.
+3. **Read the probability of each letter** and renormalise them so they sum to 1:
+
+   ```
+   Agent asked:  What's the best number to reach you on?
+   Caller said:  Sure, it's nine eight four five,
+
+   MID_THOUGHT 0.999   DONE 0.001   LIKELY_DONE 0.000   HOLDING 0.000
+   ```
+
+4. **Turn the probabilities into an action**, as described in [Using the probabilities](#using-the-probabilities):
+   - **Caller and agent:** p(DONE) + p(LIKELY_DONE) is the end-of-turn score, multiplied by the square root of an
+     audio turn model's score.
+   - **Two people talking:** the probabilities set how long to wait in silence.
+   - **Interruptions:** p(STOP) decides whether the agent stops talking.
+
+Why logits instead of an answer in words or JSON:
+
+- **Typed by construction.** The answer is always one of the options. There is nothing to parse and nothing
+  that can come back malformed.
+- **A full distribution, not a label.** On clear cases the answer is near-certain (0.999 above). On unclear ones
+  the probability splits between options, and that split carries into how long to wait.
+- **Fast.** One forward pass and one token, about 100 to 300 ms on a T4.
+- **The fine-tune moves the logits, nothing else.** Training put the loss on the answer letter only, so the model
+  learned where to put probability (the base Gemma almost never put it on HOLDING), while staying an ordinary
+  Gemma 4 E4B that any llama.cpp, Ollama or vLLM server can host.
+
+## Quick start
+
+Serve the GGUF with llama.cpp:
+
+```bash
+llama-server -m cue-v1-q8_0.gguf -c 8192 -np 4 -ngl 999 --jinja --port 8090
+```
+
+Ask it about a pause. The answer is the first token's probability mass on each option letter; nothing is generated
+beyond one token.
+
+```python
+import json, math, httpx
+
+END_OF_TURN = json.load(open("prompts/end_of_turn_phone.json"))
+INTERRUPTION = json.load(open("prompts/barge_in.json"))
+LETTERS = "ABCDEFGH"
+LABELS = {"agent_question": "Agent asked", "caller_earlier": "Caller earlier", "caller_text": "Caller said",
+          "agent_said": "Agent is saying"}
+
+def block(decision, inputs):
+    return "\n".join(f"{LABELS.get(k, k)}: {inputs.get(k) or '(nothing)'}" for k in decision["inputs"])
+
+def system(decision):
+    ids = [o["id"] for o in decision["options"]]
+    lines = [decision["instruction"], "", "Options:"]
+    lines += [f"{LETTERS[i]}: {o['describe']}" for i, o in enumerate(decision["options"])]
+    lines += ["", "Answer with exactly one letter."]
+    if decision["examples"]:
+        lines += ["", "Examples:"]
+        for ex in decision["examples"]:
+            lines += ["", block(decision, ex["inputs"]), f"Answer: {LETTERS[ids.index(ex['answer'])]}"]
+    return "\n".join(lines)
+
+def ask(decision, inputs):
+    r = httpx.post("http://localhost:8090/v1/chat/completions", json={
+        "messages": [{"role": "system", "content": system(decision)},
+                     {"role": "user", "content": block(decision, inputs) + "\nAnswer:"}],
+        "max_tokens": 1, "temperature": 0, "logprobs": True, "top_logprobs": 20,
+        "reasoning_effort": "none", "chat_template_kwargs": {"enable_thinking": False}}).json()
+    raw = {}
+    for tp in r["choices"][0]["logprobs"]["content"][0]["top_logprobs"]:
+        t = tp["token"].strip()
+        if len(t) == 1 and t in LETTERS[:len(decision["options"])]:
+            opt = decision["options"][LETTERS.index(t)]["id"]
+            raw[opt] = raw.get(opt, 0.0) + math.exp(tp["logprob"])
+    total = sum(raw.values()) or 1.0
+    return {k: v / total for k, v in raw.items()}
+
+probs = ask(END_OF_TURN, {"agent_question": "What's the best number to reach you on?",
+                          "caller_earlier": "", "caller_text": "Sure, it's nine eight four five,",
+                          "transcript_end": "no sentence end"})
+print(probs)   # {'MID_THOUGHT': 0.999, 'DONE': 0.001, 'LIKELY_DONE': 0.0002, 'HOLDING': 0.0001}: half a number
+```
+
+## Using the probabilities
+
+Ask again whenever the transcript changes, and re-check the score as the silence grows. Until the first words of the
+turn are transcribed, treat the end-of-turn score as 0.5 (or the wait as 1.0 s).
+
+### Caller and agent (voice agents, phone calls)
+
+The words decide most; an audio turn model breaks ties with what the words can't carry, such as a falling tone.
+We use Smart Turn v3.2 (BSD-2), rescored as the pause goes on.
+
+```python
+p_end = probs.get("DONE", 0) + probs.get("LIKELY_DONE", 0)
+score = p_end * p_voice ** 0.5          # p_voice: the audio model's end-of-turn probability for this moment
+if score >= THETA:
+    reply()
+```
+
+THETA sets the trade between replying fast and cutting callers off. Choose it on your own calls for the false
+cut-off rate you can accept. This is the setup behind the eot-bench numbers below: at a 5% false cut-off rate, Cue v1
+replies after 719 ms on average in English.
+
+### Two people talking
+
+Here the answer sets how long to wait. Give each option a silence budget and blend by probability:
+
+```python
+WAITS = {"DONE": 0.5, "LIKELY_DONE": 1.0, "MID_THOUGHT": 1.75, "HOLDING": 2.25}   # seconds of silence
+wait = sum(p * WAITS[o] for o, p in probs.items())
+if silence_so_far >= wait:
+    take_the_turn()
+```
+
+A confident DONE ends the turn after half a second; a likely HOLDING waits over two seconds, so someone thinking
+mid-story isn't cut off. Don't multiply by an audio model here: in our two-person tests, adding Smart Turn's score
+made it slightly worse.
+
+### Interruptions
+
+When the caller says something while the agent is talking, ask the interruption question with what the agent is
+saying, the question it last asked, and the caller's words so far:
+
+```python
+probs = ask(INTERRUPTION, {"agent_said": "...so the appointment is on Tuesday at", "agent_question": "",
+                            "caller_text": "wait, Tuesday doesn't work"})
+# {'STOP': 0.999, 'CONTINUE': 0.001}. The same question with "hmm" gives {'CONTINUE': 1.0, 'STOP': 0.0}
+if probs.get("STOP", 0) >= 0.5:
+    stop_speaking()        # a real interruption: listen
+# else: a backchannel ("hmm", "okay"), keep talking
+```
+
+Ask again as more of the caller's words arrive: a fragment can read like a backchannel until the rest of it comes in.
+The threshold trades stopping on noise against talking over a caller; 0.5 is a sensible start.
+
+## What it is
+
+- **Base:** Gemma 4 E4B instruction-tuned, fine-tuned with a LoRA adapter (rank 16) using Unsloth, merged and
+  quantised to q8_0 GGUF.
+- **Input:** text. What the other side last said, what the speaker has said so far in this turn, and how the
+  transcript ends (a question mark, a full stop, or no sentence end). Audio is read by your ASR and, optionally, an
+  audio turn model.
+- **Output:** a probability for each option, from one forward pass. No JSON, no generated text, no parsing.
+- **Prompts are part of the model.** The options, their descriptions and any worked examples live in
+  `prompts/*.json`. Changing a description or adding examples in another language changes behaviour without
+  retraining.
+
+## Training data: simulated conversations
+
+The fine-tune never saw a real recording or a benchmark transcript.
+
+- **310 conversations written by an LLM** to a written specification, each on a different topic: 150 phone calls
+  between a caller and an agent, and 160 two-person conversations (casual, storytelling, instructional,
+  argumentative, collaborative, transactional).
+- **About 10,600 labelled pauses**, plus 600 backchannels and 430 real interruptions for the barge-in decision.
+- **Speech textures written in:** fillers and false starts, repeated words, trailing conjunctions, unpunctuated
+  endings, and numbers and addresses read out in pieces. A few Indian-English backchannels ("haan", "achha") appear,
+  but the data is English.
+- **Shaped by a few aggregate statistics** from TurnBench's public dev split: the share of pauses that are holds
+  (about 35%), the share of holds that follow a complete sentence (about 70%), and the share of turn ends without
+  punctuation (about 25%). No dev audio, transcript or label was used as a training example. The TurnBench test split
+  and otoSpeech were not used at all.
+- **The loss is on the answer letter only**, so the model learns where to put probability, not how to write.
+
+On held-out simulated conversations (10% of the conversations, never trained on):
+
+| | Base Gemma 4 E4B | Cue v1 |
+|---|---|---|
+| Exact answer, every held-out question | 38.3% | **83.2%** |
+| End of turn: done vs not done | 58.2% | **86.9%** |
+| Interruptions: STOP vs CONTINUE (90 questions) | 93.3% | **98.9%** |
+
+The base model almost never answers HOLDING. That is the main thing the fine-tune teaches.
+
+## Evaluation: eot-bench, English
+
+[LiveKit's eot-bench](https://livekit.com/benchmarks/eot-bench), all 400 English turns, scored with the harness's
+own metrics. Latency at a 5% and 10% false cut-off rate, and false cut-offs at a 300 ms and 600 ms latency budget.
+
+![Cue v1 on eot-bench, English, against 13 other turn detectors](assets/cue-v1-english.png)
+
+| Model | Latency @5% | Latency @10% | Cut-offs @300 ms | Cut-offs @600 ms |
+|---|---|---|---|---|
+| LiveKit turn-detector v1 (hosted) | 543 ms | 295 ms | 9.9% | 4.5% |
+| Baton v1 | 577 ms | 350 ms | 12.3% | 4.8% |
+| Soniox stt-rt-preview | 647 ms | 512 ms | – | 5.5% |
+| **Cue v1 × √Smart Turn v3.2** | **719 ms** | **532 ms** | **26.8%** | **7.5%** |
+| Cue v1, words only | 750 ms | 552 ms | 34.0% | 7.8% |
+| Deepgram flux-general-multi | 1151 ms | 548 ms | 12.9% | 9.9% |
+| ultraVAD | 899 ms | 663 ms | 27.7% | 11.9% |
+| LiveKit turn-detector v1-mini (local) | 1070 ms | 698 ms | 27.8% | 12.1% |
+| Smart Turn v3.2 | 1051 ms | 739 ms | 35.2% | 14.8% |
+
+Cue v1 × √Smart Turn v3.2 is **4th on all four views** (AUC 0.961), behind LiveKit v1, Baton v1 and Soniox, and
+ahead of Deepgram Flux, ultraVAD, LiveKit's local model and Smart Turn v3.2 on its own.
+
+**Honest notes on this table:**
+- The same pipeline with the *base* Gemma and the same prompt scores 723 / 502 ms: on this benchmark the fine-tune is
+  a tie with a well-prompted base model. Its gains show on holds (below) and on two-person conversation.
+- Our decision's compute time (about 100 to 300 ms on a T4) is not part of these latencies.
+
+## 14 languages, one model, one English prompt
+
+Cue v1 × √Smart Turn v3.2 on all 14 eot-bench languages, with **one model and the same English prompt, English
+examples included**: no translation, no per-language examples, no per-language tuning. The fine-tune itself only
+ever saw English. The one language-aware step is automatic. Where most caller turns end without punctuation in the
+transcript (Arabic, Hindi, Indonesian, Japanese, Korean, Chinese), the "how the transcript ends" input is set to
+neutral, because a missing full stop means nothing there.
+
+| Language | Latency @5% | Latency @10% | Cut-offs @300 ms | Cut-offs @600 ms |
+|---|---|---|---|---|
+| English | 719 ms (4th of 13) | 532 ms (4th) | 26.8% (4th) | 7.5% (4th) |
+| Portuguese | **681 ms (1st of 11)** | 498 ms (3rd) | 27.7% (3rd) | 6.5% (**2nd**) |
+| Spanish | 792 ms (**2nd** of 11) | 603 ms (3rd) | 29.9% (4th) | 10.1% (3rd) |
+| French | 647 ms (3rd of 11) | 449 ms (3rd) | 24.4% (4th) | 5.2% (**2nd**) |
+| German | 786 ms (3rd of 11) | 559 ms (4th) | 22.7% (3rd) | 9.2% (4th) |
+| Italian | 912 ms (3rd of 11) | 595 ms (3rd) | 31.6% (3rd) | 9.9% (3rd) |
+| Dutch | 770 ms (3rd of 10) | 554 ms (4th) | 24.4% (3rd) | 9.4% (4th) |
+| Japanese | 557 ms (3rd of 10) | 406 ms (3rd) | 15.1% (3rd) | 4.6% (3rd) |
+| Korean | 608 ms (**2nd** of 9) | 406 ms (3rd) | 21.2% (3rd) | 5.5% (**2nd**) |
+| Chinese | 838 ms (**2nd** of 9) | 637 ms (3rd) | 35.5% (3rd) | 11.7% (3rd) |
+| Indonesian | 871 ms (**2nd** of 9) | 598 ms (**2nd**) | 34.4% (**2nd**) | 9.9% (**2nd**) |
+| Hindi | 607 ms (4th of 10) | 494 ms (3rd) | 30.8% (4th) | 5.3% (4th) |
+| Turkish | 1012 ms (3rd of 9) | 692 ms (3rd) | 33.9% (**2nd**) | 11.6% (3rd) |
+| Arabic | 815 ms (6th of 9) | 640 ms (5th) | 39.9% (4th) | 12.4% (4th) |
+
+Ranks are among the models the benchmark reports for that language. Not every model covers every language.
+
+**In Portuguese, Cue v1 is 1st at a 5% false cut-off rate**, ahead of LiveKit v1 and Soniox (both 702 ms).
+
+**Fine-tuning on English made the other languages better too.** Against the same recipe with the base Gemma, the
+fine-tune is faster at the 5% budget in 11 of 14 languages and at the 10% budget in 11 of 14. The biggest moves:
+Hindi from 7th to 4th, Portuguese from 4th to 1st, French 698 to 647 ms, Korean 485 to 406 ms at 10%. It is slower
+in Dutch (688 to 770 ms at 5%), and at the 10% budget in English (502 to 532 ms) and Chinese (606 to 637 ms).
+
+The whole board, with Cue v1 in the outlined column. The small rank under each Cue value counts every model eot-bench
+reports for that language; the outlined cell in each row is the best. Grey cells are languages a model does not support.
+
+![Latency at a 5% false cut-off rate, 14 languages](assets/cue-v1-languages-latency.png)
+
+![False cut-offs at a 300 ms latency budget, 14 languages](assets/cue-v1-languages-cutoffs.png)
+
+<details>
+<summary>The other two views: latency at 10% cut-offs, and cut-offs at a 600 ms budget</summary>
+
+![Latency at a 10% false cut-off rate, 14 languages](assets/cue-v1-languages-latency-10pct.png)
+
+![False cut-offs at a 600 ms latency budget, 14 languages](assets/cue-v1-languages-cutoffs-600ms.png)
+
+</details>
+
+Across the 14 languages, counting the 5% and 10% budgets:
+
+| Against | Cue v1 is faster in |
+|---|---|
+| OpenAI GPT Realtime 2 (semantic VAD) | 28 of 28 |
+| VAP | 28 of 28 |
+| Gradium | 28 of 28 |
+| Smart Turn v3.2 | 26 of 28 |
+| ultraVAD | 25 of 28 |
+| LiveKit turn-detector v1-mini (local) | 25 of 28 |
+| Deepgram Flux | 12 of 18 |
+| Soniox | 12 of 28 |
+| LiveKit turn-detector v1 (hosted) | 1 of 28: still the one to beat |
+
+Arabic is the weak spot (6th at 5%).
+
+## Compute
+
+- One decision is one forward pass of a 4B model plus one token: about 100 to 300 ms on an NVIDIA T4 with llama.cpp,
+  4 concurrent calls per T4 in our deployment.
+- The q8_0 GGUF is 7.5 GB.
+
+## Files
+
+| File | What |
+|---|---|
+| `cue-v1-q8_0.gguf` | Merged model, q8_0, for llama.cpp |
+| `adapter/` | The LoRA adapter (safetensors) for `google/gemma-4-E4B-it` |
+| `prompts/end_of_turn_phone.json` | End of turn, caller and agent on a phone call |
+| `prompts/end_of_turn_dialogue.json` | End of turn, two people talking |
+| `prompts/barge_in.json` | Interruptions: STOP or CONTINUE while the agent is speaking |
+| `assets/` | The English table, the 14-language heatmaps and the script that draws them; the Thought Hold demo clip |
+
+## Intended use
+
+Turn-taking inside voice agents and other spoken-dialogue systems that already have an ASR: deciding when to
+reply, when to keep listening, and whether something the caller says over the agent should stop it.
+
+## Limits
+
+- **Reads words, not prosody.** On its own it cannot hear a falling tone or a breath. Pair it with an audio turn model
+  for that.
+- **Short objections can pass as backchannels.** "Hmm, actually no" said over the agent comes back CONTINUE (0.94).
+  Clear interruptions ("wait, Tuesday doesn't work") are STOP at 0.999, but a lone "no" or "actually" can be missed.
+- **Needs an ASR and a GPU.** It is not an on-device model.
+- **Trained on English only.** It carries over to 13 other languages with the English prompt, but every
+  language except Portuguese still has a faster hosted model, and Arabic is behind most of the board.
+- **Trained on simulated conversations.** Real speech is messier than any written transcript. Measure it on your
+  own calls before relying on its probabilities.
+
+## Licence
+
+Apache 2.0, the same as the base model, Gemma 4 E4B.
+
+## Citation
+
+```bibtex
+@misc{pype2026cue,
+  title  = {Cue v1: turn detection by a fine-tuned decision model},
+  author = {Pype AI},
+  year   = {2026},
+  url    = {https://huggingface.co/Pype/cue-v1}
+}
+```

assets/cue-v1-thought-hold.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fbb0f47b294625195378cb405cf9e30bb46b71d5cbb51717dd48069af07181e
+size 2612863

assets/make_infographics.py

@@ -0,0 +1,173 @@
+"""Cue v1 launch infographics on an off-white surface: the English table and the 14-language heatmaps."""
+import json
+import sys
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+from matplotlib.patches import FancyBboxPatch, Rectangle
+
+SUMMARY = Path(sys.argv[1])
+OUT = Path(sys.argv[2])
+s = json.loads(SUMMARY.read_text())
+V = s["values"]
+L5, L10 = "best_mean_latency_at_5pct_cutoff", "best_mean_latency_at_10pct_cutoff"
+C3, C6 = "best_cutoff_rate_at_0_3s_latency", "best_cutoff_rate_at_0_6s_latency"
+CUE = "Shortwire Cue v1 (fine-tuned)"
+
+SURFACE = "#faf8f3"
+INK, INK2, MUTED = "#1b1b1a", "#5f5e5a", "#9a9890"
+RULE = "#e6e3da"
+BLUE, BLUE_TINT = "#2a78d6", "#e6f0fb"
+RAMP = ["#cde2fb", "#b7d3f6", "#9ec5f4", "#86b6ef", "#6da7ec", "#5598e7", "#3987e5", "#2a78d6", "#256abf",
+        "#1c5cab", "#184f95", "#104281", "#0d366b"]
+plt.rcParams.update({"font.family": ["Helvetica Neue", "Helvetica", "Arial"], "text.color": INK,
+                     "axes.edgecolor": SURFACE, "figure.facecolor": SURFACE, "axes.facecolor": SURFACE})
+
+NAMES = {CUE: "Cue v1 (Shortwire)", "LiveKit Turn Detector v1": "LiveKit Turn Detector v1",
+         "LiveKit Turn Detector v1-mini": "LiveKit v1-mini (local)", "SmartTurn v3.2": "Smart Turn v3.2",
+         "OpenAI GPT Realtime 2": "OpenAI GPT Realtime 2", "JoinIn AI Baton": "JoinIn AI Baton",
+         "VAP (silent agent)": "VAP", "VAD baseline": "Silence only (VAD)"}
+LANG = {"en": "English", "pt": "Portuguese", "es": "Spanish", "fr": "French", "de": "German", "it": "Italian",
+        "nl": "Dutch", "ja": "Japanese", "ko": "Korean", "zh": "Chinese", "id": "Indonesian", "hi": "Hindi",
+        "tr": "Turkish", "ar": "Arabic"}
+
+
+def english_table(path: Path) -> None:
+    rows = []
+    for m in s["models"]:
+        v = [V[k]["en"].get(m) for k in (L5, L10, C3, C6)]
+        if v[0] is None:
+            continue
+        rows.append((NAMES.get(m, m), v[0] * 1000, None if v[1] is None else v[1] * 1000,
+                     None if v[2] is None else v[2] * 100, None if v[3] is None else v[3] * 100, m == CUE, False))
+    rows.append(("turn-1-mini †", 849.0, None, 22.6, None, False, True))
+    base = [r for r in rows if r[0] == "Silence only (VAD)"]
+    rows = sorted([r for r in rows if r[0] != "Silence only (VAD)"], key=lambda r: r[1]) + base
+
+    n = len(rows)
+    fig = plt.figure(figsize=(12, 1.5 + 0.46 * n), dpi=200)
+    ax = fig.add_axes([0.04, 0.07, 0.92, 0.79])
+    ax.set_xlim(0, 100)
+    ax.set_ylim(n, -0.75)
+    ax.axis("off")
+    fig.text(0.04, 0.94, "Cue v1 on eot-bench, English", fontsize=20, fontweight="bold")
+    fig.text(0.04, 0.905, "400 caller turns, scored with the benchmark's own harness. Lower is better in every column.",
+             fontsize=11, color=INK2)
+    cols = [(3, "#", "left"), (7, "Model", "left"), (38, "Latency @ 5% cut-offs", "left"), (66, "@ 10%", "right"),
+            (84, "Cut-offs @ 300 ms", "right"), (97, "@ 600 ms", "right")]
+    for x, label, ha in cols:
+        ax.text(x, -0.45, label, fontsize=10, color=INK2, ha=ha, va="center", fontweight="bold")
+    ax.plot([0, 100], [-0.05, -0.05], color=INK, lw=0.8)
+    vmax = max(r[1] for r in rows)
+    for i, (name, l5, l10, c3, c6, cue, reported) in enumerate(rows):
+        y = i + 0.5
+        if cue:
+            ax.add_patch(FancyBboxPatch((0.4, i + 0.08), 99.2, 0.84, boxstyle="round,pad=0,rounding_size=0.6",
+                                        fc=BLUE_TINT, ec="none", zorder=0))
+        else:
+            ax.plot([0, 100], [i + 1, i + 1], color=RULE, lw=0.7)
+        weight = "bold" if cue else "normal"
+        ink = MUTED if name.startswith("Silence") else INK
+        rank = "" if name.startswith("Silence") else str(i + 1)
+        ax.text(3, y, rank, fontsize=11, color=INK2, va="center")
+        ax.text(7, y, name, fontsize=12, color=ink, va="center", fontweight=weight, style="italic" if reported else "normal")
+        w = 14 * l5 / vmax                                  # inline bar for the headline column
+        ax.add_patch(FancyBboxPatch((38, y - 0.13), w, 0.26, boxstyle="round,pad=0,rounding_size=0.12",
+                                    fc=BLUE if cue else ("#c9c6bc" if not name.startswith("Silence") else "#e2dfd6"),
+                                    ec="none"))
+        ax.text(38 + w + 0.8, y, f"{l5:,.0f} ms", fontsize=11, va="center", color=ink, fontweight=weight)
+        for x, val, unit in ((66, l10, " ms"), (84, c3, "%"), (97, c6, "%")):
+            txt = "–" if val is None else (f"{val:,.0f}{unit}" if unit == " ms" else f"{val:.1f}{unit}")
+            ax.text(x, y, txt, fontsize=11, ha="right", va="center", color=MUTED if val is None else ink,
+                    fontweight=weight)
+    fig.text(0.04, 0.025, "† turn-1-mini as published by P99Lab on the same benchmark (two views reported). "
+             "– means the view isn't reported. Cue v1 = fine-tuned Gemma 4 E4B × √Smart Turn v3.2.",
+             fontsize=9, color=INK2)
+    fig.savefig(path, facecolor=SURFACE)
+    plt.close(fig)
+
+
+def heatmap(metric: str, title: str, sub: str, fmt, path: Path, lo: float, hi: float, legend_label: str = "best in the row") -> None:
+    langs = ["en", "pt", "es", "fr", "de", "it", "nl", "ja", "ko", "zh", "id", "hi", "tr", "ar"]
+    models = [CUE, "LiveKit Turn Detector v1", "Soniox", "Deepgram Flux", "Gradium", "ultraVAD",
+              "LiveKit Turn Detector v1-mini", "SmartTurn v3.2", "OpenAI GPT Realtime 2", "AssemblyAI", "VAP (silent agent)"]
+    models = [m for m in models if any(V[metric][l].get(m) is not None for l in langs)]
+    cmap = LinearSegmentedColormap.from_list("blue", RAMP)
+    nr, nc = len(langs), len(models)
+    fig = plt.figure(figsize=(14, 9.6), dpi=200)
+    ax = fig.add_axes([0.11, 0.07, 0.86, 0.68])
+    ax.set_xlim(0, nc)
+    ax.set_ylim(nr, 0)
+    ax.axis("off")
+    fig.text(0.03, 0.935, title, fontsize=21, fontweight="bold")
+    fig.text(0.03, 0.895, sub, fontsize=11.5, color=INK2)
+    for j, m in enumerate(models):
+        label = NAMES.get(m, m).replace(" (Shortwire)", "")
+        ax.text(j + 0.5, -0.25, label, rotation=35, ha="left", va="bottom", fontsize=10.5,
+                color=BLUE if m == CUE else INK, fontweight="bold" if m == CUE else "normal",
+                rotation_mode="anchor")
+    for i, l in enumerate(langs):
+        ax.text(-0.15, i + 0.5, LANG[l], ha="right", va="center", fontsize=11.5, color=INK)
+        vals = {m: V[metric][l].get(m) for m in models}
+        present = {m: v for m, v in vals.items() if v is not None}
+        best = min(present, key=present.get)
+        board = {k: x for k, x in V[metric][l].items() if x is not None and k not in ("VAD baseline", "Shortwire cue-v1 (Gemma)", "Shortwire cue-v1 (Jev)")}
+        order = sorted(board, key=board.get)
+        for j, m in enumerate(models):
+            v = vals[m]
+            g = 0.035
+            if v is None:
+                ax.add_patch(Rectangle((j + g, i + g), 1 - 2 * g, 1 - 2 * g, fc="#efece4", ec="none"))
+                continue
+            t = float(min(1.0, max(0.0, (v - lo) / (hi - lo))))
+            c = cmap(t)
+            ax.add_patch(FancyBboxPatch((j + g, i + g), 1 - 2 * g, 1 - 2 * g, boxstyle="round,pad=0,rounding_size=0.06",
+                                        fc=c, ec="none"))
+            dark = t > 0.55
+            txt = fmt(v)
+            ax.text(j + 0.5, i + 0.5 - (0.1 if m == CUE else 0), txt, ha="center", va="center", fontsize=11,
+                    color="white" if dark else INK, fontweight="bold" if (m == best or m == CUE) else "normal")
+            if m == CUE:
+                r = order.index(m) + 1
+                ax.text(j + 0.5, i + 0.78, {1: "1st", 2: "2nd", 3: "3rd"}.get(r, f"{r}th"), ha="center", va="center",
+                        fontsize=8.5, color="white" if dark else INK2)
+            if m == best:
+                ax.add_patch(Rectangle((j + 0.07, i + 0.07), 0.86, 0.86, fc="none", ec=INK, lw=1.6))
+    ax.add_patch(FancyBboxPatch((0.0, -0.02), 1.0, nr + 0.04, boxstyle="round,pad=0,rounding_size=0.08",
+                                fc="none", ec=BLUE, lw=2.4))
+    # legend: ramp + best marker
+    lx = fig.add_axes([0.62, 0.036, 0.2, 0.012])
+    lx.imshow([[i / 100 for i in range(101)]], cmap=cmap, aspect="auto")
+    lx.set_xticks([0, 100])
+    lx.set_xticklabels([fmt(lo), fmt(hi) + "+"], fontsize=9, color=INK2)
+    lx.set_yticks([])
+    for sp in lx.spines.values():
+        sp.set_visible(False)
+    lx.tick_params(length=0)
+    bx = fig.add_axes([0.875, 0.028, 0.014, 0.022]); bx.axis("off")
+    bx.add_patch(Rectangle((0.05, 0.05), 0.9, 0.9, fc="none", ec=INK, lw=1.6))
+    fig.text(0.893, 0.033, legend_label, fontsize=10, color=INK)
+    fig.text(0.11, 0.045, "Cue v1 = fine-tuned Gemma 4 E4B × √Smart Turn v3.2: one model, one English prompt.", fontsize=9.5, color=INK2)
+    fig.text(0.11, 0.022, "Rank under Cue counts every model eot-bench reports for that language. Grey: not covered.", fontsize=9.5, color=INK2)
+    fig.savefig(path, facecolor=SURFACE)
+    plt.close(fig)
+
+
+OUT.mkdir(parents=True, exist_ok=True)
+english_table(OUT / "cue-v1-english.png")
+heatmap(L5, "Latency at a 5% false cut-off rate, 14 languages",
+        "How long each model waits after the caller stops, when at most 5% of turns get cut off. Lighter is faster.",
+        lambda v: f"{v * 1000:.0f}", OUT / "cue-v1-languages-latency.png", 0.3, 1.15, "fastest in the row")
+heatmap(C3, "False cut-offs at a 300 ms latency budget, 14 languages",
+        "Share of turns cut off when the model must answer within 300 ms. Lighter is better.",
+        lambda v: f"{v * 100:.0f}%", OUT / "cue-v1-languages-cutoffs.png", 0.05, 0.55, "fewest in the row")
+heatmap(L10, "Latency at a 10% false cut-off rate, 14 languages",
+        "How long each model waits after the caller stops, when at most 10% of turns get cut off. Lighter is faster.",
+        lambda v: f"{v * 1000:.0f}", OUT / "cue-v1-languages-latency-10pct.png", 0.2, 0.9, "fastest in the row")
+heatmap(C6, "False cut-offs at a 600 ms latency budget, 14 languages",
+        "Share of turns cut off when the model must answer within 600 ms. Lighter is better.",
+        lambda v: f"{v * 100:.0f}%", OUT / "cue-v1-languages-cutoffs-600ms.png", 0.03, 0.2, "fewest in the row")
+print("ok")

prompts/barge_in.json

@@ -0,0 +1,24 @@
+{
+ "name": "barge_in",
+ "clock": "partial",
+ "priority": 1,
+ "instruction": "The agent is speaking on a phone call and the caller just said something over her. Should she stop?",
+ "options": [
+  {
+   "id": "STOP",
+   "describe": "a real interruption: a question, request, objection, correction, 'wait', 'hello?', or a full answer to her question"
+  },
+  {
+   "id": "CONTINUE",
+   "describe": "only listening or not for her: 'hmm', 'haan', 'ji', 'okay', 'achha', laughter, noise, a fragment"
+  }
+ ],
+ "inputs": [
+  "agent_said",
+  "agent_question",
+  "caller_text"
+ ],
+ "examples": [],
+ "deadline_ms": 400,
+ "default": "CONTINUE"
+}

prompts/end_of_turn_dialogue.json

@@ -0,0 +1,32 @@
+{
+ "name": "end_of_turn",
+ "clock": "pause",
+ "priority": 2,
+ "instruction": "Two people are talking. The speaker has just paused. Is it the other person's turn now? The speaker is done once they have finished their sentence and their point: answered or asked something, made their point, or reacted to what the other person said. They are not done if the last words leave the sentence hanging, if they are partway through a list, a story or an explanation that is clearly going on, or if they have only set up what they are about to say. How the speaker's words end is given below: a question mark almost always means they are done; no sentence end usually means more is coming.",
+ "options": [
+  {
+   "id": "DONE",
+   "describe": "finished: they asked something, answered, reacted or made their point, in a complete sentence. The other person can speak now"
+  },
+  {
+   "id": "LIKELY_DONE",
+   "describe": "probably finished: a complete statement that might still get one more sentence"
+  },
+  {
+   "id": "MID_THOUGHT",
+   "describe": "not finished: the sentence is left hanging (it stops on 'and', 'the', 'with', 'because', a repeated word, or a noun that needs more), or they have only set up what they are about to say. They will continue"
+  },
+  {
+   "id": "HOLDING",
+   "describe": "telling something long, a story or an explanation: a pause is them thinking. They will continue"
+  }
+ ],
+ "inputs": [
+  "Other person last said",
+  "Speaker said",
+  "Speaker's words end with"
+ ],
+ "examples": [],
+ "deadline_ms": 400,
+ "default": "DONE"
+}

prompts/end_of_turn_phone.json

@@ -0,0 +1,121 @@
+{
+ "name": "end_of_turn",
+ "clock": "pause",
+ "priority": 2,
+ "instruction": "The caller has paused on a phone call with an agent. Is it the agent's turn now? The caller is done once they have asked their question, made their request, or answered what the agent asked (even in a different form than asked: a name, a date, a code read out), in a complete sentence. They are not done if the last words leave the sentence hanging, if they are partway through reading out a number, or if they have only greeted, given their name or set the scene without yet saying what they want. How the transcript ends is given below: a question mark almost always means they are done; no sentence end usually means more is coming.",
+ "options": [
+  {
+   "id": "DONE",
+   "describe": "finished: they asked a question, made a request, answered the agent, or confirmed or declined, in a complete sentence. Reply now"
+  },
+  {
+   "id": "LIKELY_DONE",
+   "describe": "probably finished: a complete answer or statement that might still get one more sentence"
+  },
+  {
+   "id": "MID_THOUGHT",
+   "describe": "not finished: the sentence is left hanging (it stops on 'and', 'the', 'with', 'for', a repeated word, or a noun that needs more), a number is only partly read out, or they have only greeted, given their name or the background, without yet saying what they want. They will continue"
+  },
+  {
+   "id": "HOLDING",
+   "describe": "telling something long, a story or an explanation: a pause is them thinking. They will continue"
+  }
+ ],
+ "inputs": [
+  "agent_question",
+  "caller_earlier",
+  "caller_text",
+  "transcript_end"
+ ],
+ "examples": [
+  {
+   "inputs": {
+    "agent_question": "How can I help you today?",
+    "caller_text": "Hi, this is Priya.",
+    "transcript_end": "a full stop"
+   },
+   "answer": "MID_THOUGHT"
+  },
+  {
+   "inputs": {
+    "agent_question": "How can I help you today?",
+    "caller_text": "Hello, I booked a room with you last week and I need to change the dates.",
+    "transcript_end": "a full stop"
+   },
+   "answer": "DONE"
+  },
+  {
+   "inputs": {
+    "agent_question": "How can I help you today?",
+    "caller_text": "Is there a slot on Friday morning?",
+    "transcript_end": "a question mark"
+   },
+   "answer": "DONE"
+  },
+  {
+   "inputs": {
+    "agent_question": "What is your booking reference?",
+    "caller_text": "it's K L nine four two two",
+    "transcript_end": "no sentence end"
+   },
+   "answer": "DONE"
+  },
+  {
+   "inputs": {
+    "agent_question": "What's your phone number?",
+    "caller_text": "sure, it's three one two, five five",
+    "transcript_end": "no sentence end"
+   },
+   "answer": "MID_THOUGHT"
+  },
+  {
+   "inputs": {
+    "agent_question": "Anything else with the pizza?",
+    "caller_text": "yes, can I get that with extra",
+    "transcript_end": "no sentence end"
+   },
+   "answer": "MID_THOUGHT"
+  },
+  {
+   "inputs": {
+    "agent_question": "Which city are you in?",
+    "caller_text": "I stay in Pune but",
+    "transcript_end": "no sentence end"
+   },
+   "answer": "MID_THOUGHT"
+  },
+  {
+   "inputs": {
+    "agent_question": "Does that sound right?",
+    "caller_text": "Yes, that's right.",
+    "transcript_end": "a full stop"
+   },
+   "answer": "DONE"
+  },
+  {
+   "inputs": {
+    "caller_text": "yeah it was fine I guess",
+    "transcript_end": "no sentence end"
+   },
+   "answer": "LIKELY_DONE"
+  },
+  {
+   "inputs": {
+    "caller_earlier": "can I tell you what happened last year?",
+    "caller_text": "So in March my father was admitted to the hospital.",
+    "transcript_end": "a full stop"
+   },
+   "answer": "HOLDING"
+  },
+  {
+   "inputs": {
+    "agent_question": "Is there anything else I can help with?",
+    "caller_text": "No, that's all, thank you so much.",
+    "transcript_end": "a full stop"
+   },
+   "answer": "DONE"
+  }
+ ],
+ "deadline_ms": 400,
+ "default": "DONE"
+}