Shizuku-Duplex: Japanese Full-Duplex Voice With 80 ms Ticks and Async Tools

Shizuku AI Labs shipped Shizuku-Duplex on November 8, 2026: a full-duplex Japanese voice model that processes audio every 80 ms, keeps listening while it speaks, and runs web search through a background LLM without putting the caller on hold. The lab says it is the first Japanese duplex model with intelligent dialogue besides OpenAI’s GPT-Live, according to its official announcement.

For builders, the release is a worked example of three ideas that keep showing up in 2026 voice agents: turn-taking physics (backchannels and barge-in), hard real-time budgets (sub-100 ms ticks), and split brains (fast speech loop plus slow tool loop). explainx.ai already tracks the category in posts on GPT-Live in ChatGPT, GPT-Live-1 in the API, and Block’s Dessa speech-only duplex work. Shizuku’s angle is Japanese companions, not enterprise assistants.

TL;DR

Cascaded vs full-duplex: why the architecture change matters

Most production voice stacks still chain ASR → text LLM → TTS. The user finishes a sentence, the pipeline detects end-of-turn, then each stage runs in series. That design is easy to debug and works with any text model, but it struggles with backchannels (mm-hmm while the user talks), preemptive replies, and barge-in without awkward cutoffs.

Full-duplex models treat speech as a continuous stream. Shizuku-Duplex aligns to the human clock: one tick = 80 ms. On each tick it ingests user audio features and may emit audio tokens, text (an “inner monologue” slightly ahead of speech), and Live2D motion actions. Because listening never stops, the model can decide when to start or stop talking without waiting for a silence detector.

Shizuku’s post contrasts that with GPT-Realtime and Gemini Live, which their evaluation treats as non-duplex APIs that largely wait for end-of-speech. In Shizuku’s table, those services go quiet on short user backchannels and take longer to reply once the user stops. Round-trip network latency is included for those APIs but excluded for server-recorded GPT-Live and Shizuku-Duplex, which matters when you compare the 0.57 s and 0.53 s medians.

How Shizuku-Duplex works under the hood

80 ms ticks and inner monologue

The interaction core is an LLM-based Transformer. User speech passes through a streaming audio encoder into continuous features; those features mix with the previous tick’s text and audio tokens. Outputs are audio tokens (decoded to waveform), text (planned speech), and action (character motion).

Shizuku AI highlights TensorRT and Triton kernel optimizations to keep each tick under 80 ms. That is the same class of constraint called out in latency-focused releases like AssemblyAI-TTS-1’s 90 ms first-audio pitch, but duplex adds the harder requirement that every tick pays inference, not only the first packet after silence.

Interaction model plus background model

A microphone sends a green sound wave toward a speaker in a simple voice-AI diagram

Heavy tools do not fit inside 80 ms. Shizuku-Duplex therefore runs two models:

1. Interaction model — maintains the live duplex loop.
2. Background model — runs search and harder reasoning on a tool harness.

When the interaction model needs help, it outputs a DELEGATE token. The background job can take multiple seconds (their Kyoto travel example cites ~7.1 s for web search), but the interaction model keeps talking and later paraphrases results. The post credits prior art from KAME and Thinking Machines Lab’s Interaction Models blog, and claims Shizuku-Duplex is the first Japanese duplex model with tool calling besides GPT-Live.

That pattern is the practical answer to a question voice teams keep asking in 2026: how to combine MCP-style tools with speech latency. Text agents can hide multi-second tool calls behind streaming tokens; duplex speech cannot freeze without breaking the illusion of presence.

Compaction for long sessions

Shizuku cites recent papers on long-session degradation in duplex models. Their mitigation summarizes roughly every five minutes and rebuilds context, aiming to complete the swap inside a single tick so listeners do not hear a gap. Anyone shipping companions should treat long-call memory as a first-class eval, not an afterthought.

Benchmarks: what Shizuku AI measured

Public Japanese duplex benchmarks are thin. Shizuku built a Japanese Full-Duplex-Bench-style suite from English Full-Duplex-Bench and M3-DuplexBench scenarios, then checked English parity against OpenAI’s published GPT-Live scores.

Compared models:

• Full-duplex: Shizuku-Duplex, GPT-Live-1, J-Moshi-ext, LLM-jp-Moshi-v1
• Non-duplex reference: GPT-Realtime-2.1, Gemini 3.8 Live

Audio was transcribed with Haas-ja-v1.0; Claude Opus 5.5 judged answer quality. That judge choice means content scores are model-mediated, not human panel scores. Use them to compare within the blog’s table, not as absolute truth.

Headline outcomes from the official table:

• Turn-taking: Shizuku-Duplex leads five of six duplex metrics (e.g., keeps talking through user backchannels far more often than J-Moshi).
• Latency after turn end: 0.57 s median vs 0.53 s for GPT-Live (server-side).
• QA: Multi-turn accuracy 79% vs GPT-Live 95%; web lookup 43% vs 50%.
• Chit-chat naturalness: 6.2 vs GPT-Live 7.6 on their 1–10 scale.

Non-duplex APIs score well on some content rows but fail turn-taking behaviors duplex targets. That matches the product split: assistant accuracy vs social presence.

Product direction: companion, not copilot

Shizuku AI frames GPT-Live as a tool assistant and Shizuku as a daily companion with empathy and character motion. The demos on the blog are persona calls with backchannels, barge-in, and search-while-talking. Roadmap items named in the post include vision input and more languages.

Builders evaluating stacks should decide which axis they optimize:

• Task completion — non-duplex or cascaded pipelines plus strong text models may be enough.
• Social telephony — duplex plus motion and compaction matter.

For a wider market map, see Mistral’s Voxtral voice agent SDK and Hume’s audio judgment API for adjacent layers (modular EU hosting vs meta-judgments on audio).

What builders can try today

The November 8 post does not document a public Hugging Face repo or API key flow. Practical steps until access appears:

1. Read the architecture figures on shizuku.ai/en/blog/1/ and map them to your stack (tick budget, delegate channel, summarizer).
2. Prototype delegate-and-continue in a cascaded stack: keep a lightweight TTS loop running while a side task executes, even before true duplex.
3. Reproduce turn-taking evals using Full-Duplex-Bench scenarios for English before localizing.
4. Compare latency budgets against GPT-Live-1 API guidance if you ship bilingual products.

What builders ask after a duplex launch

Three questions show up in every full-duplex thread, including debates around Block’s Dessa and OpenAI’s Live API pricing:

Do I need true duplex or just low-latency cascade? Cascaded stacks win when your UX is command-and-response (set a timer, file an expense). Duplex wins when social presence matters: companions, coaching calls, language practice with interruptions, or VTubers that react while the user talks. Shizuku’s product story is explicitly companion-first, not copilot-first.

How do I budget GPU for 80 ms forever? Unlike text streaming, duplex inference is always on. Shizuku’s TensorRT and Triton note is the minimum bar; teams also need a story for idle ticks when the user is silent but the model must still listen. Compaction every five minutes adds another always-on summarizer. Size capacity plans from concurrent minutes, not tokens per request.

Can I copy the delegate pattern without duplex? Yes. Many teams run a fast conversational loop plus a slow worker today using partial transcripts. Shizuku’s DELEGATE token is a clean spec for that split. The background model in their Kyoto demo keeps chatting about matcha sweets while search runs ~7 seconds. That is the same user promise as DeepSeek’s router and worker split, but at speech cadence.

How Shizuku-Duplex fits the 2026 voice stack map

Japanese open duplex predecessors J-Moshi and LLM-jp-Moshi appear in Shizuku’s tables with weak multi-turn QA in the author eval. That gap is why the lab argues intelligent Japanese dialogue was still open before Shizuku-Duplex. English teams should not assume Japanese scores transfer; localize benchmarks or license Japanese judges.

Training and eval transparency

Shizuku trained on Japanese text and audio datasets but does not publish dataset cards on the November 8 page. Evaluations mix turn-taking metrics from adapted Full-Duplex-Bench scenarios with chit-chat and QA tasks. They validated their English methodology against OpenAI’s published GPT-Live numbers before trusting the Japanese suite.

The Claude Opus 5.5 judge choice matters: content scores are LLM-graded, which can favor models correlated with Anthropic’s stack. Independent human listening tests would strengthen claims. For fraud and safety, duplex presence also raises deepfake voice concerns explainx.ai covered in video-call deepfake fraud; companion products need consent and disclosure, not only WER tables.

Limits and verification gaps

• Benchmarks are author-run with an LLM judge; independent replication is not published yet.
• Weights and hosting are not part of the announcement.
• Japanese-only training is explicit; other languages are roadmap.
• Competitor API versions (GPT-Realtime-2.1, Gemini 3.8 Live) may change defaults after November 2026.

Related reading

• GPT-Live: OpenAI’s duplex ChatGPT voice
• GPT-Live-1 in the developer API
• Block’s Dessa: speech-only duplex on a MacBook
• AssemblyAI-TTS-1 latency and pricing
• DeepSeek Super Agent architecture for async workers

Specs, API names, and competitor versions reflect Shizuku AI’s November 8, 2026 post and may change without notice.