AI Voice and Speech Release Notes

Latest AI Voice and Speech Updates

• Aug 13, 2026

  • Date parsed from source:
    Aug 13, 2026
  • First seen by Releasebot:
    Aug 14, 2026
  

  Speechify

  API: voice cloning now verifies the speaker’s consent

  Speechify adds a new voice cloning consent challenge flow that verifies the speaker agreed before a cloned voice is created. It introduces single-use consent recordings, new required fields, version pinning, and clearer 422 error codes, while deprecating the old unverified flow.

  Creating a cloned voice now requires proof that the speaker agreed to it, in place of the consent object you used to send.

  The flow adds one call in front of your existing create. POST /v1/voices/consent-challenges with the speaker’s full_name returns a phrase and an id. Show the phrase to the speaker exactly as it comes back, record them reading it aloud, and send that recording as consent_recording with consent_challenge_id on POST /v1/voices. Speechify transcribes the recording, checks it against the phrase it issued, and keeps it as the consent record for that voice.

  A challenge is single use, bound to your workspace, and short-lived, so create it when your speaker is ready to record rather than at the start of your flow. If it expires, create another one and record again.

  The unverified flow is deprecated and will be switched off. The date will be announced in this changelog and to affected workspaces ahead of time; plan for a window deliberately shorter than the standard 12-month sunset, because an endpoint that clones a voice without checking the speaker agreed is a safety liability, not just an old shape. The new shape is Speechify-Version: 2026-09-13; it is callable now by pinning that version, and it becomes the default for new workspaces on that date. Until the switch-off, workspaces pinned to earlier versions keep the old consent object, and a pinned default does not move on its own: migrating means re-pinning 2026-09-13. Existing cloned voices are unaffected and keep working, and synthesis endpoints are unchanged.

  If you cannot migrate ahead of the switch-off, contact support and we will work out an extension for your workspace.

  One thing to know if you use an SDK: each release sends its own build date as the default version, so upgrading to an SDK published on or after 2026-09-13 moves you to the new flow even though your workspace is pinned to the old one. That is a deliberate break rather than a silent one - consent_challenge_id and consent_recording are required arguments on the new create, and the consent argument is gone, so the call stops building rather than failing at runtime. To upgrade the SDK without migrating yet, pass the version explicitly:

  client = Speechify(token=os.environ["SPEECHIFY_API_KEY"], version="2026-08-07")
  

  Migrating: full_name moves from the consent object onto the challenge call, email is dropped and nothing replaces it, and consent_challenge_id plus consent_recording become required.

  Three of the new error codes share HTTP 422 and mean different things, so branch on the code rather than the status: consent_phrase_mismatch (the phrase was misread - read it again), consent_speaker_mismatch (the person in the recording is not the person in the sample - the speaker consenting has to be the speaker being cloned), and consent_recording_unusable (silence, too little speech, or an unreadable file - record it again). See Consent and the Voice Cloning API.

  Original source

  Show more
• Aug 12, 2026

  • Date parsed from source:
    Aug 12, 2026
  • First seen by Releasebot:
    Aug 14, 2026
  

  Speechify

  API: text is screened before synthesis

  Speechify adds preflight content screening before audio generation, returning a 400 content_policy_violation with no audio or billing for disallowed text across speech, stream, dialogue, and agent prompts. Streaming refusals now happen before the first audio byte.

  Content Policy

  Text you send for synthesis is now screened before Speechify produces audio from it. A request whose content is not permitted returns 400 content_policy_violation with no audio, and is not billed. This applies to /v1/audio/speech, /v1/audio/stream, /v1/audio/stream/with-timestamps and /v1/audio/dialogue, and to an agent’s prompt and first_message when you create or update one.

  Most published work is unaffected - fiction, journalism, true crime and court reporting routinely describe or quote violence, and depicting that material is treated differently from producing it.

  One thing worth handling in your client: content_policy_violation is a persistent error, so retrying the same text will be refused again. On the streaming endpoints the decision is always made before the first audio byte, so a 200 means the request passed and a refusal is always a JSON 400, never a truncated or empty audio file. See Content Policy.

  Original source

  Show more
• All of your release notes in one feed

  Join Releasebot and get updates from Speechify and hundreds of other software products.

  Create account

  Get updates with: RSS Email CLI MCP API Slack n8n
• Aug 12, 2026

  • Date parsed from source:
    Aug 12, 2026
  • First seen by Releasebot:
    Aug 13, 2026
  

  Resemble

  DETECT-World: The first world model for deepfake detection

  Resemble launches DETECT-World, a deepfake detection model that combines artifact-based analysis with physics-based reasoning to catch zero-day AI-generated media by checking lighting, motion, timing, and other real-world cues.

  New generative models launch every day, making it harder to catch deepfakes with detection trained only on known signatures. DETECT-World changes that by combining artifact-based detection with physics-based reasoning — understanding lighting, motion, timing, and physics to recognize when something doesn't match reality, even from tools that launched today. The result is detection built to catch zero-day deepfake attacks, not just known ones. Watch the video to learn more.

  Transcript

  A phone call with a manager. A reimbursement receipt. A video call with a candidate. Things your average employee encounters everyday. Everything looks and sounds real. But it’s not.

  AI companies that enable hyper-realistic deepfakes launch thousands of new models and variants every single day. So how do you catch something made by a tool that just launched today?

  Our detection model worked like a forensic expert, examining content closely, hunting for the tiny traces of AI tells left behind like an artifact. It's fast. It's precise. But it has to have seen that signature before to quickly deliver an accurate verdict.

  Today, we introduce DETECT-World, the first world model for deepfake detection. Same forensic expert, but now, it also understands how the real world works. Lighting. Motion. Timing. Physics. Now, our detection asks two questions at once: "Do I recognize this?" And: "Does this make sense in the real world?"

  Artifact-based detection is excellent at catching known techniques. It’s precise, down to details most people, and tools, would miss. Physics-based detection is excellent at catching something brand new. Not because it's checking against a known list, but because it's checking against reality itself. And the better generative models get at mimicking reality, the more detection needs to understand it too. Together these approaches — precision on recognizable threats, and broader coverage on the new ones — are what makes DETECT-World built to cover zero-day attacks.

  At Resemble AI, we believe that not all AI-generated media is deceptive. But the only way to prevent AI misuse is with detection that keeps pace with frontier generative labs and lives wherever your media and communication happen. Put the most comprehensive, real-time deepfake detection API in your app or workflow today.

  Original source

  Show more
• Aug 12, 2026

  • Date parsed from source:
    Aug 12, 2026
  • First seen by Releasebot:
    Aug 13, 2026
  

  Resemble

  Introducing DETECT-World: The First World Model for Deepfake Detection

  Resemble introduces DETECT-World, a third-generation deepfake detection model that adds physical-reality reasoning to audio, image, and video analysis. It ships via API with streaming, batch, on-prem, and air-gapped support, plus stronger coverage for new generators and real-time attacks.

  Three Generations of Detection

  For close to a decade, the goal of deepfake detection has been simple: look at a clip, photo, or audio file and decide if it's real or fake. Commercial detectors answer that question by analyzing pixels, frequencies, and biometric signals and the best of them post strong accuracy numbers on standard benchmarks. The problem, as researchers at the Vector Institute have increasingly documented in 2026, is that in deployment, performance drops sharply on content from newer generators. And as of now, there are over 2.2 million AI model variants on Hugging Face, nearly doubling year over year.

  So, improving performance means rethinking what detection is actually trying to detect which is the problem our new model DETECT-World addresses. Instead of only asking "does this content contain artifacts I've learned and memorized from known generators?", we also ask "does this content violate my model of how physical reality works?"

  DETECT-World is the third generation of Resemble AI's detection model. Each generation expanded what the previous one could do.

  DETECT-2B was our first production-grade audio detector. Built on a Wav2Vec2 and Mamba-SSM ensemble architecture with self-supervised representation learning, it achieved 94% accuracy across 30+ languages at 200ms latency. Frame-by-frame analysis with tunable classification thresholds made it deployable in real-time pipelines including contact centres, editorial workflows, and enterprise voice authentication.

  DETECT-3B Omni was the first multimodal step. Three billion parameters spanning audio, image, and video through a single unified API. The audio component built on DETECT-2B's foundation with substantially expanded training data, telephony codec robustness, replay attack protection, and coverage of 51 languages. The vision stack added coverage of major generative architectures including StyleGAN, DALL·E 3, Stable Diffusion, GPT-4o, Veo 2 and ranked first on DFBench for both image and speech detection and EER dropped across every public benchmark we tracked.

  DETECT-World adds the layer neither of those models had: a learned understanding of physical reality. Rather than only asking whether content matches known generator signatures, it also evaluates whether the content is physically coherent — whether the lighting, geometry, motion, and audio-visual synchronisation of a scene make sense as something that could have happened in the real world.

  What a World Model Does Differently

  Where DETECT-3B Omni asks "does this look like a known fake?", DETECT-World asks both that question and a second one: "does this make sense as a physical event in the real world?"

  The model achieves this through the World-Vision Hybrid Encoder, a spatiotemporal backbone that processes video as 4-second windows at 40 frames per second, and images as static clips. Both pass through the same encoder, producing spatiotemporal tokens that are evaluated by a patch head to generate per-patch logits. From those logits, the model produces three outputs: an overall probability of manipulation, per-frame scores showing exactly when in a video the anomaly occurs, and a spatial heatmap showing where in the frame the manipulation is concentrated.

  The model may look to determine things like:

  • Does the lighting on a person's face change in a way that is inconsistent with the light sources visible in the scene?
  • Does the shadow cast by a subject match the direction and intensity of the ambient light?
  • Do background elements move in a way that is coherent with the foreground motion?

  None of these checks require prior exposure to the generator that produced the content. They only need a learned model of how reality behaves. That is what world detection means: generalizing from the constraints of physical reality rather than just the signatures of known tools.

  This is why DETECT-World can reach zero-day coverage more quickly than any approach built on signature memorization alone as the physics do not change when a new generator launches.

  How We Built It: Training

  The model is trained across hundreds of distinct manipulated image and video sources including individual generators, generator versions, and manipulation pipelines covering:

  • Face swap, including real-time injection tools
  • Lip-sync and talking-head reanimation
  • Fully synthetic text-to-video and image-to-video generation
  • Partial edits including splices, inpainting, and AI filters
  • Classic GAN and diffusion-based forensics baselines (image corpus)

  What makes coverage of new generators fast is how the training corpus is sampled. Rather than treating all sources equally, the training process continuously prioritises sources the model is currently getting wrong and automatically pulls newly ingested generators into focus without manual scheduling. A new generator added to the catalog is covered quickly because the training distribution adjusts to it immediately.

  Augmentation is designed to simulate the real-world transformations that content undergoes in deployment: platform re-encoding, compression, frame-rate variation, and social-media degradation chains. Every augmentation is applied symmetrically to real and fake content alike, so the model cannot learn to detect the augmentation rather than the manipulation.

  What This Means in Practice

  The most immediate practical consequence is coverage that does not degrade on novel attack types.

  On internal tests, DETECT-World caught the Haotian-style real-time face-swap attack at approximately 95% accuracy. Haotian AI is a Chinese real-time deepfake tool marketed to scammers and commercially available at under $2,000 per year, integrating natively with Zoom and Teams, and requiring no specialist knowledge to deploy. A May 2026 investigation by 404 Media found it misclassified nearly 100% of its outputs as authentic on leading academic deepfake detectors. DETECT-World had no prior exposure to it. The physics were wrong, and that was enough.

  World detection is also structurally resistant to evasion through adversarial fine-tuning. The physical consistency checks are grounded in reality, not in any model's training data.

  The Numbers Across Modalities

  DETECT-World ships with meaningful accuracy improvements across all three modalities, bringing image and video detection into the same tier as our audio detection.

  • Audio: 99.5% accuracy on the Podonos benchmark — externally validated, ranked first ahead of commercial competitors with a publicly available API. Approximately 0.5% improvement over the prior generation. Audio detection now covers 54 languages, with improved coverage of VoIP streaming and packet-loss scenarios.
  • Image: 95.8% accuracy on internal benchmarks, moving image detection into the mid-90s for the first time.
  • Video: 98.2% accuracy on internal benchmarks, covering real-time face-swap, lip-sync manipulation, and AI filter injection during live video calls.
  • Coverage: Benchmarked across 250+ generation models, up from 160+ in the prior generation, with the ability to generalise to generators it has never seen.

  Scope and Known Limitations

  Long video. Above 60 seconds, spatial heatmaps are disabled and input resolution is reduced. For forensic-grade review of a long video, re-run flagged segments as shorter clips at full resolution.

  Temporal granularity. Detection operates on short windows with overlapping context. Few-frame manipulations are detectable but reported segment boundaries are approximate.

  The score is a probability. Output is a calibrated score, not proof of manipulation. For high-stakes decisions, pair automated scoring with human review of the uncertain band and threshold tuning for your specific content distribution.

  Getting Started

  DETECT-World powers Resemble Detect and is available now via API, with streaming support for real-time detection and batch processing for forensic and compliance workflows. Deployable on-prem and in air-gapped environments.

  Read more about Resemble Detect or talk to the team.

  Original source

  Show more
• Aug 11, 2026

  • Date parsed from source:
    Aug 11, 2026
  • First seen by Releasebot:
    Aug 13, 2026
  

  Cartesia

  New to Ink-2: Keyterm prompting and configurable turn detection

  Cartesia releases new Ink-2 features that improve enterprise speech recognition, adding keyterm prompting for harder names and technical terms plus configurable turn detection for faster latency or more accurate endpointing. The updates are live now for all Ink-2 users.

  Keyterm prompting: boost transcription accuracy on difficult entities

  Brands, drug names, and industry terms are naturally difficult to transcribe, even for the best STT models.

  With keyterm prompting, pass up to 100 keyterms (1,200 characters total) with the keyterm query parameter when you open a connection. Ink-2 biases toward transcribing these terms correctly with no extra latency.

  Here’s a clinician walking a patient through a prescription change, with Ink-2 and Deepgram Flux each given the same three keyterms.

  Keyterms provided to both models:

  Paracetamol

  Ibuprofen

  Aspirin

  ink-2

  Returns all three keyterms as given

  flux-general-en

  Transcribes "Paracetamol" incorrectly

  Keyterm prompting on Ink-2 is also strong on getting names correct.

  Keyterms provided to both models:

  Sarita

  Singh

  ink-2

  Returns both keyterms as given

  flux-general-en

  Misses both keyterms

  We measure keyword recall on Earnings22, a benchmark built from real quarterly earnings calls: company names, tickers, acronyms, the kind of vocabulary general-purpose STT tends to find tricky.

  Keyterm prompting takes Ink-2, the most accurate STT model, and boosts its recall by 20%. With prompting enabled, Deepgram Flux misses 13.5% of keywords and Ink-2 only misses 6.2%, so Ink-2 misses less than half as many.

  Keyterm prompting works well for:

  • Product and brand names (“Cartesia”, “Ink-2”)
  • Drug names and clinical terms (“semaglutide”, “atorvastatin”)
  • Names or addresses on a caller’s account
  • Industry acronyms and internal jargon

  Ink-2 has improved measurably on our purpose-built enterprise AI benchmark, EVA-Bench, in our evaluation. It holds up on the domain-specific vocabulary that shows up in real enterprise conversations (airline, IT service, HR), and the gains we saw between runs came from Cartesia’s own iteration, not from anything we tuned.

  Joyce Li
  AI Product Manager

  Configurable turn detection: tune for faster latency or more accurate endpointing

  Configurable turn detection allows you to tune latency and endpointing accuracy to optimize your agent’s conversational flow for your use case.

  Lower latency

  Closes the turn sooner

  Ends a turn at each pause, splitting the request into three, so the agent can start replying earlier.

  Higher turn-taking accuracy

  Holds the turn longer

  Waits through the caller's pauses and keeps the whole request as one turn.

  Ink-2 ships with a balanced default, but now you can configure turn detection yourself: tune toward lower latency for snappy conversation, or toward higher turn-taking accuracy when capturing information correctly matters most. Set it when you open the connection, or adjust it mid-stream as the call unfolds.

  Try it today

  Keyterm prompting and configurable turn detection are live now for all Ink-2 users. Check out the docs for keyterm prompting and turn detection, and try Ink-2 at play.cartesia.ai.

  Original source

  Show more
• Aug 10, 2026

  • Date parsed from source:
    Aug 10, 2026
  • First seen by Releasebot:
    Aug 13, 2026
  

  Eleven Labs

  August 10, 2026

  Eleven Labs adds Dubbing v2 API support with editable project-based dubbing in 90+ languages, plus new conversation, branch, guardrail, voice search and post-call analysis controls. SDK updates bring realtime STT enhancements and broader API coverage across JavaScript, Python and Android.

  Dubbing v2 API

  Dubbing v2 is now available through the API. It translates audio and video into more than 90 languages while preserving each speaker's voice, tone and pacing.

  The new project-based API keeps source transcripts and translations as editable JSON. Create a project from a file or URL, add one or more target languages, edit individual transcript segments or translations, then regenerate only the regions that changed. Follow the Dubbing quickstart to create your first dub.

  ElevenAgents

  Conversation guardrail filters: List conversations adds optional guardrail_types (GuardrailType[]) and custom_guardrail_names (string array) query parameters. The existing conversation hierarchy can now be filtered with optional parent_conversation_id (string).

  Branch divergence status: List agent branches adds optional include_commit_status (boolean, default false). When enabled, branch summaries include nullable commits_ahead, commits_behind and merged_into_branch_id fields.

  Conversation and tool controls: Client overrides now support max_duration_seconds and pronunciation_dictionary_locators. MCP server configuration adds request_meta for passing MCP _meta values to tool calls, and webhook tool timeouts now support up to 300 seconds.

  Post-call analysis usage: Conversation charging adds an analysis breakdown with per-feature running totals and run snapshots. Transcript messages add triggered_guardrails, and conversation turns add optional producing_llm.

  Voices

  Voice search filters: Get all voices v2 adds optional gender, age, language, accent, use_cases, min_notice_period_days, include_custom_rates, include_live_moderated and high_quality query parameters.

  SDK Releases

  JavaScript SDK

  v2.63.0 - Added realtime Speech to Text options for secondary languages, language and entity detection, background audio filtering, logging and single-use token authentication. Added final transcript, entity and invalid request events; fixed unaccepted terms dispatch, duplicate audio_format parameters and inclusive VAD bounds.

  v2.62.0 - Added Dubbing bulk transcript update methods and DubbingRegenerateResponse; added conversation guardrail filters, agent branch commit status, agent alerting and MCP requestMeta support. Language target creation no longer accepts modelId.

  v2.61.0 - Added conversation hierarchy filtering, post-call analysis charging, triggered guardrail metadata, branch merge conflict details, DTMF input redaction and Dubbing transcript uploads. Removed exported OpenAI realtime session types and run_subagent_* tool-result variants.

  Python SDK

  v2.63.0 - Added realtime Speech to Text options for secondary languages, language and entity detection, background audio filtering, logging and single-use token authentication. Added final transcript, entity and invalid request events; fixed unaccepted terms dispatch and now rejects connections without an API key or token.

  v2.62.0 - Added Dubbing update_segments methods and DubbingRegenerateResponse; added guardrail_types, custom_guardrail_names, include_commit_status and MCP request_meta support. Dubbing segment updates now use request body models, and language target creation no longer accepts model_id.

  v2.61.0 - Added parent_conversation_id, analysis charging, triggered guardrail metadata, branch merge conflicts, DTMF input redaction and Dubbing transcript uploads. Removed OpenAI realtime session types and run_subagent_* result models.

  Android SDK

  v0.12.1 - Fixed intentional text-only session disconnects being reported as ConversationStatus.ERROR.

  v0.12.0 - Added ConversationConfig.useMediaStream for routing conversation audio through the Android media stream. Remote normal WebSocket closures now report DisconnectionDetails.Agent, while locally initiated closures report DisconnectionDetails.User.

  MCP Server

  v0.12.2 - Fixed an issue with path traversal.

  API

  Original source

  Show more
• Aug 9, 2026

  • Date parsed from source:
    Aug 9, 2026
  • First seen by Releasebot:
    Aug 11, 2026
  

  Text To Speech by Inworld

  Realtime TTS-2 Flash

  Text To Speech launches Realtime TTS-2 Flash, its fastest and most cost-efficient TTS-2 model, delivering 20 ms time to first audio, 200+ languages and locales, instant voice cloning, timestamp alignment, and support for non-verbal tags like [laugh].

  Launched Realtime TTS-2 Flash (inworld-tts-2-flash), the fastest member of the TTS-2 family — see Models:

  • Our lowest latency: 20 ms time to first audio (server-side P90 TTFB, excluding network latency) — 5× faster than inworld-tts-2 at 100 ms, making it the best choice for latency-critical real-time agents.
  • Our lowest cost: The most cost-efficient model per character, ideal for high-volume workloads.
  • Full TTS-2 language coverage: The same 200+ languages and locales as inworld-tts-2, plus instant voice cloning and timestamp alignment.

  Steering instructions and Professional Voice Cloning are supported on inworld-tts-2 only — use it when you need directed, contextually aware delivery. Non-verbal tags like [laugh] work on both models.

  Original source

  Show more
• Aug 6, 2026

  • Date parsed from source:
    Aug 6, 2026
  • First seen by Releasebot:
    Aug 11, 2026
  

  Text To Speech by Inworld

  Steering instructions now persist

  Text To Speech adds clearer steering for inworld-tts-2 with tags that stay active until changed, a new [reset] tag to return to the voice’s natural delivery, pause-proof instructions, and a request-level instruction field for whole-request control.

  Steering on inworld-tts-2 follows one rule: a [tag] applies from where you write it until you change it. See the Steering guide.

  Behavior change

  An inline [tag] previously affected only the text immediately after it and delivery could revert on its own partway through longer text. A tag now stays in force until you change it. If you relied on an instruction wearing off — for example [shout] Hi. Normal text. expecting the second sentence unstyled — add [reset] where normal delivery should resume. Requests that use no inline tags are unaffected, as are inworld-tts-1.5-max and inworld-tts-1.5-mini.

  [reset]

  New reserved tag that ends a styled passage and returns the voice to its own character for the rest of the text. [shouting] We need to leave now! [reset] Do you understand me? shouts only the first sentence.

  Instructions survive pauses

  A <break/> no longer clears the active instruction. A pause is a pause and never changes delivery.

  Request-level instruction field

  Set one instruction for the whole request without putting tags in your text. See instruction. Use either this field or inline tags, not both.

  Original source

  Show more
• Aug 6, 2026

  • Date parsed from source:
    Aug 6, 2026
  • First seen by Releasebot:
    Aug 9, 2026
  

  Speechify

  API: simba-3.2 voice cloning enters limited release

  Speechify adds limited-release voice cloning support on simba-3.2 for enabled workspaces, simplifying access to cloned voices and keeping the existing API flow unchanged. English-only support remains, with non-English cloned voices still routed to simba-3.0.

  API: simba-3.2 voice cloning enters limited release

  Cloned (personal) voices now synthesize on simba-3.2 for workspaces enabled for it, with no per-voice step. The earlier per-voice-key approval is gone: enablement is per workspace, and once yours is on, every clone you own works there. Contact us to be enabled.

  Nothing else changes. The request and response are identical to a stock-voice call, and simba-3.2 remains English only, so a cloned voice with a non-English locale still returns 400 — use simba-3.0 for those.

  GET /v1/voices names simba-3.2 on your cloned voices once your workspace is enabled, so drive a picker off each voice’s models array rather than assuming. Cloning on simba-3.0, simba-english, and simba-multilingual is unchanged.

  Original source

  Show more
• Aug 5, 2026

  • Date parsed from source:
    Aug 5, 2026
  • First seen by Releasebot:
    Aug 7, 2026
  

  Speechify

  API: simba-3.0 is the new default TTS model

  Speechify changes the default TTS model to simba-3.0 for speech and streaming API requests that omit a model, bringing multilingual support, streaming-native audio, and timestamps in /stream/with-timestamps while keeping explicit simba-english requests unchanged.

  API: simba-3.0 is the new default TTS model

  POST /v1/audio/speech, POST /v1/audio/stream, and POST /v1/audio/stream/with-timestamps now resolve a request that omits model to simba-3.0 instead of the legacy simba-english.
  GET /v1/audio/models marks the change on its default flag.

  Nothing you already send changes shape, and nothing that worked starts failing. A request that names a model explicitly is untouched - model: "simba-english" keeps getting Simba 1.6 English, and that model stays fully supported with nothing scheduled for removal.

  What changes if you omit model:

  Before (simba-english) Now (simba-3.0) Voices accepted any voice in GET /v1/voices unchanged - any voice, cloned voices self-serve Non-English voices synthesized by the English 1.6 training routed to the Simba 3.0 multilingual training POST /v1/audio/stream/with-timestamps 400 speech_marks_unsupported supported Audio Simba 1.6 Simba 3.0 - streaming-native, lower time-to-first-byte

  simba-3.0 was chosen over the recommended simba-3.2 precisely because it accepts everything the old default did: simba-3.2 serves a curated voice set and rejects non-English voices, so making it the default would have turned working calls into 400s.

  The rendered audio does change if you omit model.
  Pin the old behaviour by sending model: "simba-english" explicitly if your integration depends on the Simba 1.6 output. For new English work we still recommend model: "simba-3.2" - see Models.

  Original source

  Show more