Amazon Nova 2 Sonic Explained: AWS's Native Speech-to-Speech Model

Every voice assistant built before 2024 worked the same way underneath: a speech-to-text model transcribed what you said, a language model decided what to answer, and a text-to-speech model spoke the reply back. That pipeline works, but it stacks three separate hops of latency on top of each other, throws away tone of voice the moment it becomes text, and struggles to know when you have actually finished talking. Amazon's answer, first shipped in April 2025 and significantly upgraded on December 2, 2025, is a single model that listens and speaks directly, without ever converting your voice into a transcript along the way. That model is Amazon Nova 2 Sonic, and it is now generally available on Amazon Bedrock [1] [2].

This post is a full technical walkthrough of what Nova 2 Sonic actually is, why native speech-to-speech architecture matters at a mechanical level and not just a marketing one, what changed since the original Nova Sonic, how its benchmark numbers stack up against GPT-Realtime, Gemini 2.5 Flash Live, and ElevenLabs, and how to actually call it from real, documented code.

If you want to see this concept in motion rather than only read about it, here is a video generation prompt built around a real-time voice conversation, written in a cinematic style you can hand to a video model:

A single continuous cinematic shot, camera slowly orbiting a wooden tabletop scene: two vintage brass telephone handsets rest a few inches apart, connected only by a soft glowing pulse of light that travels directly between them with no interruption, growing brighter and faster each time it passes back and forth, representing an uninterrupted real-time voice conversation. Small paper tags near each handset show simple hand-drawn waveform sketches pulsing in sync with the light. Warm soft studio lighting, shallow depth of field, visible brass and wood grain texture, no readable text beyond the waveform sketches, no logos, no people, smooth slow camera movement, loopable cinematic take.

What Amazon Nova 2 Sonic Actually Is

Nova 2 Sonic is Amazon's second-generation foundation model purpose-built for real-time, spoken conversation. Amazon Bedrock's own model card lists it plainly: input and output modalities of speech and text, a 1 million token context window, a 64,000 token max output, and access exclusively through Bedrock's InvokeModelWithBidirectionalStream API under the model ID amazon.nova-2-sonic-v1:0 [4]. It is not an embeddings model, not a chat completions model, and it does not support the standard Converse API that most other Bedrock models use. It exists specifically to hold open, bidirectional, streaming audio conversations.

That specialization is the whole point. Nova Sonic v1, announced in April 2025, was Amazon's first attempt at unifying speech understanding and generation into a single model rather than stitching together separate transcription, reasoning, and synthesis stages [5]. Nova 2 Sonic keeps that same core bet and pushes further on the two things that actually determine whether a voice agent feels usable in production: language coverage and agentic reliability. Amazon's own December 2 announcement frames the release as making the model more capable and more accessible, specifically calling out improved intelligence, better agentic capabilities, and expanded language support [1].

Concretely, the documented feature set includes automatic multilingual detection and switching across English (with US, UK, India, and Australia accents), French, Italian, German, Spanish, Portuguese, and Hindi; Polyglot voices that keep the same voice identity while speaking any of those seven languages; adaptive prosody that adjusts delivery based on how the user is speaking; intelligent, configurable turn-taking; graceful interruption handling; RAG-based knowledge grounding; and asynchronous tool calling for agentic workflows [3]. Each of those pieces earns its own section below, because supporting tool calling and supporting asynchronous tool calling that never blocks the conversation are meaningfully different engineering claims, and the gap between them is exactly where a lot of production voice agents fail.

Why Native Speech-to-Speech Is a Different Architecture, Not Just a Faster Pipeline

To understand why Amazon, OpenAI, and Google have all converged on native speech-to-speech models over the last two years, it helps to be precise about what the older cascaded approach actually costs.

A cascaded voice pipeline runs three independent models in sequence. Automatic speech recognition converts your audio into text. A large language model reads that text and generates a text response. Text-to-speech converts that response back into audio. Each stage has to fully finish, or at least produce a stable enough partial output, before the next stage can meaningfully start. That is where the latency comes from. It is not one model being slow, it is three models' worst-case latencies added together, plus the serialization overhead of passing data between three separate services that were never trained together in the first place.

It is worth being honest here about what is publicly documented versus reasonable inference. Amazon has not published the internal layer-by-layer architecture of Nova 2 Sonic, so the exact mechanism by which it avoids stacking three models' latency, whether that is joint audio-text tokenization, a shared internal representation, or some other approach, is not something AWS discloses in detail in its public materials. What Amazon does state directly is the architectural framing: Nova Sonic unifies speech understanding and generation into a single model, explicitly contrasted against pipelines that separate those stages [5], and the bidirectional streaming API is built so a single persistent connection carries both directions of audio at once rather than exchanging complete request-response payloads the way a cascaded pipeline typically does [3].

Two consequences follow directly from cutting the cascade down to one model, and both are documented rather than inferred.

Prosody and emotion survive the round trip. In a cascaded system, the LLM only ever sees text. It has no idea whether you sounded frustrated, sarcastic, or urgent, because the ASR stage stripped that information out the moment it produced a transcript. A model that reasons directly over audio can carry tone through the whole exchange instead of losing it at the first hop. Nova 2 Sonic's documented adaptive speech response feature, which dynamically adjusts delivery based on the prosody of the input speech, is a direct product of this [3].

Turn-taking becomes a first-class, tunable behavior instead of a bolt-on heuristic. A cascaded system typically has to guess when you have stopped talking using a separate voice activity detection component, then wait for ASR to catch up before the LLM can even start thinking. A model reasoning directly over the audio stream can fold the question of whether the user has actually finished, or simply paused to think, into the same processing that is already happening, which is why Nova 2 Sonic exposes a single, direct configuration setting for this rather than a separate voice activity detection service to tune independently.

It is worth noting that not every serious competitor in this space has made the same architectural bet. ElevenLabs, for instance, is explicit that its Conversational AI stack is an advanced cascaded architecture with in-house speech-to-text and text-to-speech models, tuned hard for low latency at each individual stage rather than collapsed into one fused model [24]. That is a legitimate, different engineering tradeoff, not an inferior one by default, and it is covered in the comparison section below.

What's New in Nova 2 Sonic Versus the Original Nova Sonic

The original Nova Sonic, announced in April 2025, launched with English only, in American and British accents, and shipped in a single AWS Region [5]. Nova 2 Sonic, generally available since December 2, 2025, is a meaningfully broader and more agent-ready release. The concrete deltas, according to Amazon's own announcement and documentation, are worth listing individually rather than summarizing away.

Language coverage nearly doubled, from English, French, Italian, German, and Spanish to those five plus Portuguese and Hindi, seven languages total, with automatic detection and switching within a session [1] [3]. Polyglot voices mean the same named voice, Tiffany is the example Amazon uses publicly, can now speak fluidly across every supported language in a single session, including code-switching mid-sentence, rather than forcing a voice swap whenever the conversation changes language [1].

Configurable turn-taking sensitivity lets developers set endpointingSensitivity to LOW, MEDIUM, or HIGH in the session configuration. High sensitivity optimizes for the fastest possible response time, which suits quick transactional exchanges like checking an order status. Lower sensitivity gives users more room to pause mid-thought before the model jumps in, which suits open-ended or emotionally sensitive conversations like a support intake call [1].

Cross-modal interaction means a single session can accept both audio and text input and switch between them without losing conversational context, useful for a chat widget that also offers a tap-to-talk button, or an in-car assistant that falls back to text input in a noisy cabin [3]. Asynchronous tool calling lets Nova 2 Sonic keep talking, or keep listening, while a tool call executes in the background, rather than freezing the conversation until the tool returns. This is covered in depth in its own section below, since it is one of the more consequential changes for anyone building a real agent rather than a scripted demo [1].

The context window grew to 1 million tokens, up sharply from v1, which matters directly for long customer service calls, multi-hour support sessions, or agent workflows that accumulate a large tool-call history over a single conversation [2] [4]. And robustness improved across the board: better handling of accents, background noise, and 8kHz telephony audio, plus higher accuracy on alphanumeric strings and short utterances, both of which matter enormously for the unglamorous but extremely common case of call center automation where audio quality is rarely studio grade [1].

The model has not stood still since general availability, either. Amazon has shipped two documented in-place refreshes since the December 2 launch, deployed automatically with no API changes required on the developer's side. The March 2026 refresh added Amazon Polly-compatible voices, cut p50 user-perceived latency by 150 milliseconds, and improved turn-taking specifically on 8kHz telephony audio. The May 2026 refresh reduced speech-generation hallucinations by 88% on Amazon's internal evaluation set for verbatim content like alphanumeric codes, addresses, and phone numbers, cut speaker drift by 52%, and reduced overall critical speech-generation errors by 28%, with no regression in latency or speech understanding accuracy [27]. That release cadence is worth flagging on its own. A production voice model receiving silent, non-breaking quality refreshes every couple of months is a genuinely different support posture than a model you download once and never revisit.

Benchmark Results: What Big Bench Audio, BFCL, ComplexFuncBench, and IFBench Actually Measure

Headline benchmark numbers are only useful once you know what the benchmark is actually testing and who built it. Here is each one Amazon cites for Nova 2 Sonic, with its real origin and methodology.

Big Bench Audio is the benchmark most directly relevant to a speech-to-speech model, because it specifically measures reasoning ability when the input arrives as audio rather than text. It was created by Artificial Analysis, an independent AI benchmarking firm, and released with a companion Hugging Face dataset [8] [9]. It adapts 1,000 questions from Big Bench Hard, an established hard-reasoning text benchmark, into the audio domain, and evaluates models across four modality combinations: speech-to-speech, speech-to-text, text-to-speech, and text-to-text [8]. The benchmark exists because of a genuinely striking finding when it launched. GPT-4o scored 92% on the text-only version of the same questions but dropped to 66% once the same questions arrived as speech and had to be answered in speech, a 26-point speech reasoning gap that had nothing to do with underlying reasoning ability and everything to do with how much capability voice models lose in the audio round trip [8].

Nova 2 Sonic scores 87.0% on Big Bench Audio according to Amazon [1], and Artificial Analysis's own independent measurement puts it at 87.1%, placing it second on their live leaderboard behind Google's Gemini 2.5 Flash Native Audio Thinking variant and ahead of OpenAI's GPT-Realtime, which scored 83% [7]. That ranking detail is worth stating precisely rather than rounding up. Nova 2 Sonic beats the standard Gemini 2.5 Flash Live native audio configuration, which the same reporting places at 71.0%, but trails Gemini's separate Thinking variant that spends extra inference time reasoning before answering [18].

BFCL, the Berkeley Function-Calling Leaderboard, is where Amazon's 74.5% score for Nova 2 Sonic comes from. It is maintained by UC Berkeley's Sky Computing Lab as part of the Gorilla project, and it has become the de facto standard benchmark for function-calling evaluation since its original release [10]. The current version, BFCL v4, evaluates over 2,000 question-function-answer pairs spanning Python, Java, JavaScript, and REST API calls, testing simple calls, parallel calls, multiple-function selection, and function relevance detection, all scored with an Abstract Syntax Tree evaluation method that checks whether a generated function call is structurally and semantically correct rather than just string-matching it [11] [12]. A paper describing BFCL's methodology, "The Berkeley Function Calling Leaderboard: From Tool Use to Agentic Evaluation of Large Language Models," was accepted at ICML 2025, underscoring that this is a peer-reviewed evaluation framework rather than an informal leaderboard someone assembled over a weekend [12].

ComplexFuncBench, where Nova 2 Sonic scores 65.2%, comes from a research team published under the THUDM and zai-org GitHub organizations and was introduced in a 2025 arXiv paper [13]. It specifically targets the kind of function calling that simpler benchmarks miss: multi-step tool chains, requests with real user-specified constraints, parameters that must be inferred from implicit context rather than stated directly, function arguments longer than 500 tokens, and scenarios set inside a 128,000 token long context [14]. A model can look strong on a simple single-call function benchmark and still fall apart on ComplexFuncBench's multi-step, constraint-heavy tasks, which is exactly the gap Amazon is pointing at when it specifically calls out better handling of multi-step, constraint-heavy tasks as one of Nova 2 Sonic's improvements [1].

IFBench, where Nova 2 Sonic scores 37.5%, is the newest and hardest of the four. It comes from the Allen Institute for AI, built specifically because models had started overfitting to the older IFEval instruction-following benchmark [15]. IFBench tests 58 new, diverse, out-of-domain verifiable constraints across roughly 300 single-turn and 1,300 multi-turn prompts, and its prompts are deliberately pulled from real user conversations rather than written from scratch by researchers, specifically to avoid the kind of benchmark-specific overfitting that made IFEval scores stop being a reliable signal [15]. Artificial Analysis has since adopted IFBench into its own Intelligence Index precisely because of that overfitting problem with older instruction-following tests [16]. A 37.5% score on a benchmark this deliberately hard is not a weak result the way it might look next to Big Bench Audio's 87%. It reflects the benchmark's difficulty as much as the model's actual instruction-following ability, and it is one of the clearer examples of why comparing raw scores across benchmarks with different difficulty ceilings, rather than within a single benchmark, tends to mislead.

How Nova 2 Sonic Compares to GPT-Realtime, Gemini 2.5 Flash Live, and ElevenLabs

Benchmark scores only tell part of the story for a voice product, because latency, pricing, and architecture philosophy all affect whether a model is the right choice for a specific use case. Here is how the four most relevant options actually compare as of this Nova 2 Sonic release.

A few things are worth pulling out of that table rather than leaving as raw numbers. OpenAI's GPT-Realtime line, most recently refreshed as gpt-realtime-2.1 and a lower-cost gpt-realtime-2.1-mini variant in mid-2026, is also natively multimodal, taking audio directly into the model without a separate transcription step, and OpenAI has continued pushing latency down, citing internal model latency in the 80 to 120 millisecond range for pure audio processing and a roughly 25% reduction in p95 voice latency from improved caching [22]. Google's Gemini Live API takes a somewhat different product shape. Rather than a single Sonic-style model, Google offers native audio variants, including the higher-scoring Thinking configuration mentioned above, alongside a broader set of Live-API-compatible models, with 30 distinct voices across 24 languages and features like Proactive Audio, where the model deliberately stays silent unless a query is actually directed at it, and Affective Dialog, where the model adapts to the emotional tone of what it hears [23].

ElevenLabs occupies a genuinely different category. Rather than betting on a single native speech-to-speech model, it has built a highly optimized cascaded stack, with its own in-house speech-to-text and text-to-speech models (Flash v2.5 claims roughly 75 millisecond synthesis latency on its own) glued together with a dedicated turn-taking model that reads pauses, filler words, and conversational cues to decide when to let the user keep talking [24] [25]. That is a legitimate architectural answer to the same latency problem native models solve differently, and for teams that want to swap the reasoning model in the middle of the pipeline independently of the voice layer, a cascaded approach still has real advantages a fused native model does not offer.

Amazon's own framing of the competitive picture, reported independently by DeepLearning.AI's The Batch, is that users preferred Nova 2 Sonic to GPT Realtime and Gemini 2.5 Flash in most of its seven languages, based on Amazon's internal human evaluations [19], a claim worth treating as exactly what it is: a vendor's own preference study, directionally useful but not the same evidentiary weight as an independent leaderboard number like Big Bench Audio. Independent analysis has been more measured, describing the Nova 2 family as gaining meaningfully on internal benchmarks and sitting near the top group while still trailing the single best-performing models from other vendors on raw capability, even as it wins clearly on price [18]. Both things can be true at once. Nova 2 Sonic is not the single highest-scoring speech-to-speech model on every benchmark, and it is still a genuinely strong, meaningfully cheaper option that a lot of production teams will find is more than good enough for the actual conversations they need to automate.

Pricing and Regional Availability

Nova 2 Sonic bills text and speech tokens separately, which is worth understanding before estimating cost for a real deployment. Text tokens, the transcript-equivalent content flowing through the model, are priced at $0.330 per million input tokens and $2.75 per million output tokens. Speech tokens, the actual audio content, are priced separately at $3 per million input tokens and $12 per million output tokens [26]. Amazon describes this as maintaining the industry-leading price performance and low latency of the original Nova Sonic [2], and an independent case study backs that framing with a concrete number: Loka, an AWS partner that built a production voice agent on Nova 2 Sonic for an automotive dealership use case, reports an actual operating cost of roughly $0.27 per hour of input audio in their deployment [17]. Always confirm current numbers directly on the Bedrock pricing page before budgeting a production workload, since AWS updates pricing and adds volume tiers over time.

Regional availability has also grown since launch, and this is a good example of why checking a model's release notes rather than only its original launch announcement matters. At general availability on December 2, 2025, Nova 2 Sonic was available in three Regions: US East (N. Virginia), US West (Oregon), and Asia Pacific (Tokyo) [1] [2]. By the May 2026 refresh, direct Bedrock access had expanded to add Europe (Stockholm), and Amazon Connect-specific access had separately expanded to Asia Pacific (Singapore), Europe (London), Asia Pacific (Seoul), and Europe (Frankfurt) [27]. If your application needs a Region not on that list, checking Amazon Connect's own regional footprint rather than assuming the model is unavailable to you is worth doing before ruling it out.

For telephony and framework integration, Nova 2 Sonic connects to Amazon Connect natively, to third-party telephony providers Vonage, Twilio, and AudioCodes, and to the open-source voice agent frameworks LiveKit and Pipecat [2]. That breadth matters practically. A team that has already standardized on LiveKit or Pipecat for a different voice provider can generally swap in Nova 2 Sonic as the underlying model without rebuilding the surrounding telephony and session-management infrastructure from scratch.

Calling Nova 2 Sonic Through the Bedrock Bidirectional Streaming API

Nova 2 Sonic does not use Bedrock's standard Converse or InvokeModel APIs. It uses InvokeModelWithBidirectionalStream, which opens a persistent, full-duplex connection and exchanges a specific sequence of JSON events for session setup, audio streaming, and teardown [4] [20]. AWS publishes a working reference implementation in its Nova samples GitHub repository, and the event sequence it follows is genuinely simple once you see it end to end: sessionStart, then promptStart (which declares audio output format, voice, and turn-taking sensitivity), then a contentStart/textInput/contentEnd sequence for the system prompt, then a contentStart/audioInput/contentEnd cycle repeated for every chunk of user audio, and finally promptEnd and sessionEnd to close out [20].

The example below is a trimmed, illustrative version of that official pattern, condensed to show the actual event flow rather than the full audio device handling. It is based directly on AWS's published sample code and real, documented event and field names. Treat the surrounding audio device plumbing as illustrative and consult the full sample in the AWS Nova samples repository before shipping it, since a real implementation also needs the 8-minute connection renewal pattern AWS documents separately.

python
/code
"""
Illustrative, condensed version of AWS's official Nova 2 Sonic bidirectional
streaming sample. Event and field names below (sessionStart, promptStart,
contentStart, textInput, audioInput, contentEnd, promptEnd, sessionEnd, and
turnDetectionConfiguration.endpointingSensitivity) match AWS's published
documentation and GitHub sample exactly. Audio device plumbing (PyAudio
capture/playback loops) is trimmed here for clarity - see the full,
production-ready version in aws-samples/amazon-nova-samples on GitHub,
including the required 8-minute session continuation pattern.
"""
import asyncio
import base64
import json
import uuid

from aws_sdk_bedrock_runtime.client import (
    BedrockRuntimeClient,
    InvokeModelWithBidirectionalStreamOperationInput,
)
from aws_sdk_bedrock_runtime.models import (
    InvokeModelWithBidirectionalStreamInputChunk,
    BidirectionalInputPayloadPart,
)
from aws_sdk_bedrock_runtime.config import Config, HTTPAuthSchemeResolver, SigV4AuthScheme
from smithy_aws_core.identity import EnvironmentCredentialsResolver

MODEL_ID = "amazon.nova-2-sonic-v1:0"
REGION = "us-east-1"


class NovaSonicSession:
    def __init__(self):
        self.prompt_name = str(uuid.uuid4())
        self.content_name = str(uuid.uuid4())
        self.audio_content_name = str(uuid.uuid4())
        self.stream = None

    def _client(self):
        config = Config(
            endpoint_uri=f"https://bedrock-runtime.{REGION}.amazonaws.com",
            region=REGION,
            aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
            auth_scheme_resolver=HTTPAuthSchemeResolver(),
            auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="bedrock")},
        )
        return BedrockRuntimeClient(config=config)

    async def send_event(self, event: dict):
        payload = json.dumps(event).encode("utf-8")
        chunk = InvokeModelWithBidirectionalStreamInputChunk(
            value=BidirectionalInputPayloadPart(bytes_=payload)
        )
        await self.stream.input_stream.send(chunk)

    async def start(self, system_prompt: str, sensitivity: str = "HIGH"):
        client = self._client()
        self.stream = await client.invoke_model_with_bidirectional_stream(
            InvokeModelWithBidirectionalStreamOperationInput(model_id=MODEL_ID)
        )

        await self.send_event({
            "event": {
                "sessionStart": {
                    "inferenceConfiguration": {"maxTokens": 1024, "topP": 0.9, "temperature": 0.7},
                    "turnDetectionConfiguration": {"endpointingSensitivity": sensitivity},
                }
            }
        })

        await self.send_event({
            "event": {
                "promptStart": {
                    "promptName": self.prompt_name,
                    "textOutputConfiguration": {"mediaType": "text/plain"},
                    "audioOutputConfiguration": {
                        "mediaType": "audio/lpcm",
                        "sampleRateHertz": 24000,
                        "sampleSizeBits": 16,
                        "channelCount": 1,
                        "voiceId": "matthew",
                        "encoding": "base64",
                        "audioType": "SPEECH",
                    },
                }
            }
        })

        # System prompt goes in as a TEXT content block before any audio.
        await self.send_event({"event": {"contentStart": {
            "promptName": self.prompt_name, "contentName": self.content_name,
            "type": "TEXT", "interactive": True, "role": "SYSTEM",
            "textInputConfiguration": {"mediaType": "text/plain"},
        }}})
        await self.send_event({"event": {"textInput": {
            "promptName": self.prompt_name, "contentName": self.content_name,
            "content": system_prompt,
        }}})
        await self.send_event({"event": {"contentEnd": {
            "promptName": self.prompt_name, "contentName": self.content_name,
        }}})

    async def send_audio_chunk(self, pcm16_bytes: bytes):
        blob = base64.b64encode(pcm16_bytes).decode("utf-8")
        await self.send_event({"event": {"audioInput": {
            "promptName": self.prompt_name, "contentName": self.audio_content_name,
            "content": blob,
        }}})

    async def close(self):
        await self.send_event({"event": {"promptEnd": {"promptName": self.prompt_name}}})
        await self.send_event({"event": {"sessionEnd": {}}})
        await self.stream.input_stream.close()


# Usage: session = NovaSonicSession(); await session.start(
#   "You are a friendly, concise voice assistant. Keep responses to two or "
#   "three sentences.")
# Then stream microphone audio via send_audio_chunk(), read model responses
# from session.stream (textOutput/audioOutput events), and call
# session.close() when the conversation ends.

One detail worth calling out explicitly because it trips people up: the endpointingSensitivity field inside turnDetectionConfiguration is the direct API surface for the configurable turn-taking sensitivity feature covered earlier. Setting it to HIGH is the right choice for a fast transactional IVR replacement. LOW is usually the better choice for a conversation where users legitimately pause mid-sentence to think, like a troubleshooting call, where an eager assistant that jumps in during a pause reads as rude rather than responsive.

Asynchronous Tool Calling and Agentic Voice Workflows

The tool-calling flow is where Nova 2 Sonic's asynchronous framing actually shows up as a concrete engineering difference rather than a marketing adjective. Tools are declared as JSON-schema toolSpec entries directly inside the promptStart event, the same event that configures audio output and turn-taking, using a toolChoice setting of auto where the model decides, any where at least one tool must be called, or a named tool that forces a specific tool [21].

json
/code
{
  "event": {
    "promptStart": {
      "promptName": "<prompt-id>",
      "textOutputConfiguration": { "mediaType": "text/plain" },
      "audioOutputConfiguration": {
        "mediaType": "audio/lpcm",
        "sampleRateHertz": 24000,
        "sampleSizeBits": 16,
        "channelCount": 1,
        "voiceId": "matthew",
        "encoding": "base64",
        "audioType": "SPEECH"
      },
      "toolUseOutputConfiguration": { "mediaType": "application/json" },
      "toolConfiguration": {
        "tools": [
          {
            "toolSpec": {
              "name": "check_order_status",
              "description": "Look up the current status of a customer order by order ID",
              "inputSchema": {
                "json": {
                  "type": "object",
                  "properties": {
                    "order_id": {
                      "type": "string",
                      "description": "The order confirmation number"
                    }
                  },
                  "required": ["order_id"]
                }
              }
            }
          }
        ],
        "toolChoice": { "auto": {} }
      }
    }
  }
}

When Nova 2 Sonic decides a tool is needed, it emits a toolUse event carrying a unique toolUseId, the tool name, and a JSON string of extracted parameters, with the event's role field set to TOOL [21]. Your application executes the real logic, an API call, a database lookup, a booking action, and sends the result back as a toolResult event. The asynchronous part is that the model does not have to freeze the audio stream waiting for that round trip. It can continue speaking a filler acknowledgment, keep listening for a user interruption, or move on to clarify a different part of the request, and only integrate the tool's actual result once it comes back.

AWS's own documentation is blunt about the one hard requirement this creates: Nova 2 Sonic expects a toolResult event after every toolUse event it sends, and if your application fails to respond, even when an error occurs, the model enters a waiting state that causes unresponsive behavior [21]. Always send a toolResult, even a deliberately generic error message, or the entire session can silently stall from the user's perspective.

A quick way to sanity-check that your AWS account and Region actually have model access configured before building against any of this:

bash
/code
# Verify Nova 2 Sonic model access before writing any streaming code.
# Confirms your account and region have the model enabled.
aws bedrock get-foundation-model \
  --model-identifier amazon.nova-2-sonic-v1:0 \
  --region us-east-1

# List which of your Bedrock model access requests are approved:
aws bedrock list-foundation-models \
  --region us-east-1 \
  --query "modelSummaries[?modelId=='amazon.nova-2-sonic-v1:0']"

Building a Production Voice Agent: The Loka Case Study

The gap between a working demo and a voice agent people actually trust is usually where the real engineering happens, and one of the more useful public accounts of that gap comes from Loka, an AWS partner that built a Nova 2 Sonic voice agent for an automotive dealership use case and published a detailed technical breakdown of the result [17].

Their production architecture used LiveKit as the transport layer, which abstracts away WebRTC for browser and app clients and SIP for actual phone calls, running as containerized LiveKit Agents on AWS Fargate with ECS. Amazon RDS handled persistent application data, ElastiCache handled ephemeral session state, and Langfuse, self-hosted on AWS, handled observability. For real phone calls, audio came in through a SIP trunk routed via a Network Load Balancer, which kept the raw media packet path separate from call-signaling logic [17].

Two operational numbers from that deployment are worth internalizing if you are estimating what a real system will feel like. First, Loka measured time-to-first-audio at 1.39 seconds, slower than the fastest cascaded systems and OpenAI's latest Realtime latency figures, but fast enough to support natural barge-in interruption, and consistent with the 87.0% Big Bench Audio score Amazon reports [17]. Second, and more instructive, Loka's own evaluation judge scores across five dimensions, response appropriateness, intent understanding, completeness, error recovery, and conversational naturalness, jumped from an average of 2.7 to 3.8 purely from prompt optimization work, with no model change at all. The specific change that helped most: restructuring the system prompt from numbered lists into bullet-pointed headings like "Tool Usage Rules" and "Error Recovery" measurably reduced instruction bleed and improved model focus [17].

That is a genuinely useful, non-obvious finding. For a model this capable, prompt structure is doing as much work as prompt content, and it is worth testing both independently rather than assuming a bad response means the model needs entirely different instructions rather than the same instructions organized differently. Loka also stress-tested the agent with adversarial personas, an angry customer, a busy parent, an elderly caller with unclear speech, and found that edge cases involving long, meandering user input scored measurably lower, around 3.0, than clean, direct requests, flagging exactly where future refinement should focus rather than treating the whole system as uniformly reliable [17].

Production Best Practices for Building on Nova 2 Sonic

A handful of practices are worth applying directly if you are building a real deployment rather than a prototype.

Match endpointingSensitivity to the conversation type instead of picking a single global default. Use high sensitivity for fast transactional flows and low sensitivity for anything where users think out loud or pause mid-sentence. Test both settings against real recorded calls from your actual use case before picking one, since the right answer genuinely differs by domain.

Never let a tool call go unanswered. Every toolUse event needs a corresponding toolResult, including a generic error payload when the underlying tool call fails, or the session can enter a silent stall state that a user experiences as the assistant simply going quiet mid-conversation [21].

Budget for the 8-minute connection limit from day one. Nova 2 Sonic's bidirectional streaming connections have a hard 8-minute ceiling, with a documented session-continuation pattern for renewing the connection mid-conversation without the user noticing a gap [3]. Building this in from the start is far easier than retrofitting it after a support call drops at the eight-minute mark in production.

Treat prompt structure as a real lever, not an afterthought. Loka's jump from a 2.7 to a 3.8 average judge score came entirely from reorganizing instructions into clearer bulleted sections, with zero model or architecture changes [17]. Iterate on prompt structure with the same rigor you would apply to a model or parameter change.

Separate media transport concerns from application logic early, the way Loka's SIP-trunk-through-Network-Load-Balancer pattern keeps raw audio packet handling distinct from call-signaling and business logic. Mixing those concerns tends to produce brittle systems that are hard to debug once call quality issues show up in production.

Validate tool parameters with strict JSON schemas rather than open-ended strings. AWS's own tool-configuration guidance recommends enums and structured types specifically because Nova 2 Sonic extracts tool parameters from spoken, sometimes ambiguous, user input, and a strict schema catches malformed extraction before it reaches your backend [21].

Check the release notes, not just the launch announcement, before reporting a fact as current. Nova 2 Sonic's region list, latency figures, and even hallucination rate have all measurably changed through in-place refreshes since general availability [27]. A fact that was accurate at launch can be stale within a few months for a model on this release cadence.

Common Mistakes to Avoid

Assuming Nova 2 Sonic works through the standard Converse or InvokeModel API is a common early mistake. It does not. It requires InvokeModelWithBidirectionalStream specifically, and code written against Bedrock's more common request-response APIs will not work against this model at all [4].

Comparing Big Bench Audio, BFCL, ComplexFuncBench, and IFBench scores as if they sit on the same difficulty scale is another. An 87% on Big Bench Audio and a 37.5% on IFBench are not directly comparable achievements. IFBench was deliberately built to be much harder and more resistant to overfitting than older instruction-following tests, so a lower raw score there does not mean weaker real-world instruction following than the higher Big Bench Audio number implies [15].

Treating asynchronous tool calling as optional to implement correctly causes real production failures. Skipping the toolResult response after an error, rather than sending an explicit error payload, leaves the model waiting indefinitely and produces exactly the kind of silent, unresponsive failure a voice agent cannot afford in front of a real user [21].

Assuming pricing and regional availability from the original December launch announcement are still current is an easy trap given how fast this space moves. Both have changed through documented refreshes. Always check the live Bedrock pricing page and the Nova 2 release notes rather than citing the general availability announcement as the current state of either [26] [27].

Picking a competing model based purely on a single Big Bench Audio ranking screenshot skips over the variables that actually decide a production outcome. Latency, pricing model, architecture philosophy, and language coverage all matter for a real deployment decision, and the model that wins on one axis, like Gemini's Thinking variant on raw Big Bench Audio score, is not automatically the right production choice once latency and cost enter the picture [18].

Assuming a single turn-taking sensitivity setting works for every part of an application is a subtler mistake that shows up later. A global endpointingSensitivity value tuned for a quick balance-check flow will feel abrupt and rude in a longer troubleshooting or intake conversation within the same product, and the reverse setting will feel sluggish in the quick flow.

Voice is also becoming a real creative and production input, not just a customer-service channel, and it is worth thinking about turn-taking and expressive delivery in that broader context too. Tools like Text2Shorts on Miraflow AI already put a voice-and-speed choice directly into a content pipeline, generating a script, scene visuals, and a spoken voiceover for a short video end to end, and the same underlying interest in natural-sounding, well-paced speech is what makes a model like Nova 2 Sonic worth understanding even if you never touch a Bedrock console yourself. The AI Music Generator on Miraflow AI leans on a related idea in its Custom Mode, where lyrics, tempo, and an AI reasoning toggle all shape how a vocal performance actually lands, the same kind of expressive-delivery problem that adaptive prosody in a conversational model like Nova 2 Sonic is solving for spoken dialogue specifically.

Frequently Asked Questions

Is Amazon Nova 2 Sonic a cascaded speech pipeline or a truly native speech-to-speech model? It is documented by Amazon as a unified model that handles speech understanding and generation together, rather than a pipeline of separate ASR, LLM, and TTS stages chained together. The exact internal mechanism is not fully disclosed publicly, but the architectural framing and the bidirectional streaming API design are both consistent with a native approach rather than a cascade.

How is Nova 2 Sonic different from the original Nova Sonic? The original, from April 2025, supported English only. Nova 2 Sonic adds Portuguese and Hindi for seven total languages, adds Polyglot voices that speak all of them fluidly, introduces configurable turn-taking sensitivity, cross-modal text-and-voice switching, asynchronous tool calling, and expands the context window to 1 million tokens.

What languages does Nova 2 Sonic support? English with US, UK, India, and Australia accents, French, Italian, German, Spanish, Portuguese, and Hindi, with automatic language detection and switching within a single session.

How much does Nova 2 Sonic cost to run? Text tokens are billed at $0.330 per million input tokens and $2.75 per million output tokens. Speech tokens are billed separately at $3 per million input tokens and $12 per million output tokens. Always check the current Amazon Bedrock pricing page, since these figures can change.

Which Regions is Nova 2 Sonic available in? At general availability it launched in US East (N. Virginia), US West (Oregon), and Asia Pacific (Tokyo). By May 2026, direct Bedrock access had expanded to include Europe (Stockholm), with additional Regions available specifically through Amazon Connect.

How does Nova 2 Sonic compare to OpenAI's GPT-Realtime and Google's Gemini 2.5 Flash Live on benchmarks? On Big Bench Audio, Nova 2 Sonic's 87.0 to 87.1% score beats GPT-Realtime's 83% and the standard Gemini 2.5 Flash Live native audio configuration's 71.0%, while trailing Gemini's separate, more compute-intensive Thinking variant. Amazon also reports winning human preference evaluations against both in most of its seven supported languages, though that specific claim comes from Amazon's own internal testing rather than an independent source.

Can Nova 2 Sonic call external tools and APIs during a live conversation? Yes, through asynchronous tool calling. Tools are declared with a JSON schema in the session setup, and the model can continue the conversation naturally while a tool call executes in the background, rather than freezing until the tool returns a result.

Is Nova 2 Sonic only useful for customer service bots? No. Its documented use cases span contact center automation, outbound marketing calls, in-app voice assistants, and interactive language learning, and the same real-time, low-latency, expressive-speech capabilities apply anywhere a product needs natural spoken interaction instead of a purely typed interface.

Conclusion

Amazon Nova 2 Sonic is a genuine architectural bet paying off, not just a version-number bump. The move from a cascaded ASR-LLM-TTS pipeline to a single model that reasons directly over audio removes a real source of latency and lost expressiveness, and Nova 2 Sonic's specific improvements, seven-language Polyglot voices, configurable turn-taking, asynchronous tool calling, and a 1 million token context window, all target the actual friction points that show up once a voice agent meets real users instead of a demo audience. The benchmark picture is honest rather than a clean sweep. Nova 2 Sonic leads GPT-Realtime and Gemini's standard native-audio configuration on Big Bench Audio while trailing Gemini's Thinking variant, and it wins clearly on price without claiming to be the single best model on every axis. For a developer actually building on this, the API details matter as much as the marketing claims. The bidirectional streaming event sequence, the strict requirement to answer every tool call, and the 8-minute connection limit are the specifics that determine whether a production deployment feels reliable or fragile. Understanding those mechanics, not just the headline benchmark numbers, is what actually decides whether Nova 2 Sonic is the right foundation for a real voice product.

References and Sources

[1] Amazon Web Services. "Introducing Amazon Nova 2 Sonic: Our new speech-to-speech model for conversational AI."

[2] AWS What's New. "Amazon Nova 2 Sonic: Real-time conversational AI."

[3] AWS Documentation. "Speech-to-Speech (Amazon Nova 2 Sonic): Key features."

[4] AWS Documentation. "Amazon Bedrock model card: Nova 2 Sonic."

[5] AWS What's New. "Amazon Nova Sonic: Human-like voice conversations on Bedrock."

[6] Amazon Science. "Amazon Nova 2: Multimodal Reasoning and Generation Models (technical report)."

[7] Artificial Analysis. "Amazon Nova Sonic 2.0 ranks #2 on the Big Bench Audio speech reasoning benchmark."

[8] Artificial Analysis via Hugging Face. "Evaluating Audio Reasoning with Big Bench Audio."

[9] Artificial Analysis. "Big Bench Audio dataset."

[10] UC Berkeley Sky Computing Lab. "Berkeley Function-Calling Leaderboard."

[11] Gorilla Project, UC Berkeley. "Berkeley Function Calling Leaderboard (BFCL) V4."

[12] Patil et al. "The Berkeley Function Calling Leaderboard (BFCL): From Tool Use to Agentic Evaluation of Large Language Models." ICML 2025 / PMLR.

[13] Zhong, Du, et al. "ComplexFuncBench: Exploring Multi-Step and Constrained Function Calling under Long-Context Scenario."

[14] THUDM / zai-org. "ComplexFuncBench GitHub repository."

[15] Allen Institute for AI. "IFBench: An instruction-following benchmark for generalization."

[16] Allen Institute for AI. "Why Artificial Analysis uses Ai2's IFBench instruction-following eval."

[17] AWS Machine Learning Blog. "How Loka Built a Natural, Low-Latency Voice Agent with Amazon Nova 2 Sonic."

[18] The Decoder. "Amazon's Nova 2 undercuts OpenAI and Google on price but still trails top-tier models."

[19] DeepLearning.AI, The Batch. "Amazon Steps Forward: Nova 2 family boosts cost-effective performance, adds new agentic features."

[20] AWS Documentation. "Getting started with speech-to-speech (Amazon Nova 2 Sonic)."

[21] AWS Documentation. "Tool configuration for Amazon Nova 2 Sonic."

[22] MarkTechPost. "OpenAI Releases GPT-Realtime-2.1 and GPT-Realtime-2.1-mini for Low-Latency Voice Agents in the API."

[23] Google Cloud Documentation. "Gemini 2.5 Flash with Gemini Live API."

[24] ElevenLabs. "ElevenLabs Conversational AI 2.0 voice agents now live."

[25] ElevenLabs. "Interaction models: Building natural human-AI dialogue."

[26] Amazon Web Services. "Amazon Bedrock Pricing."

[27] AWS Documentation. "Release notes for Amazon Nova 2 Sonic."