# TEN VAD for Real-Time Voice Agent Pipelines

> TEN VAD is a C-based voice activity detector with Python bindings, ONNX assets, native libraries, and examples for desktop and mobile platforms. It suits developers who need frame-level speech segmentation before ASR, but integration details and custom licensing require review.

**TEN-framework/ten-vad** — Voice Activity Detector (VAD) : low-latency, high-performance and lightweight

- Repository: https://github.com/TEN-framework/ten-vad
- Website: https://huggingface.co/TEN-framework/ten-vad
- Stars: 2,292 · Forks: 181
- Language: C
- License: NOASSERTION
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/ten-framework-ten-vad

## TEN VAD's Role Before Speech Recognition

TEN VAD addresses a narrow but consequential stage in a real-time voice pipeline: deciding which portions of an audio stream contain speech. It is intended for conversational AI agents, automatic speech recognition systems, voice commands, and other applications that should process speech segments rather than every incoming sample. The README describes frame-level speech activity detection and positions the project as part of the TEN ecosystem for conversational voice agents.

This is not a transcription engine. TEN VAD does not turn audio into words, identify speakers, or manage a dialogue by itself. Its role is upstream of ASR, where speech detection can reduce unnecessary processing, identify segment boundaries, and provide timing information to the next component. The repository also includes a turn-detection project as a separate TEN component, which helps distinguish this project's scope from a complete conversational agent stack.

The documented comparison is framed around WebRTC VAD and another detector, but the repository description does not provide reproducible benchmark data. The useful adoption question is not whether TEN VAD wins a general ranking. It is whether its frame decisions meet the boundary tolerance of a particular voice application. That matters because an ASR system can still lose accuracy when a segment starts late, ends early, or splits one utterance into several pieces.

## TEN VAD's C Core, Bindings, and ONNX Path

The primary language is C, and the repository layout reflects a native library with interfaces and examples around it. The `include/` directory contains the public-facing interface, while `lib/` holds platform libraries or related assets. The root `setup.py` packages the Python interface as `ten_vad` and copies supported desktop libraries into the Python package. This indicates a packaged native library behind a Python-facing wrapper, rather than a Python-only neural network implementation.

The project also provides an ONNX direction. According to the release history, `v1.0-ONNX` added open-source ONNX assets and a Python demo using prebuilt libraries. The README's news entries state that the ONNX model and corresponding preprocessing code were released in June 2025, followed by Python inference support on Linux and macOS in November. That path is relevant when a team wants model execution through ONNX or needs broader deployment choices than the native library alone provides.

The repository also contains WebAssembly and JavaScript-related material under `examples/` and `lib/Web`. The documented platform matrix has expanded beyond C into Python, Java, Go, JavaScript, WASM, Android, and iOS. That breadth is useful, but it should not be confused with identical support guarantees on every platform. The README does not define the internal algorithm, tensor shapes, memory model, or exact wrapper call sequence in enough detail to assess resource use without reading the headers and examples.

## Supported Audio Shapes and Boundary Constraints

The README includes a section titled “Supported Sampling Rate and Hop Size,” which confirms that sample rate and hop size are first-class configuration concerns. The README does not include the actual accepted values, so this article does not infer a numeric audio contract. That omission is significant. A VAD cannot be integrated responsibly without matching the input format expected by the library and by the application feeding it.

The frame-level design also makes timing semantics part of the interface. A caller must know how detection results relate to incoming audio windows, how speech start and end are represented, and whether the output can be consumed as a continuous stateful stream. Those details are implementation-sensitive. The repository's `examples/main.c`, Python examples, browser test, and integration-oriented directories can help confirm them.

The README does not document behavior for truncated buffers, silence padding, overlapping audio, microphone discontinuities, or loss of stream state. It also does not explain whether the detector is intended to reject all background noise or only classify broader voice activity. For a voice agent, those are product requirements, not footnotes. An application that expects precise turn-taking may need stricter end-of-speech behavior than a command recognizer that simply wants to avoid sending silence to ASR.

## Installation and First-Use Boundaries

The Python packaging files show that the repository can be prepared as a `ten_vad` package. `setup.py` identifies the package as `ten_vad`, version `1.0.6.9`, declares `numpy` as its runtime dependency, and packages native libraries for Linux x64, Windows x64, Windows x86, and macOS. The top-level `requirements.txt` likewise contains `numpy`.

The README excerpt does not include the exact installation command or a complete first-use API call. It would therefore be misleading to invent a shell command, import statement, model download step, or initialization sequence. The first documented starting points are the repository's `examples/` directory, the `examples/main.c` native example, `examples/test.py`, the Java, Go, and JavaScript examples, and the browser test in `examples/test_browser.html`. The README identifies those examples as the supported entry points for the corresponding languages.

For a first integration review, read the C header and the matching example for the target platform, confirm the native library is present for that platform, then trace the audio sample rate, frame size, and output interpretation before connecting the result to ASR. The README also points to the Hugging Face TEN VAD page for model-related material. Because the README does not show a complete runtime command, there is no honest command example to present.

## TEN VAD Compared With WebRTC VAD and sherpa-onnx

WebRTC VAD is one of the detectors used in the repository's documented comparison. TEN VAD instead presents a learned-model path, including ONNX assets and preprocessing code, while retaining a C core and multiple language bindings. The practical difference is therefore not merely the project name. It is the combination of frame-level learned inference, model portability, and deployment surfaces. The README claims improved precision in its comparison, but it does not establish the datasets, operating points, audio conditions, or latency measurements behind that claim.

The documented integration with `k2-fsa/sherpa-onnx` is a more concrete alternative path for teams already using that ecosystem. The README states that TEN VAD was integrated to support more precise speech segment extraction and an enhanced ASR experience, with separate sherpa-onnx documentation. A team using sherpa-onnx can therefore evaluate TEN VAD inside an existing ASR pipeline rather than replacing the whole recognizer. Teams without that dependency should compare the detector's expected output and deployment requirements with WebRTC VAD, but should not choose based on a generic quality label.

## Platform Support, Licensing, and Ongoing Changes

The release history records `v1.0` on 2025-07-11 for prebuilt libraries across Linux, Windows, macOS, WebAssembly, Android, and iOS. It records `v1.0-ONNX` on the same date, and the README news section later lists Python, WebAssembly, Go, and Java support additions. The repository is not archived, and the last push was on 2026-10-09. These facts indicate recent repository activity, but they do not establish API stability or a formal compatibility policy.

The Python package version in `setup.py` is `1.0.6.9`, while the release labels listed in the repository description are `v1.0` and `v1.0-ONNX`. That distinction should be checked when selecting a download, because the package build version and GitHub release naming are not identical. The upgrade cost is also affected by native libraries and ONNX assets. Teams must match the library, wrapper, preprocessing code, and target architecture instead of assuming that replacing one file is sufficient.

The root `LICENSE` uses a custom licensing arrangement. `setup.py` describes the code as licensed under Apache License 2.0 with certain conditions, but the repository metadata classifies the license as Other and directs readers to the root file. The exact conditions therefore require direct review, especially for redistribution, model use, commercial deployment, or platform packaging. This article does not interpret those terms. License review is a concrete adoption gate because the code, prebuilt libraries, model files, and ONNX assets may have separate notices.

## Conclusion

Adopt TEN VAD when a conversational AI or ASR application needs a lightweight C core, streaming speech boundaries, and a path to native or ONNX deployment. Do not choose it as an unchanged replacement for a full conversational framework, and do not approve it without checking the custom LICENSE. Before integration begins, verify the Python and native examples against the intended release, confirm the supported sample rate and hop size, and test speech boundaries on representative audio. If that boundary quality and the license terms do not fit the product, use an established VAD path already supported by the surrounding stack instead.

## FAQ

### How do I install TEN VAD for Python?

The repository includes Python packaging through `setup.py`, a `ten_vad` package name, and a `numpy` dependency. The README does not include the exact installation command, so the package's own installation instructions and release documentation should be checked before installation.

### Which platforms does TEN VAD support?

The README and release information list Linux, Windows, macOS, WebAssembly, Android, and iOS. The repository also documents Python, Java, Go, and JavaScript usage or support, although the level of detail varies by integration.

### Does TEN VAD perform speech recognition?

No. TEN VAD is a voice activity detector that identifies speech activity at frame level. It is intended to feed or gate a speech-recognition or conversational AI pipeline rather than transcribe speech itself.

### Can TEN VAD be used with ONNX?

Yes, according to the release information. The `v1.0-ONNX` release added the ONNX model and preprocessing code, and the README describes Python inference using ONNX on supported platforms.

### What license should I review before using TEN VAD?

Review the repository's root `LICENSE` file. The project metadata calls it a custom license, while `setup.py` refers to Apache License 2.0 with certain conditions, so the exact terms should be checked for the intended use and distribution model.

## Sources

- [Issues](https://github.com/TEN-framework/ten-vad/issues)
- [Project website](https://huggingface.co/TEN-framework/ten-vad)
- [README](https://github.com/TEN-framework/ten-vad/blob/main/README.md)
- [Releases](https://github.com/TEN-framework/ten-vad/releases)
- [TEN-framework/ten-vad on GitHub](https://github.com/TEN-framework/ten-vad)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ten-framework-ten-vad