---
title: Fluxos de conversa
slug: aura/fluxos-de-conversa
createdAt: 2026-11-19T14:33:13.832Z
---

O fluxo é o roteiro do seu robô: o que ele fala, o que pergunta e o que faz com cada resposta. Você monta tudo de forma visual, arrastando blocos e ligando-os com setas. Este guia explica cada bloco, cada opção e cada ferramenta do editor — sem enrolação.

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/jOOwgz99jc0G60McjZFRn_ec5a2f9bb79911ff5ebacbcb68256b9c.jpg" alt="Cada fluxo com o assistente a que pertence e o estado de publicação" caption size="160" width="1600" height="911"} *Cada fluxo com o assistente a que pertence e o estado de publicação*

## O editor de fluxo por inteiro

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/DLG71AQFZbIZG4o1XKOLW_8c2cb94784237a4bda313e372dd04355.jpg" alt="O editor de fluxo por inteiro" caption size="160" width="1600" height="900"} *O editor de fluxo por inteiro*

### As três áreas do editor

1. **Biblioteca de ações** (esquerda) — todos os blocos disponíveis, agrupados. Arraste um bloco para o quadro para adicioná-lo.
2. **Quadro** (centro) — onde o fluxo é desenhado. Cada caixa é um bloco; cada seta liga um bloco ao próximo.
3. **Propriedades** (direita) — abre quando você clica num bloco. É onde você configura tudo daquele bloco.

Todo bloco tem dois campos no topo das Propriedades:

- **Tipo do bloco** — o que ele faz (dá para trocar o tipo aqui mesmo).
- **Nome do bloco** — um rótulo seu, para se organizar (obrigatório). Também há o botão **Tornar bloco inicial**, que marca por onde a conversa começa.

## Os blocos, um por um

A biblioteca separa os blocos em três grupos: **Básicos**, **Inteligência artificial** e **Integrações**.

## Básicos

### Início

Onde a conversa começa. Todo fluxo tem um. Ligue uma seta sempre dele para o primeiro bloco de verdade.

### Mensagem

O assistente fala. Pode enviar vários balões em sequência, e cada balão pode ser:

| Tipo de balão    | O que envia                                                                              |
| ---------------- | ---------------------------------------------------------------------------------------- |
| Texto            | Um balão de texto (aceita negrito, itálico e emojis)                                     |
| Imagem           | Uma imagem (JPG/PNG) por URL                                                             |
| Vídeo            | Um vídeo (MP4) por URL                                                                   |
| Documento        | Um PDF ou arquivo por URL                                                                |
| Áudio            | Um áudio (MP3/OGG) por URL                                                               |
| Botão link (CTA) | Um botão que abre um link. O rótulo já vem **Abrir**, que é o que sai se você não trocar |
| Localização      | Um ponto no mapa (latitude/longitude)                                                    |
| Contato          | Um cartão de contato (nome, telefone)                                                    |

Em **Avançado** há a opção **ecoar anexos recebidos** (repetir o que o cliente enviou).

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/flPJiYw8BLoZ_5s8rkAoS_0f87fe086edee7016d43ed5eaf0b919c.jpg" alt="Balões de texto, mídia e botões" caption size="160" width="1600" height="900"} *Balões de texto, mídia e botões*

### Menu

Mostra opções para o cliente escolher um caminho. Você escreve o texto que o cliente vê e cada opção vira uma seta saindo do bloco.

- **Texto que o cliente vê** — o menu em si (ex.: "1) Vendas 2) Suporte").
- **Salvar escolha em** — guarda a opção escolhida numa variável (ex.: `assunto`).
- **Opções** — cada seta que sai do menu é uma opção, com um gatilho (número, palavra ou rótulo do botão). O cliente pode responder pelo número ou pelo texto.
- Uma seta **senão** trata respostas fora do menu.

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/gZa7WtuXKDbT1unRDHv3W_6a411e8be86927d21c033d937675acbf.jpg" alt="Cada opção é uma seta com um gatilho" caption size="160" width="1600" height="900"} *Cada opção é uma seta com um gatilho*

### Formulário

Pede dados ao cliente, um campo por vez, e já valida o formato. É o jeito certo de coletar nome, e-mail, CPF, etc.

- **Começar de um template** — modelos prontos (cadastro, lead, chamado, agendamento, CSAT, endereço). Substitui os campos; depois é só ajustar.
- **Campos** — para cada campo você define:
  - a **variável** (onde o valor é guardado, ex.: `email`);
  - a **pergunta** (o que o cliente lê);
  - o **tipo** (Texto, E-mail, Telefone, Número, CPF/CNPJ, Data, Escolha, Arquivo) — o tipo valida o formato automaticamente;
  - se for **Arquivo**, o que o cliente pode enviar (imagem, documento ou ambos);
  - os **destinos** do dado: **Dashboard** (vira métrica nos painéis), **Automação** (fica disponível para webhooks/integrações) e **Atendimento humano** (aparece no card do atendente).
- **Mensagem após preencher** — confirmação de sucesso (ex.: "Prontinho, !").
- **Título e botão** e **Lista de itens** — o título do cartão, os textos dos botões, a pergunta entre um item e o próximo e os avisos da soma já vêm na caixa com o que o cliente recebe. Edite para trocar; apagar tudo volta ao texto padrão.
- **Proteção de fuga** — limita as tentativas por campo e permite uma saída quando o cliente erra demais ou digita "sair/cancelar", evitando prender a pessoa. O aviso antes de encaminhar já vem na caixa; apague para não avisar nada (a caixa oferece voltar ao texto padrão).

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/9xSHZYL1qY234qkZ9tzbe_7f6f5b392d4abb4eafa23ec18c42adbd.jpg" alt="Campos, tipos, destinos e proteção de fuga" caption size="160" width="1600" height="900"} *Campos, tipos, destinos e proteção de fuga*

### Decisão

Segue caminhos diferentes conforme uma regra (verdadeiro/falso).

- **Casos de uso comuns** — atalhos que preenchem a regra (ex.: "já informou o CPF", "disse sim", "pediu atendente").
- **Campo do contexto** — o que avaliar: uma **entidade** coletada (cpf, produto), **texto** (a última mensagem) ou uma **variável** salva.
- **Operador** — existe, igual a, diferente de, contém, maior que, menor que.
- **Valor** — o que comparar (quando o operador não é "existe").
- Ligue duas setas: uma **sim** (regra verdadeira) e uma **senão** (regra falsa).

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/h-9CBsArX3KhlH_D1-W7V_bbb2068585d268125c74c03c6febb6c7.jpg" alt="Campo, operador e valor" caption size="160" width="1600" height="900"} *Campo, operador e valor*

### Atendente (transferir para humano)

Passa a conversa para uma pessoa da equipe.

- **Fila de atendimento** — para qual fila a conversa vai (puxa as filas cadastradas em [Filas](https://docs.citsmart.com/aura/filas)). Sem fila definida, ninguém recebe.
- **Aviso antes de transferir** — mensagem opcional enviada logo antes de entrar na fila (ex.: "Um momento, vou te transferir…").

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/lREN3QHSmT0z-WbwuKay6_78668866e14a85cee187d29094952f6b.jpg" alt="Fila de destino e aviso ao cliente" caption size="160" width="1600" height="900"} *Fila de destino e aviso ao cliente*

### Outro assistente

Passa a conversa para outro assistente virtual do workspace — não para uma pessoa.

- **Passa a conversa para** — o assistente de destino. A lista marca quem está **sem fluxo publicado** (destino sem fluxo publicado emudeceria a conversa).
- **Motivo registrado** (opcional) — vai na nota interna da conversa, então quem acompanha o atendimento vê por que ela trocou de assistente. Aceita `{{variáveis}}`.
- **Aviso antes de passar** (opcional) — enviado logo antes da troca. Vazio = o assistente de destino simplesmente começa a falar.

A conversa continua no mesmo canal, com o mesmo histórico e o mesmo protocolo. O que muda é quem responde: fluxo, intenções, assuntos e entidades passam a ser do assistente escolhido, que começa pelo início do fluxo dele.

### Fim

Encerra a conversa. A mensagem final é opcional (despedida). Depois de encerrar, a próxima mensagem do cliente reinicia o fluxo.

### Pausa

Espera um instante antes de seguir, deixando a conversa mais natural.

- **Segundos** — a pausa (máx. 8).
- **Mostrar "digitando…"** — no widget, o cliente vê o indicador durante a pausa.

### Dado do cliente

Guarda uma informação no perfil único do cliente — vale em todos os canais.

- **Campo** — o que guardar (ex.: plano, cidade).
- **Valor** — o conteúdo (texto fixo ou uma variável, ex.: `{{nome}}`).
- **Chave de ligação** — CPF, e-mail ou telefone. Com ela, a plataforma "costura" o mesmo cliente entre canais diferentes.

### Teste A/B

Sorteia um dos caminhos ao acaso. Ligue 2 ou mais setas saindo dele — cada conversa cai numa aleatoriamente. Serve para comparar duas abordagens.

### Aguardar resposta

Se o cliente demorar a responder, avisa e segue por outro caminho.

- **Espera máxima em minutos** — quanto esperar (0 = padrão do canal: WhatsApp \~14h, widget \~30min).
- **Aviso antes de encerrar** — um "cutucão" opcional (ex.: "Ainda tá aí? Em  min a conversa encerra.").
- Ligue duas setas: uma **sempre** (respondeu) e uma **tempo esgotado** (silêncio).

### Confirmar identidade

Confirma quem é o cliente antes de continuar.

- **Método**: **Código por e-mail** (no chat), **Link único** (página com código) ou **Provedor de identidade** (gov.br, Google, Keycloak).
- **Mensagens** ao pedir, ao verificar e nos erros: cada caixa já traz o texto que o bot envia. Edite para trocar; apague tudo para o bot não mandar nada naquele passo (a caixa avisa e oferece voltar ao texto padrão).
- **Regras do e-mail** (no método por código): reusar o e-mail já informado e/ou exigir e-mail corporativo (com lista de domínios aceitos).

**Como funciona (passo a passo):**

- **Código por e-mail** — o bot pede o e-mail, envia um código para ele, e o cliente digita o código no chat. Conferiu → segue pela seta "sempre" e grava o e-mail como verificado no contato. Se as Regras do e-mail pedirem, reusa um e-mail já informado (não pergunta de novo) e/ou aceita só domínios corporativos.
- **Link único** — manda um link no chat; o cliente abre uma página, recebe o código por e-mail e confirma ali. Não precisa de configuração no admin.
- **Provedor de identidade** (gov.br / Google / Keycloak) — manda um link; o cliente entra no provedor e volta verificado, com e-mail/CPF gravados. O operador cola o Client ID/Secret em **Administração › Autenticação** (o Link único não precisa).

Enquanto não verifica, o fluxo não avança — o bloco só libera a seta "sempre" depois da confirmação. Isso é diferente do login da sua equipe na plataforma.

## Inteligência artificial

### Entender o assunto (Intenção)

A IA lê a mensagem e descobre o que o cliente quer, direcionando a conversa — é o NLU (embeddings), não o LLM. Os assuntos são criados no painel **"O que ele entende"** (botão no topo do editor de fluxo), não numa tela separada.

- **Assuntos** — quais intenções este bloco considera (marque as da biblioteca de [Intenções](https://docs.citsmart.com/aura/intencoes-ia); nenhuma marcada = todas).
- **Precisão (confiança mínima)** — abaixo desse nível o bloco não "casa" o assunto e segue pela saída de fallback.
- **Em caso de dúvida** — pergunta as opções ou confirma o assunto antes de seguir. As mensagens já vêm na caixa com o texto enviado; `{rotulo}` vira o assunto entendido.
- Ligue uma seta para cada assunto + uma **"Qualquer outra"** de fallback.

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/aaiaiweKDDZDUEkuKKH1m_045067261b5616dc863200456589f923.jpg" alt="Assuntos considerados e confiança mínima" caption size="160" width="1600" height="900"} *Assuntos considerados e confiança mínima*

### Resposta com IA

Responde perguntas conversando, usando a base de conhecimento.

- **Provedor de IA** — qual conexão usar (de **Administração › Integrações › Provedores de IA**). Sem provedor, o bloco não responde.
- **Como a IA responde**: **Conversa natural** (responde "oi" e perguntas gerais, usa a base para falar da empresa) ou **Só a base** (responde apenas o que a base cobre; fora dela, segue a saída "não soube responder").
- **Conhecimento** — em quais bases e conhecimentos buscar, e a opção **Refinar a busca** (reordena por relevância — mais preciso, um pouco mais lento).
- **Tom de voz** — a formalidade (descontraída, neutra, formal ou personalizada) e instruções extras livres.
- **Desvios** — a IA pode sair da conversa e mandar o cliente a outro ponto: **rotas** que ele pede ("quero meu boleto") e o **desvio automático** se o cliente estiver irritado. Cada rota tem nome e um "quando usar" que a IA lê para decidir.
- **Convite** — se envia uma mensagem ao entrar no chat ou espera o cliente falar.
- **Avançado** — mensagem de "não sei" e salvar a resposta numa variável. A caixa do "não sei" já traz o que sai: a mensagem do assistente (aba Configurações), se houver, senão a da plataforma. Editar ali vale só para o bloco.

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/_aJclzC600xirAnAl3WL6_934d93a53f71bf6734d97cbb18c21a15.jpg" alt="Provedor, modo, conhecimento, tom e desvios" caption size="160" width="1600" height="900"} *Provedor, modo, conhecimento, tom e desvios*

**Regras de negócio (como a IA decide):**

- **Modo "Só a base" (estrito)** — a plataforma busca na base e mede a relevância do melhor trecho. Se não atinge o limiar (padrão 0.45), a IA não é chamada e o fluxo segue pela saída "não soube responder". Assim o robô não inventa.
- **Modo "Conversa natural"** — responde saudações e perguntas gerais, usa a base para fatos da empresa, lembra as últimas mensagens e não inventa dados.
- **Rotas** — quando a IA decide desviar:
  - **Durante a conversa** (padrão) — as rotas entram no prompt; o modelo conversa e, só quando a mensagem pede claramente uma rota, desvia. Menos falso-positivo.
  - **Antes de responder** — faz uma classificação rápida primeiro; se casou uma rota, desvia sem gastar a chamada de conversa nem a busca na base. Mais agressivo.
- **Desvio por sentimento** — se a última mensagem se encaixa no critério de "irritado", a IA desvia (ex.: para um bloco Atendente) em vez de responder.
- **Falha** (sem provedor, timeout ou erro) → a conversa segue pelo fallback, nunca fica muda.
- **Refinar a busca (rerank)** — reordena os trechos por relevância: mais preciso, um pouco mais lento.

### Agente IA

Entrega uma tarefa a um agente de IA (via integração) e usa o resultado. Aparece só quando há um provedor de agentes conectado (**Administração › Integrações**).

**Regras de negócio:** você define o agente, um título e uma descrição da tarefa e a prioridade. Com **aguardar** ligado, o fluxo espera o resultado (até o timeout, padrão 30s) e salva a resposta numa variável para os próximos blocos; desligado, dispara e segue sem esperar.

A confirmação automática e o aviso de quando não consegue abrir já vêm na caixa com o texto enviado, e o protocolo citado acompanha o **Salvar em** (`{{agente_issue_id}}`).

## Integrações

### Outro sistema (API / Webhook)

Busca ou envia dados em qualquer sistema por uma chamada de API. Você define o método (GET/POST…), a URL, o corpo (pode usar `{{variáveis}}`) e onde salvar a resposta.

**Testar e usar os campos — sem código:**

1. Clique em **Testar chamada** — a plataforma dispara a chamada de verdade e mostra o retorno.
2. Cada campo da resposta vira um botão clicável (inclusive campos aninhados, tipo `beneficio.situacao`).
3. Clique no campo → ele vira a variável `{{salvar_em.campo}}`, é copiado, e fica disponível nos próximos blocos — no seletor da Decisão e nos textos de Mensagem. Você não precisa adivinhar a estrutura do JSON nem digitar o caminho.

### Integração

Usa um sistema já conectado (CITSmart, Agility…) em **Administração › Integrações** — sem configurar API na mão. O passo a passo:

1. Escolhe a **Conexão** (a instância do sistema já cadastrada).
2. Escolhe a **Ação** (as ações que aquele sistema oferece — ex.: abrir chamado, consultar status).
3. Preenche os **Parâmetros** da ação (aceitam `{{variáveis}}`). Alguns campos têm busca dinâmica — a plataforma consulta o próprio sistema e lista as opções (ex.: categorias, filas do CITSmart).
4. Define onde salvar o resultado.

Campos obrigatórios em branco são sinalizados; sem conexão cadastrada, o bloco avisa para conectar em **Administração › Integrações**.

**Mais campos da ação.** Ações que aceitam campos além do essencial trazem a faixa **Avançado › Mais campos da ação**, fechada por padrão — o painel principal continua mostrando só o que a ação precisa para funcionar. Na abertura de chamado do CITSmart os campos vêm em quatro seções: **Classificação** (origem — o canal que abriu, WhatsApp, URA, Portal —, grupo responsável e situação inicial), **Prioridade** (urgência, impacto, motivo), **Contato e local** (e-mail, telefone, localidade e unidade) e **Resposta e vínculo** (a resposta do chamado e o chamado principal, para este nascer como subchamado). Origem, grupo, localidade e unidade são listados pelo próprio CITSmart, então trazem os valores daquela instância.

Todos são opcionais, e opcional aqui significa fora do envio: campo em branco não vai como vazio — o sistema aplica o padrão dele, como se o bloco não tivesse o campo. Preencher a origem é o que faz o relatório do ITSM separar o chamado aberto pelo bot por canal.

**Solicitante.** É o login ou e-mail de quem pede o chamado — um valor fixo ou uma variável coletada na conversa, como `{{email}}`. Na hora de abrir, a plataforma localiza a pessoa no CITSmart (por e-mail quando o valor tem `@`, por login quando não tem) e abre o chamado no nome dela. Se ninguém for encontrado, o chamado não é aberto: o fluxo segue pela saída de erro do bloco e o caso aparece em **Administração ›&#x20;**[Erros de sistemas externos](https://docs.citsmart.com/aura/erros-de-sistemas-externos).

**Formulário do CITSmart.** Na ação **Abrir chamado** do CITSmart, o bloco pode perguntar ao cliente os campos de um formulário do CITSmart antes de abrir o chamado — e levar as respostas no formulário estruturado do chamado. No grupo **Formulário do CitSmart** do painel:

1. Escolhe o **Projeto** e o **Formulário do projeto** — as listas vêm do próprio CITSmart. Trocar qualquer um limpa os campos.
2. Clica em **Puxar do CitSmart**: a plataforma lê o desenho do formulário e traz os campos, com o tipo já certo (e-mail, número, data, arquivo, lista de opções).
3. Ajusta o que quiser: o texto da pergunta, obrigatório ou opcional, o tipo, a máscara, as opções e a ordem; remove campos ou inclui perguntas novas.

Cada campo diz de onde vem. **No CitSmart**: a resposta vai para o campo do formulário no chamado. **Só no fluxo**: é uma pergunta que você incluiu — a resposta fica em `{{nome_do_campo}}` para usar onde quiser (na descrição, no Solicitante), mas não vai sozinha para o chamado. A descrição do chamado continua sendo a que você escreveu.

Na conversa, o cliente responde como num bloco Formulário — um cartão único no widget, no Teams e no formulário do WhatsApp; uma pergunta por vez nos demais canais — e só então o chamado abre. Quem desiste ("sair") ou erra além do limite não abre chamado: o fluxo segue pela saída de erro do bloco. Sem formulário escolhido, ou sem campos puxados, o bloco abre o chamado direto, sem perguntar nada.

Puxar de novo depois de editar não desfaz o seu trabalho: os campos que continuam no CITSmart mantêm as suas edições, os novos entram no fim, os que sumiram saem (o painel diz quais) e as perguntas que você incluiu ficam. Um campo que você removeu, e que ainda existe no CITSmart, volta ao puxar de novo.

Formulário que não declara objeto de negócio no CITSmart não serve: sem ele o chamado não tem onde levar as respostas. O painel avisa e não guarda os campos.

O que **NÃO** vira pergunta, e o painel diz quais ficaram de fora:

| Campo no CitSmart | Por quê                                         |
| ----------------- | ----------------------------------------------- |
| Oculto            | o cliente não vê nem responde                   |
| Botão             | não é dado, é ação                              |
| Sem nome          | não há variável do fluxo para gravar a resposta |

Campo **somente leitura** VIRA pergunta. No CITSmart o "desabilitado" costuma ser uma condição de tela (só se resolve na hora, para aquele usuário), e sumir com o campo por causa dela tiraria do fluxo um dado que o cliente precisa informar. Se não servir, remova o campo no painel.

Na publicação, o fluxo avisa quando um **Abrir chamado** está com Atividade, Contrato, Solicitante ou Título em branco — o chamado falharia na hora de abrir — e quando há formulário escolhido sem campos puxados.

### Formulário CitSmart (descontinuado)

O antigo bloco **Formulário CitSmart**, que montava a coleta em vários blocos no canvas, saiu da paleta: o formulário agora fica dentro do bloco **Integração** (veja acima). Fluxos já montados com ele continuam iguais — os blocos que ele criou são blocos comuns. Se um fluxo ainda tiver o bloco no canvas, ele abre só com um aviso, não faz nada na conversa e a publicação acusa: remova-o e escolha o formulário no bloco que abre o chamado.

### Início por API

Faz um sistema externo (URA, portal, app) começar a conversa neste ponto do fluxo, já com dados (CPF, protocolo…). Cada bloco tem sua própria slug — você abre quantas rotas quiser, uma por assunto. O guia completo está em [Rotas de API](https://docs.citsmart.com/aura/entrada-por-api-outro-sistema-inicia).

### Enviar e-mail

Manda um e-mail pelo servidor de e-mail do workspace (confirmação para o cliente, resumo, aviso interno para a equipe).

- **Para** — quase sempre uma variável: `{{email}}` coletado no formulário, `{{contato.email}}` do perfil, ou um endereço fixo da equipe. Aceita vários, separados por vírgula.
- **Assunto** — obrigatório. Sem ele, o painel acusa **sem assunto**, a publicação avisa e o e-mail sai como "(sem assunto)".
- **Assunto** e **Mensagem** aceitam `{{variáveis}}`.
- **Guardar o resultado em** — cria `{{email_ok}}` (enviou ou não) e `{{email.erro}}`, úteis numa Decisão adiante.
- **Aviso ao cliente se NÃO enviar** (opcional).

Ligue duas saídas — **enviou** e **não enviou** — para tratar a falha (servidor fora, endereço inválido). Com uma saída só, o fluxo segue igual nos dois casos. Todo envio, inclusive o que falha, fica no log em **Administração › E-mail**.

### MCP

Aciona uma ferramenta externa via protocolo MCP (uso avançado): informa a tool e onde salvar a resposta.

### Código (Python)

Customização para o caso que nenhum bloco cobre: recortar o retorno de uma API, calcular prazo em dias úteis, normalizar CPF. Escrever o código exige administrador da plataforma; usar o bloco e ligar as saídas, não. Detalhes, teste na hora e como publicar o código como um card reutilizável: veja [Blocos próprios](https://docs.citsmart.com/aura/blocos-proprios-codigo).

### Meus blocos

Os blocos que a sua equipe publicou aparecem na paleta como cards próprios. Quem usa preenche só os campos declarados — não vê nem edita o código. Veja [Blocos próprios](https://docs.citsmart.com/aura/blocos-proprios-codigo).

### Ação

Guarda um valor numa variável para usar nos próximos blocos (ex.: `protocolo = {{nome}}-2026`).

## Encerrar por inatividade (timeout global)

No topo do editor, o botão **Inatividade** define um timeout único para o fluxo inteiro: se o cliente ficar em silêncio por X minutos em qualquer espera (menu, pergunta, formulário…), a conversa é encerrada com uma mensagem e recomeça do início na próxima mensagem. Não precisa configurar bloco a bloco.

- **Ativar timeout global** — liga/desliga.
- **Encerrar após (minutos)** — tempo de silêncio do cliente.
- **Mensagem ao encerrar** — já traz o texto que o bot envia. Edite para trocar; se sair da caixa vazia, ela volta ao texto padrão (a conversa nunca encerra calada).
- **Aplicar também no atendimento humano** — quando ligado, vale também enquanto um atendente humano cuida da conversa (usa o mesmo tempo).

## Ligando os blocos (as setas)

Arraste da bolinha de um bloco até outro para criar uma seta. O tipo da seta muda conforme o bloco de origem:

| Tipo de seta   | Quando usar                                          |
| -------------- | ---------------------------------------------------- |
| sempre         | Segue direto para o próximo bloco                    |
| opção          | Uma escolha de um Menu (com gatilho: número/palavra) |
| sim / senão    | Os dois lados de uma Decisão                         |
| rota           | Um desvio decidido por um bloco de IA                |
| tempo esgotado | O caminho do silêncio num bloco Aguardar resposta    |

## As ferramentas do editor (barra do topo)

- **Salvar** — grava o fluxo. O menu ao lado permite **Sobrescrever** a versão atual (Ctrl+S) ou **Publicar nova versão** (guarda a atual no histórico). Abaixo ficam as **versões salvas** — dá para voltar a uma versão anterior.
- **Desfazer** / **Refazer** (Ctrl+Z / Ctrl+Shift+Z).
- **O que ele entende** — abre a biblioteca de intenções e entidades do assistente.
- **Quando não entender** — configura o que fazer quando o robô não entende a mensagem.
- **Buscar** / **ir para bloco** — acha um bloco por nome e centraliza no quadro.
- **Testar** — abre um chat de **simulação** para você conversar com o fluxo sem publicar.

Arraste o testador para onde ele não atrapalhe: a posição fica guardada neste navegador. Enquanto o teste está aberto, o fluxo fica **somente leitura** (dá para navegar e ver os blocos, não para alterar), porque o teste usa o fluxo como estava ao abrir.

- **Organizar blocos** — arruma tudo automaticamente (vertical ou horizontal).
- **Ir-para** — retornos a blocos muito usados viram um "chip" em vez de uma linha atravessando a tela — mata o "novelo" de setas.
- **Focar um ramo** — isola um pedaço do fluxo por vez (um sub-fluxo navegável).
- **Copiloto** — abre o painel de IA que **lê o fluxo aberto** (mesmo o que você não montou), explica, aponta o que está quebrado e **propõe** edições. Guia completo em [Copiloto de fluxo](https://docs.citsmart.com/aura/copiloto-de-fluxo-ia).
- **Notação BPMN** — troca as caixas simples pelas **formas padrão BPMN 2.0** e abre a legenda; dentro dela, **Raias** separa o quadro por faixas (cliente, robô, sistema, atendente). É só o **desenho** — nada muda no fluxo que roda.
- **Mais** — **Exportar JSON** (pacote de migração, veja abaixo), **Exportar .bpmn** (BPMN 2.0, abre no Camunda Modeler e afins), **Importar JSON ou .bpmn** e **Salvar como PDF**.

## Comentários no bloco — o "porquê" que o desenho não guarda

No painel de Propriedades, cada bloco tem duas abas: **Configuração** e **Comentários**. A segunda é onde se escreve o que o desenho não diz: por que este menu tem 4 opções e não 6, de onde veio a regra, qual exigência ele atende, o que **não** pode mudar.

| Tipo       | Como aparece           | Para que serve                                |
| ---------- | ---------------------- | --------------------------------------------- |
| Regra      | faixa cheia + alfinete | Instrução a respeitar. Fica no topo da lista. |
| Observação | faixa pontilhada       | Contexto, histórico, lembrete.                |

- Dá para **editar**, **excluir** (com confirmação) e **virar regra** pelo próprio card.
- O bloco no quadro ganha um selo: **alfinete cheio** = tem instrução · **folha vazada** = só contexto.
- A busca do editor acha por texto de comentário — é assim que se encontra "aquele bloco da exigência tal" sem lembrar o nome.

Isso serve duas vezes: quem herda o fluxo entende, e o Copiloto lê como instrução fixa — é o que impede a IA de "consertar" algo que estava certo de propósito. Comentário de regra não é alterado sem aviso, e comentário escrito por pessoa nunca é apagado pela IA.

## Automação em segundo plano (aba Gatilho)

O editor tem dois quadros: o **fluxo** (que reage ao cliente) e a aba **Gatilho** (que roda sozinha, repetidas vezes, em segundo plano). Um gatilho é armado durante a conversa e, dali em diante, trabalha sem ninguém pedir.

**Quando ele roda:**

- **A cada (minutos)** — 1 vez por dia = 1440.
- **Parar depois de (horas)** — 0 = sempre.
- **Máx. de checagens** — 0 = sem limite.
- **Começar em (data e hora)** — em branco, começa assim que o cliente passa pelo bloco (o primeiro tique sai depois de um intervalo). Com data marcada, o primeiro tique é na data, e a duração passa a contar dali. Data para trás não roda: se a data já passou quando a conversa chega no bloco, o gatilho não arma — o editor avisa antes de publicar e a tela de Gatilhos recusa a gravação.
- **Permitir novo pedido nesta mesma conversa** — desligado (padrão), arma uma vez só por conversa. Ligado, o cliente pode pedir de novo; o campo que identifica o pedido (ex.: o protocolo) evita armar duas vezes para a mesma coisa.

**Dois jeitos de funcionar:**

| Modo                | O que faz                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Monitorar e avisar  | Checa um dado por agenda numa conexão já cadastrada (ex.: a situação de um chamado no CITSmart). Quando mudar, avisa o cliente — em "só avisar" manda a mensagem; em "perguntar se quer ver" pergunta e, no "Sim", consulta de novo ao vivo e mostra os detalhes. As caixas da pergunta e do que mostrar no "Sim" já trazem o texto que o cliente recebe; sair de uma delas vazia volta ao texto padrão. No "Não" o cliente segue de onde estava, sem interrupção. |
| Montar um sub-fluxo | Você liga, a partir do bloco Gatilho, a cadeia inteira — Integração, Decisão, Mensagem, Disparos — até um Fim. Regra: chegou no Fim → encerra (resolveu); travou numa Decisão sem saída (o "ai\[…] próximo intervalo.                                                                                                                                                                                                                                              |

:inlineImage[]{src="https://api.archbee.com/api/optimize/pu5VMc-2TW3GQX4ly5Xp7/ldgdWYigwlVAuuQsmGTGv_2a2df429455f6ff5df8d017a07294d89.jpg" alt="O botão Testar abre um chat de simulação" caption size="160" width="1600" height="900"} *O botão Testar abre um chat de simulação*

## Como o fluxo roda (o motor)

Entender o runtime ajuda a montar fluxos que não travam:

- Começa no **bloco inicial** e segue as setas. Cada bloco executa e passa ao próximo conforme o tipo de seta.
- Só o fluxo **publicado** vale para o cliente. Rascunho é seguro — edite à vontade.
- **Menu** — casa a resposta por número (1, 2…) ou pelo texto/rótulo; resposta fora do menu segue a seta "senão".
- **Decisão** — avalia o campo com o operador; verdadeiro → sim, falso → senão.
- **Formulário** — pergunta um campo por vez e valida o formato; erro repergunta até o limite de tentativas — passou disso (ou o cliente digita "sair") → segue a saída de fuga.
- **Aguardar resposta** — se o cliente responde, segue "sempre"; se fica em silêncio além do tempo, segue "tempo esgotado".
- **Confirmar identidade** — só avança pela seta "sempre" depois de verificar; grava o e-mail/CPF verificado no contato.
- **Fim** — encerra; a próxima mensagem do cliente reinicia o fluxo.
- **Variáveis** — o que os blocos coletam/salvam (`{{nome}}`, entidades, resposta da IA) fica disponível para os blocos seguintes.

## Levar o fluxo para outro workspace (migração)

**Exportar JSON** não baixa só os blocos: baixa um **pacote** com o fluxo, as integrações que ele usa e as filas de atendimento dos blocos de handoff.

Das integrações vão vendor, URL e todos os campos que não são segredo (`client_id`, `company_id`, usuário de serviço…). Do token vai apenas o **nome** do campo: o arquivo circula por e-mail, chat e git, e valor de senha dentro dele seria vazamento.

O pacote cobre os dois quadros: o fluxo principal e a aba **Gatilho**. Blocos de integração dentro de um gatilho são remapeados igual aos do fluxo, e a agenda de cada gatilho (intervalo, janela, nº de execuções) vai junto.

Do bloco **Agente** vai o nome do agente. O identificador dele só continua valendo se a conexão do destino apontar para a mesma empresa no Hyper; se for outra empresa, o bloco chega sem agente e você reescolhe. O token individual do agente é segredo e não viaja — preencha em **Administração → Integrações → Hyper**.

Das filas vai a configuração inteira — horário de atendimento, protocolo, avaliação (CSAT), mensagens de boas-vindas/despedida, posição na fila, distribuição, prioridade, transferência, privacidade. Não vão a equipe (agentes e supervisores), a base de conhecimento vinculada nem o provedor de IA: são coisas deste workspace, e e-mail de agente não deve viajar dentro de um arquivo.

Ao **Importar JSON** o pacote em outro workspace, a plataforma primeiro mostra o que vem — quantos blocos, quantas automações da aba Gatilho, quais conexões serão criadas ou reusadas, quais filas entram (e quais já existem) e quais agentes o fluxo usa. Nada é gravado nessa tela: se você cancelar, o workspace fica exatamente como estava.

Ao confirmar, a plataforma:

1. cria as integrações que faltam, já preenchidas com a parte não-secreta;
2. deixa cada uma **desligada** — sem token ela não funciona, e ligar antes publicaria um fluxo que falha na frente do cliente;
3. reaponta os blocos para as conexões deste workspace (o id da origem não vale aqui);
4. cria as filas do pacote que ainda não existem aqui, já com toda a configuração;
5. abre o painel **"Fluxo importado — falta o token"**: um campo por segredo, com **Testar conexão** e **Salvar e ligar**, e o resumo do que cada fila ainda precisa.

Se este workspace já tiver aquela conexão (mesmo sistema, mesma URL), ela é reusada — nada é duplicado e não sobra token para preencher.

## Trocar o desenho com outras ferramentas (.bpmn)

**Mais → Exportar .bpmn** gera o fluxo em BPMN 2.0, o padrão de desenho de processo: abre no Camunda Modeler, bpmn.io, Bizagi. **Mais → Importar JSON ou .bpmn** lê de volta — inclusive arquivo desenhado fora da plataforma.

|                            | .bpmn                                          | JSON (pacote)                           |
| -------------------------- | ---------------------------------------------- | --------------------------------------- |
| Para quê                   | trocar o desenho com quem não usa a plataforma | migrar o fluxo entre workspaces         |
| Leva integrações           | não                                            | sim (a parte não-secreta)               |
| Leva filas                 | não                                            | sim, com horário, protocolo e avaliação |
| Abre em ferramenta de BPMN | sim                                            | não                                     |

Cada bloco sai como a forma padrão que o corresponde: consultar sistema e integração viram tarefa de serviço, o bloco Código e o bloco do workspace viram tarefa de script (os dois executam código), atendimento humano vira tarefa de usuário.

O arquivo exportado aqui volta idêntico ao ser reimportado: nada se perde na ida e volta. O desenho chega posicionado na outra ferramenta, do jeito que você organizou.

O que o padrão não sabe dizer sai anotado no próprio arquivo, nunca em silêncio: bloco com várias saídas (para o padrão, duas setas saindo de uma tarefa significam execução paralela — o que a plataforma não faz), prioridade das setas, o sorteio do Teste A/B e bloco com vários balões de mensagem.

Ao importar um arquivo feito fora, o que não tem equivalente vem marcado como pendência em vez de chutado: caixa vira Mensagem "escrever a mensagem", desvio vira Decisão "definir a regra", tarefa de usuário vira Atendente "escolher a fila". Dois casos merecem atenção:

- **Desvio paralelo** chega como bloco desativado — a plataforma segue um caminho só, e fingir o contrário quebraria ao vivo.
- **Tarefa de script** não é importada: rodar código executável vindo de arquivo de terceiro seria perigoso, então o bloco não é criado.

## Publicar com segurança

Um fluxo só afeta os clientes quando é salvo/publicado. Ao publicar, a plataforma pode mostrar avisos (não bloqueiam) apontando o que quebraria na frente do cliente — por exemplo, um "beco sem saída", uma variável repetida ou uma integração de outro ambiente.

## Boas práticas

- Comece pelo caminho mais comum (ex.: "segunda via do boleto"), monte-o inteiro, e só depois adicione as exceções.
- Todo fluxo deve ter um caminho de **Atendente** — mesmo o melhor robô precisa de escape.
- Não deixe becos sem saída: todo bloco deve levar a algum lugar.
- Use **Organizar blocos** de vez em quando para manter o quadro legível.
