The Complete Guide to QVAC's 15 AI Capabilities

Most coverage of QVAC describes it as "Tether's local LLM thing." That's like describing a Swiss Army knife as a blade.

QVAC exposes fifteen distinct AI capabilities through one unified JS/TS interface, all running on-device, all cross-platform. Several of them — brain–computer interfaces, robot control, local video generation — have essentially zero coverage anywhere.

This is the complete reference. For each capability: what it does, which backend powers it, and when you'd reach for it.

All of these run locally. No cloud, no API keys, no per-request cost, and they work offline once the model is downloaded.

---

Language and text

1. Text generation

Backend: qvac-fabric-llm.cpp (a fork of llama.cpp)

LLM inference for text generation and chat — the foundation. Load a model, pass a conversation history, stream tokens back. This is what powers writing assistance, summarization, Q&A, and chat in any QVAC app.

Use it for: chat interfaces, writing tools, summarization, classification-by-prompting, anything text-in-text-out.

2. Text embeddings

Backend: qvac-fabric-llm.cpp

Turns text into vectors that capture meaning, so you can measure semantic similarity. The foundation of search that understands intent rather than matching keywords.

Use it for: semantic search over user data, clustering, deduplication, retrieval (see RAG below).

3. RAG (retrieval-augmented generation)

Backend: the rag package — document ingestion, vector search, LLM integration

An out-of-the-box workflow for answering questions from a document set. QVAC bundles ingestion, vector search, and generation rather than making you assemble them. This is how "chat with your own notes" works without any of the notes leaving the device.

Use it for: Q&A over personal documents, knowledge bases, note-taking apps, any "ask my data" feature.

4. Translation

Backends: qvac-fabric-llm.cpp or Bergamot

Neural machine translation, on-device. QVAC gives you two paths — a general LLM, or Bergamot, the efficient NMT engine built for in-browser translation.

Use it for: offline travel translation, multilingual apps, avoiding per-request translation API bills.

5. Fine-tuning (LoRA)

Backend: qvac-fabric-llm.cpp

Adapting a model to a domain-specific task using LoRA, on-device. This is unusual and underappreciated: training, not just inference, on consumer hardware.

Use it for: personalizing a model to a user's own data without that data ever leaving their device.

---

Vision and images

6. Multimodal

Backend: qvac-fabric-llm.cpp

LLM inference over text, images, and other media within a single conversation context. Show the model a picture and ask about it.

Use it for: visual Q&A, describing images, document understanding, anything mixing text and pictures.

7. OCR (optical character recognition)

Backend: ONNX Runtime (ocr-onnx)

Extract text from images. Fully local, which matters enormously — OCR inputs tend to be photographed receipts, documents, forms, and IDs.

Use it for: receipt scanning, document digitization, reading text out of screenshots.

8. Image classification

Backend: customized GGML (classification-ggml)

Assign class labels with confidence scores to images.

Use it for: auto-tagging photos, content filtering, sorting images by category, triage pipelines.

9. Image generation

Backend: qvac-ext-stable-diffusion.cpp (Diffusion)

Text-to-image and image-to-image generation, running locally. No credits, no queue, no upload of your reference images.

Use it for: creative tools, asset generation, private image editing, offline creation.

10. Video generation

Backend: customized Diffusion engine

Text-to-video and image-to-video generation, on-device. Local video generation is genuinely rare — most of the ecosystem assumes a cloud GPU.

Use it for: short-form generation, animation from stills, experimentation without cloud GPU bills.

---

Speech and audio

11. Transcription (speech-to-text)

Backends: customized Whisper (qvac-ext-lib-whisper.cpp) or NVIDIA Parakeet

Automatic speech recognition. Two engines: Whisper for broad multilingual accuracy, Parakeet for high-performance inference. Your voice is never uploaded.

Use it for: dictation, voice notes, meeting transcription, voice-logged data entry, accessibility.

12. Text-to-speech

Backend: ONNX Runtime with Chatterbox / Supertonic neural TTS models (lib-infer-onnx-tts)

Speech synthesis, locally.

Use it for: reading content aloud, accessibility, voice interfaces, audio output for agents.

13. Voice assistant

Backend: a pipeline chaining transcription → text generation → TTS

Not a separate model, but a real-time loop that composes three capabilities into a full voice conversation. Speak, the model reasons, it speaks back — end to end on-device.

Use it for: private voice assistants, hands-free interfaces, offline conversational agents.

---

Embodied and frontier

14. BCI (brain–computer interface)

Backend: customized Whisper (bci-whispercpp)

Decodes multi-channel neural signals into text. Yes, really. Treating neural decoding as a transcription problem — the same shape as speech — is an elegant architectural choice.

Use it for: assistive communication research, neural interface applications. And note: neural data is the most sensitive data that exists, which makes on-device processing not a nice-to-have but a precondition. → Full deep-dive

15. VLA (vision-language-action)

Backend: customized GGML (vla-ggml)

Turns camera frames, robot state, and a natural-language instruction into action chunks for robot control. Robots can't wait for a cloud round trip inside a control loop — this has to be local. → Full deep-dive

Use it for: robotics, embodied agents, real-time physical control.

---

Beyond the fifteen: P2P and utilities

The capabilities above run on top of infrastructure worth knowing:

• Delegated inference — offload heavy inference to a peer device over encrypted P2P, no cloud involved.
• Blind relays — connect peers across NATs and firewalls.
• Distributed model registry — fetch models from peers; contribute your own.
• Sharded models & download lifecycle — pause and resume large model downloads.
• Plugin system — include only the capabilities you need, or add your own.
• Profiler, logging, cancellation, runtime lifecycle — the production-grade plumbing that on-device AI actually requires.
• OpenAI-compatible HTTP server — point existing OpenAI code at local inference.

---

What the list tells you

Two things stand out when you see all fifteen together.

First, the breadth is the point. Real applications need several modalities at once. A finance app needs OCR and transcription and embeddings and generation. A robot needs vision and language and action and speech. Assembling that from separate libraries — each with its own lifecycle, memory model, and platform quirks — is most of the work. QVAC's bet is that a unified interface across all of them is worth more than being best-in-class at any single one.

Second, the range of ambition. An SDK that covers both "summarize this note" and "decode neural signals" and "control this robot arm" is not positioning itself as a chatbot library. It's positioning itself as an inference layer for anything that computes, anywhere. Tether's framing — "from the most powerful industrial server to the smallest chip in a light bulb" — is grandiose, but the capability list is consistent with it.

A note on accuracy

QVAC is pre-1.0 and ships frequently (195 releases as of this writing). Capabilities, backends, and API signatures change. Everything above is drawn from the current official documentation, but verify against docs.qvac.tether.io before building. Some capabilities are more mature than others; the language and speech paths are the most trodden, while BCI, VLA, and video generation are frontier.

---

We're building Local Notes and Local Money on QVAC — both coming soon. For the technical foundations, see QVAC SDK Explained and How QVAC Works Under the Hood.