> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Conversation flow

## Overview

Conversation flow settings determine how your assistant handles periods of user silence, interruptions during speech, and turn-taking behavior. These settings help create more natural conversations and can be customized based on your use case.

Configure how long your assistant waits during periods of silence

Provide natural audio feedback when your agent needs time to think

Control whether users can interrupt your assistant while speaking

Adjust how quickly your assistant responds to user input

## Turn timeout

Turn timeout determines how long your assistant waits during periods of user silence before prompting for a response.

### Configuration

The timeout duration is specified in seconds and determines how long the assistant will wait in silence before prompting the user. Turn timeouts must be between 1 and 30 seconds.

Open your agent in the dashboard, navigate to the **Advanced** tab, and adjust the **Turn Timeout** value. Save your changes.

![Timeout settings](https://files.buildwithfern.com/https://elevenlabs.docs.buildwithfern.com/docs/b0b1941575dd4ff3c7b68f1370bd5419c0a0a1d26aa106b35264afb0a3df1329/assets/images/conversational-ai/timeouts.png)

```bash
elevenlabs agents pull --agent "<agent-name>"
```

Set `conversation_config.turn.turn_timeout`:

```json
{
  "conversation_config": {
    "turn": {
      "turn_timeout": 7
    }
  }
}
```

```bash
elevenlabs agents push --agent "<agent-name>"
```

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "turn": {"turn_timeout": 7},
    },
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    turn: { turnTimeout: 7 },
  },
});
```

Choose an appropriate timeout duration based on your use case. Shorter timeouts create more
responsive conversations but may interrupt users who need more time to respond, leading to a less
natural conversation.

### Best practices

* Set shorter timeouts (5-10 seconds) for casual conversations where quick back-and-forth is expected
* Use longer timeouts (10-30 seconds) when users may need more time to think or formulate complex responses
* Consider your user context - customer service may benefit from shorter timeouts while technical support may need longer ones

## Soft timeout

Soft timeout provides immediate audio feedback when the LLM takes longer than expected to generate a response. Instead of awkward silence while waiting, your agent speaks a brief filler phrase like "Hmm..." or "Let me think..." to maintain natural conversational flow.

This feature is useful for:

* Complex queries requiring longer LLM processing
* Handling variable latency from LLM providers
* Creating more human-like conversations with natural thinking pauses

### How it works

1. When the user finishes speaking, the system starts generating an LLM response
2. A timer begins based on the configured timeout duration
3. If the LLM response arrives **before** the timeout, no filler is spoken
4. If the timeout is reached **before** the LLM responds:
   * The configured filler message is spoken immediately
   * The agent continues waiting for the actual response
   * Once ready, the agent speaks the full LLM response

Soft timeout triggers only once per turn to prevent multiple fillers in succession.

### Configuration

Open your agent in the dashboard, navigate to the **Advanced** tab, and adjust the **Soft timeout** settings. Save your changes.

![Soft timeout settings](https://files.buildwithfern.com/https://elevenlabs.docs.buildwithfern.com/docs/7fdaca49ad50e6bc1f09f5eac46e36f0f4b071c5477e061a62791df9e100be75/assets/images/conversational-ai/soft-timeout.png)

```bash
elevenlabs agents pull --agent "<agent-name>"
```

Set `conversation_config.turn.soft_timeout_config`:

```json
{
  "conversation_config": {
    "turn": {
      "soft_timeout_config": {
        "timeout_seconds": 3.0,
        "message": "Hhmmmm...yeah.",
        "use_llm_generated_message": false
      }
    }
  }
}
```

```bash
elevenlabs agents push --agent "<agent-name>"
```

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "turn": {
            "soft_timeout_config": {
                "timeout_seconds": 3.0,
                "message": "Hhmmmm...yeah.",
                "use_llm_generated_message": False,
            },
        },
    },
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    turn: {
      softTimeoutConfig: {
        timeoutSeconds: 3.0,
        message: "Hhmmmm...yeah.",
        useLlmGeneratedMessage: false,
      },
    },
  },
});
```

#### Timeout duration

The time in seconds before the filler message is spoken while waiting for the LLM response.

| Setting         | Description            |
| --------------- | ---------------------- |
| **Default**     | `-1` (disabled)        |
| **Range**       | `0.5` to `8.0` seconds |
| **Recommended** | `3.0` seconds          |

Start with 3.0 seconds—long enough to avoid unnecessary fillers on fast responses, short enough to
prevent awkward silences.

#### Static message

A predefined filler phrase spoken when soft timeout triggers.

| Setting     | Description        |
| ----------- | ------------------ |
| **Default** | `"Hhmmmm...yeah."` |
| **Length**  | 1–200 characters   |

This message supports:

* **Language overrides**: Auto-translates to additional languages configured for your agent
* **Client overrides**: Can be customized per-call via the SDK

#### LLM-generated message

When enabled, generates a contextually-appropriate filler phrase dynamically using a lightweight LLM, instead of the static message.

| Setting      | Description                             |
| ------------ | --------------------------------------- |
| **Default**  | `false`                                 |
| **Fallback** | Uses static message if generation fails |

The system uses recent conversation context (up to 4 messages, 1000 characters) to generate relevant fillers like "Hmm...", "I see...", "Understood...", "Got it...", or "Alright..."

A static fallback message is still required when using LLM-generated messages.

### Best practices

* Avoid time indicators in filler messages (e.g., "One second...") as actual response times are unpredictable
* Disable soft timeout for quick FAQ bots where responses are consistently fast

## Interruptions

Interruption handling determines whether users can interrupt your assistant while it's speaking.

### Configuration

Interruption settings can be configured in the agent's **Advanced** tab under **Client Events**.

To enable interruptions, make sure interruption is a selected client event.

#### Interruptions enabled

![Interruption allowed](https://files.buildwithfern.com/https://elevenlabs.docs.buildwithfern.com/docs/1da794be8ea3bfed45d06241ce5db390480cd45d27c0f886943518bd52d76157/assets/images/conversational-ai/interruptions.png)

#### Interruptions disabled

![Interruption ignored](https://files.buildwithfern.com/https://elevenlabs.docs.buildwithfern.com/docs/847a2ebcdfff9498501502ab4b568fc498b6995f860a5552177a7883942197ff/assets/images/conversational-ai/no-interruption.png)

Disable interruptions when the complete delivery of information is crucial, such as legal
disclaimers or safety instructions.

### Best practices for interruptions

* Enable interruptions for natural conversational flows where back-and-forth dialogue is expected
* Disable interruptions when message completion is critical (e.g., terms and conditions, safety information)
* Consider your use case context - customer service may benefit from interruptions while information delivery may not

## Turn eagerness

Turn eagerness controls how quickly your assistant responds to user input during conversation. This setting determines how eager the assistant is to take turns and start speaking based on detected speech patterns.

### How it works

The assistant now includes two key improvements for more natural turn-taking:

1. **Faster response generation** - The assistant starts speaking after receiving enough words and a comma from the language model, rather than waiting for complete sentences. This reduces latency and creates more responsive conversations, especially when the assistant has longer responses.

2. **Configurable turn eagerness** - Control how quickly the assistant interprets pauses or speech patterns as opportunities to respond.

### Configuration

Three modes are available:

* **Eager** - The assistant responds quickly to user input, jumping in at the earliest opportunity. Best for fast-paced conversations where immediate responses are valued.
* **Normal** - Balanced turn-taking that works well for most conversational scenarios. The assistant waits for natural conversation breaks before responding.
* **Patient** - The assistant waits longer before taking its turn, giving users more time to complete their thoughts. Ideal for collecting detailed information or when users need time to formulate responses.

Open your agent in the dashboard, navigate to the **Agent** settings, and select the desired turn eagerness mode. Save your changes.

```bash
elevenlabs agents pull --agent "<agent-name>"
```

Set `conversation_config.turn.turn_eagerness` to one of `"patient"`, `"normal"`, or `"eager"`:

```json
{
  "conversation_config": {
    "turn": {
      "turn_eagerness": "normal"
    }
  }
}
```

```bash
elevenlabs agents push --agent "<agent-name>"
```

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "turn": {"turn_eagerness": "normal"},
    },
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    turn: { turnEagerness: "normal" },
  },
});
```

Turn eagerness is especially powerful when combined with workflows. You can dynamically adjust the
assistant's responsiveness based on context—making it jump in faster during casual conversation,
or wait longer when collecting sensitive information like phone numbers or email addresses.

### Best practices for turn eagerness

* Use **Eager** mode for customer service scenarios where quick responses improve user experience
* Use **Patient** mode when collecting structured information like phone numbers, addresses, or email addresses
* Use **Normal** mode as a default for general conversational flows
* Combine with workflows to dynamically adjust turn eagerness based on conversation context
* Test different settings with your specific use case to find the optimal balance

## Recommended configurations

* Shorter timeouts (5-10 seconds) for responsive interactions - Enable interruptions to allow
  customers to interject with questions - **Eager** turn eagerness for quick, responsive
  conversations

- Moderate timeouts (10-15 seconds) to allow users time to gather information - Enable
  interruptions for natural conversation flow - **Patient** turn eagerness when collecting phone
  numbers, addresses, or email addresses

* Longer timeouts (15-30 seconds) to allow for complex responses - Disable interruptions to
  ensure full delivery of legal information - **Normal** turn eagerness to maintain steady pacing

- Longer timeouts (10-30 seconds) to allow time to think and formulate responses - Enable
  interruptions to allow students to interject with questions - **Patient** turn eagerness to give
  students adequate time to respond