Gemini 3.1 Flash TTS vs Gemini 2.0 Flash

We've been building [Scenema Audio](https://scenema.ai/audio) as part of our video production platform at scenema.ai, and we're releasing the model weights and inference code.

The core idea: emotional performance and voice identity are independent. You describe how the speech should be performed (rage, grief, excitement, a child's wonder), and optionally provide reference audio for voice identity. The reference provides the "who." The prompt provides the "how." Any voice can perform any emotion, even if that voice has never been recorded in that emotional state.

# Limitations (and why we still use it)

This is a diffusion model, not a traditional TTS pipeline. Common issues include repetition and gibberish on some seeds. Different seeds give different results, and you will not get a perfect output with 0% error rate. This model is meant for a post-editing workflow: generate, pick the best take, trim if needed. Same way you'd work with any generative model.

That said, we keep coming back to Scenema Audio over even Gemini 3.1 Flash TTS, which is already more controllable than most TTS systems out there. The reason is simple: the output just sounds more natural and less robotic. There's a quality to diffusion-generated speech that autoregressive TTS doesn't quite match, especially for emotional delivery.

# Audio-first video generation

As [this video](https://www.youtube.com/watch?v=ZZO3XAy3KTo) points out, generating audio first and then using it to drive video generation is a powerful workflow. That's actually how we've used Scenema Audio in some cases. Generate the voice performance, then feed it into an A2V pipeline (LTX 2.3, Wan 2.6, Seedance 2.0, etc.) to generate video that matches the speech. [Here's an example of that workflow in action.](https://youtu.be/dcAjQhPKNLk?si=4iOwtpsLR-WzwDmF)

# On distillation and speed

A few people have asked this. Our bottleneck is not denoising steps. The diffusion pass is a small fraction of total generation time. The real costs are elsewhere in the pipeline. We're already at 8 steps (down from 50 in the base model), and that's the sweet spot where quality holds.

# Prompting matters

This model is sensitive to prompting, the same way LTX 2.3 is for video. A generic voice description gives you generic output. A specific, theatrical description with action tags gives you a performance. There's also a `pace` parameter that controls how much time the model gets per word. Takes some experimentation to find what works for your use case, but once you do, you can generate hours of audio with minimal quality loss.

Complex words and proper nouns benefit from phonetic spelling. Unlike traditional TTS, it doesn't have a phoneme-to-audio pipeline or a pronunciation dictionary. If it garbles "Tchaikovsky," you would spell it "Chai-koff-skee" or whatever makes sense to you.

# Docker REST API with automatic VRAM management

We ship this as a Docker container with a REST API. Same setup we use in production on scenema.ai. The service auto-detects your GPU and picks the right configuration:

|VRAM|Audio Model|Gemma|Notes|
|:-|:-|:-|:-|
|16 GB|INT8 (4.9 GB)|CPU streaming|Needs 32 GB system RAM|
|24 GB|INT8 (4.9 GB)|NF4 on GPU|Default config|
|48 GB|bf16 (9.8 GB)|bf16 on GPU|Best quality|

We went with Docker because that's how we serve it. No dependency hell, no conda environments. Pull, set your HF token for Gemma access, then `docker compose up`.

# ComfyUI

Native ComfyUI node support is planned. We're hoping to release it in the coming weeks, unless someone from the community beats us to it. In the meantime, the REST API is straightforward to call from a custom node since it's just a local HTTP service.

# Links

* **All demos + article:** [scenema.ai/audio](https://scenema.ai/audio)
* **Model weights:** [huggingface.co/ScenemaAI/scenema-audio](https://huggingface.co/ScenemaAI/scenema-audio)
* **Code + setup:** [github.com/ScenemaAI/scenema-audio](https://github.com/ScenemaAI/scenema-audio)
* **YouTube demo:** [youtu.be/VnEQ\_ImOaAc](https://youtu.be/VnEQ_ImOaAc)

This is fully open source. The model weights derive from the LTX-2 Community License but all inference and pipeline code is MIT.

Changelog

April 9, 2025

Model updates:

Released veo-2.0-generate-001, a generally available (GA) text- and image-to-video model, capable of generating detailed and artistically nuanced videos. To learn more, see the Veo docs.

Released gemini-2.0-flash-live-001, a public preview version of the Live API model with billing enabled.

# 80,000 NOK ($7,500) drained from my Google Cloud account in 5 minutes — full forensic breakdown of how the attack worked

I want to write this up while it's fresh, because the *mechanism* of the attack is more interesting than the "I leaked a key, oops" headline — and the platform design that allowed it is something every Google Cloud user should know about.

# What happened

* May 8, 2026, evening (CET): I get a billing alert email saying I owe NOK 82,305.36 (\~$7,500 USD) on my Google Cloud account.
* My typical monthly spend: \~100 NOK ($10).
* The spike happened in roughly 5 minutes.
* All charges were on the Gemini API in a single project I'd barely touched (an old "no-code maps" project from 2017).
* An API key from that project was leaked somewhere — I'm still hunting where. Most likely an old GitHub repo or a public webpage from 2018-ish that had Gemini API enabled on its project years later (I think this is what made it exploitable — the key sat dormant, but the moment Gemini got enabled on its project, the dormant key became a Gemini-capable wallet).

# What the attacker actually did (the part nobody talks about)

I pulled the SKU-level breakdown from Billing → Reports. The attacker didn't just hit one model. They ran an automated framework that fanned out across every Gemini variant simultaneously:

* Gemini 3 Pro (text + image generation)
* Gemini 3 Flash
* Gemini 3.1 Flash Image
* Gemini 3.1 Flash Lite Preview
* Gemini 2.5 Pro (text + TTS)
* Gemini 2.5 Flash (short + long context, multimodal)
* Gemini 2.5 Flash Lite
* Gemini 2.0 Flash TTS
* Gemini Embedding-2 + Embedding-001

15+ distinct models in 5 minutes. No human application uses 15 models in parallel. This is the signature of an automated abuse framework, almost certainly a credential-resale operation.

Token volumes:

* 1.09 BILLION input tokens on Gemini 2.5 Flash Lite alone
* 402M image input tokens on Gemini 3 Pro
* 226M text input tokens on Gemini 3 Pro
* 19.4M image output tokens on Gemini 3 Pro Image — kr 21,674 ($2,000) on this single SKU, the most expensive line item

The attacker prioritized image generation because that's where the real money is — image output tokens are 50–100x more expensive than text.

# How they bypassed rate limits (this is the architectural problem)

You'd think rate limits would protect you. They don't — at least not on Google Cloud:

* Gemini 3 Pro: 1,000 RPM
* Gemini 3 Flash: 2,000 RPM
* Gemini 2.5 Flash Lite: 4,000 RPM
* (etc., for every model — *each with its own independent quota*)

There is no per-key aggregate cap across models. If you fan out across 15 models concurrently, you cap at the *sum* — easily 30,000+ RPM combined.

OpenAI, Anthropic, and Mistral all have per-key aggregate caps. Google does not. This is not a policy oversight — it's the core mechanism that makes a single compromised key a 5-minute, 5-figure liability.

Also: Google Cloud does not offer a hard spending cap. No "stop all spend at $X" option. The closest is a budget alert that *emails you* (after the fact), or — and this is the documented "solution" — you can write your own Cloud Function that listens to budget Pub/Sub events and programmatically disables your billing account. Yes, Google's official answer to "how do I stop runaway spending" is "deploy code on the same platform that's billing you." This has been a known gripe for years.

# What logging gave me — almost nothing

I tried every audit log query:

* `protoPayload.serviceName="generativelanguage.googleapis.com"` → empty
* `resource.type="consumed_api"` for the project → empty
* Vertex AI logs → empty

Google does not log per-request data for Gemini API key calls. No caller IP, no user-agent, no request size. The only forensic record that exists is the SKU-level billing report — and that only goes down to "model + token type", not session/request/key.

So I can't tell you who did it, where they were, or what they generated. I just know it was 15 models in parallel and 19M image output tokens.

# What I did in the first 90 minutes

* Deleted all 13 API keys on the affected project (after seeing the alert at \~01:25)
* Disabled [`generativelanguage.googleapis.com`](http://generativelanguage.googleapis.com) and [`aiplatform.googleapis.com`](http://aiplatform.googleapis.com) on every one of my 25+ projects (script via `gcloud services disable`)
* Closed all 3 billing accounts
* Called my bank, blocked the Visa
* Got into Google's billing chat queue, escalated to specialist team within 5 messages
* Case 71021804 opened, 24-48h response window
* Pulled SKU-level forensic evidence

The chat agent confirmed end-of-month billing cycle, so the actual charge attempt won't fire until \~May 28-31. By then either the specialist team has waived it, or the card-block + chargeback dispute kicks in.

# What I'm pretty sure happens next

* \~85% chance: specialist team waives the charge under the compromised-credentials policy. Google has standardized this for exactly this scenario because they know the rate-limit architecture allows it.
* \~10% chance: partial waiver / settlement.
* \~5% chance: they refuse, my bank chargeback wins it under Norwegian Finansavtaleloven (450 NOK max liability for unauthorized card use).

I'm not actually going to pay 80k. The realistic worst case is several months of paperwork.

# Lessons / PSA for everyone running Google Cloud

1. Restrict every API key at creation time. Application restriction (HTTP referrer or IP allowlist) + API restriction (only the APIs you use). An unrestricted key on a project where Gemini happens to be enabled is a wallet.
2. Audit every project for keys you've forgotten about. I had keys from 2017, 2020, 2021 — most predating Gemini's existence. The moment Gemini got enabled on those old projects, the old keys could call it.
3. Disable APIs you don't actively use. Per-project. An enabled API + an unrestricted key = exposure.
4. Set up a budget-disables-billing Cloud Function. The auto-shutdown one. Yes it's stupid that Google makes you write code for this, but it's the only real circuit breaker.
5. Don't trust rate limits. They protect Google's infrastructure, not your wallet. Per-model RPM × N models = no real cap.
6. Don't store API keys in client-side code, ever. Even if you think a project is dead.

# Where the leak came from

Honestly, I don't know yet. The project was created in 2017 (back when Google appended a numeric suffix like `-364317` to project IDs). It had 13 keys accumulated over years. One of them is somewhere out in the wild. I'll be searching GitHub history, old Vercel deployments, Wayback Machine, and screenshots over the coming days. If I find it I'll edit this post.

If anyone has run into the same multi-model abuse pattern recently, I'd love to hear about it — particularly if you have any signals on which credential-resale operations are currently active.

Edit: Will update with specialist team's response when it arrives in 24-48h.

We've been building [Scenema Audio](https://scenema.ai/audio) as part of our video production platform at scenema.ai, and we're releasing the model weights and inference code.

The core idea: emotional performance and voice identity are independent. You describe how the speech should be performed (rage, grief, excitement, a child's wonder), and optionally provide reference audio for voice identity. The reference provides the "who." The prompt provides the "how." Any voice can perform any emotion, even if that voice has never been recorded in that emotional state.

# Limitations (and why we still use it)

This is a diffusion model, not a traditional TTS pipeline. Common issues include repetition and gibberish on some seeds. Different seeds give different results, and you will not get a perfect output with 0% error rate. This model is meant for a post-editing workflow: generate, pick the best take, trim if needed. Same way you'd work with any generative model.

That said, we keep coming back to Scenema Audio over even Gemini 3.1 Flash TTS, which is already more controllable than most TTS systems out there. The reason is simple: the output just sounds more natural and less robotic. There's a quality to diffusion-generated speech that autoregressive TTS doesn't quite match, especially for emotional delivery.

# Audio-first video generation

As [this video](https://www.youtube.com/watch?v=ZZO3XAy3KTo) points out, generating audio first and then using it to drive video generation is a powerful workflow. That's actually how we've used Scenema Audio in some cases. Generate the voice performance, then feed it into an A2V pipeline (LTX 2.3, Wan 2.6, Seedance 2.0, etc.) to generate video that matches the speech. [Here's an example of that workflow in action.](https://youtu.be/dcAjQhPKNLk?si=4iOwtpsLR-WzwDmF)

# On distillation and speed

A few people have asked this. Our bottleneck is not denoising steps. The diffusion pass is a small fraction of total generation time. The real costs are elsewhere in the pipeline. We're already at 8 steps (down from 50 in the base model), and that's the sweet spot where quality holds.

# Prompting matters

This model is sensitive to prompting, the same way LTX 2.3 is for video. A generic voice description gives you generic output. A specific, theatrical description with action tags gives you a performance. There's also a `pace` parameter that controls how much time the model gets per word. Takes some experimentation to find what works for your use case, but once you do, you can generate hours of audio with minimal quality loss.

Complex words and proper nouns benefit from phonetic spelling. Unlike traditional TTS, it doesn't have a phoneme-to-audio pipeline or a pronunciation dictionary. If it garbles "Tchaikovsky," you would spell it "Chai-koff-skee" or whatever makes sense to you.

# Docker REST API with automatic VRAM management

We ship this as a Docker container with a REST API. Same setup we use in production on scenema.ai. The service auto-detects your GPU and picks the right configuration:

|VRAM|Audio Model|Gemma|Notes|
|:-|:-|:-|:-|
|16 GB|INT8 (4.9 GB)|CPU streaming|Needs 32 GB system RAM|
|24 GB|INT8 (4.9 GB)|NF4 on GPU|Default config|
|48 GB|bf16 (9.8 GB)|bf16 on GPU|Best quality|

We went with Docker because that's how we serve it. No dependency hell, no conda environments. We built it for production deployment.

# ComfyUI

Native ComfyUI node support is planned. We're hoping to release it in the coming weeks, unless someone from the community beats us to it. In the meantime, the REST API is straightforward to call from a custom node since it's just a local HTTP service.

# Links

* **All demos + article:** [scenema.ai/audio](https://scenema.ai/audio)
* **Model weights:** [huggingface.co/ScenemaAI/scenema-audio](https://huggingface.co/ScenemaAI/scenema-audio)
* **Code + setup:** [github.com/ScenemaAI/scenema-audio](https://github.com/ScenemaAI/scenema-audio)
* **YouTube demo:** [youtu.be/VnEQ\_ImOaAc](https://youtu.be/VnEQ_ImOaAc)

This is fully open source. The model weights derive from the LTX-2 Community License but all inference and pipeline code is MIT.

# How to Try Scenema Audio

1. You can clone the repo and run `docker compose up` locally or
2. Go to [Scenema](https://scenema.ai) and start a conversation to create a voiceover. You will be able to try voice design for free, iterate on your prompts, tune pacing, etc.