> ## Documentation Index
> Fetch the complete documentation index at: https://zeropath.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Assistente de AppSec com IA
> Um agente de IA autônomo que faz a triagem de achados, responde a eventos de segurança e gerencia sua postura de AppSec entre execuções
Visão Geral
O Assistente de AppSec com IA é um agente persistente, por organização, que trabalha ao lado da sua equipe de segurança. Ele pode fazer a triagem de achados, investigar vulnerabilidades, criar patches, responder a eventos de scan, responder perguntas no Slack e agendar suas próprias tarefas recorrentes — tudo isso lembrando o contexto de interações anteriores.
O assistente é executado como um ambiente isolado e sandboxed por organização. Ele tem acesso aos seus dados do ZeroPath por meio das ferramentas MCP da plataforma e pode interagir com sua equipe via Slack, Jira, Confluence e Linear.
O Assistente de AppSec é um recurso de acesso antecipado. Para habilitá-lo na sua organização, entre em contato com o [suporte do ZeroPath](mailto:support@zeropath.com).
Principais Capacidades
Operações de Segurança Autônomas
O assistente pode executar tarefas de segurança em várias etapas sem intervenção humana:
* **Triagem de achados** — avaliar status de verdadeiro/falso positivo, avaliar a severidade, recomendar prioridade de remediação
* **Investigação de vulnerabilidades** — clonar repositórios, revisar caminhos de código, avaliar alcançabilidade
* **Criação de patches** — gerar correções, criar PRs pelo pipeline de patches da plataforma
* **Modelagem de ameaças** — analisar a arquitetura da aplicação e identificar superfícies de ataque
* **Alcançabilidade de SCA** — determinar se vulnerabilidades de dependências são de fato exploráveis no seu código
Equipes de Agentes
Para tarefas complexas, o assistente pode criar equipes de subagentes que trabalham em paralelo. Por exemplo, ao receber a tarefa de fazer a triagem de 20 novos achados, ele pode investigar vários achados simultaneamente em repositórios diferentes, em vez de tratá-los um de cada vez. Cada subagente tem acesso às mesmas ferramentas da plataforma e à mesma memória, e o agente principal coordena e sintetiza os resultados.
Autoaperfeiçoamento
O assistente aprende e melhora continuamente por meio de três mecanismos:
* **Memória** — armazena e recupera decisões, preferências da equipe, conhecimento específico de repositórios e resultados de investigações entre execuções. Antes de cada tarefa, busca na memória decisões anteriores sobre questões semelhantes para manter a consistência. Ao concluir o trabalho, salva os principais resultados para que execuções futuras não reinvestiguem as mesmas questões.
* **Regras em linguagem natural** — quando identifica um padrão recorrente (por exemplo, falsos positivos repetidos vindos de um padrão de código específico), pode criar regras de scanner para que a plataforma capture ou suprima achados semelhantes automaticamente em scans futuros. Isso significa que as decisões de triagem do assistente melhoram permanentemente a precisão do scanner.
* **Contexto de tarefas recorrentes** — em tarefas agendadas, o assistente recebe automaticamente os resultados das suas últimas 3 execuções. Ele usa isso para acompanhar tendências, dar continuidade ao trabalho anterior e evitar começar do zero a cada vez.
Automação Orientada a Eventos
O assistente pode ser acionado automaticamente por eventos da plataforma, cada um com instruções totalmente personalizáveis:
* Um scan é concluído → o assistente faz a triagem dos novos achados e publica um resumo
* Um PR é bloqueado → o assistente revisa os achados bloqueantes e sugere correções
* Um novo CVE é descoberto → o assistente avalia a alcançabilidade nos seus repositórios
* Um scan falha → o assistente investiga o erro e notifica a equipe
Cada gatilho tem seu próprio template de prompt com variáveis dinâmicas (`{repo}`, `{vulnCount}`, `{prNumber}` etc.), então você controla exatamente o que o assistente faz para cada tipo de evento. Veja [Gatilhos de Eventos](#event-triggers) abaixo.
Ambiente Persistente
Cada organização recebe um pod dedicado e sandboxed com armazenamento persistente:
* **Diretórios de tarefas recorrentes** — tarefas agendadas recebem um diretório de trabalho persistente em `/data/recurring//`. Cada execução cria um subdiretório com timestamp, e os resultados das últimas 3 execuções são fornecidos automaticamente como contexto para a execução seguinte. Isso permite que o assistente acompanhe tendências ao longo do tempo (por exemplo, "na semana passada, 12 achados críticos; nesta semana, 8").
* **Memória entre execuções** — o assistente usa o [mem0](https://mem0.ai) para armazenar e recuperar conhecimento organizacional que persiste indefinidamente por todas as execuções.
Controlabilidade
Você tem controle total sobre o comportamento do assistente:
* **Instruções globais** — diretrizes da organização adicionadas ao início de toda tarefa. Defina políticas como "sempre publique no Slack antes de modificar registros" ou "escale achados críticos para @security-oncall". Editáveis na aba **Settings** ou pelo próprio assistente via ferramentas MCP.
* **Gatilhos de eventos** — configure quais eventos da plataforma (scan concluído, novas vulnerabilidades etc.) invocam o assistente automaticamente, com prompts personalizáveis por tipo de evento.
* **Agendamento cron** — o assistente pode criar e gerenciar seus próprios agendamentos recorrentes (por exemplo, "fazer a triagem de novos achados toda segunda-feira às 9h").
* **Permissões** — três permissões granulares controlam quem pode visualizar, gerenciar ou executar o assistente.
Painel
A página do Assistente é organizada em abas:
* **Overview** — Estatísticas rápidas (jobs em execução, jobs concluídos hoje, agendamentos ativos, gatilhos ativos, serviços conectados), uma visão ao vivo dos jobs em execução no momento, com contadores de duração em tempo real, e um feed de ações recentes com resumos gerados por IA descrevendo as ações concretas realizadas (por exemplo, achados triados, PRs abertos, scans acionados).
* **Activity** — Uma lista pesquisável de todas as conversas, com títulos gerados por IA que resumem o propósito de cada conversa. Você pode filtrar por origem (Chat, Scheduled, Events, Slack) e clicar em qualquer linha para abrir a thread completa da conversa com streaming em tempo real.
* **Chat** — Inicie novas conversas ou continue as existentes. A visão de chat inclui uma barra lateral que lista todas as conversas, com busca, filtro por origem (All, Chat, Scheduled, Event, Slack) e indicadores de status. Conversas de tarefas agendadas e gatilhos de eventos são somente leitura, enquanto conversas vinculadas ao Slack direcionam você a responder na thread original do Slack. O assistente recebe automaticamente o histórico completo da conversa ao responder a mensagens de acompanhamento, mantendo o contexto por múltiplas trocas na mesma thread.
* **Schedules** — Crie e gerencie tarefas recorrentes com expressões cron, templates e escopo por repositório/tag.
* **Triggers** — Configure quais eventos da plataforma invocam o assistente, com prompts por gatilho e escopo por repositório/tag.
* **Playbooks** — Navegue e gerencie templates de playbooks reutilizáveis que definem fluxos de trabalho em várias etapas que o assistente pode executar. Playbooks oferecem uma forma estruturada de codificar operações de segurança comuns (por exemplo, runbooks de triagem, procedimentos de resposta a incidentes) para que possam ser acionadas de forma consistente por toda a equipe.
* **Memory** — Visualize, pesquise, edite e exclua o conhecimento organizacional armazenado pelo assistente.
* **Settings** — Habilite/desabilite o agente, configure o canal do Slack, defina instruções globais e reinicie o assistente.
Primeiros Passos
Habilitar o Assistente
1. Navegue até **[Assistant](https://zeropath.com/app/agent)** no painel do ZeroPath.
2. Vá para a aba **Settings**.
3. Alterne o agente para **on**.
Uma vez habilitado, o ZeroPath provisiona um pod dedicado para sua organização. Isso pode levar até um minuto.
Executar Sua Primeira Tarefa
1. Clique no botão **Ask** no canto superior direito, ou vá para a aba **Chat**.
2. Digite uma mensagem no campo na parte inferior da página para iniciar uma nova conversa, por exemplo:
* *"Liste todos os achados de severidade crítica do último scan e faça a triagem deles"*
* *"Revise os resultados do último scan de PR e sinalize quaisquer verdadeiros positivos"*
* *"Quais são os 5 tipos de vulnerabilidade mais comuns nos nossos repositórios?"*
3. Acompanhe os resultados em streaming em tempo real. Você pode enviar mensagens de acompanhamento na mesma thread de conversa.
Configurar Instruções Globais
Instruções globais são adicionadas ao início de **toda** tarefa do agente — execuções manuais, gatilhos de eventos, interações no Slack e jobs agendados. Use-as para políticas da organização.
1. Vá para a aba **Settings**.
2. Clique em **"Show example"** para obter um template inicial.
3. Escreva suas instruções. Por exemplo:
```text theme={null}
## Escalation & Approval
- Before modifying or deleting any issue, post a summary in Slack
and wait for confirmation from a team member before proceeding.
- For critical or high severity findings, escalate to @security-oncall
in #security-alerts with finding details and your recommended action.
## Memory
- At the start of every task, search memory for prior decisions about
similar findings. Use existing decisions as precedent.
- After completing any triage or investigation, store the key decision
and reasoning in memory for future reference.
## Pull Requests
- Never auto-merge pull requests. Create the PR, tag the repo owner,
and post the PR link in Slack for review.
```
4. Clique em **"Save Instructions"**.
Gatilhos de Eventos
Gatilhos de eventos permitem que o assistente responda automaticamente a eventos da plataforma. Cada gatilho tem um prompt personalizável que diz ao assistente o que fazer.
Configurando Gatilhos
Você pode criar múltiplos gatilhos por tipo de evento, cada um com seu próprio prompt e escopo. Por exemplo, você poderia ter dois gatilhos de "Scan Complete" — um com escopo nos repositórios de produção, que escala achados críticos, e outro com escopo nas ferramentas internas, que gera um resumo simples.
1. Vá para a aba **Triggers**.
2. Clique em **"Add trigger"** no tipo de evento desejado, ou ative um gatilho existente:
| Evento | Descrição |
| ----------------------------------- | ----------------------------------------------------------------------- |
| **Scan Complete** | Um scan completo ou agendado foi finalizado |
| **PR Scan Complete** | Um scan de pull request foi finalizado |
| **New Vulnerabilities (Full Scan)** | Novos achados descobertos em um scan completo |
| **New Vulnerabilities (PR Scan)** | Novos achados descobertos em um scan de PR |
| **PR Blocked** | Um PR foi bloqueado devido a achados de segurança |
| **PR Merged with Issues** | Um PR foi mesclado com achados de segurança em aberto |
| **Vulnerability Patched** | Uma vulnerabilidade foi marcada como corrigida |
| **Vulnerability Reopened** | Uma vulnerabilidade resolvida anteriormente foi reaberta |
| **SCA New CVE** | Um novo CVE foi encontrado em uma dependência |
| **SCA New Issue** | Um novo issue de SCA foi criado para uma vulnerabilidade de dependência |
| **Scan Failed** | Um scan encontrou um erro |
| **Long Running Scan** | Um scan está em execução há um tempo incomumente longo |
| **Report Complete** | Um relatório gerado está pronto para revisão |
| **Scan Started** | Um scan completo foi iniciado |
| **PR Scan Started** | Um scan de PR foi iniciado |
| **Scan Scheduled** | Um scan foi agendado |
| **Audit Log Event** | Um evento de log de auditoria foi registrado |
3. Clique em **"Edit prompt"** para personalizar o que o assistente faz para cada evento.
4. Opcionalmente, restrinja cada gatilho a **repositórios** ou **tags** específicos para que ele só dispare para um subconjunto do seu código.
Webhooks de Entrada
Webhooks de entrada permitem que sistemas externos acionem o assistente enviando uma requisição HTTP POST. Use-os para integrar o assistente a ferramentas fora da plataforma ZeroPath — pipelines de CI/CD, plataformas de bug bounty, sistemas de alerta, scripts personalizados ou qualquer serviço capaz de enviar requisições HTTP.
Criando um Webhook de Entrada
1. Vá para a aba **Triggers**.
2. Na seção **Webhooks**, clique em **"Add trigger"**.
3. Dê um nome ao gatilho e escreva um template de prompt. Use `{webhookBody}` como placeholder para o payload da requisição recebida.
4. Clique em **"Save"**. O ZeroPath gera uma URL de webhook exclusiva com um token secreto.
A URL do webhook tem o formato:
```
POST https://zeropath.com/api/agent/webhook/{triggerId}?secret={webhookSecret}
```
Envie um corpo JSON para essa URL e o assistente o receberá como `{webhookBody}` no seu template de prompt.
Exemplo
Template de prompt:
```text theme={null}
A new bug bounty report was submitted. Analyze the report for validity,
check if the described vulnerability exists in our codebase, and post
your assessment to Slack.
Report contents:
{webhookBody}
```
O sistema externo envia um POST:
```json theme={null}
{
"title": "Open redirect in /auth/callback",
"severity": "medium",
"description": "The redirect_uri parameter is not validated..."
}
```
O assistente recebe o JSON completo como parte do seu prompt e executa as instruções.
Escopo
Como outros gatilhos, webhooks de entrada podem ser restritos a repositórios ou tags específicos. Se houver escopo, o webhook ainda dispara, mas o contexto do assistente fica limitado aos repositórios selecionados.
Modo Confiável
Gatilhos de eventos e tarefas agendadas têm um toggle **Trusted** que controla as permissões de execução do assistente.
* **Trusted (padrão)** — o assistente tem capacidades completas: acesso a shell, leitura/escrita de arquivos e todas as ferramentas MCP. Use para gatilhos acionados por eventos internos da plataforma (scan concluído, novas vulnerabilidades etc.), em que o conteúdo do prompt é controlado pela sua equipe.
* **Untrusted** — o assistente é executado em um modo restrito, sem acesso a shell e sem capacidade de ler ou modificar arquivos de configuração sensíveis. Todas as ferramentas MCP (plataforma ZeroPath, Slack, Linear etc.) continuam funcionando normalmente. Use para gatilhos que processam entrada externa, como webhooks de entrada que carregam payloads de fora da sua organização.
Quando Usar o Modo Não Confiável
Marque um gatilho como não confiável quando o prompt dele incluir conteúdo de fora do seu perímetro de confiança:
* Webhooks de entrada que recebem payloads de sistemas externos
* Gatilhos que processam relatórios de bug bounty, avisos de fornecedores ou dados enviados por clientes
* Qualquer gatilho em que `{webhookBody}` ou outros placeholders carreguem texto de autoria externa
O modo não confiável protege contra injeção de prompt — se um payload malicioso tentar instruir o assistente a ler segredos ou executar comandos, essas capacidades não estarão disponíveis.
O Que Muda no Modo Não Confiável
| Capacidade | Trusted | Untrusted |
| ------------------------------------------------------------ | ---------- | ------------------------------------------ |
| Ferramentas MCP (ZeroPath, Slack, Linear etc.) | Disponível | Disponível |
| Memória (buscar, armazenar) | Disponível | Disponível |
| Agendamento | Disponível | Disponível |
| Ler/gravar arquivos (repositórios, tarefas recorrentes, tmp) | Disponível | **Apenas caminhos na lista de permissões** |
| Ler/gravar todos os outros caminhos | Disponível | **Bloqueado** |
| Execução de shell / Bash | Disponível | **Bloqueada** |
No modo não confiável, o acesso a arquivos usa uma lista de permissões — apenas `/data/repos/`, `/data/recurring/` e `/tmp/` são acessíveis. Todos os outros caminhos (incluindo configuração, segredos e arquivos de ambiente) são bloqueados por padrão. O assistente também recebe um aviso explícito no nível do prompt de que está processando entrada não confiável e deve ignorar quaisquer instruções embutidas no payload externo.
O assistente ainda pode executar operações da plataforma (fazer a triagem de achados, acionar scans, criar patches via MCP, publicar no Slack, gerenciar agendamentos) no modo não confiável.
Variáveis de Prompt
Prompts de gatilhos de eventos suportam variáveis de placeholder que são preenchidas quando o evento dispara:
| Variável | Descrição |
| ----------------------------- | ---------------------------------------------------------------- |
| `{repo}` / `{repositoryName}` | Nome do repositório |
| `{vulnCount}` | Número de vulnerabilidades encontradas |
| `{prNumber}` | Número do pull request |
| `{vulnSummary}` | Detalhamento por severidade (por exemplo, "3 críticas, 5 altas") |
| `{cveId}` | Identificador do CVE |
| `{score}` | Pontuação de severidade da vulnerabilidade |
| `{packageName}` | Nome do pacote afetado |
| `{error}` | Mensagem de erro (para scans com falha) |
| `{vulnTitle}` | Título da vulnerabilidade |
| `{reason}` | Motivo pelo qual uma vulnerabilidade foi reaberta |
| `{minutes}` | Duração em minutos (para scans de longa duração) |
| `{reportTitle}` | Título de um relatório concluído |
| `{issueCount}` | Número de issues em um relatório |
| `{issueId}` | Identificador do issue no ZeroPath |
| `{manifestPath}` | Caminho para o arquivo de manifesto de dependências |
| `{webhookBody}` | Corpo JSON completo de uma requisição de webhook de entrada |
Tarefas Agendadas
Você pode criar agendamentos recorrentes na aba **Schedules** ou pedindo ao assistente em uma conversa ou mensagem no Slack. Cada agendamento é executado com uma expressão cron padrão.
Criando Agendamentos pela Interface
1. Vá para a aba **Schedules** e clique em **"New Schedule"**.
2. Escolha um **template** como ponto de partida (Daily Triage, Weekly Security Digest ou SCA Monitoring), ou crie um do zero.
3. Insira um **nome**, selecione uma **expressão cron** (ou use um dos presets integrados, como "Weekdays at 9am UTC" ou "Every hour") e escreva o **prompt** que diz ao assistente o que fazer.
4. Opcionalmente, restrinja o agendamento a **repositórios** ou **tags** específicos para que o assistente opere apenas em um subconjunto do seu código.
5. Clique em **Save**. Você pode habilitar, desabilitar, editar ou acionar manualmente qualquer agendamento a partir da lista.
Criando Agendamentos via Chat
Você também pode pedir diretamente ao assistente que crie agendamentos:
* *"Crie uma triagem semanal de todos os novos achados toda segunda-feira às 9h"*
* *"Verifique vulnerabilidades críticas de SCA diariamente à meia-noite"*
* *"Execute um resumo da postura de segurança toda sexta-feira às 16h"*
Contexto de Tarefas Recorrentes
Cada execução agendada recebe um diretório persistente em disco. O assistente grava seus resultados em `result.md`, e os resultados das últimas 3 execuções são incluídos automaticamente como contexto na execução seguinte. Isso possibilita:
* **Acompanhamento de tendências** — "Na semana passada havia 12 achados críticos, nesta semana são 8. Melhoria nos repositórios X e Y."
* **Trabalho incremental** — o assistente pode continuar de onde parou, em vez de começar do zero.
* **Trilha de auditoria** — a saída de cada execução é preservada para revisão.
Tarefas agendadas também suportam o toggle **Trusted**. Se um agendamento processa entrada externa ou você quer restringir seu ambiente de execução, defina-o como não confiável. Veja [Modo Confiável](#trusted-mode) acima para detalhes.
Visualize todos os agendamentos ativos na aba **Schedules**.
Integração com Slack
O assistente pode interagir com sua equipe pelo Slack — responder perguntas, receber orientações e publicar atualizações.
Configuração
1. Garanta que sua organização tenha uma [integração com Slack](/pt/integrations/slack) conectada.
2. Na aba **Settings** do assistente, insira o ID do canal do Slack onde o agente deve publicar.
3. O assistente responderá a @-menções em canais e a mensagens diretas.
Conversando com o Assistente
**Em canais:** mencione o bot do ZeroPath com um pedido:
> @ZeroPath Você pode fazer a triagem dos 5 novos achados críticos do scan de hoje?
**Em DMs:** envie uma mensagem direta ao bot do ZeroPath — sem necessidade de @-menção:
> Qual é a postura de segurança atual nos nossos repositórios?
O assistente reage imediatamente com um emoji :eyes: para confirmar o recebimento da sua mensagem, cria um job e publica os resultados de volta na thread. Ele envia atualizações de progresso em tarefas mais longas, para que você saiba o que ele está fazendo.
Ações Suportadas
| Tipo de Mensagem | O Que Acontece |
| --------------------------- | --------------------------------------------------------------------------------------------------------- |
| Novo pedido | Cria um novo job do agente e responde na thread |
| Acompanhamento na thread | Continua a conversa com o contexto anterior |
| `cancel` / `stop` | Cancela todos os jobs em execução na thread atual |
| `replace` / `restart` | Cancela os jobs em execução e inicia um novo com o seu pedido atualizado |
| `amend` / `also` / `add to` | Cancela os jobs em execução e inicia um novo que combina a tarefa anterior com suas instruções adicionais |
Conversas em thread são persistentes — você pode responder a qualquer thread em que o assistente tenha participado, e ele responderá automaticamente às mensagens de acompanhamento sem precisar de outra @-menção.
Integração com Jira e Confluence
Quando sua organização tem uma integração com Jira conectada, o assistente pode criar e atualizar tickets do Jira e consultar o Confluence em busca de documentação, runbooks e contexto de arquitetura. Isso permite que o assistente:
* Crie tickets de remediação vinculados a achados do ZeroPath
* Consulte tickets existentes para obter contexto durante a triagem
* Pesquise documentação de arquitetura no Confluence para embasar a modelagem de ameaças e a análise de alcançabilidade
O acesso ao Confluence fica disponível quando habilitado explicitamente nas configurações da sua integração com Jira.
Integração com Linear
Quando sua organização tem uma integração com Linear conectada, o assistente pode criar e atualizar issues do Linear. Use isso para:
* Criar tickets de remediação diretamente a partir dos resultados de triagem
* Consultar tickets existentes para obter contexto de remediação
Fluxo de PR para Tickets do Linear
Quando o assistente abre um pull request para corrigir um ticket do Linear, ele:
* Inclui a chave do ticket do Linear (por exemplo, `ZP-123`) no nome da branch, no título do PR e no corpo do PR, para que o Linear vincule o PR ao ticket automaticamente.
* Move o ticket do Linear para **Todo** depois de publicar o link do PR, para que o responsável pelo ticket possa revisar e verificar a correção. O ticket não é movido para um estado concluído ou fechado — ele permanece em Todo até você verificar a correção e fechá-lo manualmente.
Se já existir um PR para um ticket do Linear quando o assistente o reencontrar, o assistente move o ticket para **Todo** e informa a URL do PR existente, em vez de abrir um duplicado.
Para tickets que precisam de escalonamento humano em vez de um PR, o ticket permanece em **Triage** (ou no equivalente mais próximo) para que continue na fila de revisão.
Servidores MCP Personalizados
Você pode estender as capacidades do assistente instalando servidores MCP adicionais. Peça ao assistente para instalar um servidor (por exemplo, GitHub, PagerDuty ou qualquer ferramenta compatível com MCP), e ele configurará o servidor para o pod da sua organização. Servidores MCP personalizados persistem entre reinicializações e ficam disponíveis na mensagem seguinte à instalação.
Memória
O assistente armazena conhecimento organizacional em memória persistente usando o [mem0](https://mem0.ai). Isso inclui:
* Decisões de triagem e seus fundamentos
* Preferências da equipe e políticas de segurança
* Conhecimento específico de repositórios (arquitetura, padrões comuns, problemas conhecidos)
* Planos de remediação e resultados
Visualizando e Gerenciando a Memória
Vá para a aba **Memory** para navegar por todas as memórias armazenadas. Você pode:
* **Pesquisar** memórias por palavra-chave para encontrar entradas específicas.
* **Editar** qualquer entrada de memória inline para corrigir ou refinar o que o assistente armazenou.
* **Excluir** entradas individuais que não são mais relevantes.
* **Limpar todas** as memórias para redefinir completamente o conhecimento organizacional do assistente. Essa ação não pode ser desfeita.
Boas Práticas
* O assistente pesquisa a memória automaticamente antes de cada tarefa e armazena os resultados depois. Você não precisa dizer explicitamente para ele lembrar das coisas.
* Se quiser corrigir uma decisão passada, diga diretamente ao assistente — ele atualizará sua memória.
* Use instruções globais para orientar o comportamento da memória (por exemplo, "sempre verifique na memória decisões anteriores sobre CVEs semelhantes antes de fazer a triagem").
Permissões
O acesso ao assistente é controlado por três permissões:
| Permissão | Descrição |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agent View** | Visualizar execuções, agendamentos, gatilhos, memória e configurações |
| **Agent Manage** | Editar configurações, instruções globais e gatilhos de eventos |
| **Agent Run** | Acionar novas execuções manualmente e cancelar jobs. Também concede acesso de visualização — um usuário com Agent Run mas sem Agent View ainda pode ver o assistente. |
Elas são atribuídas por meio de [Equipes](/pt/platform/teams) nas configurações da plataforma.
Controle de Acesso no Nível de Repositório
Conversas e jobs do assistente vinculados a um repositório específico respeitam os controles de acesso no nível de repositório da sua organização. Se um usuário perder o acesso a um repositório (por exemplo, por uma mudança de permissão de equipe), as conversas e os jobs vinculados a esse repositório deixam de ficar visíveis para ele. Isso se aplica uniformemente a listar, visualizar, enviar mensagens e arquivar conversas — o acesso é avaliado no momento da leitura, então revogar o acesso a um repositório tem efeito imediato, sem nenhum estado de visibilidade armazenado para atualizar.
Log de Auditoria
As principais ações do assistente são registradas no log de auditoria da organização, incluindo a criação de conversas, o envio de mensagens, o arquivamento e desarquivamento de conversas e o cancelamento de jobs. Cada entrada de auditoria inclui os IDs da conversa e do job, para que integrações SIEM downstream possam correlacionar os eventos.
Acesso via API
Você pode gerenciar o Assistente de IA programaticamente por meio da API. Todos os endpoints do assistente ficam sob `/api/v2/agent/` e usam a mesma autenticação dos outros endpoints da API do ZeroPath. Consulte a [Referência da API](/api-reference/introduction#ai-assistant) para a lista completa de operações.
As principais capacidades da API incluem:
* **Conversas** — criar conversas, enviar mensagens, listar e pesquisar conversas e arquivá-las/desarquivá-las
* **Jobs** — listar, visualizar e cancelar jobs do agente com filtros de status e de gatilho
* **Streaming em tempo real** — assinar mensagens de jobs do agente via Server-Sent Events (SSE). Você pode fazer streaming de um único job por ID ou de uma conversa inteira. No modo conversa, o stream acompanha automaticamente os novos jobs à medida que são criados, envia eventos de inatividade entre jobs e fecha após 30 minutos com um evento de timeout para que seu cliente possa reconectar
* **Agendamentos Cron** — criar, atualizar, excluir e acionar manualmente agendamentos recorrentes, com escopo opcional por repositório e tag
* **Gatilhos de Eventos** — criar, atualizar e excluir gatilhos orientados a eventos com prompts e escopo personalizáveis
* **Histórico de Gatilhos** — listar execuções passadas de gatilhos com paginação baseada em cursor e recuperar os detalhes completos do job, incluindo as mensagens da conversa
* **Memória** — listar, editar, excluir e limpar o conhecimento organizacional armazenado do assistente
* **Configuração** — habilitar/desabilitar o assistente, definir o canal do Slack, configurar o máximo de execuções simultâneas e gerenciar instruções globais