Picture this: a voice assistant that transcribes your speech, searches your notes, generates an answer, and reads it back out loud — all without a single network call. No OpenAI key. No Google Cloud bill. No latency spike because your wifi decided to hiccup. That's not a hypothetical. It's what you get from one npm package.
Normally, stitching together four different AI capabilities means wrangling four different runtimes, four different APIs, and four different sets of dependencies that inevitably fight each other over CUDA versions or Python bindings. Speech-to-text has its own quirks. Embeddings have their own. LLM inference frameworks are their own beast entirely. And text-to-speech models rarely play nice with anything.
QVAC, an open source local AI platform from Tether, collapses all of that into a single SDK install. This guide walks through what it is, why it matters, and exactly how to get a local voice pipeline running on your own machine.
What is QVAC, exactly?
QVAC is Tether's local-first AI platform, built as an alternative to renting intelligence from centralized cloud APIs. The official site describes it directly: QVAC is Tether's answer to centralized AI, an entirely new paradigm where intelligence runs privately, locally, and without permission on any device, and the era of Stable Intelligence has begun.
Under the hood, it's a JavaScript/TypeScript SDK that wraps a surprising number of AI capabilities behind one unified interface. The official QVAC documentation lists the core building blocks: LLM inference for text generation and chat via Fabric LLM, vector embedding generation for semantic search and retrieval, out-of-the-box retrieval-augmented generation workflow, adapting LLMs to domain-specific tasks via LoRA, LLM inference over text and images within a single conversation context, and text-to-image generation via a customized Diffusion backend. It also handles text-to-video and image-to-video generation, plus automatic speech recognition via a customized Whisper backend or NVIDIA Parakeet.
The project launched publicly in April 2026. According to reporting at the time, Tether's AI research division QVAC launched the QVAC SDK on April 9, a fully open-source, cross-platform software development kit that allows developers to build, run, and fine-tune AI models directly on consumer devices without cloud dependency. It's part of a broader buildout — a sustained infrastructure effort that began in mid-2025, including QVAC Workbench, the Genesis I and Genesis II synthetic datasets totaling 148 billion tokens, and a mobile-optimized QVAC Fabric framework that reportedly reduces memory requirements by approximately 78% using Microsoft's 1-bit BitNet and LoRA optimizations.
The bigger strategic play is fairly transparent too: Tether is positioning QVAC as an open alternative to the centralized AI infrastructure dominated by OpenAI, Google, and Anthropic, where models are trained on massive datasets and served through proprietary APIs.
Why does a single npm install matter so much?
If you've ever tried to build a multimodal local AI app the "normal" way, you already know the pain. Whisper.cpp needs its own build toolchain. A local LLM runtime like llama.cpp needs its own bindings. Embedding models often want yet another inference engine. And text-to-speech models are notoriously fragmented across projects with wildly different APIs and dependency trees.
QVAC's pitch is that you shouldn't have to deal with any of that. The SDK's own description puts it plainly: install the npm package @qvac/sdk in your project, then load models and use them to perform AI inference locally, or delegate inference to peers using the built-in P2P capability. That's the entire onboarding story — one package, then you start loading models.
The design goals reinforce this. Per the docs, the SDK is cross-platform, type-safe, and pluggable, exposing all QVAC capabilities through a unified interface — portable code across Linux, macOS, and Windows via Node.js or Bare runtime, and Android and iOS via Expo, letting you build lean apps by including only what you need, with a typed JS API and one single npm package to install in your project.
That "pluggable" part matters more than it sounds. You're not forced to bundle every capability into your app if you only need speech-to-text and an LLM. The QVAC CLI even ships a bundler for this: the qvac bundle sdk command allows you to select only the plugins you need in your project and reduce your application's final bundle size.
How do you actually install and set it up?
Getting a bare-bones test running takes about three commands. Start with the official getting started guide, which is the best primary resource for setup specifics across environments.
For a standard Node.js project:
mkdir qvac-test && cd qvac-test
npm init -y
npm install @qvac/sdk
The installation docs spell out the version requirements you'll want to check first: Node.js ≥ v22.17, Bare ≥ v1.24, Expo ≥ v54. On Linux, there's an extra hardware dependency worth knowing about upfront — Ubuntu 22 requires g++ ≥ 13, and you'll need a Vulkan runtime with a loader plus a GPU driver with Vulkan support, though on most desktop Linux distributions these requirements are typically satisfied out of the box.
Mobile setup requires a few more steps since Expo apps need native modules registered. The docs outline it as: npm i react-native-bare-kit, npm i -D bare-pack, npx expo install expo-file-system expo-build-properties expo-device, then configure expo-build-properties and add @qvac/sdk/expo-plugin to the plugins array in your app.json, followed by prebuilding your project to generate the native files. One caveat if you're testing on mobile: due to limitations with llamacpp, QVAC currently does not run on emulators — you must use a physical device.
Once installed, loading a model doesn't require you to manage file paths or hunt down GGUF files manually. The SDK exposes constants for popular pre-configured models. As the introduction docs explain, the SDK package does not ship with built-in models, but its API exposes constants representing preconfigured models, and each constant maps to a model already published to the QVAC model registry — when calling loadModel(), you can provide one of these constants instead of a location, making model retrieval transparent.
What can you build with it besides a voice pipeline?
A four-model voice assistant — Whisper for transcription, an embedding model for retrieval, Qwen for generation, and a TTS model to speak the answer back — is a great demo, but it barely scratches the surface of what's packed into the SDK. The full capability list on the installation page reads like a checklist most teams would normally need a dozen separate vendors for: Text generation, Text embeddings, RAG, Fine-tuning, Multimodal, Image generation, Transcription, Text-to-Speech, Voice assistant, Translation, OCR.
That RAG capability is worth calling out specifically, since it's not just "bring your own vector database" — it's a built-in workflow. The docs describe it as an out-of-the-box retrieval-augmented generation workflow. That means the embedding step, the similarity search, and the generation step are designed to work together without you gluing together three separate libraries.
For developers who don't want to touch the JS SDK directly, there's also an HTTP server mode. The CLI docs note that QVAC CLI provides an HTTP server that is compatible with the OpenAI REST API, enabling broad integration with the AI ecosystem, internally translating HTTP requests into SDK calls — as a result, any system compatible with the OpenAI REST API can point to a local URL and work without changes. That's a genuinely useful escape hatch if you already have tooling built around the OpenAI API shape and just want to swap the backend to something local.
And if peer-to-peer distributed compute sounds interesting, that's baked in too — not bolted on as an afterthought. The SDK lets you run AI tasks like LLMs, speech, RAG, and more locally across Linux, macOS, Windows, Android, and iOS — or delegate inference to peers using its built-in P2P capabilities.
How do you decide if local AI is right for your project?
Local AI isn't a universal upgrade over cloud APIs — it's a trade-off. You give up the raw horsepower of a massive hosted model in exchange for privacy, zero marginal cost per request, and resilience when the network goes down. For some projects that trade is an easy yes. For others, it isn't.
Consider local-first if:
- Privacy is non-negotiable. Health data, journal entries, legal documents, anything a user would be uncomfortable sending to a third-party server.
- You need offline reliability. Field apps, embedded devices, or anything running somewhere with spotty connectivity.
- You're doing high-volume inference. No per-token billing means a chatbot that runs a thousand times a day doesn't cost more than one that runs ten times.
- You want to avoid vendor lock-in. Swapping which model powers your app becomes a config change, not a rewrite.
Stick with cloud APIs if you need frontier-model reasoning quality on genuinely hard tasks, or if your users' hardware is too underpowered to run even quantized models at acceptable speed.
What should your first project be?
Don't start by trying to rebuild ChatGPT locally. Start small and specific. A good first project mirrors the voice pipeline idea: point the SDK at a folder of your own notes, load an embedding model to index them, load an LLM to answer questions about them, and wire in Whisper so you can ask questions out loud instead of typing. That's four capabilities, one import, and a genuinely useful tool by the end of an afternoon.
From there, the QVAC examples repository is worth digging into — it's full of sample apps and code patterns for wiring these pieces together correctly rather than guessing at the API shape. And if you hit a wall on the P2P delegation features or model registry search, the full API reference documents every method mentioned above in more depth than any tutorial can cover.
The local AI space has been maturing fast, but the tooling story has always lagged behind the model story — plenty of great open weights, not enough easy ways to actually ship them together. A single install that hands you speech, retrieval, generation, and voice in one API is the kind of thing that turns "I could build that" into "I built that this weekend." Worth finding out what you'd build if the infrastructure stopped being the hard part.