AuK-Flash: one open model that writes, clones and edits speech, tested on a 24 GB card

The recording says "Our quarterly revenue grew by twelve percent, and the new office opens in March." We sent it to a speech model with one line of instructions (Replace 'twelve percent' with 'eighteen percent'.) and got back the same voice saying eighteen. The graphics card (GPU), a rented NVIDIA RTX A5000, spent 0.73 seconds on it.

The model is AuK-Flash, the fast version of AuK, released on 9 September by researchers from Shanghai Jiao Tong University, Tencent Hunyuan and the Shanghai Innovation Institute. The same model, driven by the same kind of plain-English instruction, also makes up a voice from a written description, copies a voice from a few seconds of audio, changes pitch, speed and emotion, turns speech into a whisper, cleans up noise and echo, and pulls one speaker out of a conversation. Today that usually takes a stack of separate tools: one to read text aloud, one to clone voices, an editor, a noise remover and a speaker separator. Here it is one model, and an engineer can put it behind one address and switch jobs by changing the sentence. The code and the trained model files are under the MIT licence, which allows commercial use. AuK also needs a second model, Alibaba's Qwen2.5-Omni-3B, whose licence does not allow commercial use.

What you take away:

What	Result
Model	AuK-Flash, the fast version of AuK: 1.5B parameters (the model's size, small enough for one card). It builds each clip in 4 passes instead of 32, which the authors measured as 4.5 times faster
Jobs in one model	voice from a description, voice cloning, replace or insert words, pitch, speed, emotion, whisper, noise and echo removal, keep one speaker, and more we did not test
Download	18.75 GB in total: 6.76 GB for AuK-Flash, plus a required 12 GB model that reads your instruction (Qwen2.5-Omni-3B, the "encoder")
Memory while serving	about 20 GB at peak, so it needs a 24 GB card. About 11 GB with a slower setting that parks part of the model in normal memory
Speed on an RTX A5000	0.4 to 0.8 s of GPU per request, 4 to 24 times faster than the audio plays
Edits	every edit we tried kept the rest of the sentence word for word (checked by transcript, not by ear)
Weak spots	voice descriptions sometimes get read aloud, one long output repeated a phrase, Spanish came out partly garbled
Start-up	71.6 s from asking for the model until it was ready to serve, once the rented GPU machine was connected to InferenceKey (nothing downloaded or installed yet). Connecting that machine took about 84 s more

Speech you edit like a document

The useful way to think about AuK is a sound engineer you talk to. In a studio you do not touch the faders yourself. You say "the second line, a bit warmer, and lose that cough", and the engineer does it. AuK puts that engineer in a model: you hand it a recording (or nothing, if it should start from scratch) and a sentence saying what you want. The cookbook lists the instruction templates the authors recommend, and they read like notes to a person:

• Say the following with the same voice: "{text}" to clone a voice from a short sample.
• Replace '{original}' with '{new}'. and Add '{text}' before '{anchor}'. to change the words.
• Raise the pitch by 2 semitones. or Adjust the speech speed to 1.25x.
• Keep only the first speaker to start talking and remove all other speakers.
• Preserve all speakers, remove noise and reverberation, and output clean speech of the same length.

The project's task table goes further than what we tried: editing the lyrics of singing without instruments, volume, the character of the voice, removing an accent, adding or removing breaths, laughs and coughs, separating music, and pulling out a speaker by what they say. The authors describe it as one general model for making and editing speech, trained on millions of hours of audio.

Why it matters to an engineer: one model is one thing to deploy, watch and update, on one graphics card, behind one address. A new task is a new sentence. The catch is that one address is also one queue: on a single card, a long cleanup job makes the next request wait.

How it does it

AuK has three parts, according to the technical report. The encoder, a model that understands text and audio together (Qwen2.5-Omni, made by Alibaba's Qwen team), reads your instruction and the input recording. A sound generator, the part that is AuK proper, then builds the new audio. A third piece turns the result into ordinary audio you can play.

The generator works like a painter going from a blurry sketch to a finished picture. The base AuK sharpens the sketch 32 times. At each step it makes two versions, one that follows your instruction and one that ignores it, and leans away from the second. AuK-Flash was trained to finish in 4 steps with one version each, which the authors measured as 4.5 times faster. The code enforces that recipe: if you ask Flash for more steps or the second version, it ignores you. A comment in the source warns that turning the second version back on makes the output so loud it distorts ("blows up the amplitude").

The training set is large: about 3 billion instruction and audio pairs, 1.95 million hours, in Chinese and English. The report is signed by Ziyang Ma and 32 other authors.

How good, by the authors' numbers

These scores are from the report's Table 3. We did not reproduce them.

Read aloud in a cloned voice, AuK-Flash gets about 3 words in 100 wrong (2.85%), slightly better than the strongest earlier system in the report's comparison (3.07%). In English alone it is about 1 word in 100.

Asked to replace or insert words, AuK-Flash got the edit right 87.5 times in 100 on the authors' editing test (SpeechEditBench), against about 76 for the best earlier system in the table.

For cleaning and separating audio, the authors call their results "competitive", not leading. On one test of pulling two voices apart, a tool built only for that job does better than AuK-Flash.

The report says the best results still need a separate language model in front of AuK, to work out the task and rewrite the request into the phrasing the model was trained on. We did not use one, and it showed in one place (see "What it sounds like").

Two models to download, 20 GB of memory

A working install downloads 18.75 GB, because AuK needs a second, 12 GB model to read your instructions. The AuK-Flash page alone lists 6.8 GB. The AI Search video where we spotted the release (a news roundup published on 13 September) went lower still, "only like 6.12 gigabytes", which is the main file alone.

• The encoder comes extra. AuK needs Qwen2.5-Omni-3B to understand instructions, downloaded separately. That is 11.99 GB on top of the 6.76 GB of AuK-Flash.
• Memory. On our card it used about 15.6 GB right after loading and about 20.3 GB at peak while working. That needs a 24 GB card. A setting that keeps part of the model in the computer's normal memory brought the peak down to about 11.3 GB, but each request then took about 13 seconds instead of under one. That might fit a 16 GB card, but we have not run it on one.
• The licence. AuK's code and model files are MIT. Qwen2.5-Omni-3B is under the Qwen Research Licence, which does not allow commercial use. A user opened issue #13 to point out that this makes the release non-commercial in practice. A collaborator on the project, ZhikangNiu, answered that the MIT licence covers AuK's own code and weights, that it does not override third-party licences, and that the team plans to replace the encoder with a permissively licensed one in a future release. Until then, a business shipping a product on AuK as released has a licensing question to settle first.

Running it on InferenceKey

The GPU and the cost

We ran AuK-Flash on one NVIDIA RTX A5000 with 24 GB, a workstation card, rented from RunPod at 0.27 USD an hour. Four edits sent together took 5.8 seconds in total. That is roughly 2,500 edits an hour, or about a hundredth of a US cent per edit at that raw GPU rental price, before any platform fee. It is worked out from one burst of four requests through a development tunnel, not from a long load test.

The backend, and why a custom one

InferenceKey runs each model through a small adapter we call a backend. None of the ready-made ones handles AuK yet. InferenceKey can run text-to-audio models through vLLM-Omni, an open-source server. The vLLM-Omni project published a recipe for AuK, but for a much bigger data-centre card, and we did not try it on 24 GB. So we wrote our own adapter: a small package that downloads Tencent's code at a fixed version and the model files, loads them and passes each request to Tencent's code. It accepts an instruction plus an optional recording, guesses the output length when you do not give one, caps outputs at 30 seconds and runs one job on the GPU at a time.

The steps

Our example code for the InferenceKey Python library does it in two scripts. publish.py uploads the custom backend to your account once. main.py asks InferenceKey to run the model on your GPU machine and waits until it is ready. It uses the model's chat address, because our text-to-speech address cannot return audio from a custom adapter yet (see "What went wrong"). Then it runs a short chain that needs no recording of yours: design a voice, clone it for a new sentence, replace "small teams" with "two engineers", speed it up 1.25 times, and shut down. The heart of it:

spec = WorkloadSpec(
    name="AuK-Flash speech generation and editing",
    slug=SLUG,
    model="tencent/AuK-Flash",
    backend=BACKEND_SLUG,  # our own adapter instead of a built-in one
    task_type="text2audio",
    worker_id=os.environ["IK_WORKER_ID"],
    execution_policy=ExecutionPolicy.FIXED,
    execution_policy_config={"replicas": 1},
)
ref = mgmt.ensure(spec)
enable_chat_route(base, project, ref.workload_slug)
mgmt.wait_until_ready(ref.workload_slug, timeout=2400)

out = auk(url, key, "Replace 'small teams' with 'two engineers'.", audio=host, seed=7)

Each request goes to the model's chat address (the same kind of address a chatbot uses), with the instruction as text and, for edits, the recording attached. The answer comes back as text with the audio packed inside it, and the example turns it back into a normal WAV file. Round trips were measured through a development tunnel to the rented card and may differ on the hosted service.

What we measured

Ready in 72 seconds once the GPU machine was connected. From the moment we asked for the model until it was ready to serve took 71.6 s, on a rented machine already connected to InferenceKey but with no model software or files on it. Getting that freshly rented machine connected took about 84 s more. Installing the software took 25.8 s, downloading the 18.75 GB of model files took only 8.7 s, and loading the model onto the card took 22.1 s. The remaining 13 s or so was setup. A second start, with the files already on the machine, took 47.2 s.

Under a second of GPU per job. Once warm, every request took 0.4 to 0.8 seconds of the card's time. An 18.5-second narration took 0.76 s, about 24 times faster than it plays. A 4.4-second edit took about 0.7 s. Cloning was the slowest: 0.84 s for 3.3 seconds of speech, still 4 times faster than it plays. The very first request after loading is slower, 1.2 to 2.3 s, while the card warms up. Counting the network trip from our development machine to the rented card, an edit came back in about 1.3 to 1.5 seconds.

About 20 GB of memory at peak. The model took about 15.6 GB of the card's memory once loaded and about 20.3 GB at its busiest. The memory-saving setting peaked at about 11.3 GB, but each request then took 13 to 15 seconds, longer than the audio itself.

One at a time. Four edits sent together were answered in turn, the last after 5.8 s. That is by design here: the backend runs one job on the GPU at a time.

What it sounds like

To check quality without trusting our ears alone, we transcribed every output with OpenAI's Whisper (large-v3-turbo) on the same machine and compared the words. The input voices are synthetic, made with Pocket TTS: clean studio-like speech, which is the easiest case for editing and cloning. Real recordings, with room noise, accents and people talking over each other, were not tested. These are single tries, not a listening test.

Editing is the strong part. Every edit kept the rest of the sentence word for word. The transcript proves the words. It does not prove that the pitch actually rose, that the whisper is a whisper, or that the replaced word joins the rest without an audible seam: that takes an ear or a pitch measurement, and we did not measure it. Listen and judge. Here is the original and what came out:

• Original (synthetic voice): "Our quarterly revenue grew by twelve percent, and the new office opens in March."
• Replace 'twelve percent' with 'eighteen percent' (0.73 s of GPU)
• Add 'almost' before 'twelve percent' (0.76 s of GPU)
• Raise the pitch by 3 semitones (0.66 s of GPU)
• Turned into a whisper (0.72 s of GPU)

Cleaning and separating. We added noise and echo to the recording and asked for clean speech. The transcript stayed the same, which proves the words survived. It does not measure how clean the result is, so judge that by ear. For separation, we overlapped two voices, and the second speaker's whole sentence disappeared from the output.

• Before: the same sentence with noise and echo added
• After: "remove noise and reverberation" (0.69 s of GPU)
• Before: two voices talking over each other
• After: "keep only the first speaker" (0.77 s of GPU)

New voices, and a copy of one. Voice design starts from a written description and no audio at all. Cloning takes the voice of the original revenue clip and makes it say something it never said.

• Voice design: a sports announcer, "And she crosses the line first, a new course record by almost four seconds." (0.41 s of GPU)
• Voice design: an 18.5 s documentary narration about a river (0.76 s of GPU)
• Clone of the revenue clip's voice, from that one sample and no training: "The board approved the budget, and hiring starts next quarter." (0.84 s of GPU)

We did not measure how close the clone is to the original voice.

Voice design depends on the wording. Phrased as Based on the following description: "...", generate speech content "...". (the project's command-line example, which ours uses), 7 of 8 English voice designs came out exactly right. The eighth, the 18.5-second narration on another try, repeated "the river begins as snow on the high peaks" and dropped the next phrase. Phrased as Generate speech based on the following description: "...". The content to speak is: "...". (the cookbook's English template), the model read part of the description aloud in 8 of 8 tries ("A sports chatty excited, and she crosses the line first..."). This fits what the report says about rewriting requests first: phrasing matters.

• The cookbook template: the description leaks into the speech

Spanish is not there yet. AuK is trained on Chinese and English. A Spanish line came out partly garbled. A user on the repo reported the same for Polish (issue #17). Following a project collaborator's advice, that same user later trained AuK-Base further on about 100 hours of Polish recordings and got it working.

• Spanish voice design, partly garbled

Shouting may be a gap. One user reports that AuK cannot reproduce shouting or yelling from a reference recording (issue #23). The issue is still open, and we have not tested it.

In about 60 requests there were no crashes, and none of them came back broken.

The demo video

The video shows the model on the RTX A5000 in the InferenceKey dashboard, then a terminal asking for the number replacement (4.44 s of audio, 0.71 s of GPU, 1.4 s round trip), the announcer voice and the noise removal, with the before and after audio mixed into the soundtrack so you can hear them.

What went wrong

• The text-to-speech address does not work with custom backends. The natural address for this model, the standard text-to-speech one, returned an error instead of audio. Our platform does not yet return audio from a home-made adapter on that address. That is a gap on our side. The workaround is the chat address, which we had to switch on for this model. The answer then arrives as text with the audio packed inside, not as a plain audio file. The example does both.
• The first start crashed while downloading. Two downloads ran at the same time and their progress bars clashed. Turning the progress bars off fixed it.
• A missing package. The first audio request failed because a library the encoder needs to read audio files (audioread) was not installed. We added it to the requirements.

Who did what

The AuK team, Ziyang Ma and 32 co-authors from Shanghai Jiao Tong University, Tencent Hunyuan and the Shanghai Innovation Institute, built AuK and AuK-Flash, wrote the technical report and the cookbook, and released the code and model files under MIT. After the release they made a test version run on Apple Silicon Macs, made it run on smaller cards, cut the encoder's memory use by about 8 GB, and published how they trained the fast version. Other open-source projects that run models in production did their own share: SGLang-Omni supported AuK on release day, vLLM-Omni added a recipe two days later, and 0xShug0's audio.cpp runs AuK as GGUF in a pure C++ engine with no Python. Alibaba's Qwen team made Qwen2.5-Omni, the encoder AuK listens through. Kyutai's Pocket TTS made the synthetic voices we used as input, and OpenAI's Whisper did our transcription checks. Contributors on the repo's issues raised the licence question, the Polish results and the shouting report, and project collaborators replied in the open. The person who reported the Polish results went on to train a working Polish version. We spotted the release in AI Search's news video.

Our part was the custom backend that brings Tencent's inference code into InferenceKey, the SDK example, running it end to end on one RTX A5000, and measuring start-up time, memory, speed per task and whether the words survived each edit.

What to take away

On a 24 GB card, every edit we tried kept the rest of the sentence word for word: a word changed, a word added, a second speaker removed, each in under a second of GPU time. One model behind one address did the jobs of five tools in our test, one request at a time. Whether it matches each specialist tool is the authors' benchmark, not ours, and on one separation test a dedicated model beats AuK-Flash. The limits are just as concrete. It needs about 20 GB of memory at peak. It speaks Chinese and English. Voice design is sensitive to wording. Our checks were about 60 requests, mostly one try each, with synthetic voices and no listening panel.

The encoder licence decides most business use today. The team has said it plans to swap in an encoder with a permissive licence, and until then issue #13 is the thread to watch.

For engineers

Model (AuK-Flash card, AuK card, repo, cookbook, arXiv 2609.08936, project page). tencent/AuK-Flash sha 575b92f0, last modified 2026-09-09, not gated, MIT, 6,762,642,715 B stored: auk_flash.safetensors 6,122,209,092 B (fp32 DiT), vae.safetensors 637,322,604 B. tencent/AuK (base, auk_base.safetensors) same storage. README and HF cards say MIT (the GitHub API reports NOASSERTION). 1,524 GitHub stars, AuK-Flash 1,599 downloads and 107 likes, AuK 2,695 downloads and 389 likes (2026-10-17). HF languages: zh, en. Upstream timeline (README news): MLX on Apple Silicon on branch feat/mlx-apple-silicon and CUDA CPU offload 2026-09-13, PR #19 encoder memory 2026-09-16, distillation training pipeline 2026-10-14 (PR #22).

Architecture (report section 4.2). Qwen2.5-Omni as MLLM semantic encoder with layer-wise hidden states aggregated; audio VAE trained on speech, general audio and music (50 Hz latents, 64 dims, 24 kHz output); hybrid rectified-flow Transformer, 30 layers = 10 dual-stream MMDiT + 20 single-stream DiT, hidden 1536, 24 heads, about 1.5B params. Encoder and VAE frozen. Training: about 3.03B instruction-audio instances, 1.95M hours of effective supervision, five task families. AuK-Flash: consistency initialization plus task-routed Decoupled DMD, 4 steps, CFG-free, 4.5x wall clock over the 32-NFE, CFG 2.0 teacher. src/auk/infer/infer_auk.py @ 9481474f detects Flash by config name and locks it to 4 steps, CFG 0, t-grid [0, 0.0761, 0.2929, 0.6173, 1], ignoring caller sampling knobs. Base defaults: nfe 32, cfg_strength 2.0.

Paper Table 3 (authors' numbers). Seed-TTS-Eval avg WER: AuK 2.65, AuK-Flash 2.85, Qwen3-TTS 3.07, Seed-TTS 3.65, VoxCPM2 3.65. Avg SIM: AuK 0.795, Flash 0.790, Seed-TTS 0.778. EN WER: AuK 1.02, Flash 1.03, Qwen3-TTS 1.23. MMAE(Speech) EMR: Flash 13.85, AuK 12.44, Ming-UniAudio 7.04, Step-Audio-EditX 4.69. SpeechEditBench content ACC: Flash 87.50, AuK 91.83, Ming-UniAudio 76.46, Step-Audio-EditX 16.50. DNS Challenge dWER: Flash 2.93, AuK 2.66, RE-USE 3.31. Libri2Mix WER: Flash 10.07, AuK 9.12, MossFormer2-SS 9.34.

Upstream VRAM. README table (A800, bf16, max_memory_allocated): AuK-Flash 24.77 GiB text-only 1.5 s output, 16.75 GiB with --cpu_offload; 24.97 / 16.98 GiB with 5 s reference audio. That table predates PR #19 (merged 2026-09-16), which casts only the DiT to fp32 and keeps Qwen in bf16, about 7.5 GiB less (Qwen 7.515 GiB in bf16, 15.031 GiB upcast).

Our setup. RunPod RTX A5000 24,564 MiB, SECURE, CA-MTL-1, 0.27 USD/h (RTX 4090 COMMUNITY returned 409), driver 580.178.04 (CUDA 13.0), 230 W limit, compute 8.6, 7.65 CPUs by cgroup, 503 GB host RAM, Python 3.12.3, 100.7 MB/s single-stream curl from huggingface.co. In a separate measurement from the cold start below, the worker was bootstrapped by a local InferenceKey manager over HTTP and TCP tunnels in 84 s after the pod POST (ssh after 38.5 s, 25,243,632 B worker binary over SFTP in 14.8 s).

Backend. Custom Python backend auk-flash-speech 0.1.3, task type text2audio. Pins: AuK 9481474f107ee4d8dec959b3aed05b0627cebbf8, AuK-Flash 575b92f0, Qwen2.5-Omni-3B f75b40e3 (Thinker only). AukInfer(config, ckpt, dtype="bf16", qwen_path=...). max_gen_seconds 30, chars_per_second 14 for length estimation, AUK_* env overrides, AukFlashOffloadBackend sets cpu_offload=True. Returns audio_b64 (16-bit WAV, 24 kHz mono), seconds, timings {gpu_s, total_s, realtime_factor, peak_vram_mib}. GPU call under a lock. publish.py packages with requires_python >=3.10,<3.13. Example README: keep inputs under about 15 s to stay under the platform's 2 MB request body limit; torch 2.7 from PyPI is the CUDA 12.6 build, so the driver must support CUDA 12.6+. Note: the example's .env.example says "about 17 GB of free VRAM"; the measured nvidia-smi peak was 19,390 MiB, so plan for a 24 GB card. SDK example commit aa7e900 on inferencekey-sdk main.

Cold start. ensure() to SDK ready 71.6 s with HF, uv and venv caches empty: venv 25.8 s (torch 2.7, transformers 4.57), downloads 8.7 s for 18.75 GB, about 13 s imports and setup, load 22.1 s (setup_s 44.1, vram_loaded_mib 14,305). Weights cached and warm uv cache: 47.2 s. With the venv present: 36.1 s and 19.8 s.

VRAM (nvidia-smi -l 1). 14,837 MiB after load, 19,390 MiB peak serving, torch max_memory_allocated 17,309 to 17,964 MiB per request. Offload variant: 1,571 MiB idle, 10,755 MiB peak, 12.7 to 15.2 s of GPU per request (0.3x to 0.5x real time), not tested on a 16 GB card. Power peak 181 W.

Per request (warm, seed 7, non-streaming /v1/chat/completions, CLI template unless noted; GPU time is the backend's synchronized gpu_s, round trip measured by the client through the tunnel):

Case	Input	Out s	GPU s	x real time	Round trip s	Whisper says
Voice design, announcer	none	5.96	0.41	14.5	0.76	exact text
Voice design, 18.5 s narration	none	18.46	0.76	24.3	1.23	exact text
Zero-shot clone, new sentence	4.3 s clip	3.34	0.84	4.0	1.81	exact text
Replace "twelve percent" with "eighteen percent"	4.3 s	4.44	0.73	6.1	1.53	"...grew by 18%, and..."
Insert "almost"	4.3 s	4.80	0.76	6.3	1.49	"...grew by almost 12%..."
Pitch +3 semitones	4.3 s	4.28	0.66	6.5	1.39	unchanged text
Emotion: excited	4.3 s	4.28	0.68	6.3	1.27	unchanged text
Whisper	4.3 s	4.28	0.72	5.9	1.33	unchanged text
Denoise + dereverb	4.4 s	4.40	0.69	6.4	1.29	unchanged text
Keep first speaker	5.8 s	5.76	0.77	7.5	1.40	only speaker 1's sentence
Spanish voice design	none	6.96	0.43	16.3	0.79	partly garbled

First request after a cold load: 1.23 to 2.30 s of GPU for a 6.1 s voice design. Platform overhead (round trip minus GPU) about 0.3 to 1.0 s for edits, since the request and answer each carry a base64 WAV. Four parallel edits: wall 5.82 s, round trips 1.42, 2.92, 4.46, 5.81 s (assignment concurrency 1 plus the backend lock), all four outputs correct. Speed 1.25x: 6.10 s to 4.88 s. The "about 2,500 edits an hour" in the narrative is 3,600 / (5.82 / 4), a projection from this one burst of four through a dev tunnel; no sustained load run was done.

Quality check. openai/whisper-large-v3-turbo on the pod. Voice design templates: cookbook EN Generate speech based on the following description: "...". The content to speak is: "...". leaked description words in 8 of 8 outputs (4 plus 4 with shorter gen_seconds); CLI Based on the following description: "...", generate speech content "...". gave 7 of 8 exact, the 18.5 s seed-8 output repeated a phrase and dropped "every spring it melts". The cookbook says to pass gen_seconds for tasks that need an explicit output length (TTS, content editing, speed) and that lyric editing input must be a cappella.

Platform issues. (1) /v1/audio/speech with a custom backend returns HTTP 500 "worker returned no payload for passthrough route": the worker only surfaces custom-backend JSON as binary for transcription, embeddings, rerank, forecast and image kinds (needs_json_binary_surfacing in crates/worker/src/jobs.rs), and the manager passthrough requires binary_b64. Workaround: PATCH /api/workloads/<id>/endpoint_settings/chat {"enabled":true} and /v1/chat/completions, whose message content is the backend JSON as a string. (2) tqdm race between two parallel snapshot_download calls (AttributeError: type object 'tqdm' has no attribute '_lock'), fixed with HF_HUB_DISABLE_PROGRESS_BARS=1 in 0.1.1. (3) No module named 'audioread' on the first audio request (client saw HTTP 503 backend_unavailable), fixed in 0.1.2. (4) Fixed workloads start at concurrency 1. (5) Panel cosmetics: Access "No access" with a working wildcard key, "GPU telemetry partial".

Known upstream limits. Issue #13 (open): encoder licence. Issue #17 (open): zero-shot Polish median WER about 80% against 23% for English; the same reporter later fine-tuned AuK-Base on 103.65 h of Polish MLS and reached 3.3% mean CER. Issue #23 (open): one user reports AuK and AuK-Flash do not reproduce shouting from a reference. ComfyUI integration has a 30 s source-plus-target budget.

Limits. About 60 requests of our own, one seed each mostly, synthetic input voices, no speaker-similarity metric, no listening test, denoise checked for content preservation only. Not tested: lyric editing, volume, timbre, de-accent, nonverbal edits, music separation, target speaker extraction, word removal, AuK base, the offload variant on a real 16 GB card, the Prompt Enhancer. Benchmark numbers are the authors' (SpeechEditBench content accuracy: AuK-Flash 87.50 against Ming-UniAudio 76.46; Seed-TTS-Eval average WER 2.85 against Qwen3-TTS 3.07), not reproduced by us.

Sources: AuK-Flash, AuK, GitHub, cookbook, technical report, project page, Qwen2.5-Omni-3B licence, SDK example, demo video, AI Search video.