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

# Permissões, aprovações e rascunhos

## Como o ElevenAgents Architect se autentica

O Architect não usa uma conta de serviço separada nem atua como uma identidade diferente. No dashboard da ElevenLabs, as ferramentas dele são executadas no seu navegador, dentro da sua sessão autenticada. Toda leitura ou gravação que ele realiza, desde buscar a configuração de um agente até criar uma branch, é uma solicitação comum feita como se fosse você, sob as permissões do seu workspace.

Isso tem três consequências:

* **O Architect só pode fazer o que você pode fazer.** Se você não pode editar um agente, o Architect pode lê-lo, mas não pode preparar alterações nele. Se a sua função não permite fazer merge em uma branch protegida, o Architect também não pode fazer merge nela.
* **O trabalho dele é registrado em seu nome.** As versões que você publica, as branches e as propostas de merge que o Architect cria mostram você como autor. Nada indica que foram criadas pelo Architect.
* **Usuários diferentes recebem resultados diferentes.** Dois colegas de equipe que pedem ao Architect a mesma alteração podem ter resultados distintos se as funções deles forem diferentes.

> **Note**
>
> Esta página descreve o Architect no dashboard da ElevenLabs, que é o único lugar onde o Architect funciona
> atualmente. O Architect chegará a outras plataformas, como o Slack, mas isso ainda não está disponível. Em
> todas as plataformas, o Architect manterá o mesmo modelo: ele se autentica como a pessoa com quem está falando
> e atua com as permissões dessa pessoa.

## O que cada função permite

As funções de acesso ao agente se aplicam ao Architect exatamente como se aplicam a você no dashboard.

| Seu acesso ao agente       | O que o Architect pode fazer por você                                                                                                                                                                   |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Visualizador               | Ler a configuração, as conversas, os testes, as branches e as propostas. Investigar e recomendar alterações, mas não prepará-las.                                                                       |
| Editor                     | Tudo o que um visualizador pode fazer, além de preparar alterações em rascunhos, criar branches, escrever e executar testes, abrir propostas de merge e fazer merge em branches que não são protegidas. |
| Administrador do workspace | Tudo o que um editor pode fazer, além de fazer merge em branches protegidas e alterar a divisão de tráfego das branches protegidas.                                                                     |

Recursos no nível do workspace, como ferramentas, documentos da base de conhecimento e testes, seguem suas próprias permissões de compartilhamento. Consulte [O que o Architect pode alterar](/docs/pt/eleven-agents/operate/architect/capabilities) para saber quais ações se aplicam ao agente e quais se aplicam ao workspace.

## Modos de aprovação

Toda conversa com o Architect é executada em um de três modos. Altere os modos pelo botão no compositor ou pressione <kbd>Shift</kbd>+<kbd>Tab</kbd> para alternar entre eles.

| Modo                               | Comportamento                                                                                                                                                                                                                                                         |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Aprovação obrigatória** (padrão) | O Architect pede confirmação antes de ações que afetam o tráfego ativo ou recursos compartilhados. Ele mostra exatamente o que será alterado e espera você aprovar ou rejeitar.                                                                                       |
| **Aprovação automática**           | O Architect não pede confirmação antes de nenhuma ação, incluindo fazer merge de uma branch, alterar a divisão de tráfego, descartar um rascunho, arquivar um agente ou realizar uma chamada de teste. Use-o apenas para trabalhos sobre os quais você tem confiança. |
| **Plano**                          | O Architect pesquisa com ferramentas somente de leitura, escreve um plano e espera você aprovar o plano antes de alterar qualquer coisa. Depois que você aprova, as ações são controladas como no modo Aprovação obrigatória.                                         |

A sua escolha de modo é lembrada no navegador. Não há uma configuração do workspace que imponha um modo para todos. Para exigir revisão de cada alteração em um agente ativo, proteja a branch `main` dele para que as alterações precisem passar por uma [proposta de merge](/docs/pt/eleven-agents/operate/merge-proposals) aprovada.

### Quais ações pedem confirmação primeiro

No modo **Aprovação obrigatória**, o Architect prepara alterações na configuração do agente no seu rascunho sem perguntar, porque um rascunho nunca afeta os chamadores ativos. Ele pede confirmação antes de:

* Alterações que têm efeito imediato para chamadores ativos: fazer merge de uma branch e alterar a divisão de tráfego.
* Alterações em recursos compartilhados do workspace: criar, atualizar ou excluir ferramentas, atualizar ou excluir testes e a maioria das alterações na base de conhecimento.
* Ações destrutivas: descartar um rascunho, excluir um procedimento, arquivar um agente ou uma branch.
* Ações no mundo real: realizar uma chamada telefônica de teste.

Leituras nunca pedem confirmação. O aviso de aprovação marca exclusões que não podem ser desfeitas com o rótulo **Permanente**. A lista completa do que pede confirmação primeiro está em [O que o Architect pode alterar](/docs/pt/eleven-agents/operate/architect/capabilities).

Três etapas sempre precisam de você, em todos os modos:

* **Publicar um rascunho.** O Architect abre a caixa de diálogo de publicação, e você seleciona **Publicar**.
* **Aprovar um plano** no modo Plano.
* **Decidir o que fazer com um rascunho existente.** Se a branch já tiver um rascunho que o Architect não criou neste chat, incluindo edições não salvas no editor, o Architect para e pergunta se deve mantê-lo ou descartá-lo antes de preparar qualquer coisa.

### Confiar em uma ferramenta durante a sessão

O aviso de aprovação tem uma caixa de seleção **Confiar nestas ferramentas nesta sessão**. Quando você a seleciona, chamadas posteriores para as mesmas ferramentas nessa sessão são executadas sem perguntar. A confiança termina quando você inicia uma nova conversa. Se você não responder a um aviso de aprovação em cerca de dois minutos, a solicitação expira e o Architect não executa a ação.

## Rascunhos, versões e branches

O Architect usa o mesmo modelo de [versionamento](/docs/pt/eleven-agents/operate/versioning) do restante do ElevenAgents.

| Conceito | O que é                                                                                         | Como o Architect o utiliza                                                                                                                               |
| -------- | ----------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Rascunho | Suas alterações não publicadas em uma branch. Cada usuário tem seu próprio rascunho por branch. | Todas as edições de configuração feitas pelo Architect são preparadas aqui. O chat mostra um painel de alterações preparadas com **Revisar e publicar**. |
| Versão   | Um snapshot imutável, criado quando um rascunho é publicado.                                    | Você publica. O Architect não pode. Em uma branch protegida, a caixa de diálogo oferece a publicação em uma nova branch.                                 |
| Branch   | Uma linha nomeada de versões. O tráfego ativo é direcionado às branches por porcentagem.        | O Architect cria uma branch para alterações que precisam de revisão, para que a `main` não seja afetada até que a branch receba merge.                   |

"Nada entra em produção sem a sua aprovação" tem um significado preciso:

* As alterações na configuração de um agente são preparadas em um rascunho e chegam aos chamadores ativos somente depois que você publica, em uma branch que recebe tráfego.
* No modo **Aprovação obrigatória**, ações que afetam o tráfego ativo ou recursos compartilhados aguardam sua aprovação.
* No modo **Aprovação automática**, o Architect ainda não pode publicar, mas pode fazer merge de branches e alterar divisões de tráfego sem perguntar, dentro das suas permissões.

Algumas alterações fora da configuração do agente passam a valer no workspace assim que são feitas, como criar uma ferramenta ou um documento da base de conhecimento. Elas não afetam o comportamento do agente até que ele as use, o que acontece quando você publica um rascunho que as associa. Recursos do workspace já associados a agentes ativos são a exceção: atualizar uma ferramenta usada por um agente ativo altera esse agente imediatamente. O Architect pede confirmação antes de atualizar ferramentas no modo **Aprovação obrigatória**.

## Histórico de versões e reversão

Cada versão publicada registra o que foi alterado e quem a publicou.

* **Ver o que mudou**: em **Controle de versão** > **Branches**, abra o **Histórico de versões** de uma branch. Compare qualquer versão com a anterior ou com a versão ativa. Ou pergunte ao Architect, por exemplo: "O que mudou na main na última semana?" Ele lê o histórico da branch e compara as versões para você.
* **Ver quem alterou**: cada versão mostra o usuário que a publicou. Uma alteração feita pelo Architect mostra o usuário que estava falando com ele.
* **Reverter**: selecione **Reverter para esta versão** no histórico de versões. A reversão não remove o histórico. Ela publica a configuração antiga como uma nova versão. Você também pode usar `/rollback` para que o Architect revise alterações recentes e prepare uma reversão para você publicar.