LiveKit docs › Logic & Structure › Turn detection & interruptions › Adaptive interruption handling

---

# Adaptive interruption handling

> Distinguish between true interruptions and conversational backchanneling.

> ℹ️ **Available for agents deployed to LiveKit Cloud**
> 
> Adaptive interruption handling is available for agents deployed to LiveKit Cloud. For details, see [quota and limits](#quota-and-limits).

## Overview

Adaptive interruption handling allows an agent to respond naturally when users speak mid-response. Instead of relying on fixed timing or volume thresholds, the model analyzes the acoustic signals to identify intentional interruptions (barge-ins) from conversational backchanneling.

Backchanneling includes short listener cues such as "uh-huh," "okay," or "right" that indicate attention but don't require a response. By filtering these out, the agent avoids unnecessary turn switches caused by brief acknowledgments, incidental sounds, or background noise. The result is smoother, more natural interactions.

> ℹ️ **Agents SDK version**
> 
> Adaptive interruption handling requires the latest Agents SDK versions:
> 
> - Python SDK v1.5.0 or greater
> - Node.js SDK v1.2.0 or greater

[Video: Adaptive interruption handling demo](https://www.youtube.com/watch?v=DSXCE7D4Kvs)

## How it works

The adaptive interruption (barge-in) model is trained on real conversational audio to distinguish true interruption attempts from non-interruptive speech. It operates after voice activity detection (VAD) identifies incoming user audio.

Instead of immediately stopping the agent whenever speech is detected, the model analyzes the audio to determine whether the agent should actually yield the turn. Because the decision is based on acoustic signals rather than waiting for a transcript, the model can respond faster and reduce unnecessary interruptions.

> ℹ️ **Language support**
> 
> The adaptive interruption model is meant to be used with any spoken language. It might perform better with English in some cases, but in most cases it works with any language.

![Diagram of adaptive interruption handling model architecture.](/images/agents/adaptive-interruption-diagram.png)

## How to use

Adaptive interruption handling is available in LiveKit Cloud and is enabled by default if the following conditions are met:

- Agent is [deployed to LiveKit Cloud](https://docs.livekit.io/agents/deploy.md) or running in dev mode.
- VAD is enabled.
- LLM is not a realtime model.
- STT model supports [aligned transcripts](#aligned-transcripts).

Otherwise, the default behavior is to rely on VAD for interruption detection.

> ℹ️ **Availability and usage limitations**
> 
> Adaptive interruption handling is available for unlimited usage to agents deployed to LiveKit Cloud. It's also available for local development with usage limitations.

You can also explicitly set the interruption `mode` to `"adaptive"` in the turn handling options:

**Python**:

```python
session = AgentSession(
    # ... stt, llm, tts, vad
    turn_handling=TurnHandlingOptions(
        turn_detection=MultilingualModel(),
        interruption={
            "mode": "adaptive",
        },
    ),
)

```

---

**Node.js**:

```typescript
const session = new voice.AgentSession({
  // ... stt, llm, tts, vad
  turnHandling: {
    turnDetection: new livekit.turnDetector.MultilingualModel(),
    interruption: {
      mode: 'adaptive',
    },
  },
});

```

## Audio samples

Compare the following audio samples to see how the agent responds to interruptions and non-interruptions with and without adaptive interruption handling.

### Using adaptive interruption handling

The following samples have adaptive interruption handling enabled and demonstrate how the agent ignores the speaker's brief acknowledgments signaling attention, but responds to genuine interruptions (barge-ins).

**Audio comparison** (audio-only, not available in text):

- Backchannel (non-interruption)
- Genuine interruption (barge-in)

### Without adaptive interruption handling

This sample uses VAD-only detection. Without adaptive interruption handling, the agent is interrupted by the speaker's brief acknowledgment of the agent's response.

**Audio comparison** (audio-only, not available in text):

- VAD-only detection

## Performance

The adaptive interruption model analyzes streaming audio chunks during overlapping speech to determine whether a detected speech segment is a true interruption.

The model runs on LiveKit Cloud's global inference infrastructure and adds minimal latency to the interruption pipeline. When agents are deployed to LiveKit Cloud, they run in the same data centers as the inference service, further reducing end-to-end latency.

## Turn boundary cooldown

Available in:
- [ ] Node.js
- [x] Python

At the beginning or end of an agent's turn, the adaptive model can mistake a real interruption for a backchannel. The following are two common cases:

- Immediately after the agent starts speaking, a user correction or change of mind might be incorrectly filtered out as a backchannel.
- Just before the agent stops speaking, a short answer to its final question might be incorrectly discarded as overlap if the STT transcript arrives too late.

The `backchannel_boundary` option defines a cooldown window around each agent turn to handle both cases. The default start and end cooldown values are `(1.0, 3.5)`:

- Start cooldown of `1.0` seconds: adaptive detection is suppressed for the first second after the agent starts speaking. VAD-based interruption is used instead during this window, so true barge-ins still pass through.
- End cooldown of `3.5` seconds: late STT transcripts whose timestamps fall within the last 3.5 seconds of agent speech are included as a real user turn instead of being discarded as overlap.

The end value is larger than the start value because STT transcript timestamps aren't precise. Pass a single `float` to use the same value for both sides, or `None` to disable the cooldown entirely.

The following example tunes both sides of the boundary. Pass it to the `turn_handling` parameter of `AgentSession`:

```python
turn_handling = {
    "interruption": {"backchannel_boundary": (0.5, 2.0)},
}

```

For the full parameter reference, see [`backchannel_boundary`](https://docs.livekit.io/reference/agents/turn-handling-options.md#interruptionoptions-parameters).

## Quota and limits

Adaptive interruption handling is included at no extra cost for all agents deployed to LiveKit Cloud.

For local development and testing, every plan includes 40,000 free inference requests per month.

## Aligned transcripts support

An aligned transcript includes timing information that allows you to synchronize the transcript with the audio. Each word or chunk of speech is assigned a start and end timestamp. Support for aligned transcripts is required for [adaptive interruption handling](https://docs.livekit.io/agents/logic/turns/adaptive-interruption-handling.md). All STT models provided by [LiveKit Inference](https://docs.livekit.io/agents/models.md#inference) support aligned transcripts.

For plugins, you can determine if the model supports aligned transcripts by checking the `capabilities.aligned_transcript` property:

**Python**:

```python
if stt.capabilities.aligned_transcript:
    print("This STT model supports aligned transcripts.")

```

---

**Node.js**:

```typescript
if (stt.capabilities.alignedTranscript) {
    console.log("This STT model supports aligned transcripts.");
}

```

## Metrics and usage

When adaptive interruption handling is enabled, an agent session collects interruption metrics for each barge-in detection, including per-event latency, and the number of requests and interruptions. `InterruptionMetrics` events are available through per-plugin metrics listeners. See the [metrics reference](https://docs.livekit.io/deploy/observability/data.md#metrics-reference) for the full list of fields.

Interruption model usage, including total requests per provider and model, is available in `session.usage`. See [Session usage](https://docs.livekit.io/deploy/observability/data.md#session-usage) for details.

To learn more, see [Metrics and usage](https://docs.livekit.io/deploy/observability/data.md#metrics).

## Turn off adaptive interruption handling

To use VAD-only interruption detection instead of adaptive handling, set the interruption `mode` to `"vad"` in the turn handling options:

**Python**:

```python
turn_handling = {
    "interruption": {
        "mode": "vad",
    },
}

```

---

**Node.js**:

```typescript
const turnHandling = {
  interruption: {
    mode: 'vad',
  },
};

```

To disable interruption handling entirely, set `enabled` to `false` in the [interruption options](https://docs.livekit.io/reference/agents/turn-handling-options.md#interruptionoptions). This means the agent cannot be interrupted by user speech.

---

This document was rendered at 2026-06-07T11:36:30.311Z.
For the latest version of this document, see [https://docs.livekit.io/agents/logic/turns/adaptive-interruption-handling.md](https://docs.livekit.io/agents/logic/turns/adaptive-interruption-handling.md).

To explore all LiveKit documentation, see [llms.txt](https://docs.livekit.io/llms.txt).