Pika Labs' Pika Speech Undercuts ElevenLabs by 9x With Studio-Quality Audio

Pika Labs, better known for text-to-video, just shipped a text-to-speech model that is aggressively fast and aggressively cheap. Pika Speech is a 3B-parameter flow-matching transformer that produces studio-quality 48 kHz audio, clones voices from a few seconds of reference, and prices out at roughly a tenth of what the incumbents charge.

The headline number is a real-time factor (RTF) of 0.02. On three-minute requests in Pika's locally run tests, one minute of typing the input text takes longer than generating the speech itself. The company claims requests up to five minutes long, cloning from about five seconds of reference audio.

The pricing gap

Speed translates directly into cost on inference-priced APIs. Pika lists its model as 9x more cost-efficient than ElevenLabs v3, 4.5x more efficient than Cartesia and ElevenLabs Turbo, and 2x more efficient than Fish Audio. On the Pika API, Pika Speech is $0.01 per minute against ElevenLabs v3 at $0.09 and Fish Audio S2.1 Pro at $0.21.

Quality tells a more nuanced story. On Pika's own eval of 2,000 samples per language, Pika Speech posts English WER of 1.99% and Resemblyzer speaker similarity of 80.30, trailing MiniMax Speech 2.8 HD (90.16) and Cartesia Sonic 3.5 (87.41) on how closely a cloned voice matches its reference. Perceptual quality holds up: DNSMOS OVR is 3.188 for English, roughly matching the top of the field.

Flow matching, distilled

The architecture is where things get interesting for anyone building real-time audio pipelines. The teacher is a latent flow-matching model: text passes through a large language model encoder whose hidden states are projected into conditioning tokens carrying both the transcript and a delivery caption. Audio is compressed by a VAE into 25 latent frames per second at 128 channels each, so a one-minute clip is only 1,500 tokens.

The generator is a 3B-parameter diffusion transformer with 48 blocks that learns the flow from noise to speech, trained by corrupting a clean latent toward noise along a straight path and predicting the velocity that points back to the data. Flow matching, compared with traditional diffusion, produces a mapping smooth enough to compress into very few steps.

That compression is done with distribution matching distillation (DMD). Rather than teaching the student to imitate the teacher's trajectory step by step, DMD teaches it to match the teacher's output distribution, with a frozen teacher score and a trained critic score providing a gradient evaluated directly in clean-speech space. The result: eight or fewer denoising steps, with guidance baked into the model.

The EOS latent trick

Duration control is where most TTS systems cheat, trimming or time-stretching after generation. Pika Speech controls it inside the model with what they call the EOS latent.

The mechanism prepends a clean latent, never noised and never contributing to the loss, that carries what end of speech looks like, and gives it the RoPE position of the frame where the utterance should land. Slide the anchor earlier and delivery compresses. Slide it later and the same words breathe. One knob controls two effects: total duration and speaking rate.

For streaming, a per-frame EOS head predicts whether speech has ended so generation stops at the sentence boundary rather than a fixed buffer edge.

Why it runs so fast

Few-step inference gets you partway there. The rest is a hand-optimized serving stack:

• FlashAttention-3 across both self- and cross-attention, with conditioning sequences trimmed to their valid lengths to avoid masked computation on unused tokens.
• Token packing that splits long requests at sentence boundaries and denoises all chunks together as one packed sequence with segment-isolated attention, so five chunks cost roughly twice as much as one, not five times.
• A compiled full-precision vocoder that, on long requests, becomes the largest single cost, accounting for more than half of total latency.
• CUDA graphs for the full denoising loop, capturing all eight steps as a single replayable graph per duration bucket so a request replays one captured graph in around 0.1 seconds instead of launching thousands of kernels.
• Fused RoPE kernels and packed graphs, which together dropped one-minute generation from 1.29 s to 1.04 s.

Training data

The final training set contains 403,000 hours of filtered speech, combining open corpora selected for breadth, including conversational, read, and expressive speech in English and Chinese, with a large-scale collection of in-the-wild audio. Every recording is passed through voice-activity segmentation, denoising and loudness normalization, quality filtering with DNSMOS and dedicated audio-quality models, and ASR transcription. End-of-speech boundaries are annotated at latent-frame resolution so the model can learn the EOS latent behavior directly.

Where this fits

For anyone building voice agents, dubbing pipelines, IVR replacements, or long-form narration tools, the tradeoff is clear. Pika Speech is cheap and fast enough to make previously prohibitive workloads viable, and quality on perceptual metrics is roughly on par with the field. Speaker cloning fidelity trails MiniMax and Cartesia, so if pixel-perfect voice matching is the core requirement, it may not be the right pick yet.

Pika also positions this as infrastructure for its own roadmap. Pika Speech is a foundation for a broader real-time generation stack, and will support PikaStream 2.0, their real-time video generation model, by providing low-latency speech for synchronized audiovisual generation. That explains why a video-first company just shipped a state-of-the-art TTS model. The endgame is real-time avatars and interactive video where audio latency cannot be the bottleneck.