logo DuplexSLA
Native full-duplex foundation model

DuplexSLA A Full-Duplex Spoken Language Model with Synchronized Speech, Language, and Action

StepFun · NTU · PKU · SJTU · UNSW · ICL

A single 7B backbone that listens, speaks, plans and acts on the same 160 ms timeline. A dual-stream, three-channel formulation gives planning and tool calls their own time-stamped lane — so the assistant can think and dispatch side-effects while still speaking.

Turn-taking delay
0.30 s
Average; sub-second on all 4 scenarios
Backchannel accuracy
98.3%
vs <= 40% for closed-source baselines
Tool-call latency
0.64 s
About 4x faster than ASR + LLM cascade
DuplexSLA-Bench
2,100
Turn-taking + tool-call cases
Motivation

Why a third channel?

Most deployed speech agents glue together VAD → ASR → LLM → TTS. That stack has two structural failures in real conversations:

  • Energy-VAD can't read intent. Hesitations look like end-of-turn; bolting on a semantic VAD adds latency and still can't see the assistant's internal state.
  • Tool calls don't fit a turn loop. Pre-speech → adds delay. Post-speech → side-effect arrives a turn late. Mid-speech on the speech channel → breaks the audio.

DuplexSLA puts listen / speak / plan / act on one shared 160 ms clock inside a single backbone — turn-taking decisions and tool calls become token-level dynamics, not external rules.

Conventional cascade vs DuplexSLA
at one moment in a conversation
Cascade pipeline
VADenergy-based, no semantics
ASRstreaming transcript
LLMplan + tool call
TTSrender audio
Tool calls and turn-taking decisions live between modules → ≥1 s latency, no shared timeline.
DuplexSLA (single backbone)
User ch.continuous audio, 2×80 ms
Assistant ch.TA4: T + 4×40 ms audio
Action ch.≤10 text tokens / chunk
Clock160 ms chunks, shared
Planning, tool-calls and interrupt / backchannel / response labels are emitted on a dedicated, time-stamped lane in lockstep with assistant audio.
Architecture

Dual-stream, three-channel chunk format

Every 160 ms chunk carries causal user audio in, and the backbone autoregressively emits assistant audio (TA4) plus action text in a single decoding step.

User channel Assistant channel Action channel
DuplexSLA chunk-level architecture
Figure: chunk-level architecture. The same backbone consumes user audio + previous assistant audio + previous action text, and predicts the next chunk's TA4 audio and action text.
A walkthrough of 8 chunks
t = 0 → 1.28 s 160 ms per chunk
U (causal audio feat.) T / A (TA4) action text
Chunk c
c0 · 0–160
c1 · 160–320
c2 · 320–480
c3 · 480–640
c4 · 640–800
c5 · 800–960
c6 · 960–1120
c7 · 1120–1280
User
UU
"play…"
UU
"…some…"
UU
"…Beatles"
UU
silence
UU
UU
UU
UU
Assistant
(TA4)
TAAAA
"Sure,"
TAAAA
"playing"
TAAAA
"music"
TAAAA
"now."
<tts_pad>····
silence
<vad_silence>
listening
<vad_silence>
<vad_silence>
Action
(≤10 tok)
response
"User wants music"
<|toolcall_begin|>play_music(
"The Beatles")<|toolcall_end|>
·
·
·
·

Each chunk: 2× U (80 ms causal feats) in · T + 4× A assistant TA4 out · ≤10 action tokens out. The <|action_end|> marker terminates the action segment of every chunk — even empty ones — so the timeline stays strictly aligned to the 160 ms clock.

Per-chunk serialization
<|user_audio_begin|>   U  U   <|user_audio_end|>
<|assistant_audio_begin|> T A A A A <|assistant_audio_end|>
<action text>            ...        <|action_end|>
User audio is observed (causal front end). Assistant TA4 and action text are produced by the same backbone.
A chunk with a tool call
planning<|toolcall_begin|>{"function":"play_music",
                          "arguments":"The Beatles"}<|toolcall_end|>
Action-channel vocabulary
  • planning a short rationale fragment co-decoded with speech
  • labels response · interrupt · backchannel
  • tool call JSON inside <|toolcall_begin|> … <|toolcall_end|>
  • transcript delayed user / assistant transcript for time alignment
Real-time budget

After paying for the TA4 unit, a 7B backbone fits at most ~10 action tokens inside one 160 ms chunk on mainstream accelerators. Overflow tokens spill into the next chunk via a FIFO queue — never breaking an open tool-call block.

System-level summary

Runtime and channel configuration

condensed from Table 1
Backbone scale
7B speech-LM, initialized from Step-Audio 2 mini
Streaming clock
160 ms conversational chunks
User audio granularity
2 causal acoustic features per chunk (80 ms each)
Assistant audio granularity
4 discrete audio tokens per chunk (40 ms each)
Per-chunk speech layout
TA4: one text anchor + four audio tokens
Action channel content
Delayed transcript · planning text · turn-taking labels · tool calls
Per-chunk action budget
≤ 10 tokens; overflow spills into next chunks (FIFO)
Tool-call schema
50 cabin / smart-home functions + 3 interaction labels
Native duplex behaviours
Pause · interrupt · backchannel; no external semantic VAD
Online tool calling
Backchannel-triggered · single-action · multi-action
Two highlight capabilities

What the action channel unlocks

Because turn-taking labels and tool calls share a backbone with assistant speech, both are derived from the same internal semantic state that drives the response.

Capability 1

Semantic-driven turn-taking

No external semantic VAD. The action channel emits the right control label at the right chunk, while the assistant TA4 switches state accordingly.

  • pause User holds their thought

    Action stays at response-style continue-listening; assistant TA4 emits silence anchors.

  • interrupt User starts a new thought

    interrupt on action ch.; assistant TA4 switches to silence within a few chunks.

  • backchannel User says "mm-hmm" / "yes"

    backchannel on action ch.; assistant keeps speaking — current plan not reset.

Backchannel vs Interrupt
Figure: (a) backchannel keeps the assistant talking. (b) a real interruption yields the floor within a small chunk-level latency.
Capability 2

In-conversation planning & tool calling

Planning text and structured tool calls are emitted on the action channel without halting assistant audio. Each call is anchored to a chunk, so every action gets an unambiguous timestamp.

Backchannel-triggered tool calling

A topically-unrelated short utterance ("play some Beatles songs") fires a tool call while the assistant's spoken thread continues coherently.

Multi-action tool calling

One user turn → multiple tool calls (raise AC, play music, navigate) emitted in semantic order along the user's request, in parallel with assistant audio.

# chunk c — Maintaining tool-call integrity across chunks
planning_1
<|toolcall_begin|>{"function":"set_ac_temperature",
                  "arguments":{"value":22}}<|toolcall_end|>
planning_2
<|toolcall_begin|>{"function":"play_music",
                  "arguments":"The Beatles"}<|toolcall_end|>
<|action_end|>
Tool calling patterns
Figure: (a) backchannel-triggered tool call without interrupting assistant audio. (b) one user turn → three time-aligned tool calls (AC · music · navigation).
Live demos
Backchannel-triggered tool calling
Multi-action tool calling
Data & Training

Two stages, one unified serialization

CPT teaches the chunked, three-channel serialization on ~500 k hours; a smaller post-training stage (~50 k hours) sharpens the timing-critical behaviours.

Data construction pipeline
Figure: (a) LLM annotates each dialogue with tool-call objects (function · arguments · planning · semantic offset). (b) TTS + voice cloning + force-alignment merge tracks at the 160 ms chunk grid.
Stage 1 · Continued pretraining
~500 k hours + 1.92 M text samples

Internalize the format

  • Duplex dialogue~320 k h
  • User-channel ASR~90 k h
  • Assistant-channel ASR~90 k h
  • Text (preserve world knowledge)~1.92 M samples

Dual-side ASR is the trick that ties assistant audio to action time: forcing the action channel to emit the assistant transcript at the chunk each character is spoken stabilizes the model's internal clock.

Stage 2 · Capability-oriented post-training
~50 k hours

Sharpen the timing

  • Interrupt + backchannel + pause~36 k h
  • Tool-call (BC / single / multi)~14 k h

A small but highly-informative slice. Same decoder interface as CPT — only the supervision target shifts toward timing-sensitive, action-emitting behaviours.

Audio-data distribution
CPT (left) vs Post-training (right)
CPT — ~500 k h audio
Post-training — ~50 k h
Evaluation

DuplexSLA-Bench · 2,100 cases

1,200 turn-taking cases (300 each: normal, pause, interrupt, backchannel) + a 900-case tool-call subset (300 each: single-action, multi-action, backchannel-action).

Tool-call delay (lower is better)
~4× lower than ASR + LLM cascade on average
4× faster
Tool-call accuracy
Competitive with the cascade across all 3 patterns
Full-duplex turn-taking — context-prefill setting
Highest accuracy and lowest delay in every scenario.
all four scenarios
Model normal pause interrupt backchannel
Acc (%)Delay (s) Acc (%)Delay (s) Acc (%)Delay (s) Acc (%)Delay (s)
DuplexSLA 96.000.27 93.330.27 99.330.40 98.330.32
gemini-3.1-flash-live 93.671.18 94.331.17 63.670.62 40.00N/A
gpt-realtime-1.5 (semantic-vad-high) 91.331.67 90.331.68 79.000.68 0.33N/A
gpt-realtime-1.5 (server-vad-40ms) 82.330.95 71.001.02 77.000.72 13.00N/A
Closed-source baselines expose no backchannel label → backchannel delay is N/A.
No-context-prefill setting
Only sub-second system with competitive accuracy.
sub-second
Model Avg (2 scen.) normal pause
Acc (%)Delay (s) Acc (%)Delay (s) Acc (%)Delay (s)
DuplexSLA94.340.3095.670.2993.000.31
Freeze-Omni10.670.3610.330.4011.000.33
PersonaPlex22.340.4722.670.3822.000.55
MiniCPM-o82.000.6183.330.6280.670.59
gemini-3.1-flash-live93.171.1793.671.1693.671.18
gpt-realtime-1.5 (semantic-vad-high)96.501.5796.701.5796.301.57
gpt-realtime-1.5 (server-vad-40ms)85.500.8391.300.8379.700.83
Tool-call accuracy & delay
900 cases · 3 patterns
action channel
Model Avg (3 patterns) Single action Multi actions Backchannel action
Acc (%)Delay (s) Acc (%)Delay (s) Acc (%)Delay (s) Acc (%)Delay (s)
ASR + LLM cascade91.332.7789.332.3389.334.7195.331.27
DuplexSLA85.560.6485.670.6775.000.6896.000.57
Take-aways

One backbone · one clock · two breakthroughs

1

Sub-second turn taking on all 4 scenarios

Normal handover, pause, interrupt, and backchannel all become token-level dynamics — not external VAD rules.

2

~4× lower tool-call latency

The action channel emits planning + JSON tool calls without waiting for a turn boundary or breaking assistant speech.

3

Only system that handles backchannel

98.33% backchannel accuracy vs ≤ 40% for closed-source baselines that expose no such label.

The third channel is the design choice that matters.

A dedicated, chunk-synchronised text lane for planning + tool calls gives every action an unambiguous timestamp, keeps the assistant audio smooth, and is cheap enough (≤10 tokens/chunk) to fit inside a 160 ms real-time budget on mainstream accelerators. The same backbone learns what to do and when to do it from the same supervision target.