Models

ai-coustics provides enhancement, voice activity detection and audio analysis models. Choose the task first, then compare the available variants with your audio and target hardware.

Choose by task

Task	Model family	What to evaluate
Preserve multiple speakers for speech-to-text	Quail	Word error rate, speech retention and resource use.
Isolate one primary speaker for a voice agent	Quail Voice Focus	Target-word deletions, background-word insertions and speaker changes.
Improve audio for human listeners	Rook	Naturalness, intelligibility, artifacts and latency.
Detect speech activity without modifying audio	ai-coustics VAD	False starts, missed speech and prediction delay.
Assess audio quality	Tyto	Risk scores and quality dimensions against observed call outcomes.

This catalog covers model file format 7 for Python SDK 3.2.0 and core SDK 0.24.0. A download ID selects a compatible artifact; the loaded model’s ID can also include its build identifier. Record both when reproducing an evaluation. Sizes are approximate decimal MB of model files, not runtime memory. Native rate and optimal block size describe model geometry, not end-to-end latency. For removed models, see deprecated models.

These models process audio rather than a language-specific transcription vocabulary. That does not establish equal quality for every language or acoustic condition. Evaluate the languages and microphones your application supports. Streaming enhancement and VAD support non-native sample rates through the SDK; analysis has separate requirements described below.

Quail Multi Speaker

Quail Multi Speaker targets machine listening while retaining speech from multiple participants. Use it when every speaker matters, then compare transcription results and speech retention. It is not a primary-speaker selector.

Model ID	Artifact size	Native sample rate	Optimal native block
`quail-ms-l-16khz`	36.74 MB	16 kHz	160 samples (10 ms)
`quail-ms-l-8khz`	35.02 MB	8 kHz	80 samples (10 ms)
`quail-ms-s-16khz`	9.32 MB	16 kHz	160 samples (10 ms)
`quail-ms-s-8khz`	8.84 MB	8 kHz	80 samples (10 ms)

Quail Voice Focus

Quail Voice Focus targets one primary speaker for machine listening. Evaluate competing speech, quiet target speech, startup context and changes in speaker prominence.

Model ID	Artifact size	Native sample rate	Optimal native block
`quail-vf-2.2-l-16khz`	20.93 MB	16 kHz	240 samples (15 ms)
`quail-vf-2.2-s-16khz`	5.29 MB	16 kHz	240 samples (15 ms)

VAD Multi Speaker

VAD Multi Speaker detects speech activity from the original audio without producing enhanced audio. Use it when activity from any speaker should count.

Model ID	Artifact size	Native sample rate	Optimal native block
`vad-ms-2.1-xxs-16khz`	0.65 MB	16 kHz	240 samples (15 ms)

Earlier model IDs include quail-vad-2.0-xxs-16khz and vad-2.1-xxs-16khz. See renamed models before changing an existing deployment.

VAD Voice Focus

VAD Voice Focus targets primary-speaker activity. It is a dedicated VAD model, distinct from the Quail Voice Focus enhancement models.

Model ID	Artifact size	Native sample rate	Optimal native block
`vad-vf-2.0-s-16khz`	1.51 MB	16 kHz	240 samples (15 ms)

This model was also published as quail-vf-vad-2.0-s-16khz. Historical IDs remain distinct from display names. See renamed models.

Tyto

Tyto provides audio-quality analysis. It returns scores rather than enhanced audio or speech-boundary events. Use its 16 kHz analysis path and follow the real-time or batch guide for analysis windows and result interpretation.

Model ID	Artifact size	Native sample rate	Analysis window
`tyto-1.1-l-16khz`	13.33 MB	16 kHz	5 s

Rook Multi Speaker

Rook Multi Speaker targets naturalness and intelligibility for human listeners while retaining multiple speakers. Compare variants using listening tests as well as resource and latency measurements.

Model ID	Artifact size	Native sample rate	Optimal native block
`rook-ms-l-48khz`	36.82 MB	48 kHz	480 samples (10 ms)
`rook-ms-l-16khz`	36.74 MB	16 kHz	160 samples (10 ms)
`rook-ms-l-8khz`	35.02 MB	8 kHz	80 samples (10 ms)
`rook-ms-s-48khz`	9.40 MB	48 kHz	480 samples (10 ms)
`rook-ms-s-16khz`	9.32 MB	16 kHz	160 samples (10 ms)
`rook-ms-s-8khz`	8.84 MB	8 kHz	80 samples (10 ms)

Download a model

Browse the public model catalog or use your binding’s downloader. It chooses a model-file version compatible with that SDK. Use the returned path; downloaded filenames can include a build identifier.

from aic_sdk import Model

path = Model.download("quail-vf-2.2-l-16khz", "models")
model = Model.from_file(path)
print(model.get_id())

import { Model } from "@ai-coustics/aic-sdk";

const path = await Model.download("quail-vf-2.2-l-16khz", "models");
const model = Model.fromFile(path);
console.log(model.getId());

Before handling audio, provision models and record the SDK version, requested and resolved model IDs and artifact checksum. Keep loaded files unchanged. SDK authentication is still required.

Loading and reusing models

A loaded model is its own object, separate from the processor, VAD or analyzer that runs it. Each model type belongs to exactly one kind of object, and a mismatch fails when you create that object rather than when you process audio:

Model type	Used by	Error on mismatch
Enhancement and bypass	`Processor`	`ModelTypeUnsupportedError` / `AIC_ERROR_CODE_MODEL_TYPE_UNSUPPORTED`
VAD	`Vad`	`ModelTypeUnsupportedError` / `AIC_ERROR_CODE_MODEL_TYPE_UNSUPPORTED`
Analysis	`Analyzer` and `FileAnalyzer`	`ModelTypeUnsupportedError` / `AIC_ERROR_CODE_MODEL_TYPE_UNSUPPORTED`

One model, many streams

Share one loaded model across independent processors, VADs or analyzers. Each processing object holds one stream’s state while sharing the model weights:

# With import aic_sdk as aic, a provisioned model_path and your SDK key:
model = aic.Model.from_file(model_path)
config = aic.ProcessorConfig.optimal(model)

# One processor per stream, one copy of the model data.
processors = [aic.Processor(model, license_key, config) for _ in range(8)]

Loading the same model file once per stream multiplies memory usage for no benefit. Load it once and create one processing object per stream.

Model data is memory-mapped from the file rather than copied into your process, so do not modify or delete a model file while it is loaded. Objects created from a model keep the underlying data alive through reference counting, so the model handle can be released first. In C this means aic_model_destroy and the matching *_destroy calls may run in any order.

Loading from memory

Use buffer loading to embed a model or fetch it through your own transport:

Binding	API	Notes
C	`aic_model_create_from_buffer`	The buffer must be 64-byte aligned, must stay valid and unmodified for the model’s lifetime, and is not freed by the SDK.
Rust	`Model::from_buffer`	Same 64-byte alignment requirement. Use the `include_model!` macro to embed a model file with correct alignment at compile time.
WASM	`Model.fromBytes`	Takes a `Uint8Array` and copies it into an aligned allocation for you, so there is nothing to align yourself.

An unaligned buffer is rejected with AIC_ERROR_CODE_MODEL_DATA_UNALIGNED (ModelDataUnalignedError in the bindings that expose it). The Python and Node.js bindings load models from files only.

Using models with non-native sample rates

For Core SDK 0.24.0, streaming enhancement and dedicated VAD accept sample rates from 8 kHz to 192 kHz. The SDK resamples internally to the model’s native rate. Query Model.get_optimal_block_size(sample_rate) in Python or model.getOptimalBlockSize(sampleRate) in Node for the rate your application uses. The optimal block avoids additional adapter buffering; it is not the only accepted block size. Higher-rate input: a 16 kHz model processes frequency content up to its native Nyquist limit of 8 kHz, even if input arrives at 48 kHz. Resampling the result back to 48 kHz does not create model enhancement above that range. Blending with the original signal can retain original high-frequency content; the result depends on the model and enhancement setting. Lower-rate input: resampling 8 kHz input to a 16 kHz model does not recover missing high-frequency information. Compare a native 8 kHz variant when one is available, using the same recordings and downstream task. Resampling, block adaptation, model size and concurrency all affect resource use. Measure them on your hardware instead of assuming input sample rate has negligible CPU cost. See performance and latency. Tyto analysis has its own sample-rate and window requirements. Do not apply the streaming Processor rate range to Analyzer or FileAnalyzer; follow the Tyto guides.

Compatibility

Model family, file format, SDK version and framework adapter all matter. A model that loads successfully can still be the wrong type for the component you construct. The compatibility matrix records the selected releases. The official LiveKit plugin exposes its own enhancement model choices and is the canonical path for LiveKit enhancement. Dedicated VAD and Tyto examples use the ai-coustics-maintained plugin where those capabilities are needed. Review plugin scope before installing packages; Python namespaces currently conflict. Pipecat 1.11.0’s aic extra uses Python SDK 3.1.x, while the custom LiveKit 0.2.0 example uses SDK 3.2.0. Follow each framework’s pinned LiveKit or Pipecat recipe rather than applying one dependency set to both.

Choose a model

Speech enhancement

Audio insight

Voice activity detection

Human listening

Older models

Choose by task

Quail Multi Speaker

Quail Voice Focus

VAD Multi Speaker

VAD Voice Focus

Tyto

Rook Multi Speaker

Download a model

Loading and reusing models

One model, many streams

Loading from memory

Using models with non-native sample rates

Compatibility

​Choose by task

​Quail Multi Speaker

​Quail Voice Focus

​VAD Multi Speaker

​VAD Voice Focus

​Tyto

​Rook Multi Speaker

​Download a model

​Loading and reusing models

​One model, many streams

​Loading from memory

​Using models with non-native sample rates

​Compatibility

Choose by task

Quail Multi Speaker

Quail Voice Focus

VAD Multi Speaker

VAD Voice Focus

Tyto

Rook Multi Speaker

Download a model

Loading and reusing models

One model, many streams

Loading from memory

Using models with non-native sample rates

Compatibility