diff --git a/ai/generative-ai-service/tts-model-benchmarking/LICENSE b/ai/generative-ai-service/tts-model-benchmarking/LICENSE
new file mode 100644
index 0000000000..94dca6c927
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/LICENSE
@@ -0,0 +1,32 @@
+Copyright (c) 2026 Oracle and/or its affiliates.
+
+The Universal Permissive License (UPL), Version 1.0
+
+Subject to the condition set forth below, permission is hereby granted to any
+person obtaining a copy of this software, associated documentation and/or data
+(collectively the "Software"), free of charge and under any and all copyright
+rights in the Software, and any and all patent rights owned or freely
+licensable by each licensor hereunder covering either (i) the unmodified
+Software as contributed to or provided by such licensor, or (ii) the Larger
+Works (as defined below), to deal in both
+
+(a) the Software, and
+
+(b) any piece of software and/or hardware listed in the lrg_coverage.txt file,
+if one is included with the Software (each a "Covered Work", collectively
+"Covered Works"), that is available under a license listed in the
+lrg_coverage.txt file, if one is included with the Software (the "Covered
+License"), and
+
+without limitation, the right to copy, create derivative works of, display,
+perform, and distribute the Software and make, use, sell, offer for sale,
+import, export, have made, and have sold the Software and the Covered Works,
+in each case subject to the conditions and limitations set forth herein.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/README.md b/ai/generative-ai-service/tts-model-benchmarking/README.md
new file mode 100644
index 0000000000..bbf2d2e6f9
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/README.md
@@ -0,0 +1,75 @@
+# TTS Model Benchmarking on OCI Generative AI
+
+*A benchmark toolkit for text-to-speech models hosted on OCI Generative AI (imported models such as OmniVoice on a dedicated AI cluster, or on-demand models on the same speech route). It measures time to first audio, end-to-end latency, real-time factor, throughput and error rate under concurrency, with and without streaming, in English and Arabic, and scores intelligibility with Whisper to find the input length at which single-pass synthesis degrades.*
+
+Author: Brona Nilsson
+
+Reviewed: 05.10.2026
+
+# When to use this asset?
+
+*Use this asset when you need numbers, not impressions, about a TTS endpoint on OCI: how fast it answers, how much load one hosting unit takes, and whether long inputs stay intelligible.*
+
+### Who
+- Data scientists and ML engineers evaluating a TTS model in an OCI Data Science notebook session
+- Solution architects sizing a dedicated AI cluster (A10, A100, H100) for a voice workload
+- Teams comparing hosting shapes, model versions or serving-stack upgrades with repeatable runs
+
+### When
+- Choosing a hosting shape: run the same suites on each shape and compare the CSVs
+- Designing a voice application: pick streaming vs chunking from measured TTFA, not guesswork
+- Validating a fix: OmniVoice served through vLLM-Omni on OCI garbles speech past ~30 s per request; the `long-text` suite shows the breaking point as a WER curve and confirms when an upgrade removes it
+- Capacity planning: the concurrency sweep finds the knee where latency climbs and throughput flattens
+
+# How to use this asset?
+
+*Point the scripts at an endpoint, run a suite, read the report.*
+
+1. `pip install -r files/requirements.txt`, copy `files/.env.example` to `files/.env` and set the endpoint and compartment OCIDs. In a Data Science notebook session the resource principal is picked up automatically.
+2. `python files/tts_bench.py --suite quick --label <shape>` for a two-minute smoke test, then `--suite latency`, `--suite long-text`, `--suite concurrency` or `--suite full`.
+3. `python files/wer.py results/<run>` to score the saved clips for intelligibility, and `python files/plots.py results/<run>` for charts. Or open `files/notebook/tts_benchmark.ipynb` and run the cells.
+
+See the detailed [README](files/README.md) in the `files/` folder for setup on each platform, the metric definitions, the suites, reference numbers from an H100_X1 cluster and troubleshooting.
+
+### Key Capabilities
+- Industry-standard serving metrics: TTFA, E2E, RTF, p50/p90/p95/p99, error rate, requests per minute and audio seconds per second
+- Three request modes: synchronous, streaming, and client-side sentence chunking (the workaround for long inputs)
+- Closed-loop concurrency sweep (1, 2, 4, 8, 16 parallel requests) to find the capacity of one hosting unit
+- Target durations in seconds (10 to 60 s) with per-language calibration of characters per second, so English and Arabic are compared at equal speech length
+- Whisper-based WER/CER scoring with Arabic normalisation; CPU, CUDA or Apple Silicon backends
+- Constant voice across all requests through a bundled synthetic reference clip; voice design and preset-voice modes for other models
+- Works with API key, resource principal, instance principal, session token or bearer-key auth
+- CSV, Markdown report, sample audio and PNG charts per run; runs are labelled by shape for side-by-side comparison
+
+### File Structure
+```
+.
+├── README.md                     # This file
+├── LICENSE
+└── files/
+    ├── README.md                 # Detailed guide: setup, metrics, suites, reference numbers
+    ├── tts_bench.py              # The benchmark
+    ├── wer.py                    # Intelligibility scoring (Whisper WER / CER)
+    ├── plots.py                  # Charts from a run folder
+    ├── tts_client.py             # Client for the OCI speech route with OCI signing
+    ├── requirements.txt
+    ├── .env.example
+    ├── notebook/tts_benchmark.ipynb
+    ├── texts/                    # en_science, en_report, ar_coffee, ar_city
+    ├── voices/ref_voice.wav      # synthetic reference voice + transcript
+    └── results/                  # one folder per run (git-ignored)
+```
+
+# Useful Links
+
+- [OCI Generative AI documentation](https://docs.oracle.com/en-us/iaas/Content/generative-ai/home.htm)
+- [Importing K2-FSA OmniVoice models](https://docs.oracle.com/en-us/iaas/Content/generative-ai/imported-k2-fsa-models.htm)
+- [OCI OpenAI-compatible API](https://docs.oracle.com/en-us/iaas/Content/generative-ai/openai-compatible-api.htm)
+- [OCI Data Science notebook sessions](https://docs.oracle.com/en-us/iaas/data-science/using/use-notebook-sessions.htm)
+
+# License
+
+Copyright (c) 2026 Oracle and/or its affiliates.
+Licensed under the Universal Permissive License (UPL), Version 1.0.
+
+See [LICENSE](https://github.com/oracle-devrel/technology-engineering/blob/main/LICENSE.txt) for more details.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/.env.example b/ai/generative-ai-service/tts-model-benchmarking/files/.env.example
new file mode 100644
index 0000000000..acafbca400
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/.env.example
@@ -0,0 +1,25 @@
+# Copy to .env and fill in. Nothing here is a secret unless you choose the bearer-key route.
+
+# The TTS endpoint to benchmark: a dedicated endpoint OCID (imported model on a DAC)
+# or, for on-demand models that answer on the same speech route, the model name.
+TTS_MODEL=ocid1.generativeaiendpoint.oc1.<region>.<endpoint-id>
+
+# Compartment the endpoint lives in (sent as the compartment header).
+GENAI_COMPARTMENT_ID=ocid1.compartment.oc1..<compartment-id>
+
+# How to authenticate. One of:
+#   api_key             ~/.oci/config profile (laptops, default)
+#   resource_principal  OCI Data Science notebook sessions and jobs (auto-detected there)
+#   instance_principal  OCI compute VMs with a dynamic group policy
+#   security_token      `oci session authenticate` profiles
+#   bearer              an OCI Generative AI API key, see GENAI_API_KEY
+OCI_AUTH=api_key
+OCI_CONFIG_PROFILE=DEFAULT
+
+# Only for OCI_AUTH=bearer. Create it under Generative AI > API keys, in the SAME region as the endpoint.
+# GENAI_API_KEY=sk-...
+
+# Optional: force the inference host. Default is derived from the region in TTS_MODEL,
+# or from OCI_REGION when TTS_MODEL is not an OCID.
+# GENAI_SERVICE_ENDPOINT=https://inference.generativeai.<region>.oci.oraclecloud.com
+# OCI_REGION=eu-frankfurt-1
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/README.md b/ai/generative-ai-service/tts-model-benchmarking/files/README.md
new file mode 100644
index 0000000000..3fe4a93cba
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/README.md
@@ -0,0 +1,217 @@
+# TTS model benchmarking: detailed guide
+
+Scripts to measure a text-to-speech endpoint on OCI Generative AI the way a serving team
+would: time to first audio, end-to-end latency, real-time factor, throughput under
+concurrency, error rate, and intelligibility of the audio as the input gets longer. Built
+and verified against `k2-fsa/OmniVoice` imported on a dedicated AI cluster; works for any
+model that answers on OCI's OpenAI-compatible speech route.
+
+## Contents
+
+| File | Purpose |
+|---|---|
+| `tts_bench.py` | The benchmark. Suites, calibration, concurrency sweep, CSV + Markdown report, sample audio. |
+| `wer.py` | Transcribes the sample audio with Whisper and scores word / character error rate. Finds where long inputs break. |
+| `plots.py` | PNG charts from a run folder: latency vs length, RTF, load sweep, WER. |
+| `tts_client.py` | Minimal client for `/openai/v1/audio/speech` with OCI signing (API key, resource principal, instance principal, session token) or a bearer key. |
+| `notebook/tts_benchmark.ipynb` | The same steps as notebook cells, for OCI Data Science. |
+| `texts/` | Benchmark texts, `<lang>_<name>.txt`. English (`science`, `report` with many numbers) and Arabic (`coffee`, `city`), about 1,700-3,000 characters each. Add your own with the same naming. |
+| `voices/ref_voice.wav` + `.txt` | 7 s synthetic reference clip, generated by OmniVoice itself from a text prompt, with its transcript. Cloned in every request so the voice is constant. Not a real person. |
+| `results/` | One folder per run. Git-ignored. |
+| `.env.example` | Endpoint, compartment and auth settings. |
+
+## 1. Setup
+
+### On a laptop
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+cp .env.example .env         # set TTS_MODEL and GENAI_COMPARTMENT_ID
+python tts_bench.py --suite quick --label mylaptop
+```
+
+Auth uses your `~/.oci/config` profile (`OCI_CONFIG_PROFILE`). The inference region is
+derived from the endpoint OCID, so the profile can be in any region.
+
+### In an OCI Data Science notebook session
+
+Open `notebook/tts_benchmark.ipynb`, or in a terminal:
+
+```bash
+pip install -r requirements.txt
+export TTS_MODEL=ocid1.generativeaiendpoint.oc1.<region>.<id>
+export GENAI_COMPARTMENT_ID=ocid1.compartment.oc1..<id>
+python tts_bench.py --suite quick --label H100_X1
+```
+
+The resource principal is detected automatically (`OCI_RESOURCE_PRINCIPAL_VERSION` is set in
+notebook sessions and jobs). The session's dynamic group needs:
+
+```
+allow dynamic-group <notebook-dg> to use generative-ai-inference in compartment <name>
+```
+
+### Other auth modes
+
+| `OCI_AUTH` | Use when |
+|---|---|
+| `api_key` (default) | `~/.oci/config` with an API signing key |
+| `resource_principal` | Data Science notebooks and jobs, Functions, Container Instances |
+| `instance_principal` | A compute VM in a dynamic group |
+| `security_token` | A profile created by `oci session authenticate` |
+| `bearer` | An OCI Generative AI API key (`GENAI_API_KEY=sk-...`), created in the same region as the endpoint |
+
+### Which model
+
+`TTS_MODEL` is the **endpoint OCID** for an imported model on a DAC (display names return
+404). For on-demand models that answer on the same speech route, set the model name and
+`OCI_REGION`. Models with built-in voices need `--voice preset --voice-name <name>`;
+OmniVoice has none and rejects `voice`, which is why the default is `--voice clone`.
+
+## 2. Run
+
+```bash
+python tts_bench.py --suite quick --label H100_X1              # 2 min smoke test
+python tts_bench.py --suite latency --label H100_X1            # latency vs length, 3 modes
+python tts_bench.py --suite long-text --label H100_X1 --score  # where does it break? + WER
+python tts_bench.py --suite concurrency --label H100_X1        # 1,2,4,8,16 parallel
+python tts_bench.py --suite full --label H100_X1               # all of the above
+python plots.py results/H100_X1_<time>                         # charts
+```
+
+Any flag overrides the suite preset:
+
+```bash
+python tts_bench.py --langs ar --durations 15,20,25,30,35 --modes stream,chunked --n 5
+python tts_bench.py --suite concurrency --concurrency 1,4,8 --n 24 --durations 10
+python tts_bench.py --voice design --instructions "a deep, slow male voice"
+python tts_bench.py --chunk-seconds 12 --modes chunked
+python tts_bench.py --chars-per-second en=15,ar=12            # skip calibration
+```
+
+Label runs after the hosting shape (`A10_X1`, `A100_80G_X1`, `H100_X1`) so that CSVs from
+different clusters can be compared directly.
+
+### What a run does
+
+1. **Warm-up and calibration.** Two uncounted requests per language. From their output the
+   script learns how many characters make one second of speech for that language (about 15
+   for English, Arabic is measured), and uses that to cut every text at the sentence end
+   nearest each target duration. Target seconds are therefore comparable across languages.
+2. **Cells.** For every suite × concurrency × mode × language × text × duration it sends
+   `--n` requests through a thread pool of `concurrency` workers (closed loop: each worker
+   sends the next request as soon as its previous one finishes) and records each request.
+3. **Output** in `results/<label>_<time>/`:
+   - `requests.csv`: one row per request (TTFA, E2E, audio seconds, RTF, bytes, error, `opc-request-id`).
+   - `summary.csv`, `summary.md`: per cell, with p50 / p90 / p95 / p99 and throughput.
+   - `samples/<lang>__<text>__<mode>__<target>s.wav` + `.txt`: the first successful request of each cell, for listening and for `wer.py`.
+   - `config.json`: everything needed to reproduce the run.
+
+Ctrl-C writes the summary for the cells finished so far.
+
+## 3. Metrics
+
+| Metric | Definition | Why it matters |
+|---|---|---|
+| **TTFA** | time from sending the request to the first non-empty audio chunk | the pause a listener hears before playback starts; the number to optimise for conversational use |
+| **E2E** | time to the last byte | time until a file is complete; what batch jobs see |
+| **audio_s** | seconds of speech produced (pcm bytes / 48,000) | needed for RTF and to check the text was spoken in full |
+| **RTF** | E2E / audio_s | below 1.0 the server produces speech faster than it plays. A streaming player stays ahead of the audio when RTF is comfortably under 1 |
+| **err** | share of requests that failed (HTTP error, timeout) | the first thing to climb when a cluster is overloaded |
+| **req/min**, **audio s/s** | successful requests per minute, and seconds of speech per wall-clock second, over the whole cell | capacity. Plot against concurrency to find where the endpoint saturates |
+| **WER / CER** (`wer.py`) | word / character error rate of a Whisper transcript against the sent text | intelligibility. The only metric that shows the long-input failure |
+
+Percentiles are over the successful requests of a cell. With `--n 10` the p99 equals the
+maximum; use `--n 30` or more when tail latency is the question.
+
+### Modes
+
+- `sync`: one request, `stream: false`, audio in the response body. TTFA equals E2E.
+- `stream`: one request, `stream: true`, raw pcm chunks as they arrive. On OmniVoice the first
+  chunk arrives only after most of the request has been rendered, so TTFA is close to E2E and
+  grows with input length. That is a property of the serving stack, and a real measurement.
+- `chunked`: the client splits the text at sentence ends into pieces of about
+  `--chunk-seconds` (default 15 s) and sends them one after another, cloning the same voice
+  for all pieces. TTFA is the first piece's latency and stays flat as the text grows; E2E is
+  the sum. This is what an application should do for long inputs today.
+
+## 4. The long-input problem, and how to measure it
+
+OmniVoice served through vLLM-Omni on OCI renders a request in a single pass with a frame
+budget fixed from the character count. Past roughly 30 s of speech (about 450 English
+characters) the output turns into fluent-sounding babble: the audio has the right length and
+the latency looks normal, so **latency metrics do not show it**. The upstream OmniVoice code
+chunks long text itself; the vLLM-Omni serving path does not
+([vllm-omni #6333](https://github.com/vllm-project/vllm-omni/issues/6333),
+fix in [PR #6409](https://github.com/vllm-project/vllm-omni/pull/6409)).
+
+The `long-text` suite walks 15, 20, 25, 30, 35, 40, 50 and 60 s targets in `stream` and
+`chunked` mode and keeps one clip per cell. Then:
+
+```bash
+pip install faster-whisper          # CPU or NVIDIA GPU; mlx-whisper on Apple Silicon
+python wer.py results/H100_X1_<time>
+python plots.py results/H100_X1_<time>      # adds wer_vs_length.png
+```
+
+Expect WER in the low single digits for every `chunked` clip and for `stream` clips up to
+the breaking point, then a jump to 30-60 %. Measured on an H100_X1 with a 960-character
+English text: 58 % WER as one request, 1.4 % chunked. Arabic transcripts are normalised
+(diacritics removed, alef / yaa / taa-marbuta unified) before scoring. Texts with many
+digits score a few points worse than they sound because Whisper may write numbers
+differently from the source; compare modes on the same text rather than texts to each other.
+
+If the endpoint is upgraded to a vLLM-Omni build with server-side chunking, this suite is
+how to confirm it: `stream` WER should stay flat to 60 s and the `chunked` mode becomes
+unnecessary.
+
+## 5. Reference numbers
+
+OmniVoice on an `H100_X1` hosting cluster, 2 Oct 2026, cloned voice, pcm, concurrency 1,
+two requests per cell (so treat them as indicative, not as percentiles):
+
+| text | chars | audio s | single request E2E | chunked TTFA | chunked E2E |
+|---|---:|---:|---:|---:|---:|
+| English, 200 | 207 | 13.3 | 2.7-3.3 s | 2.5-2.8 s | 2.5-2.8 s |
+| English, 1000 | 1007 | 68.6 | 9.9-11.2 s | 2.6-2.9 s | 14.9-16.1 s |
+| English, 3000 | 2993 | 200.2 | 34-35 s | 2.7-3.4 s | 45-46 s |
+| Swedish, 1000 | 972 | 59.1 | 8.3-8.8 s | 2.5 s | 14.3 s |
+
+Single-request RTF was about 0.15-0.2 at every length, which looks excellent until you
+listen: everything past the first 30 s of the 1000- and 3000-character clips is babble.
+Streaming TTFA on the same cluster was 1.5-2.7 s for short texts and 20-24 s for the
+3000-character ones, confirming that the server does not stream during generation.
+
+## 6. Reading a concurrency sweep
+
+`concurrency.png` shows requests per minute next to p50 and p99 latency for each level.
+Throughput should rise roughly linearly while latency is flat, then flatten while latency
+climbs: the knee is the useful capacity of one hosting unit for that clip length. Errors or
+timeouts past the knee mean the queue is overflowing; raise `--timeout` only if you want to
+measure queueing rather than failures. Run the sweep at the clip length your application
+actually uses (`--durations`), and with `--n` at least 2× the highest concurrency level so
+every worker completes several requests.
+
+## 7. Troubleshooting
+
+- `404 Authorization failed or requested resource not found`: wrong endpoint OCID, endpoint
+  not `Active`, or no `use generative-ai-inference` on the compartment.
+- `400 Compartment ID must be provided`: `GENAI_COMPARTMENT_ID` is missing.
+- `400 Invalid voice ... Supported: none`: the model has no presets. Use `--voice clone`
+  (default), `design` or `none`.
+- `400 Invalid voice` on a model with presets: pass `--voice preset --voice-name <name>`.
+- `NotAuthenticated` or signing errors: check `OCI_AUTH` matches where you run, and test with
+  `oci iam region list` (api_key) or `oci os ns get --auth resource_principal` (notebook).
+- Warm-up reports `calibration failed`: the first requests errored; the error is printed above it.
+- Timeouts at high concurrency are data: they are counted in `err` and the run continues.
+- Every row in `requests.csv` carries the `opc-request-id`; quote it if you open an SR.
+
+## Sources
+
+- [Compatible K2-FSA OmniVoice models, OCI docs](https://docs.oracle.com/en-us/iaas/Content/generative-ai/imported-k2-fsa-models.htm)
+- [OCI OpenAI-compatible endpoints](https://docs.oracle.com/en-us/iaas/Content/generative-ai/openai-compatible-api.htm)
+- [xAI Grok TTS on OCI, same speech route](https://docs.oracle.com/en-us/iaas/Content/generative-ai/xai-grok-tts.htm)
+- [vLLM-Omni speech API](https://docs.vllm.ai/projects/vllm-omni/en/latest/serving/speech_api/)
+- [OpenAI text-to-speech API reference](https://developers.openai.com/api/docs/guides/text-to-speech), the request shape being mimicked
+- [Data Science resource principal auth](https://docs.oracle.com/en-us/iaas/data-science/using/use-notebook-sessions.htm)
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/notebook/tts_benchmark.ipynb b/ai/generative-ai-service/tts-model-benchmarking/files/notebook/tts_benchmark.ipynb
new file mode 100644
index 0000000000..2d02e6ef98
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/notebook/tts_benchmark.ipynb
@@ -0,0 +1,121 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "# TTS model benchmark on OCI Generative AI\n\nMeasures speed, latency, concurrency behaviour and long-input quality of a text-to-speech\nendpoint (for example OmniVoice imported on a dedicated AI cluster) in English and Arabic.\n\nRuns as-is in an **OCI Data Science notebook session** (resource principal auth) or on a laptop\nwith an `~/.oci/config` profile. Each step shells out to the scripts in the parent folder, so\neverything here can also be run from a terminal."
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "%cd ..\n!pip install -q -r requirements.txt"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "## 1. Configure\n\nSet the endpoint OCID and compartment. In a Data Science notebook session the resource principal is\ndetected automatically; the session's dynamic group needs `use generative-ai-inference` in that compartment.\nOn a laptop set `OCI_AUTH=api_key` and `OCI_CONFIG_PROFILE`."
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "import os\nos.environ[\"TTS_MODEL\"] = \"ocid1.generativeaiendpoint.oc1.<region>.<endpoint-id>\"   # the endpoint OCID\nos.environ[\"GENAI_COMPARTMENT_ID\"] = \"ocid1.compartment.oc1..<compartment-id>\"\n# os.environ[\"OCI_AUTH\"] = \"api_key\"; os.environ[\"OCI_CONFIG_PROFILE\"] = \"DEFAULT\"   # laptop\nLABEL = \"H100_X1\"   # name the run after the hosting shape so runs can be compared"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "## 2. Smoke test (about two minutes)\n\nTwo lengths, streaming, three requests each, English and Arabic. Confirms auth and the route."
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "!python tts_bench.py --suite quick --label {LABEL}"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "## 3. The real runs\n\nPick what you need. Each writes its own folder under `results/`.\n\n| suite | question it answers | time on one GPU |\n|---|---|---|\n| `latency` | how do TTFA and E2E grow with input length, with and without streaming, and with client-side chunking? | 20-40 min |\n| `long-text` | at what length does single-pass output degrade? saves one clip per length for Whisper scoring | 10-15 min |\n| `concurrency` | how many parallel requests before latency climbs and throughput flattens? | 10-15 min |\n| `full` | all three | about an hour |"
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "!python tts_bench.py --suite latency --label {LABEL}"
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "!python tts_bench.py --suite long-text --label {LABEL}"
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "!python tts_bench.py --suite concurrency --label {LABEL}"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "## 4. Look at the results"
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "import pandas as pd\nfrom pathlib import Path\nfrom IPython.display import Image, Markdown, display\n\nruns = sorted(Path(\"results\").glob(f\"{LABEL}_*\"))\nrun = runs[-1]\nprint(\"latest run:\", run)\nsummary = pd.read_csv(run / \"summary.csv\")\ncols = [\"suite\", \"lang\", \"text\", \"mode\", \"target_s\", \"chars\", \"concurrency\", \"n\", \"audio_s_mean\",\n        \"ttfa_p50\", \"ttfa_p90\", \"e2e_p50\", \"e2e_p90\", \"e2e_p99\", \"rtf_p50\", \"error_rate\", \"req_per_min\", \"audio_s_per_s\"]\nsummary[cols].round(2)"
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "!python plots.py {run}\nfor png in sorted((run / \"charts\").glob(\"*.png\")):\n    display(Image(filename=str(png)))"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "## 5. Intelligibility: where does the audio break?\n\nLatency numbers do not show the babble that single-pass synthesis produces past a certain length.\nTranscribe the saved samples with Whisper and compare them to the text that was sent. WER under 5 %\nis good audio; a jump to tens of percent marks the breaking point. `faster-whisper` runs on CPU;\non a GPU session it uses CUDA automatically. The first run downloads the model (about 1.6 GB for\n`large-v3-turbo`; use `--model small` for a quick look)."
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "!pip install -q faster-whisper\n!python wer.py {run}\npd.read_csv(run / \"wer.csv\").pivot_table(index=[\"lang\", \"text\", \"target_s\"], columns=\"mode\", values=\"wer\").round(3)"
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": "# redraw the charts so the WER panel is included, and show the written report\n!python plots.py {run}\ndisplay(Image(filename=str(run / \"charts\" / \"wer_vs_length.png\")))\ndisplay(Markdown((run / \"summary.md\").read_text()))"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "## 6. Compare hosting shapes\n\nRun the same suite with a different `LABEL` against an endpoint on another shape, then put the\nsummaries side by side:\n\n```python\na = pd.read_csv(\"results/A10_X1_<time>/summary.csv\")\nb = pd.read_csv(\"results/H100_X1_<time>/summary.csv\")\nkey = [\"suite\", \"lang\", \"text\", \"mode\", \"target_s\", \"concurrency\"]\na.merge(b, on=key, suffixes=(\"_a10\", \"_h100\"))[key + [\"e2e_p50_a10\", \"e2e_p50_h100\", \"req_per_min_a10\", \"req_per_min_h100\"]]\n```"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/plots.py b/ai/generative-ai-service/tts-model-benchmarking/files/plots.py
new file mode 100644
index 0000000000..fc4a93ffd4
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/plots.py
@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Draw the charts for a benchmark run.
+
+    python plots.py results/<run>            # writes PNGs into results/<run>/charts/
+
+Charts (only those the run has data for):
+  latency_vs_length.png       TTFA and E2E p50 against target seconds, one line per mode, one panel per language
+  rtf_vs_length.png           real-time factor against target seconds
+  concurrency.png             throughput and p50 / p99 latency against concurrency level
+  wer_vs_length.png           word error rate against target seconds (after wer.py)
+
+Needs pandas and matplotlib.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt  # noqa: E402
+import pandas as pd  # noqa: E402
+
+# fixed colour per mode (never cycled), validated categorical palette
+MODE_COLOR = {"sync": "#2a78d6", "stream": "#eb6834", "chunked": "#1baf7a"}
+LANG_COLOR = {"en": "#2a78d6", "ar": "#eb6834"}
+INK, MUTED, GRID = "#0b0b0b", "#52514e", "#e6e5e1"
+
+plt.rcParams.update({
+    "figure.facecolor": "white", "axes.facecolor": "white", "axes.edgecolor": GRID, "axes.labelcolor": INK,
+    "axes.grid": True, "grid.color": GRID, "grid.linewidth": 0.8, "axes.spines.top": False, "axes.spines.right": False,
+    "xtick.color": MUTED, "ytick.color": MUTED, "font.size": 10, "legend.frameon": False, "lines.linewidth": 2,
+    "lines.markersize": 6,
+})
+
+
+def _title(ax, text, sub=None):
+    ax.set_title(text, loc="left", fontsize=11, color=INK, pad=22 if sub else 6)
+    if sub:
+        ax.text(0, 1.03, sub, transform=ax.transAxes, fontsize=8.5, color=MUTED)
+
+
+def _label_ends(ax, xs, ys, text, color):
+    """Queue a direct label at the line end; `_flush_labels` spreads overlapping ones."""
+    if len(xs):
+        ax.__dict__.setdefault("_end_labels", []).append((xs[-1], ys[-1], text))
+
+
+def _flush_labels(ax):
+    labels = sorted(ax.__dict__.pop("_end_labels", []), key=lambda t: t[1])
+    if not labels:
+        return
+    lo, hi = ax.get_ylim()
+    gap = 0.045 * (hi - lo)
+    placed = []
+    for x, y, text in labels:
+        if placed and y - placed[-1] < gap:
+            y = placed[-1] + gap
+        placed.append(y)
+        ax.annotate(text, (x, y), xytext=(5, 0), textcoords="offset points", va="center", fontsize=8.5, color=INK)
+    if placed[-1] > hi - gap / 2:                       # keep the top label inside the plot
+        ax.set_ylim(lo, placed[-1] + gap)
+
+
+def latency_vs_length(df: pd.DataFrame, out: Path, label: str) -> None:
+    d = df[df.concurrency == 1]
+    if d.target_s.nunique() < 2:
+        return
+    langs = sorted(d.lang.unique())
+    fig, axes = plt.subplots(2, len(langs), figsize=(5 * len(langs), 7.5), squeeze=False, sharex=True)
+    for j, lang in enumerate(langs):
+        for i, (metric, name) in enumerate([("ttfa_p50", "Time to first audio, p50 (s)"), ("e2e_p50", "End-to-end latency, p50 (s)")]):
+            ax = axes[i][j]
+            for mode in ["sync", "stream", "chunked"]:
+                g = d[(d.lang == lang) & (d["mode"] == mode)].groupby("target_s")[metric].median().dropna()
+                if g.empty:
+                    continue
+                ax.plot(g.index, g.values, marker="o", color=MODE_COLOR[mode], label=mode)
+                _label_ends(ax, list(g.index), list(g.values), mode, MODE_COLOR[mode])
+            _title(ax, f"{lang}: {name}")
+            ax.set_ylim(bottom=0)
+            _flush_labels(ax)
+            if i == 1:
+                ax.set_xlabel("target seconds of speech")
+    axes[0][0].legend(loc="upper left")
+    fig.suptitle(f"{label}: latency against input length (concurrency 1)", x=0.01, ha="left", fontsize=12, color=INK)
+    fig.tight_layout()
+    fig.savefig(out / "latency_vs_length.png", dpi=150)
+    plt.close(fig)
+
+
+def rtf_vs_length(df: pd.DataFrame, out: Path, label: str) -> None:
+    d = df[df.concurrency == 1]
+    if d.target_s.nunique() < 2:
+        return
+    langs = sorted(d.lang.unique())
+    fig, axes = plt.subplots(1, len(langs), figsize=(5 * len(langs), 4), squeeze=False)
+    for j, lang in enumerate(langs):
+        ax = axes[0][j]
+        for mode in ["sync", "stream", "chunked"]:
+            g = d[(d.lang == lang) & (d["mode"] == mode)].groupby("target_s")["rtf_p50"].median().dropna()
+            if g.empty:
+                continue
+            ax.plot(g.index, g.values, marker="o", color=MODE_COLOR[mode], label=mode)
+            _label_ends(ax, list(g.index), list(g.values), mode, MODE_COLOR[mode])
+        ax.axhline(1.0, color=MUTED, linewidth=1, linestyle=":")
+        _title(ax, f"{lang}: real-time factor, p50", "E2E seconds per second of speech; below 1 is faster than playback")
+        ax.set_ylim(0, max(1.15, ax.get_ylim()[1]))
+        ax.text(ax.get_xlim()[1], 1.0, "real time ", ha="right", va="bottom", fontsize=8, color=MUTED)
+        ax.set_xlabel("target seconds of speech")
+        _flush_labels(ax)
+    axes[0][0].legend(loc="center left")
+    fig.tight_layout()
+    fig.savefig(out / "rtf_vs_length.png", dpi=150)
+    plt.close(fig)
+
+
+def concurrency(df: pd.DataFrame, out: Path, label: str) -> None:
+    levels = df.groupby(["lang", "text", "mode", "target_s"]).concurrency.nunique()
+    swept = levels[levels > 1].reset_index()[["lang", "text", "mode", "target_s"]]
+    if swept.empty:
+        return
+    d = df.merge(swept, on=["lang", "text", "mode", "target_s"])
+    target = d.target_s.value_counts().idxmax()          # one clip length per chart
+    d = d[d.target_s == target]
+    fig, axes = plt.subplots(1, 3, figsize=(14, 4))
+    panels = [("req_per_min", "Throughput (requests per minute)"), ("e2e_p50", "End-to-end latency, p50 (s)"), ("e2e_p99", "End-to-end latency, p99 (s)")]
+    for ax, (metric, name) in zip(axes, panels):
+        for lang in sorted(d.lang.unique()):
+            g = d[d.lang == lang].groupby("concurrency")[metric].median().dropna()
+            ax.plot(g.index, g.values, marker="o", color=LANG_COLOR.get(lang, MUTED), label=lang)
+            _label_ends(ax, list(g.index), list(g.values), lang, LANG_COLOR.get(lang, MUTED))
+        ax.set_xscale("log", base=2)
+        ax.set_xticks(sorted(d.concurrency.unique()))
+        ax.set_xticklabels([str(c) for c in sorted(d.concurrency.unique())])
+        ax.set_xlabel("concurrent requests")
+        ax.set_ylim(bottom=0)
+        _title(ax, name)
+        _flush_labels(ax)
+    axes[0].legend(loc="upper left")
+    fig.suptitle(f"{label}: load sweep ({', '.join(sorted(d['mode'].unique()))} mode, {target:.0f} s target clips)", x=0.01, ha="left", fontsize=12, color=INK)
+    fig.tight_layout()
+    fig.savefig(out / "concurrency.png", dpi=150)
+    plt.close(fig)
+
+
+def wer_vs_length(run: Path, out: Path, label: str) -> None:
+    f = run / "wer.csv"
+    if not f.exists():
+        return
+    w = pd.read_csv(f)
+    if w.target_s.nunique() < 2:
+        return
+    langs = sorted(w.lang.unique())
+    fig, axes = plt.subplots(1, len(langs), figsize=(5 * len(langs), 4), squeeze=False)
+    for j, lang in enumerate(langs):
+        ax = axes[0][j]
+        for mode in ["sync", "stream", "chunked"]:
+            g = w[(w.lang == lang) & (w["mode"] == mode)].groupby("target_s")["wer"].mean().dropna()
+            if g.empty:
+                continue
+            ax.plot(g.index, 100 * g.values, marker="o", color=MODE_COLOR[mode], label=mode)
+            _label_ends(ax, list(g.index), list(100 * g.values), mode, MODE_COLOR[mode])
+        _title(ax, f"{lang}: word error rate (%)", "Whisper transcript against the sent text; a jump marks where single-pass output degrades")
+        ax.set_ylim(bottom=0)
+        ax.set_xlabel("target seconds of speech")
+        _flush_labels(ax)
+    axes[0][0].legend(loc="upper left")
+    fig.tight_layout()
+    fig.savefig(out / "wer_vs_length.png", dpi=150)
+    plt.close(fig)
+
+
+def main() -> None:
+    if len(sys.argv) != 2:
+        sys.exit(__doc__)
+    run = Path(sys.argv[1])
+    df = pd.read_csv(run / "summary.csv")
+    out = run / "charts"
+    out.mkdir(exist_ok=True)
+    label = str(df.label.iloc[0])
+    latency_vs_length(df, out, label)
+    rtf_vs_length(df, out, label)
+    concurrency(df, out, label)
+    wer_vs_length(run, out, label)
+    made = sorted(p.name for p in out.glob("*.png"))
+    print("charts:", ", ".join(made) if made else "none (run has a single length and a single concurrency level)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/requirements.txt b/ai/generative-ai-service/tts-model-benchmarking/files/requirements.txt
new file mode 100644
index 0000000000..5211c4cac8
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/requirements.txt
@@ -0,0 +1,15 @@
+# Core: enough to run tts_bench.py
+oci>=2.185
+oci-openai>=1.1
+httpx>=0.27
+numpy>=1.26
+python-dotenv>=1.0
+
+# Charts and the notebook (plots.py, notebook/tts_benchmark.ipynb)
+pandas>=2.0
+matplotlib>=3.8
+
+# Optional, for intelligibility scoring with wer.py. Pick ONE backend:
+#   pip install faster-whisper      # CPU or NVIDIA GPU, works in OCI Data Science notebooks
+#   pip install openai-whisper      # reference implementation, needs ffmpeg
+#   pip install mlx-whisper         # Apple Silicon
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/results/.gitkeep b/ai/generative-ai-service/tts-model-benchmarking/files/results/.gitkeep
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/texts/ar_city.txt b/ai/generative-ai-service/tts-model-benchmarking/files/texts/ar_city.txt
new file mode 100644
index 0000000000..ef0cd85e0d
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/texts/ar_city.txt
@@ -0,0 +1,11 @@
+استيقظت المدينة القديمة قبل الشمس بقليل. كان الهواء ما يزال بارداً حين فتح الخباز باب فرنه، وارتفع من الشارع الضيق أول خيط من رائحة الخبز الساخن. مر عامل النظافة بعربته الصغيرة وألقى التحية، ثم اختفى خلف المنعطف. على السطوح بدأت الحمائم تتحرك، وفي البعيد سمع صوت المؤذن يمتد فوق البيوت.
+
+عند السابعة بدأ السوق يفتح أبوابه دكاناً بعد دكان. رفع البائعون الستائر المعدنية بصوت عال، وأخرجوا صناديق الخضار إلى الرصيف. كانت الطماطم حمراء لامعة، والخيار مرصوصاً في أكوام منظمة، والنعناع يملأ المكان برائحته. جلس بائع التوابل خلف أكياسه المفتوحة، وكانت ألوانها تتدرج من الأصفر إلى الأحمر الداكن كأنها لوحة.
+
+في زاوية الساحة كان صاحب المقهى يرتب كراسيه الخشبية. جاء زبائنه الأوائل كما يأتون كل يوم، رجال كبار في السن يعرفون أماكنهم ويعرف هو ما يشربونه قبل أن يطلبوا. وضع أمام كل منهم كوب شاي بالنعناع وصحيفة الصباح، وبدأ الحديث عن أسعار الأمس وأخبار الحي. لم يكن أحد في عجلة من أمره.
+
+خرج الأطفال إلى المدارس في قمصانهم البيضاء، وتبعتهم أمهاتهم إلى آخر الشارع. مرت سيارة أجرة ببطء وتوقفت أمام الصيدلية، ثم تابعت طريقها. وعند باب المسجد الكبير جلس رجل عجوز يبيع السبح والمفاتيح الصغيرة، وكان يبتسم لكل من يمر وإن لم يشتر شيئاً. عرف الجميع أنه هناك منذ أربعين عاماً.
+
+مع اقتراب الظهر اشتدت الحرارة وامتلأ السوق بالناس. تداخلت الأصوات، صوت الباعة ينادون على بضاعتهم، وصوت المطارق في سوق النحاسين، وصوت الماء يتدفق من السبيل القديم في وسط الساحة. دخلت مجموعة من الزوار يحملون الكاميرات، فوقفوا طويلاً أمام باب خشبي منقوش لا ينتبه إليه أهل الحي منذ سنوات.
+
+في الأزقة الخلفية كانت الحياة أهدأ. امرأة تنشر الغسيل على حبل بين نافذتين، وقط نائم على عتبة باب، وصبي يحمل صينية شاي إلى دكان قريب. من هنا تبدو المدينة كما كانت قبل مئة عام. وحين تدق ساعة الظهر يتوقف كل شيء لحظة قصيرة، ثم تعود الحركة من جديد كأن أحداً لم يلاحظ.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/texts/ar_coffee.txt b/ai/generative-ai-service/tts-model-benchmarking/files/texts/ar_coffee.txt
new file mode 100644
index 0000000000..cc38cddec3
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/texts/ar_coffee.txt
@@ -0,0 +1,11 @@
+تبدأ حكاية القهوة في مرتفعات الحبشة، حيث تنمو شجيرة خضراء صغيرة تحمل ثماراً حمراء. تقول الرواية الشهيرة إن راعياً لاحظ أن أغنامه تصبح نشيطة بعد أن تأكل من تلك الثمار، فجرب حبوبها بنفسه. لا أحد يعرف إن كانت القصة صحيحة، لكنها انتشرت لأنها تفسر شيئاً يعرفه الجميع. فنجان واحد يكفي ليطرد النعاس.
+
+عبرت الحبوب البحر الأحمر إلى اليمن قبل نحو ستمئة عام. هناك تعلم الناس تحميصها وطحنها وغليها في الماء، وصار الشراب الداكن رفيق السهر في حلقات الذكر. ومن ميناء المخا على ساحل اليمن خرجت القهوة إلى العالم، حتى إن اسم الميناء ما زال يطلق على نوع من القهوة إلى يومنا هذا. كانت التجارة محكمة. تغلى الحبوب أو تجفف قبل تصديرها حتى لا تنبت في أرض أخرى.
+
+وصلت القهوة إلى مكة والقاهرة ثم إلى إسطنبول، وفي كل مدينة فتحت المقاهي أبوابها. لم يكن المقهى مكاناً للشراب فقط، بل كان مجلساً للحديث والشعر والأخبار. جلس فيه التجار والطلاب والشعراء جنباً إلى جنب، وكان ذلك جديداً على مدن ذلك الزمان. لهذا السبب خاف بعض الحكام من المقاهي وحاولوا إغلاقها أكثر من مرة. وفي كل مرة كانت تعود لأن الناس أحبوها.
+
+في القرن السابع عشر حمل التجار القهوة إلى البندقية ثم إلى لندن وباريس وفيينا. تقول حكاية أخرى إن أول مقهى في فيينا فتح بأكياس من البن تركها جيش منسحب خلفه. ومع الوقت تعلم الأوروبيون إضافة الحليب والسكر، ثم ابتكروا أدوات جديدة لتحضيرها، من الإبريق البسيط إلى آلات الضغط التي تملأ المقاهي اليوم.
+
+أما زراعتها فقد انتقلت أيضاً. نقل الهولنديون شتلات إلى جزيرة جاوة، ونقل الفرنسيون شتلة واحدة إلى جزر الكاريبي، ومنها انتشرت المزارع في البرازيل وكولومبيا وأمريكا الوسطى. اليوم تزرع القهوة في أكثر من سبعين بلداً، ويعيش منها ملايين المزارعين الصغار. ومع ذلك ما زالت الحبوب التي تنمو على المرتفعات الباردة هي الأغلى والأكثر طلباً.
+
+في العالم العربي بقيت القهوة رمزاً للكرم. يقدمها المضيف بيده في فناجين صغيرة، ويصب القليل في كل مرة حتى يبقى الفنجان ساخناً. ولكل بلد طريقته. تضاف حبات الهيل في الخليج، وتضاف قطرات من ماء الزهر في بلاد الشام، وتحمص الحبوب حتى تسود في المغرب العربي. وكلها تبدأ من الثمرة الحمراء نفسها التي لاحظها راع في الجبل ذات يوم.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/texts/en_report.txt b/ai/generative-ai-service/tts-model-benchmarking/files/texts/en_report.txt
new file mode 100644
index 0000000000..103982a145
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/texts/en_report.txt
@@ -0,0 +1,9 @@
+Good morning, and thank you for joining the operations review for the third quarter of 2026. I will cover volumes, service levels, costs and the outlook for Q4, and then we will open the floor for questions. The headline is that total shipments reached 4.82 million units, up 11.3 percent on the same quarter last year and 2.7 percent ahead of the plan we agreed in June. On-time delivery finished at 96.4 percent, against a target of 95 percent, and the damage rate fell to 0.31 percent, the lowest figure since we began tracking it in 2019.
+
+Let me take the regions in turn. North America shipped 2.14 million units at an average cost of 3 dollars and 12 cents per unit, which is 8 cents better than Q2. Europe shipped 1.57 million units, with the Rotterdam and Hamburg hubs each handling more than 400,000 units for the first time. Asia Pacific came in at 1.11 million units, held back by the typhoon closures in late August that cost us roughly 14 operating days across the Taiwan and Philippines sites. Latin America remains small at 2 percent of volume but grew 38 percent year on year, driven almost entirely by the Mexico City facility that opened on March 15.
+
+Service levels were strong across the board. First-contact resolution reached 83 percent, average handle time dropped to 6 minutes 40 seconds, and the net promoter score rose 5 points to 47. The one exception is returns processing, where the median time from receipt to refund rose from 2.1 days to 3.4 days. The cause is known. The new scanning system went live on July 7 and the integration with the refund module was delayed until August 22, so the backlog built for six weeks before clearing. We expect the metric to return below 2.5 days in October.
+
+On costs, total operating expense was 61.4 million dollars, or 12 dollars and 74 cents per unit, which is 4.1 percent below plan. Fuel accounted for 9.8 million, labour for 27.3 million, facilities for 11.2 million and technology for 6.9 million, with the balance in insurance, packaging and miscellaneous items. Headcount ended the quarter at 3,412 full-time equivalents, 86 lower than June, mainly through natural attrition at the two sites we are consolidating in Ohio. Overtime hours fell 17 percent, which is the clearest sign that the scheduling changes introduced in May are working as intended.
+
+Looking ahead, we are planning for peak volumes of between 1.9 and 2.2 million units in November alone, which would be a record. Temporary hiring begins on October 6 with a target of 540 seasonal staff. We have secured an additional 12 percent of line-haul capacity on contracts fixed through January 31, and we have pre-positioned 3.5 million units of packaging in the regional hubs. The risks are the usual ones: weather, carrier reliability and the possibility that the port labour negotiations on the West Coast are not settled before the end of the month. We will send a written update on all three by Friday, October 17. That concludes the prepared remarks.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/texts/en_science.txt b/ai/generative-ai-service/tts-model-benchmarking/files/texts/en_science.txt
new file mode 100644
index 0000000000..fd4c2559b6
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/texts/en_science.txt
@@ -0,0 +1,9 @@
+Tides are the slow breathing of the ocean, and for most of human history nobody knew what caused them. Sailors knew the rhythm well enough to plan a departure, and fishing villages built their days around the turn of the water, but the link to the Moon was a matter of folklore rather than physics. The clue was always there in the timing. High water arrives roughly fifty minutes later each day, and the Moon rises roughly fifty minutes later each day, so the two keep step like dancers who never quite look at each other.
+
+The explanation that finally stuck is simple to state and surprisingly hard to picture. The Moon pulls on the near side of the Earth a little harder than on the centre, and on the centre a little harder than on the far side. The ocean, being free to move, stretches along that line of pull. The result is two bulges of water, one facing the Moon and one facing away, and the solid Earth turns underneath them once a day. A given harbour passes through both bulges, which is why most coasts see two high tides and two low tides in a little over twenty four hours.
+
+The Sun plays the same game with less than half the strength. When the Sun and Moon line up, at new moon and full moon, their bulges add together and the range between high and low water is at its greatest. These are the spring tides, named for the way the water seems to leap, not for the season. A week later, when the Moon has moved a quarter of the way round its orbit, the two pulls work at right angles and partly cancel. The gentler neap tides are the result, and anyone who has tried to float a boat off a mud bank at the wrong time of the month has learned the difference the hard way.
+
+Real coastlines complicate the picture. Water has to flow into bays and around headlands, and it sloshes in basins the way tea sloshes in a cup. In the open Pacific the tidal range is less than a metre, while at the head of the Bay of Fundy the funnel shape of the shore drives the range past fifteen metres. Some seas, like the Mediterranean, barely notice the Moon at all because their basins are too small and too enclosed for a bulge to build. Others have points where the tide hardly moves and the water simply rotates around them, a pattern that only became visible once satellite altimeters began mapping the sea surface from orbit.
+
+The energy in all this motion has to come from somewhere. It comes from the spin of the Earth, which is slowing by about two milliseconds per century as the tides drag on the sea floor. The Moon takes the lost momentum and drifts outward by nearly four centimetres a year, a figure we know precisely because astronauts left mirrors on its surface and laser pulses have been bounced off them ever since. Hundreds of millions of years ago the day was shorter and the Moon loomed larger in the sky. Coral growth bands and layered sediments still record those faster rhythms, so the ocean has been keeping a diary of the Moon for as long as there has been an ocean.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/tts_bench.py b/ai/generative-ai-service/tts-model-benchmarking/files/tts_bench.py
new file mode 100644
index 0000000000..569a3bea54
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/tts_bench.py
@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+"""Benchmark a text-to-speech endpoint on OCI Generative AI.
+
+Measures, per language, input length, request mode and concurrency level:
+  TTFA     time to first audio byte (what a listener waits before playback starts)
+  E2E      end-to-end latency until the last byte
+  audio_s  seconds of speech produced
+  RTF      real-time factor = E2E / audio_s   (1.0 = as fast as the speech itself)
+  err      error rate
+  req/min and audio_s/s   throughput of the whole run at that concurrency
+with p50 / p90 / p95 / p99 over `--n` requests per cell.
+
+Modes
+  sync      one request, stream=false; audio arrives as one body. TTFA = E2E.
+  stream    one request, stream=true; TTFA = first non-empty chunk.
+  chunked   client-side split at sentence ends into pieces of ~--chunk-seconds,
+            sent one after another, same voice throughout. This is the workaround
+            for models whose single-pass output degrades past a certain length.
+
+Suites (presets; any flag overrides the preset)
+  quick         smoke test, ~2 min                 en+ar, 10 s and 30 s, stream, n=3
+  latency       latency vs input length            7 lengths x 3 modes, n=10
+  long-text     where does single-pass degrade?    15..60 s, stream vs chunked, n=3, samples for wer.py
+  concurrency   throughput and tail latency        15 s text, stream, 1/2/4/8/16 parallel
+  full          latency + long-text + concurrency
+
+Examples
+  python tts_bench.py --suite quick --label H100_X1
+  python tts_bench.py --suite latency --label H100_X1 --langs en
+  python tts_bench.py --suite concurrency --concurrency 1,4,8 --n 24
+  python tts_bench.py --durations 15,20,25,30 --modes stream,chunked --n 5 --score
+  python tts_bench.py --suite full --label A10_X1 --score      # then: python plots.py results/<run>
+
+Texts come from texts/<lang>_<name>.txt and are cut at the sentence end nearest
+each target duration, using a per-language characters-per-second rate that is
+calibrated from the warm-up requests. Results land in results/<label>_<time>/:
+requests.csv (one row per request), summary.csv, summary.md, config.json and
+samples/*.wav (first successful request per cell, for listening and for wer.py).
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import platform
+import statistics
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+import numpy as np
+from dotenv import load_dotenv
+
+from tts_client import TTSClient, TTSError, cut_at_sentence, pcm_seconds, pcm_to_wav, split_text
+
+HERE = Path(__file__).resolve().parent
+DEFAULT_CPS = {"en": 15.0, "ar": 12.0}      # chars of text per second of speech, before calibration
+FALLBACK_CPS = 14.0
+
+SUITES = {
+    "quick":       dict(durations="10,30", modes="stream", n=3, concurrency="1", warmup=1),
+    "latency":     dict(durations="10,15,20,25,30,40,60", modes="sync,stream,chunked", n=10, concurrency="1"),
+    "long-text":   dict(durations="15,20,25,30,35,40,50,60", modes="stream,chunked", n=3, concurrency="1"),
+    "concurrency": dict(durations="15", modes="stream", n=16, concurrency="1,2,4,8,16"),
+}
+SUITES["full"] = None   # expands to latency + long-text + concurrency
+
+PCTS = (50, 90, 95, 99)
+
+
+# --- data ----------------------------------------------------------------------
+
+@dataclass
+class Job:
+    suite: str
+    lang: str
+    text_name: str
+    text: str
+    mode: str
+    target_s: float
+    concurrency: int
+    idx: int
+    chunk_chars: int
+
+
+@dataclass
+class Row:
+    label: str
+    suite: str
+    lang: str
+    text: str
+    mode: str
+    target_s: float
+    chars: int
+    pieces: int
+    concurrency: int
+    idx: int
+    started_at: str
+    ttfa_s: float | None
+    e2e_s: float
+    audio_s: float
+    rtf: float | None
+    bytes: int
+    ok: bool
+    error: str
+    request_id: str
+    pcm: bytes = field(default=b"", repr=False, compare=False)
+
+    def csv_row(self) -> dict:
+        d = asdict(self)
+        d.pop("pcm")
+        return d
+
+
+# --- one request -----------------------------------------------------------------
+
+def run_job(client: TTSClient, job: Job, voice: dict, label: str) -> Row:
+    started = time.strftime("%Y-%m-%dT%H:%M:%S")
+    t0 = time.perf_counter()
+    ttfa = None
+    audio = b""
+    pieces = 1
+    request_id = ""
+    try:
+        if job.mode == "sync":
+            r = client.speak(job.text, response_format="pcm", language=job.lang, **voice)
+            ttfa = time.perf_counter() - t0
+            audio, request_id = r.audio, r.request_id or ""
+        elif job.mode == "stream":
+            parts = []
+            with client.speak_stream(job.text, response_format="pcm", language=job.lang, **voice) as s:
+                request_id = s.request_id or ""
+                for chunk in s.chunks():
+                    if chunk and ttfa is None:
+                        ttfa = time.perf_counter() - t0
+                    parts.append(chunk)
+            audio = b"".join(parts)
+        elif job.mode == "chunked":
+            texts = split_text(job.text, job.chunk_chars)
+            pieces = len(texts)
+            kw = dict(voice)
+            parts = []
+            for i, piece in enumerate(texts):
+                r = client.speak(piece, response_format="pcm", language=job.lang, **kw)
+                request_id = r.request_id or request_id
+                parts.append(r.audio)
+                if i == 0:
+                    ttfa = time.perf_counter() - t0
+                    if "ref_audio" not in kw:        # no fixed voice: keep the first piece's voice
+                        kw.update(ref_audio=pcm_to_wav(r.audio), ref_text=piece)
+                        kw.pop("instructions", None)
+            audio = b"".join(parts)
+        else:
+            raise ValueError(f"unknown mode {job.mode}")
+        e2e = time.perf_counter() - t0
+        secs = pcm_seconds(audio)
+        return Row(label, job.suite, job.lang, job.text_name, job.mode, job.target_s, len(job.text), pieces,
+                   job.concurrency, job.idx, started, ttfa, e2e, secs, (e2e / secs if secs else None),
+                   len(audio), True, "", request_id, audio)
+    except (TTSError, Exception) as exc:        # noqa: BLE001 - every failure is a data point
+        e2e = time.perf_counter() - t0
+        rid = getattr(exc, "request_id", None) or request_id or ""
+        msg = " ".join(str(exc).split())[:300]
+        return Row(label, job.suite, job.lang, job.text_name, job.mode, job.target_s, len(job.text), pieces,
+                   job.concurrency, job.idx, started, None, e2e, 0.0, None, 0, False, msg, rid)
+
+
+# --- aggregation -------------------------------------------------------------------
+
+def pct(xs: list[float], p: int) -> float | None:
+    return float(np.percentile(xs, p)) if xs else None
+
+
+def summarise(rows: list[Row], wall: float) -> dict:
+    ok = [r for r in rows if r.ok]
+    ttfa = [r.ttfa_s for r in ok if r.ttfa_s is not None]
+    e2e = [r.e2e_s for r in ok]
+    aud = [r.audio_s for r in ok]
+    rtf = [r.rtf for r in ok if r.rtf]
+    first = rows[0]
+    s = dict(label=first.label, suite=first.suite, lang=first.lang, text=first.text, mode=first.mode,
+             target_s=first.target_s, chars=first.chars, pieces=first.pieces, concurrency=first.concurrency,
+             n=len(rows), errors=len(rows) - len(ok), error_rate=(len(rows) - len(ok)) / len(rows),
+             audio_s_mean=statistics.fmean(aud) if aud else None,
+             rtf_p50=pct(rtf, 50),
+             wall_s=wall, req_per_min=60 * len(ok) / wall if ok and wall else None,
+             audio_s_per_s=sum(aud) / wall if ok and wall else None)
+    for p in PCTS:
+        s[f"ttfa_p{p}"] = pct(ttfa, p)
+    for p in PCTS:
+        s[f"e2e_p{p}"] = pct(e2e, p)
+    return s
+
+
+def fmt(v, w=6, d=2) -> str:
+    return f"{v:{w}.{d}f}" if isinstance(v, (int, float)) and v is not None else " " * (w - 1) + "-"
+
+
+HEADER = (f"{'mode':8s} {'lang':4s} {'text':10s} {'tgt_s':>5s} {'chars':>5s} {'conc':>4s} {'audio_s':>7s} "
+          f"{'ttfa50':>6s} {'ttfa90':>6s} {'e2e50':>6s} {'e2e90':>6s} {'e2e99':>6s} {'rtf':>5s} {'err':>4s} "
+          f"{'req/min':>7s} {'aud_s/s':>7s}")
+
+
+def console_line(s: dict) -> str:
+    return (f"{s['mode']:8s} {s['lang']:4s} {s['text'][:10]:10s} {s['target_s']:5.0f} {s['chars']:5d} {s['concurrency']:4d} "
+            f"{fmt(s['audio_s_mean'], 7, 1)} {fmt(s['ttfa_p50'])} {fmt(s['ttfa_p90'])} {fmt(s['e2e_p50'])} "
+            f"{fmt(s['e2e_p90'])} {fmt(s['e2e_p99'])} {fmt(s['rtf_p50'], 5)} {100 * s['error_rate']:3.0f}% "
+            f"{fmt(s['req_per_min'], 7, 1)} {fmt(s['audio_s_per_s'], 7, 1)}")
+
+
+# --- report --------------------------------------------------------------------------
+
+def md_table(cells: list[dict], cols: list[tuple[str, str, int]]) -> str:
+    head = "| " + " | ".join(c[1] for c in cols) + " |"
+    sep = "|" + "|".join("---" if c[0] in ("lang", "text", "mode") else "---:" for c in cols) + "|"
+    lines = [head, sep]
+    for s in cells:
+        vals = []
+        for key, _, d in cols:
+            v = s.get(key)
+            if isinstance(v, float):
+                vals.append(f"{100 * v:.0f}%" if key == "error_rate" else f"{v:.{d}f}")
+            else:
+                vals.append("-" if v is None else str(v))
+        lines.append("| " + " | ".join(vals) + " |")
+    return "\n".join(lines)
+
+
+def write_report(run_dir: Path, cfg: dict, cells: list[dict], cps: dict, interrupted: bool) -> None:
+    cols = [("lang", "lang", 0), ("text", "text", 0), ("mode", "mode", 0), ("target_s", "target s", 0),
+            ("chars", "chars", 0), ("pieces", "pieces", 0), ("concurrency", "conc.", 0), ("n", "n", 0),
+            ("audio_s_mean", "audio s", 1), ("ttfa_p50", "TTFA p50", 2), ("ttfa_p90", "TTFA p90", 2),
+            ("e2e_p50", "E2E p50", 2), ("e2e_p90", "E2E p90", 2), ("e2e_p95", "E2E p95", 2),
+            ("e2e_p99", "E2E p99", 2), ("rtf_p50", "RTF", 2), ("error_rate", "errors", 0),
+            ("req_per_min", "req/min", 1), ("audio_s_per_s", "audio s/s", 1)]
+    out = [f"# TTS benchmark: {cfg['label']}", "",
+           f"Run started {cfg['started']} on {cfg['host']} with `{cfg['command']}`." + (" **Interrupted; partial results.**" if interrupted else ""),
+           "", f"- Model: `{cfg['model']}`", f"- Auth: {cfg['auth_mode']}, inference host `{cfg['url']}`",
+           f"- Voice: {cfg['voice']}", f"- Chunked mode cuts at ~{cfg['chunk_seconds']} s per piece",
+           "- Characters per second of speech (calibrated): " + ", ".join(f"{k} {v:.1f}" for k, v in cps.items()),
+           f"- Warm-up requests per language (not counted): {cfg['warmup']}", ""]
+    out += ["## How to read it", "",
+            "- **TTFA** is the time until the first audio byte, **E2E** until the last. For a listener, TTFA is the pause before playback and E2E the time until the clip is complete.",
+            "- **RTF** (real-time factor) is E2E divided by seconds of speech produced. Below 1.0 the model generates faster than it plays; a streaming player can keep up.",
+            "- **req/min** and **audio s/s** are the throughput of the whole cell at that concurrency; compare them across concurrency levels to find where the endpoint saturates (latency rises, throughput flattens).",
+            "- `stream` and `sync` send the whole text in one request. `chunked` splits it client-side; its TTFA is the first piece and its E2E the last, as a player pipelining the pieces would see it.",
+            "- Latency does not show quality. Listen to `samples/*.wav` or score them with `python wer.py <run dir>` to see where single-pass output degrades.", ""]
+    for suite in dict.fromkeys(c["suite"] for c in cells):
+        out += [f"## Suite: {suite}", "", md_table([c for c in cells if c["suite"] == suite], cols), ""]
+    (run_dir / "summary.md").write_text("\n".join(out), encoding="utf-8")
+
+
+# --- main ------------------------------------------------------------------------------
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0], formatter_class=argparse.RawDescriptionHelpFormatter,
+                                 epilog=__doc__.split("\n", 1)[1])
+    ap.add_argument("--suite", choices=list(SUITES), default="quick")
+    ap.add_argument("--label", default=None, help="name for this run, e.g. the hosting shape: H100_X1 (default: suite name)")
+    ap.add_argument("--langs", default=None, help="comma list of language codes matching texts/<lang>_*.txt (default: all present)")
+    ap.add_argument("--texts", type=Path, default=HERE / "texts", help="folder with <lang>_<name>.txt files")
+    ap.add_argument("--text-names", default=None, help="comma list of text names to use, e.g. science,coffee (default: all)")
+    ap.add_argument("--durations", default=None, help="comma list of target audio seconds, e.g. 15,20,25,30")
+    ap.add_argument("--modes", default=None, help="comma list of sync,stream,chunked")
+    ap.add_argument("--concurrency", default=None, help="comma list of parallel request counts, e.g. 1,4,8")
+    ap.add_argument("--n", type=int, default=None, help="measured requests per cell (per language, text, duration, mode, concurrency)")
+    ap.add_argument("--warmup", type=int, default=None, help="uncounted requests per language before measuring; also calibrates chars/second")
+    ap.add_argument("--chunk-seconds", type=float, default=15.0, help="target seconds of speech per piece in chunked mode")
+    ap.add_argument("--chars-per-second", default=None, help="skip calibration and use these rates, e.g. en=15,ar=12")
+    ap.add_argument("--voice", choices=["clone", "design", "preset", "none"], default="clone",
+                    help="clone: send --ref-audio with every request (default, constant voice); design: send --instructions; "
+                         "preset: send --voice-name (models with built-in voices); none: let the model pick")
+    ap.add_argument("--ref-audio", type=Path, default=HERE / "voices" / "ref_voice.wav")
+    ap.add_argument("--ref-text", default=None, help="transcript of --ref-audio (default: the .txt next to it, if any)")
+    ap.add_argument("--instructions", default="a calm, clear adult voice at a natural pace")
+    ap.add_argument("--voice-name", default=None, help="preset voice name for --voice preset")
+    ap.add_argument("--speed", type=float, default=None)
+    ap.add_argument("--timeout", type=float, default=300.0, help="per-request HTTP timeout in seconds")
+    ap.add_argument("--out", type=Path, default=HERE / "results")
+    ap.add_argument("--no-samples", action="store_true", help="do not keep a sample wav per cell")
+    ap.add_argument("--score", action="store_true", help="after the run, transcribe the samples and report WER/CER (needs a whisper backend)")
+    ap.add_argument("--model", default=None, help="override TTS_MODEL")
+    ap.add_argument("--profile", default=None, help="override OCI_CONFIG_PROFILE")
+    ap.add_argument("--auth", choices=["api_key", "resource_principal", "instance_principal", "security_token", "bearer"],
+                    default=None, help="override OCI_AUTH")
+    return ap.parse_args()
+
+
+def expand_suites(args) -> list[dict]:
+    """One plan per suite; `full` is three plans. Explicit flags override presets."""
+    names = ["latency", "long-text", "concurrency"] if args.suite == "full" else [args.suite]
+    plans = []
+    for name in names:
+        p = dict(SUITES[name], suite=name)
+        for k in ("durations", "modes", "concurrency", "n", "warmup"):
+            if getattr(args, k) is not None:
+                p[k] = getattr(args, k)
+        p["durations"] = [float(x) for x in str(p["durations"]).split(",")]
+        p["modes"] = str(p["modes"]).split(",")
+        p["concurrency"] = [int(x) for x in str(p["concurrency"]).split(",")]
+        p.setdefault("warmup", 2)
+        plans.append(p)
+    return plans
+
+
+def load_texts(folder: Path, langs: list[str] | None, names: list[str] | None) -> dict[str, dict[str, str]]:
+    texts: dict[str, dict[str, str]] = {}
+    for p in sorted(folder.glob("*_*.txt")):
+        lang, name = p.stem.split("_", 1)
+        if (langs and lang not in langs) or (names and name not in names):
+            continue
+        texts.setdefault(lang, {})[name] = " ".join(p.read_text(encoding="utf-8").split())
+    if not texts:
+        sys.exit(f"no texts found in {folder} (expected <lang>_<name>.txt)")
+    return texts
+
+
+def main() -> None:
+    load_dotenv(HERE / ".env")
+    load_dotenv()
+    args = parse_args()
+    plans = expand_suites(args)
+    label = args.label or args.suite
+    langs = args.langs.split(",") if args.langs else None
+    texts = load_texts(args.texts, langs, args.text_names.split(",") if args.text_names else None)
+
+    voice: dict = {}
+    if args.voice == "clone":
+        if not args.ref_audio.exists():
+            sys.exit(f"--voice clone needs a reference clip; {args.ref_audio} not found")
+        ref_txt = args.ref_text or (args.ref_audio.with_suffix(".txt").read_text(encoding="utf-8").strip()
+                                    if args.ref_audio.with_suffix(".txt").exists() else None)
+        from tts_client import data_uri
+        voice = dict(ref_audio=data_uri(args.ref_audio), ref_text=ref_txt)   # encode once, reuse per request
+    elif args.voice == "design":
+        voice = dict(instructions=args.instructions)
+    elif args.voice == "preset":
+        if not args.voice_name:
+            sys.exit("--voice preset needs --voice-name")
+        voice = dict(voice=args.voice_name)
+    if args.speed:
+        voice["speed"] = args.speed
+
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    run_dir = args.out / f"{label}_{stamp}"
+    (run_dir / "samples").mkdir(parents=True, exist_ok=True)
+    csv_path = run_dir / "requests.csv"
+    client = TTSClient(model=args.model, profile=args.profile, auth_mode=args.auth, timeout=args.timeout)
+    cfg = dict(label=label, started=time.strftime("%Y-%m-%d %H:%M:%S"), host=platform.node(),
+               command=" ".join(["python"] + [Path(sys.argv[0]).name] + sys.argv[1:]), model=client.model,
+               auth_mode=client.auth_mode, url=client.url, voice=args.voice + (f" ({args.ref_audio.name})" if args.voice == "clone" else ""),
+               chunk_seconds=args.chunk_seconds, warmup=plans[0]["warmup"], suites=plans, langs=sorted(texts),
+               texts={l: sorted(t) for l, t in texts.items()}, python=platform.python_version())
+    print(f"model {client.model}\nauth  {client.auth_mode} -> {client.url}\nout   {run_dir}\n")
+
+    # -- warm-up and calibration: how many characters make one second of speech, per language
+    cps: dict[str, float] = {}
+    fixed = dict(kv.split("=") for kv in args.chars_per_second.split(",")) if args.chars_per_second else {}
+    for lang, by_name in texts.items():
+        if lang in fixed:
+            cps[lang] = float(fixed[lang])
+            continue
+        guess = DEFAULT_CPS.get(lang, FALLBACK_CPS)
+        name, full = next(iter(by_name.items()))
+        probe = cut_at_sentence(full, int(10 * guess))
+        ratios = []
+        for i in range(max(1, plans[0]["warmup"])):
+            r = run_job(client, Job("warmup", lang, name, probe, "sync", 10, 1, i, 10**6), voice, label)
+            if r.ok and r.audio_s > 0.5:
+                ratios.append(r.chars / r.audio_s)
+            elif not r.ok:
+                print(f"warm-up {lang}: {r.error}")
+        cps[lang] = statistics.median(ratios) if ratios else guess
+        print(f"warm-up {lang}: {len(ratios)} ok, {cps[lang]:.1f} chars per second of speech"
+              + ("" if ratios else " (default, calibration failed)"))
+    cfg["chars_per_second"] = cps
+    (run_dir / "config.json").write_text(json.dumps(cfg, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    # -- the measured cells
+    cells: list[dict] = []
+    interrupted = False
+    fieldnames = list(Row.__dataclass_fields__)
+    fieldnames.remove("pcm")
+    print("\n" + HEADER)
+    try:
+        with open(csv_path, "w", newline="", encoding="utf-8") as fh:
+            writer = csv.DictWriter(fh, fieldnames=fieldnames)
+            writer.writeheader()
+            for plan in plans:
+                for conc in plan["concurrency"]:
+                    for mode in plan["modes"]:
+                        for lang, by_name in texts.items():
+                            chunk_chars = max(40, int(args.chunk_seconds * cps[lang]))
+                            for name, full in by_name.items():
+                                for target in plan["durations"]:
+                                    want = int(target * cps[lang])
+                                    text = cut_at_sentence(full, want)
+                                    if len(full) < want * 0.8:
+                                        print(f"note: {lang}_{name} has {len(full)} chars, too short for {target:.0f} s; using all of it")
+                                    jobs = [Job(plan["suite"], lang, name, text, mode, target, conc, i, chunk_chars) for i in range(plan["n"])]
+                                    t0 = time.perf_counter()
+                                    with ThreadPoolExecutor(conc) as pool:
+                                        rows = list(pool.map(lambda j: run_job(client, j, voice, label), jobs))
+                                    wall = time.perf_counter() - t0
+                                    for r in rows:
+                                        writer.writerow(r.csv_row())
+                                    fh.flush()
+                                    if not args.no_samples:
+                                        first = next((r for r in rows if r.ok), None)
+                                        if first:
+                                            stem = run_dir / "samples" / f"{lang}__{name}__{mode}__{target:.0f}s"
+                                            if not stem.with_suffix(".wav").exists():
+                                                stem.with_suffix(".wav").write_bytes(pcm_to_wav(first.pcm))
+                                                stem.with_suffix(".txt").write_text(text, encoding="utf-8")
+                                    s = summarise(rows, wall)
+                                    cells.append(s)
+                                    print(console_line(s), flush=True)
+                                    errs = {r.error for r in rows if not r.ok}
+                                    for e in list(errs)[:2]:
+                                        print(f"    error: {e[:160]}")
+    except KeyboardInterrupt:
+        interrupted = True
+        print("\ninterrupted; writing partial results")
+    finally:
+        client.close()
+        if cells:
+            with open(run_dir / "summary.csv", "w", newline="", encoding="utf-8") as fh:
+                w = csv.DictWriter(fh, fieldnames=list(cells[0]))
+                w.writeheader()
+                w.writerows(cells)
+            write_report(run_dir, cfg, cells, cps, interrupted)
+        print(f"\nresults: {run_dir}\n  requests.csv  one row per request\n  summary.csv / summary.md  per cell\n  samples/  one wav per cell")
+
+    if args.score and cells and not interrupted:
+        try:
+            import wer
+        except ImportError as exc:
+            sys.exit(f"--score: {exc}")
+        wer.score_run(run_dir)
+    elif cells:
+        print(f"\nnext: python plots.py {run_dir}        # charts\n      python wer.py {run_dir}          # intelligibility (needs a whisper backend)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/tts_client.py b/ai/generative-ai-service/tts-model-benchmarking/files/tts_client.py
new file mode 100644
index 0000000000..038083ccd6
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/tts_client.py
@@ -0,0 +1,263 @@
+"""Client for text-to-speech models served on OCI Generative AI's
+OpenAI-compatible speech route.
+
+    POST https://inference.generativeai.<region>.oci.oraclecloud.com/openai/v1/audio/speech
+
+Works for imported models on a dedicated AI cluster (for example k2-fsa/OmniVoice,
+where `model` is the endpoint OCID) and for on-demand models that answer on the
+same route. Requests are built with httpx rather than the OpenAI SDK because the
+SDK forces a `voice` argument that voice-cloning models such as OmniVoice reject.
+
+Facts verified live against an OmniVoice endpoint (Sep/Oct 2026):
+  - the path is /openai/v1/audio/speech, with no /20231130 prefix
+  - `model` is the endpoint OCID, not the display name
+  - the compartment header is required with OCI request signing
+  - `stream: true` returns a chunked byte stream; `stream_format: "sse"` does not work
+  - wav/pcm output is 24 kHz mono 16-bit; audio seconds = bytes / 48000
+"""
+from __future__ import annotations
+
+import base64
+import io
+import mimetypes
+import os
+import re
+import wave
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator
+
+import httpx
+
+AUDIO_FORMATS = ("wav", "mp3", "flac", "opus", "pcm")
+AUTH_MODES = ("api_key", "resource_principal", "instance_principal", "security_token", "bearer")
+SAMPLE_RATE = 24_000          # pcm/wav output: 24 kHz mono s16le
+BYTES_PER_SECOND = 2 * SAMPLE_RATE
+
+_OCID_REGION = re.compile(r"^ocid1\.generativeaiendpoint\.oc1\.([a-z0-9-]+)\.")
+_SENTENCE_END = re.compile(r"(?<=[.!?؟])(?<![A-Z][.!?])\s+")      # not after an initial such as "C."
+_CLAUSE_END = re.compile(r"(?<=[,;:،؛])\s+")
+
+
+class TTSError(RuntimeError):
+    def __init__(self, status: int, request_id: str | None, body: str):
+        super().__init__(f"TTS request failed: HTTP {status} opc-request-id={request_id}\n{body[:800]}")
+        self.status, self.request_id, self.body = status, request_id, body
+
+
+@dataclass
+class SpeechResult:
+    audio: bytes
+    content_type: str
+    request_id: str | None     # opc-request-id, what Oracle Support asks for
+
+    def save(self, path: str | Path) -> Path:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(self.audio)
+        return path
+
+
+class StreamingSpeech:
+    """Context manager around a `stream: true` response. Iterate `.chunks()`."""
+
+    def __init__(self, cm):
+        self._cm = cm
+        self.request_id: str | None = None
+        self.content_type = ""
+
+    def __enter__(self) -> "StreamingSpeech":
+        self._resp = self._cm.__enter__()
+        self.request_id = self._resp.headers.get("opc-request-id")
+        self.content_type = self._resp.headers.get("content-type", "")
+        if self._resp.status_code != 200:
+            self._resp.read()
+            raise TTSError(self._resp.status_code, self.request_id, self._resp.text)
+        return self
+
+    def chunks(self) -> Iterator[bytes]:
+        return self._resp.iter_bytes()
+
+    def __exit__(self, *exc):
+        return self._cm.__exit__(*exc)
+
+
+def resolve_auth_mode(explicit: str | None = None) -> str:
+    """Pick the auth mode: explicit > OCI_AUTH env > bearer key present >
+    resource principal environment (Data Science notebooks, jobs) > api_key."""
+    mode = (explicit or os.getenv("OCI_AUTH") or "").lower().strip()
+    if mode:
+        if mode not in AUTH_MODES:
+            raise ValueError(f"OCI_AUTH must be one of {AUTH_MODES}, got {mode!r}")
+        return mode
+    if os.getenv("GENAI_API_KEY"):
+        return "bearer"
+    if os.getenv("OCI_RESOURCE_PRINCIPAL_VERSION"):
+        return "resource_principal"
+    return "api_key"
+
+
+def build_auth(mode: str, profile: str) -> httpx.Auth | None:
+    """OCI request signer for httpx, or None for bearer-key auth."""
+    if mode == "bearer":
+        return None
+    from oci_openai import (
+        OciInstancePrincipalAuth, OciResourcePrincipalAuth, OciSessionAuth, OciUserPrincipalAuth,
+    )
+    if mode == "resource_principal":
+        return OciResourcePrincipalAuth()
+    if mode == "instance_principal":
+        return OciInstancePrincipalAuth()
+    if mode == "security_token":
+        return OciSessionAuth(profile_name=profile)
+    return OciUserPrincipalAuth(profile_name=profile)
+
+
+def _region(model: str, mode: str, profile: str) -> str:
+    m = _OCID_REGION.match(model)
+    if m:
+        return m.group(1)
+    if os.getenv("OCI_REGION"):
+        return os.environ["OCI_REGION"]
+    if mode in ("api_key", "security_token"):
+        import oci
+        return oci.config.from_file(profile_name=profile)["region"]
+    raise ValueError("Cannot derive the region: set OCI_REGION or GENAI_SERVICE_ENDPOINT")
+
+
+def data_uri(audio: bytes | str | Path, mime: str | None = None) -> str:
+    """Inline a reference clip as a base64 data URL, the form the server accepts."""
+    if isinstance(audio, (str, Path)):
+        path = Path(audio)
+        mime = mime or mimetypes.guess_type(path.name)[0] or "audio/wav"
+        audio = path.read_bytes()
+    return f"data:{mime or 'audio/wav'};base64," + base64.b64encode(audio).decode("ascii")
+
+
+class TTSClient:
+    """Thread-safe: one instance can be shared by a ThreadPoolExecutor."""
+
+    def __init__(
+        self,
+        *,
+        model: str | None = None,
+        compartment_id: str | None = None,
+        auth_mode: str | None = None,
+        profile: str | None = None,
+        service_endpoint: str | None = None,
+        api_key: str | None = None,
+        timeout: float = 300.0,
+    ):
+        self.model = model or os.environ["TTS_MODEL"]
+        self.compartment_id = compartment_id or os.environ["GENAI_COMPARTMENT_ID"]
+        self.auth_mode = resolve_auth_mode(auth_mode)
+        profile = profile or os.getenv("OCI_CONFIG_PROFILE", "DEFAULT")
+        host = service_endpoint or os.getenv("GENAI_SERVICE_ENDPOINT") or (
+            f"https://inference.generativeai.{_region(self.model, self.auth_mode, profile)}.oci.oraclecloud.com"
+        )
+        self.url = host.rstrip("/") + "/openai/v1/audio/speech"
+        headers = {"CompartmentId": self.compartment_id, "opc-compartment-id": self.compartment_id}
+        if self.auth_mode == "bearer":
+            key = api_key or os.getenv("GENAI_API_KEY")
+            if not key:
+                raise ValueError("OCI_AUTH=bearer needs GENAI_API_KEY")
+            headers["Authorization"] = f"Bearer {key}"
+        self._http = httpx.Client(auth=build_auth(self.auth_mode, profile), headers=headers, timeout=timeout)
+
+    # -- request body ---------------------------------------------------------
+    def body(
+        self,
+        text: str,
+        *,
+        response_format: str = "wav",
+        language: str | None = None,
+        voice: str | None = None,
+        instructions: str | None = None,
+        ref_audio: bytes | str | Path | None = None,
+        ref_text: str | None = None,
+        speed: float | None = None,
+        stream: bool = False,
+    ) -> dict:
+        if response_format not in AUDIO_FORMATS:
+            raise ValueError(f"response_format must be one of {AUDIO_FORMATS}")
+        body: dict = {"model": self.model, "input": text, "response_format": response_format}
+        if language:
+            body["language"] = language
+        if voice:                       # preset-voice models only; OmniVoice rejects it
+            body["voice"] = voice
+        if instructions:                # voice design
+            body["instructions"] = instructions
+        if ref_audio is not None:       # voice cloning
+            body["ref_audio"] = ref_audio if isinstance(ref_audio, str) and ref_audio.startswith("data:") else data_uri(ref_audio)
+            if ref_text:
+                body["ref_text"] = ref_text
+        if speed is not None:
+            body["speed"] = speed
+        if stream:
+            body["stream"] = True
+        return body
+
+    # -- calls ----------------------------------------------------------------
+    def speak(self, text: str, **kwargs) -> SpeechResult:
+        """One request, whole audio back in the response body."""
+        r = self._http.post(self.url, json=self.body(text, **kwargs))
+        request_id = r.headers.get("opc-request-id")
+        if r.status_code != 200:
+            raise TTSError(r.status_code, request_id, r.text)
+        return SpeechResult(r.content, r.headers.get("content-type", ""), request_id)
+
+    def speak_stream(self, text: str, *, response_format: str = "pcm", **kwargs) -> StreamingSpeech:
+        """`stream: true`. Use pcm so partial chunks are playable:
+
+            with client.speak_stream("Hello") as s:
+                for chunk in s.chunks(): ...
+        """
+        body = self.body(text, response_format=response_format, stream=True, **kwargs)
+        return StreamingSpeech(self._http.stream("POST", self.url, json=body))
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+
+# --- text and audio helpers --------------------------------------------------
+
+def split_text(text: str, max_chars: int) -> list[str]:
+    """Pack sentences into chunks of at most `max_chars`. A sentence longer than
+    that on its own is cut at clause punctuation. Handles Latin and Arabic marks."""
+    pieces: list[str] = []
+    for sentence in _SENTENCE_END.split(" ".join(text.split())):
+        pieces += _CLAUSE_END.split(sentence) if len(sentence) > max_chars else [sentence]
+    chunks: list[str] = []
+    for piece in pieces:
+        if chunks and len(chunks[-1]) + 1 + len(piece) <= max_chars:
+            chunks[-1] += " " + piece
+        else:
+            chunks.append(piece)
+    return chunks
+
+
+def cut_at_sentence(text: str, length: int) -> str:
+    """The text up to the sentence end nearest `length` characters."""
+    text = " ".join(text.split())
+    ends = [m.end() for m in re.finditer(r"[.!?؟](?=\s|$)", text)] or [len(text)]
+    return text[: min(ends, key=lambda e: abs(e - length))].strip()
+
+
+def pcm_seconds(audio: bytes) -> float:
+    return len(audio) / BYTES_PER_SECOND
+
+
+def pcm_to_wav(pcm: bytes) -> bytes:
+    buf = io.BytesIO()
+    with wave.open(buf, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(SAMPLE_RATE)
+        w.writeframes(pcm)
+    return buf.getvalue()
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/voices/ref_voice.txt b/ai/generative-ai-service/tts-model-benchmarking/files/voices/ref_voice.txt
new file mode 100644
index 0000000000..e085c7a175
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/voices/ref_voice.txt
@@ -0,0 +1 @@
+The quick brown fox jumps over the lazy dog. Oracle Cloud Infrastructure runs generative AI inside your own tenancy.
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/voices/ref_voice.wav b/ai/generative-ai-service/tts-model-benchmarking/files/voices/ref_voice.wav
new file mode 100644
index 0000000000..98933212e7
Binary files /dev/null and b/ai/generative-ai-service/tts-model-benchmarking/files/voices/ref_voice.wav differ
diff --git a/ai/generative-ai-service/tts-model-benchmarking/files/wer.py b/ai/generative-ai-service/tts-model-benchmarking/files/wer.py
new file mode 100644
index 0000000000..6f96b43cd7
--- /dev/null
+++ b/ai/generative-ai-service/tts-model-benchmarking/files/wer.py
@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Score the sample audio of a benchmark run for intelligibility.
+
+Transcribes every results/<run>/samples/*.wav with Whisper and compares the
+transcript with the text that was sent, giving word error rate (WER) and
+character error rate (CER). This is how the "speech turns to babble past N
+seconds" problem shows up as a number: WER stays in the low single digits
+for good audio and jumps to 30-60% where the model degrades.
+
+    python wer.py results/H100_X1_20261002-160726
+    python wer.py results/<run> --model small --device cpu      # faster, less accurate
+    python wer.py results/<run> --backend faster-whisper --device cuda
+
+Backends (install one):  pip install faster-whisper   (CPU or NVIDIA GPU; OCI Data Science)
+                         pip install openai-whisper   (reference, needs ffmpeg)
+                         pip install mlx-whisper      (Apple Silicon)
+
+Text normalisation before scoring: lower-case, punctuation removed; Arabic
+additionally loses diacritics and tatweel, and alef / yaa / taa-marbuta
+variants are unified (the usual Arabic ASR normalisation). Digits are left
+as written, so texts with many numbers score a few points worse than their
+audio deserves because Whisper may write "4.82" where the text says "4.82
+million" or vice versa. Compare modes on the same text, not texts to each other.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import re
+import sys
+from pathlib import Path
+
+_AR_DIACRITICS = re.compile(r"[ؐ-ًؚ-ٰٟۖ-ۭـ]")
+_PUNCT = re.compile(r"[^\w\s]|_", re.UNICODE)
+
+
+def normalise(text: str, lang: str) -> list[str]:
+    text = text.lower().replace("-", " ")
+    if lang == "ar":
+        text = _AR_DIACRITICS.sub("", text)
+        text = re.sub("[إأآا]", "ا", text)
+        text = text.replace("ى", "ي").replace("ة", "ه").replace("ؤ", "و").replace("ئ", "ي")
+    return _PUNCT.sub(" ", text).split()
+
+
+def edit_distance(ref: list, hyp: list) -> int:
+    d = list(range(len(hyp) + 1))
+    for i in range(1, len(ref) + 1):
+        prev, d[0] = d[0], i
+        for j in range(1, len(hyp) + 1):
+            cur = d[j]
+            d[j] = min(d[j] + 1, d[j - 1] + 1, prev + (ref[i - 1] != hyp[j - 1]))
+            prev = cur
+    return d[-1]
+
+
+def wer(ref: list[str], hyp: list[str]) -> float:
+    return edit_distance(ref, hyp) / max(1, len(ref))
+
+
+def cer(ref: list[str], hyp: list[str]) -> float:
+    r, h = list(" ".join(ref)), list(" ".join(hyp))
+    return edit_distance(r, h) / max(1, len(r))
+
+
+# --- transcription backends -----------------------------------------------------
+
+def pick_backend(name: str) -> str:
+    order = [name] if name != "auto" else ["faster-whisper", "mlx-whisper", "openai-whisper"]
+    mods = {"faster-whisper": "faster_whisper", "mlx-whisper": "mlx_whisper", "openai-whisper": "whisper"}
+    for b in order:
+        try:
+            __import__(mods[b])
+            return b
+        except ImportError:
+            continue
+    sys.exit("no transcription backend found; pip install faster-whisper (or openai-whisper, or mlx-whisper on a Mac)")
+
+
+class Transcriber:
+    def __init__(self, backend: str, model: str, device: str):
+        self.backend = backend
+        if backend == "faster-whisper":
+            from faster_whisper import WhisperModel
+            dev = device
+            if dev == "auto":
+                try:
+                    import torch  # noqa: F401
+                    dev = "cuda" if __import__("torch").cuda.is_available() else "cpu"
+                except ImportError:
+                    dev = "cpu"
+            self.m = WhisperModel(model, device=dev, compute_type="float16" if dev == "cuda" else "int8")
+        elif backend == "openai-whisper":
+            import whisper
+            self.m = whisper.load_model(model, device=None if device == "auto" else device)
+        else:
+            import mlx_whisper
+            self.m = mlx_whisper
+            self.repo = model if "/" in model else f"mlx-community/whisper-{model}"
+
+    def __call__(self, path: Path, lang: str) -> str:
+        if self.backend == "faster-whisper":
+            segs, _ = self.m.transcribe(str(path), language=lang, condition_on_previous_text=False, beam_size=5)
+            return " ".join(s.text for s in segs)
+        if self.backend == "openai-whisper":
+            return self.m.transcribe(str(path), language=lang, condition_on_previous_text=False)["text"]
+        return self.m.transcribe(str(path), path_or_hf_repo=self.repo, language=lang, condition_on_previous_text=False)["text"]
+
+
+# --- scoring a run ---------------------------------------------------------------------
+
+def score_run(run_dir: Path, model: str = "large-v3-turbo", device: str = "auto", backend: str = "auto") -> list[dict]:
+    run_dir = Path(run_dir)
+    wavs = sorted((run_dir / "samples").glob("*.wav"))
+    if not wavs:
+        sys.exit(f"no samples in {run_dir / 'samples'}")
+    backend = pick_backend(backend)
+    print(f"transcribing {len(wavs)} clips with {backend} / {model} ...")
+    asr = Transcriber(backend, model, device)
+    rows = []
+    print(f"{'lang':4s} {'text':10s} {'mode':8s} {'target_s':>8s} {'words':>5s} {'WER':>7s} {'CER':>7s}")
+    for wav in wavs:
+        lang, text, mode, target = wav.stem.split("__")
+        ref_text = wav.with_suffix(".txt").read_text(encoding="utf-8")
+        hyp_text = asr(wav, lang)
+        ref, hyp = normalise(ref_text, lang), normalise(hyp_text, lang)
+        row = dict(lang=lang, text=text, mode=mode, target_s=float(target.rstrip("s")), words=len(ref),
+                   wer=wer(ref, hyp), cer=cer(ref, hyp), file=wav.name, transcript=hyp_text.strip())
+        rows.append(row)
+        print(f"{lang:4s} {text[:10]:10s} {mode:8s} {row['target_s']:8.0f} {len(ref):5d} {100 * row['wer']:6.1f}% {100 * row['cer']:6.1f}%", flush=True)
+    out = run_dir / "wer.csv"
+    with open(out, "w", newline="", encoding="utf-8") as fh:
+        w = csv.DictWriter(fh, fieldnames=list(rows[0]))
+        w.writeheader()
+        w.writerows(rows)
+    md = run_dir / "summary.md"
+    if md.exists():
+        lines = ["", "## Intelligibility (Whisper WER / CER of one sample per cell)", "",
+                 f"Backend {backend}, model {model}. WER under 5% is good audio; a jump to tens of percent marks where the model degrades.", "",
+                 "| lang | text | mode | target s | words | WER | CER |", "|---|---|---|---:|---:|---:|---:|"]
+        lines += [f"| {r['lang']} | {r['text']} | {r['mode']} | {r['target_s']:.0f} | {r['words']} | {100 * r['wer']:.1f}% | {100 * r['cer']:.1f}% |" for r in rows]
+        with open(md, "a", encoding="utf-8") as fh:
+            fh.write("\n".join(lines) + "\n")
+    print(f"\nwrote {out}" + (f" and appended to {md}" if md.exists() else ""))
+    return rows
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0], formatter_class=argparse.RawDescriptionHelpFormatter,
+                                 epilog=__doc__.split("\n", 1)[1])
+    ap.add_argument("run_dir", type=Path)
+    ap.add_argument("--model", default="large-v3-turbo", help="whisper size: tiny, base, small, medium, large-v3, large-v3-turbo")
+    ap.add_argument("--device", default="auto", help="auto, cpu or cuda")
+    ap.add_argument("--backend", default="auto", choices=["auto", "faster-whisper", "openai-whisper", "mlx-whisper"])
+    a = ap.parse_args()
+    score_run(a.run_dir, a.model, a.device, a.backend)
+
+
+if __name__ == "__main__":
+    main()