On the morning of June 3, 2026, a tweet from Miso Labs co-founder Aoden Teo — reposted by tech evangelist Robert Scoble — slid into a lot of timelines with a bold claim: “the most emotive voice model in the world.” By 9:06 AM the post had already crossed 312,000 views. The product is called Miso One, and the pitch is deceptively simple. It’s an 8-billion-parameter text-to-speech (TTS) model that, in Teo’s words, “emotes like a human and responds faster than a human, with just 110 milliseconds of latency.“
Miso Labs made the model weights publicly available at launch, with API access promised to follow. The current Hugging Face page labels the license as “other,” so public access to the weights should not be read as an unrestricted commercial-use license. Check the model and dependency terms before deploying.
What Miso One actually is
Stripped of the marketing language, Miso One (the model repository is named MisoTTS) is an 8-billion-parameter text-to-dialogue RVQ Transformer. If you’ve been following the open speech-synthesis scene, the lineage will feel familiar: Miso Labs describes the model as “inspired by the Sesame CSM architecture” — the same conversational-speech-model family that made waves for sounding eerily natural in back-and-forth dialogue.
According to the official GitHub README, the model “generates Mimi audio codes from text and optional audio context, using a large Llama 3.2-style backbone and a smaller autoregressive audio decoder.” In plainer terms: it borrows the transformer brain of a Llama-style language model and repurposes it to predict audio tokens instead of words.
The design splits into two transformer components, and understanding that split is key to understanding why the model is both expressive and reasonably fast:
- A large backbone transformer that consumes interleaved text and audio-frame embeddings. Because it accepts both modalities, it can condition its output on the conversation history — meaning it “remembers” how the dialogue has been flowing and adjusts tone accordingly.
- A smaller decoder transformer that autoregressively predicts the higher-order audio codebooks within each frame.
The Hugging Face model card spells out the division of labor precisely: “Codebook 0 is predicted from the backbone hidden state, while codebooks 1 through 31 are predicted by the audio decoder autoregressively in codebook depth.” So the heavyweight backbone sets the coarse acoustic direction, and the lightweight 300M decoder fills in the fine-grained detail. This two-stage approach is the same trick Sesame’s CSM popularized, and it’s a big part of why the model can stay responsive without sacrificing nuance.
The model is designed for conversational speech generation and voice continuation from prompt audio. The current README specifies English only. Prompted generation is documented; a complete phone-call agent and its behavior are not demonstrated by the model card alone.
The specs, in a table
Miso Labs publishes a clean model summary in both the GitHub repo and on Hugging Face. Here’s the consolidated spec sheet:
| Item | Value |
|---|---|
| Model | Miso TTS 8B |
| Organization | Miso Labs |
| Task | Text-to-speech |
| Architecture | RVQ Transformer (Sesame-style CSM) |
| Backbone | llama-8B |
| Audio decoder | llama-300M |
| Text vocabulary | 128,256 |
| Audio vocabulary | 2,051 |
| Audio codebooks | 32 |
| Audio tokenizer | Mimi |
| Max sequence length | 2,048 |
A few things stand out. The text vocabulary of 128,256 is the standard Llama 3 tokenizer size — another confirmation of the Llama 3.2-style heritage. The 32 audio codebooks with a tiny 2,051-token audio vocabulary is characteristic of the Mimi neural audio codec, which compresses speech into a stack of discrete residual-vector-quantization tokens. The 2,048-token max sequence length is the practical ceiling on how much combined text-and-audio context you can feed in a single generation — generous for turn-by-turn dialogue, though something to keep in mind for very long monologues.
On Hugging Face, the model is listed at 8B parameters with tensors stored in F32 (full 32-bit float) precision in the published checkpoint, though — as we’ll see below — the recommended inference path runs in bfloat16.
The headline benchmark: latency
Miso Labs has chosen to fight on one battlefield above all others — latency — and it’s the centerpiece of the misolabs.ai landing page. The company frames the problem clearly: “Most AI voice agents lag at 700ms or more, creating awkward pauses that kill conversational flow.”
The following is Miso Labs’ own marketing comparison, not an independently reproduced latency benchmark:
| System | Latency |
|---|---|
| ElevenLabs | 700 ms |
| Sesame | 300 ms |
| Human reaction | 160 ms |
| Miso Labs | 110 ms |
The current README explains the 110 ms figure as the hosted production API’s time-to-first-byte on H100-class hardware. That is not the latency of this repository’s unoptimized local inference path, and it does not establish an end-to-end conversational response time or a like-for-like comparison with human reaction time.
These remain vendor-published numbers. The README now identifies the hardware class and TTFB metric, but it does not provide a full independent comparison protocol or MOS, WER and speaker-similarity results. The live demo can help listeners form an impression; it does not establish a world-leading emotiveness ranking.
Why people are excited
Three features anchor Miso Labs’ pitch, and each maps to a real pain point in deploying voice AI today.
1. Hosted latency claim. Miso cites 110 ms TTFB on H100-class hardware. Local users should expect materially slower startup and generation; do not budget a workstation deployment around the hosted figure.
2. One-shot voice cloning. Per the landing page, you can “clone any voice with a ten-second audio clip,” and the agent’s voice “remains an exact replica of the original sample from the first second of a call to the last.” This is backed up in the code: the repo ships a Segment API for prompted generation, where you pass in prompt.wav plus its transcript as context, and the model continues in that voice. Consistency across a long call is the hard part of cloning, and Miso is explicitly promising it.
3. On-premises sovereignty. This is the most strategically interesting one. Miso Labs leans hard into the open-source angle: “Our models are open source and built for local deployment. Keep your most sensitive data in-house and maintain total sovereignty over your voice layer.” For regulated industries — healthcare, finance, government — the ability to keep voice data from ever leaving the building is often a hard requirement, not a nice-to-have. Miso also offers on-premises hosting and enterprise support contracts on request. This is plausibly the real business model: open weights as the funnel, enterprise support as the revenue.
The emotive angle deserves its own note. The demo line on the landing page — “You’re my best friend, and my favourite person in the whole wide world… honestly, you’re just unbelievable” — is deliberately chosen to show off prosody, emphasis, and the kind of casual filler-laden cadence (“like, so smart”) that most TTS systems flatten into monotone. The model also exposes voice presets like friend, teacher, and voiceover in the preview UI.
Can it run locally? Yes — with caveats
The repository documents a local inference path. Kingy has not run the installation or generated audio for this update; the requirements below are Miso’s recommendations, not a measured Kingy configuration.
The GitHub repository ships full inference code — generator.py, models.py, a moshi_compat.py shim, watermarking, and a run_misotts.py entry point. Setup is refreshingly modern, built around Astral’s uv:
# Install uv if you don't have it curl -LsSf https://astral.sh/uv/install.sh | sh # Clone and set up git clone https://github.com/MisoLabsAI/MisoTTS.git cd MisoTTS uv sync --python 3.10 source .venv/bin/activate # Run the example — writes full_conversation.wav uv run python run_misotts.py
There’s a pip-based path too for those who prefer a classic virtualenv. On first run, the script pulls the weights from the MisoLabs/MisoTTS Hugging Face repo and caches them locally — so subsequent runs are offline-friendly.
Generating speech from Python is about as terse as it gets:
import torch
import torchaudio
from generator import load_miso_8b
device = "cuda"if torch.cuda.is_available() else"cpu"
generator = load_miso_8b(device=device, model_path_or_repo_id="MisoLabs/MisoTTS")
audio = generator.generate(
text="Hello from Miso.",
speaker=0,
context=[],
max_audio_length_ms=10_000,
)
torchaudio.save("miso.wav", audio.unsqueeze(0).cpu(), generator.sample_rate)
Voice cloning adds just a few lines — you load your prompt.wav, resample it to the generator’s sample rate, wrap it in a Segment with its transcript, and pass it as context.
Hardware and storage: the README describes roughly 8.2B parameters across the backbone, decoder, embeddings and heads. It recommends 24 GB VRAM for bf16/fp16 (~16 GB weights), or 40 GB+ VRAM for float32 (~33 GB weights), with codec, watermarking, cache and activation headroom included. GPU inference defaults to torch.bfloat16. CPU inference is documented as slow, with about 20 GB RAM for bf16 or 40 GB for float32. Allow roughly 30–40 GB disk space for the initial model and dependency downloads. These are approximate vendor requirements; a smaller quantized variant needs its own compatibility and quality assessment.
Safety and watermarking
To Miso Labs’ credit, the safety story isn’t an afterthought bolted on at the end. The repo states plainly: “Do not use it to impersonate people, create deceptive audio, commit fraud, or generate harmful content.” More importantly, that intent is backed by code — generated audio is watermarked by default, using Sony’s SilentCipher model, which the script downloads on first run alongside the main weights.
There’s a sensible operational note attached: if you deploy the model in your own application, “use your own private watermark key and keep it secret.” For a one-shot voice-cloning model — a technology that is, let’s be honest, tailor-made for misuse — shipping default watermarking is a responsible baseline. It won’t stop a determined bad actor who strips the watermarking code, but it does mean honest deployments leave a traceable signal, and it raises the friction for casual abuse.
How it stacks up — and what we still don’t know
Positioned against the field, Miso One’s differentiators are clear: it claims lower latency than both ElevenLabs (700 ms) and Sesame (300 ms), it ships open weights where ElevenLabs is closed, and it bakes in on-prem deployment and watermarking. Architecturally it’s a Sesame-CSM descendant, so it inherits that family’s strength in conversational, context-aware speech rather than flat narration.
But a clear-eyed reader should note what hasn’t been published yet:
- No independent benchmarks. The latency numbers and the “most emotive” claim are vendor-stated. There’s no released MOS naturalness study, no WER figures, no third-party A/B results.
- The README identifies 110 ms as hosted H100-class TTFB; a full independent latency protocol and local-performance measurements remain unverified.
- API access was described as forthcoming at launch. The current site has an API Access link and the README discusses a hosted production API, but public API enrollment, pricing and eligibility have not been verified here.
- The current README provides approximate VRAM, RAM and disk recommendations. Actual latency, memory use and quantized-model behavior on your hardware still require testing.
The original June 3 launch report noted roughly 271 stars, 27 forks and a single commit. Those are historical observations, not current repository counts or evidence of model quality.
The verdict
Miso One is one of the more exciting open releases in voice AI this year, and the reason is strategic as much as technical. By publishing the weights of an 8B Sesame-style model with credible-sounding latency, real one-shot cloning, and a privacy-first, on-prem deployment story, Miso Labs is targeting exactly the gap that closed APIs like ElevenLabs leave open: teams that need a great-sounding voice agent and need to keep their data in-house.
The useful distinction is between a hosted latency claim and a documented local model. Teams considering local deployment should budget for the stated hardware and downloads, check licensing and voice-consent requirements, and measure quality and latency in their intended workflow.
Miso supplies public weights and a local inference reference for conversational speech. Its 110 ms and “most emotive” claims remain vendor claims; neither establishes a general performance threshold or a measured win over people or competing systems.
Popular Tools
Related Models
Compare
Latest News
Recent Launches
Continue Reading
The Kingy Brief
Get The Kingy Brief.
AI changes, original tests and one practical thing to try. Fridays at 09:00 Vancouver time.
Free · Double opt-in · Unsubscribe anytime
Sign up for The Kingy Brief on Beehiiv.
Signup help and newsletter schedule
Signup form provided by Beehiiv. After submitting, check your inbox for "Confirm your subscription to The Kingy Brief" and open its confirmation link. Check Spam or Promotions if you cannot find it.
Fridays at 09:00 Vancouver time: source-checked AI changes, original tests and one practical thing to try. We skip a week when there is not enough verified material. Free. Unsubscribe anytime.