> 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.

# Fluxo da conversa

## Visão geral

As configurações de fluxo da conversa determinam como seu assistente lida com períodos de silêncio do usuário, interrupções durante a fala e o comportamento de alternância de turnos. Essas configurações ajudam a criar conversas mais naturais e podem ser personalizadas de acordo com seu caso de uso.

#### [Duração máxima da conversa](#maximum-conversation-duration)

Limite a duração total de cada conversa

#### [Assumir o turno após o silêncio](#turn-timeout)

Configure por quanto tempo seu assistente espera durante períodos de silêncio

#### [Timeout suave](#soft-timeout)

Ofereça feedback de áudio natural quando seu agente precisar de tempo para pensar

#### [Interrupções](#interruptions)

Controle se os usuários podem interromper seu assistente enquanto ele fala

#### [Agilidade de turno](#turn-eagerness)

Ajuste a rapidez com que seu assistente responde à entrada do usuário

## Duração máxima da conversa

A configuração **Duração máxima da conversa** limita o tempo total em que uma conversa pode permanecer ativa.
Esse limite global começa quando a conversa é iniciada e é aplicado independentemente dos timeouts
por turno. O padrão é 600 segundos (10 minutos). Você pode definir um valor de 60 a 7.200 segundos.

### Configuração

Na CLI e na API, configure essa opção com o campo
`conversation_config.conversation.max_duration_seconds`.

#### Atualizar pelo painel

Abra seu agente no painel, acesse a aba **Avançado** e ajuste a **Duração máxima da
conversa** em \*\*Limites de chamada \*\*. Salve suas alterações.

#### Atualizar pela CLI

#### Baixar a configuração do agente

```bash
elevenlabs agents pull --agent agent_7101k5zvyjhmfg983brhmhkd98n6
```

#### Editar a configuração do agente

Defina `conversation_config.conversation.max_duration_seconds`:

```json
{
  "conversation_config": {
    "conversation": {
      "max_duration_seconds": 1200
    }
  }
}
```

#### Enviar a configuração do agente

```bash
elevenlabs agents push --agent agent_7101k5zvyjhmfg983brhmhkd98n6
```

#### Atualizar pela API

```python
from elevenlabs import ElevenLabs

elevenlabs = ElevenLabs()

elevenlabs.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    conversation_config={
        "conversation": {"max_duration_seconds": 1200},
    },
)
```

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

const elevenlabs = new ElevenLabsClient();

await elevenlabs.conversationalAi.agents.update("agent_7101k5zvyjhmfg983brhmhkd98n6", {
  conversationConfig: {
    conversation: { maxDurationSeconds: 1200 },
  },
});
```

> **Warning**
>
> Conversas por mensagem no WhatsApp têm um timeout padrão de inatividade de 15 minutos, medido a partir da
> resposta mais recente do agente. Esse timeout pode encerrar uma conversa por mensagem antes da duração
> máxima configurada. Clientes Enterprise cujo caso de uso exija um timeout diferente devem entrar em contato
> com o suporte em [support@elevenlabs.io](mailto:support@elevenlabs.io).

## Assumir o turno após o silêncio

A configuração **Assumir o turno após o silêncio** determina por quanto tempo seu assistente espera durante períodos de silêncio do usuário antes de assumir o próximo turno e solicitar uma resposta.

### Configuração

O valor é especificado em segundos e deve estar entre 1 e 30 segundos. Na CLI e na API, configure essa opção com o campo `conversation_config.turn.turn_timeout`.

#### Atualizar pelo painel

Abra seu agente no painel, acesse a aba **Avançado** e ajuste o valor de **Assumir o turno após o silêncio**. Salve suas alterações.

![Configuração de assumir o turno após o silêncio](/docs/_fern-img/9de7653a0940ae3441b3470c2af53f4a72294ad3680946d4c3fa3b91df69c566.webp)

#### Atualizar pela CLI

#### Baixar a configuração do agente

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

#### Editar \`agent_configs/\<agent-name>.json\`

Defina `conversation_config.turn.turn_timeout`:

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

#### Enviar suas alterações

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

#### Atualizar pela API

```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 },
  },
});
```

> **Note**
>
> Escolha uma duração de timeout adequada ao seu caso de uso. Timeouts mais curtos criam conversas mais
> responsivas, mas podem interromper usuários que precisam de mais tempo para responder, resultando em uma
> conversa menos natural.

### Boas práticas

* Defina timeouts mais curtos (5 a 10 segundos) para conversas informais, nas quais se espera uma troca rápida
* Use timeouts mais longos (10 a 30 segundos) quando os usuários puderem precisar de mais tempo para pensar ou formular respostas complexas
* Considere o contexto do usuário: o atendimento ao cliente pode se beneficiar de timeouts mais curtos, enquanto o suporte técnico pode precisar de timeouts mais longos

## Timeout suave

O timeout suave fornece feedback de áudio imediato quando o LLM demora mais do que o esperado para gerar uma resposta. Em vez de um silêncio constrangedor durante a espera, seu agente diz uma breve frase de preenchimento, como "Hmm..." ou "Deixe-me pensar...", para manter o fluxo natural da conversa.

Este recurso é útil para:

* Consultas complexas que exigem processamento mais longo pelo LLM
* Lidar com latência variável de provedores de LLM
* Criar conversas mais humanas com pausas naturais para pensar

### Como funciona

1. Quando o usuário termina de falar, o sistema começa a gerar uma resposta do LLM
2. Um temporizador é iniciado com base na duração de timeout configurada
3. Se a resposta do LLM chegar **antes** do timeout, nenhuma frase de preenchimento será dita
4. Se o timeout for atingido **antes** de o LLM responder:
   * A mensagem de preenchimento configurada é dita imediatamente
   * O agente continua aguardando a resposta real
   * Quando estiver pronta, o agente diz a resposta completa do LLM

O timeout suave é acionado apenas uma vez por turno para evitar várias frases de preenchimento em sequência.

### Configuração

#### Atualizar pelo painel

Abra seu agente no painel, acesse a aba **Avançado** e ajuste as configurações de **Timeout suave**. Salve suas alterações.

![Configurações de timeout suave](/docs/_fern-img/7fdaca49ad50e6bc1f09f5eac46e36f0f4b071c5477e061a62791df9e100be75.webp)

#### Atualizar pela CLI

#### Baixar a configuração do agente

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

#### Editar \`agent_configs/\<agent-name>.json\`

Defina `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
      }
    }
  }
}
```

#### Enviar suas alterações

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

#### Atualizar pela API

```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,
      },
    },
  },
});
```

#### Duração do timeout

O tempo em segundos antes de a mensagem de preenchimento ser dita enquanto se aguarda a resposta do LLM.

| Configuração    | Descrição              |
| --------------- | ---------------------- |
| **Padrão**      | `-1` (desativado)      |
| **Intervalo**   | `0.5` a `8.0` segundos |
| **Recomendado** | `3.0` segundos         |

> **Tip**
>
> Comece com 3.0 segundos — tempo suficiente para evitar preenchimentos desnecessários em respostas rápidas e curto o bastante para
> evitar silêncios constrangedores.

#### Mensagem estática

Uma frase de preenchimento predefinida, dita quando o timeout suave é acionado.

| Configuração | Descrição          |
| ------------ | ------------------ |
| **Padrão**   | `"Hhmmmm...yeah."` |
| **Tamanho**  | 1–200 caracteres   |

Esta mensagem oferece suporte a:

* **Substituições de idioma**: traduz-se automaticamente para outros idiomas configurados para seu agente
* **Substituições do cliente**: pode ser personalizada por chamada via SDK

#### Mensagem gerada por LLM

Quando ativada, gera dinamicamente uma frase de preenchimento adequada ao contexto usando um LLM leve, em vez da mensagem estática.

| Configuração | Descrição                                   |
| ------------ | ------------------------------------------- |
| **Padrão**   | `false`                                     |
| **Fallback** | Usa a mensagem estática se a geração falhar |

O sistema usa o contexto recente da conversa (até 4 mensagens, 1.000 caracteres) para gerar preenchimentos relevantes como "Hmm...", "Entendo...", "Compreendido...", "Certo..." ou "Tudo bem..."

> **Note**
>
> Uma mensagem estática de fallback ainda é necessária ao usar mensagens geradas por LLM.

### Boas práticas

* Evite indicadores de tempo nas mensagens de preenchimento (por exemplo, "Um segundo...") porque os tempos reais de resposta são imprevisíveis
* Desative o timeout suave para bots de FAQ rápidos, cujas respostas são consistentemente ágeis

## Interrupções

O tratamento de interrupções determina se os usuários podem interromper seu assistente enquanto ele fala.

### Configuração

As configurações de interrupção podem ser definidas na aba **Avançado** do agente, em **Eventos do cliente**.

Para ativar interrupções, verifique se interrupção está selecionada como um evento do cliente.

#### Interrupções ativadas

![Interrupção permitida](/docs/_fern-img/1da794be8ea3bfed45d06241ce5db390480cd45d27c0f886943518bd52d76157.webp)

#### Interrupções desativadas

![Interrupção ignorada](/docs/_fern-img/847a2ebcdfff9498501502ab4b568fc498b6995f860a5552177a7883942197ff.webp)

> **Note**
>
> Desative as interrupções quando a transmissão completa das informações for crucial, como em avisos
> legais ou instruções de segurança.

### Boas práticas para interrupções

* Ative interrupções para fluxos de conversa naturais, nos quais se espera diálogo de ida e volta
* Desative interrupções quando a conclusão da mensagem for essencial (por exemplo, termos e condições, informações de segurança)
* Considere o contexto do seu caso de uso: o atendimento ao cliente pode se beneficiar de interrupções, enquanto a transmissão de informações pode não

## Agilidade de turno

A agilidade de turno controla a rapidez com que seu assistente responde à entrada do usuário durante a conversa. Essa configuração determina o quanto o assistente está disposto a assumir turnos e começar a falar com base nos padrões de fala detectados.

### Como funciona

O assistente agora inclui duas melhorias importantes para uma alternância de turnos mais natural:

1. **Geração de resposta mais rápida** — O assistente começa a falar após receber palavras suficientes e uma vírgula do modelo de linguagem, em vez de esperar frases completas. Isso reduz a latência e cria conversas mais responsivas, especialmente quando o assistente tem respostas mais longas.

2. **Agilidade de turno configurável** — Controle com que rapidez o assistente interpreta pausas ou padrões de fala como oportunidades para responder.

### Configuração

Há três modos disponíveis:

* **Ávido** — O assistente responde rapidamente à entrada do usuário, intervindo na primeira oportunidade. Ideal para conversas dinâmicas em que respostas imediatas são valorizadas.
* **Normal** — Alternância de turnos equilibrada que funciona bem na maioria dos cenários de conversa. O assistente aguarda pausas naturais na conversa antes de responder.
* **Paciente** — O assistente espera mais antes de assumir seu turno, dando aos usuários mais tempo para concluir seus pensamentos. Ideal para coletar informações detalhadas ou quando os usuários precisam de tempo para formular respostas.

#### Atualizar pelo painel

Abra seu agente no painel, acesse as configurações de **Agente** e selecione o modo de agilidade de turno desejado. Salve suas alterações.

#### Atualizar pela CLI

#### Baixar a configuração do agente

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

#### Editar \`agent_configs/\<agent-name>.json\`

Defina `conversation_config.turn.turn_eagerness` como `"patient"`, `"normal"` ou `"eager"`:

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

#### Enviar suas alterações

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

#### Atualizar pela API

```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" },
  },
});
```

> **Note**
>
> A agilidade de turno é especialmente eficaz quando combinada com workflows. Você pode ajustar dinamicamente a
> capacidade de resposta do assistente com base no contexto — fazendo com que ele intervenha mais rápido durante uma conversa informal
> ou espere mais ao coletar informações sensíveis, como números de telefone ou endereços de e-mail.

### Boas práticas para agilidade de turno

* Use o modo **Ávido** em cenários de atendimento ao cliente nos quais respostas rápidas melhoram a experiência do usuário
* Use o modo **Paciente** ao coletar informações estruturadas, como números de telefone, endereços ou endereços de e-mail
* Use o modo **Normal** como padrão para fluxos gerais de conversa
* Combine com workflows para ajustar dinamicamente a agilidade de turno com base no contexto da conversa
* Teste diferentes configurações no seu caso de uso específico para encontrar o equilíbrio ideal

## Configurações recomendadas

#### Atendimento ao cliente

* Timeouts mais curtos (5 a 10 segundos) para interações responsivas - Ative interrupções para permitir que
  clientes façam perguntas - Agilidade de turno **Ávida** para conversas rápidas e
  responsivas

#### Coleta de informações

* Timeouts moderados (10 a 15 segundos) para dar aos usuários tempo de reunir informações - Ative
  interrupções para um fluxo de conversa natural - Agilidade de turno **Paciente** ao coletar números de telefone,
  endereços ou endereços de e-mail

#### Avisos legais

* Timeouts mais longos (15 a 30 segundos) para permitir respostas complexas - Desative interrupções para
  garantir a transmissão completa de informações legais - Agilidade de turno **Normal** para manter um ritmo
  constante

#### EdTech conversacional

* Timeouts mais longos (10 a 30 segundos) para dar tempo de pensar e formular respostas - Ative
  interrupções para permitir que os alunos façam perguntas - Agilidade de turno **Paciente** para dar aos
  alunos tempo adequado para responder