failproofai 1.0.1-beta.1 → 1.0.2-beta.0

package/.next/standalone/docs-old/pt-br/agenteye/event-stream.mdx

@@ -0,0 +1,50 @@
+---
+title: "Event Stream"
+description: "No momento em que seu agente faz algo, você vê."
+---
+
+
+No momento em que seu agente faz algo, você vê. O Event Stream é o seu pulso em tempo real sobre cada agente em produção: sem espera, sem vasculhar logs, sem precisar adivinhar o que acabou de acontecer.
+
+![O Event Stream ao vivo: linhas de eventos com código de cores atualizando em tempo real, filtráveis por ambiente, agente, sessão, tipo de evento e texto livre](/agenteye/images/events-stream.png)
+
+*Todos os eventos de todos os agentes da sua organização, os mais recentes primeiro, atualizando conforme acontecem.*
+
+## Seu pulso em tempo real sobre cada agente
+
+Quando um agente inicia uma execução, chama um modelo, dispara uma ferramenta, executa um hook ou encontra um erro, a linha aparece no topo do stream no exato momento em que acontece. Ele acompanha todos os eventos de todos os agentes da sua organização, os mais recentes primeiro, para que você tenha sempre uma visão atual em vez de uma desatualizada.
+
+Isso significa sem ficar monitorando arquivos de log em algum servidor, sem vasculhar máquinas com grep, sem juntar timestamps manualmente. Você abre uma página e já está observando a produção.
+
+As linhas têm código de cores por tipo, então você consegue ler o stream de relance em vez de analisar cada linha. De uma olhada, cada linha mostra:
+
+- **Seu tipo**, com código de cores: `agent_start`, `model_response`, `tool_use`, `hook_completed`, `error`, entre outros.
+- **Um resumo em uma linha** do que aconteceu, para que raramente seja necessário abrir algo só para entender o geral.
+- **Contagens de tokens** para a etapa.
+- **Um indicador de preenchimento da janela de contexto** onde aplicável, tornando o crescimento do prompt e uma compactação iminente visíveis antes que se tornem um problema.
+
+Acompanhar ao vivo significa que você identifica um deploy problemático, um loop descontrolado ou uma rajada de erros assim que acontece — não na revisão de logs do dia seguinte.
+
+## Encontre a execução que importa
+
+Quando algo parece errado, você não quer o fluxo completo de dados. Você quer a única execução que quebrou. O stream filtra rapidamente: por ambiente, por agente, por sessão, por tipo de evento ou por texto livre.
+
+Filtre por ID de sessão ou ID de agente para acompanhar uma execução do primeiro ao último evento. Filtre por tipo de evento para isolar um único tipo de atividade — por exemplo, todos os `error` da organização em uma única visão. Combine filtros para ir de "tudo, em todo lugar" para "este agente, em prod, com erro" em alguns cliques, e então aja sobre o que encontrar.
+
+A busca por texto livre vai direto a uma mensagem, um nome de ferramenta ou um ID que você já tem em mãos, então um relato de cliente se transforma na execução exata em segundos.
+
+## Onde encontrar
+
+O Event Stream é a página inicial da sua organização. Faça login e é a primeira tela que você vê, em `/<org-slug>/`, para que o triagem comece no segundo em que você chega.
+
+Por baixo, seus agentes emitem eventos pelo SDK, o coletor os envia ao seu servidor de Observabilidade Failproof AI, e o stream os acompanha conforme chegam na infraestrutura que você controla. Quando quiser a visão consolidada em vez do rastro bruto, os eventos de cada execução se recolhem em uma única linha em Sessions, a um clique de distância.
+
+Esta é a fonte primária de verdade sobre a qual todas as outras superfícies de observabilidade se baseiam — então quando um número parece errado em outro lugar, o stream é onde você confirma o que realmente aconteceu.
+
+## Relacionado
+
+- [Sessions](/pt-br/agenteye/sessions): os mesmos eventos consolidados em uma linha por execução, com um gráfico de execução no estilo git.
+- [Telemetry](/pt-br/agenteye/telemetry): o que seus agentes enviam e como os eventos chegam ao stream.
+- [Error tracking](/pt-br/agenteye/error-tracking): uma única superfície de triagem para tudo que deu errado.
+- [Alerts](/pt-br/agenteye/alerts): transforme qualquer limite em uma regra de notificação.
+- [CLI and agents](/pt-br/agenteye/cli-and-agents): o mesmo rastro ao vivo pelo seu terminal.

package/.next/standalone/docs-old/pt-br/agenteye/hermes-capture.mdx

@@ -0,0 +1,53 @@
+---
+title: "Captura de sessões do Hermes"
+description: "Traga as sessões do gateway Hermes da sua equipe — Slack, Telegram, CLI e execuções agendadas — para o AgentEye como sessões e eventos comuns."
+---
+
+O [Hermes](https://hermes-agent.nousresearch.com) responde à sua equipe de onde quer que ela já trabalhe — Slack, Telegram, CLI, execuções agendadas. A captura de sessões do Hermes traz tudo isso para o AgentEye como sessões e eventos comuns, tornando o assistente com o qual sua equipe conversa todos os dias tão observável quanto os agentes que você mesmo escreve.
+
+Um pequeno coletor em segundo plano lê o armazenamento local de sessões do Hermes conforme ele é escrito e envia as sessões para o AgentEye. Funciona da mesma forma que a captura do [Codex](/pt-br/agenteye/codex-capture) e do [OpenClaw](/pt-br/agenteye/openclaw-capture), e um único coletor pode capturar vários ao mesmo tempo.
+
+---
+
+## O que é capturado
+
+Todas as sessões do Hermes na máquina são capturadas, independentemente do canal de origem. Cada uma se torna uma [sessão](/pt-br/agenteye/sessions) no AgentEye; suas mensagens de usuário e assistente, chamadas de ferramenta e resultados de ferramenta se tornam os [eventos](/pt-br/agenteye/event-stream) correspondentes.
+
+O canal pelo qual uma sessão foi iniciada — Slack, Telegram, CLI ou uma execução agendada — é registrado na sessão, para que você possa diferenciá-las e filtrar por uma de cada vez. Junto a isso, são registrados o modelo usado na sessão, o chat e a pessoa que a iniciou e, quando uma sessão originou outra, o vínculo com a sessão pai.
+
+As sessões aparecem assim que o Hermes as inicia, mesmo que nada tenha sido dito ainda, e a resposta de um turno e suas chamadas de ferramenta são mantidas na ordem em que realmente ocorreram. Quando uma sessão termina, você também obtém o motivo do encerramento, o custo e a quantidade de tokens utilizados.
+
+---
+
+## Como ativar
+
+A captura fica desativada até você habilitá-la. Instale o coletor com uma chave de API que tenha a permissão `events:add` (consulte [Chaves de API](/pt-br/agenteye/api-keys)) e ative a captura do Hermes:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --hermes-enabled
+```
+
+Isso instala o coletor, o registra como um serviço em segundo plano e inicia a captura. Confirme que está em execução:
+
+```bash
+agenteye-collector health
+```
+
+Capturando mais de um agente na mesma máquina? Adicione a flag de cada um ao mesmo comando — por exemplo, `--hermes-enabled --codex-enabled`.
+
+Na primeira execução, suas sessões existentes do Hermes são preenchidas retroativamente uma vez, e a nova atividade passa a ser transmitida em segundos. Os dados do próprio Hermes são apenas lidos — nunca modificados ou excluídos — e cada mensagem é enviada uma única vez, mesmo após reinicializações.
+
+O `health` também informa se tudo que o coletor capturou realmente chegou ao AgentEye. Se um lote não puder ser entregue, ele é mantido e reenviado em vez de descartado, e a verificação reporta estado não saudável enquanto houver itens pendentes — portanto, "saudável" significa que seus dados chegaram, não apenas que o processo está ativo.
+
+---
+
+## Onde aparece
+
+As sessões capturadas aparecem em **Sessions**, e seus eventos na stream de **Events**, da mesma forma que qualquer outro agente que você observa — portanto, o [replay de sessão](/pt-br/agenteye/sessions), a [busca](/pt-br/agenteye/queries), as [avaliações](/pt-br/agenteye/evaluations) e os [alertas](/pt-br/agenteye/alerts) funcionam normalmente com elas. Filtre pelo agente Hermes para visualizá-las separadamente.
+
+---
+
+## Privacidade
+
+As sessões do Hermes contêm a transcrição completa — incluindo saída de comandos, conteúdo de arquivos e tudo que o agente leu ou escreveu — e podem conter segredos. As sessões capturadas são enviadas no estado em que se encontram, portanto, ative a captura somente onde centralizar esse conteúdo no AgentEye for adequado, e forneça ao coletor uma chave com escopo limitado a `events:add`. Consulte [Segurança](/pt-br/agenteye/security) para saber como seus dados são mantidos isolados.

package/.next/standalone/docs-old/pt-br/agenteye/incidents.mdx

@@ -0,0 +1,50 @@
+---
+title: "Incidentes"
+description: "Quando um alerta dispara, todos podem ver que o incidente está aberto, quem é o responsável e o que aconteceu até agora — em uma linha do tempo atribuída."
+---
+
+
+Quando um alerta dispara, a primeira pergunta é sempre "quem está cuidando disso?" Os incidentes respondem a essa questão: no momento em que algo ultrapassa um limiar, todos podem ver que o incidente está aberto, quem é o responsável e exatamente o que aconteceu até agora, com um registro limpo e atribuído que pode ser entregue diretamente para uma análise pós-incidente.
+
+![A caixa de entrada de Incidentes: cartões de incidentes vinculados a alertas e abertos manualmente, agrupados por estado, cada um com um badge de severidade e um responsável](/agenteye/images/incidents.png)
+*A caixa de entrada agrupa os incidentes abertos por estado e filtra por severidade e responsável, para que você veja o que precisa de atenção humana agora.*
+
+## Saiba quem está cuidando, de relance
+
+Chega de "alguém está olhando para isso?" em uma thread de chat. Uma violação abre um incidente automaticamente e o coloca em uma caixa de entrada compartilhada, agrupada por estado. Reconheça-o e seu nome estará nele, para que o restante da equipe saiba que está sendo tratado. O reconhecimento é compartilhado: vários operadores podem reconhecer o mesmo incidente e cada um é registrado individualmente, para que uma equipe completa de resposta apareça por nome em vez de se sobrepor. Atribua um único responsável pelo triagem e filtre a caixa de entrada por severidade ou responsável para reduzir ao que é seu.
+
+## Toda a história, em uma única linha do tempo
+
+Quando o incidente termina, você já tem o relatório. Abra qualquer incidente e você terá as evidências da violação, seus responsáveis e assinantes, uma thread de comentários para coordenação no local e uma linha do tempo de atividade somente de acréscimo.
+
+![Uma visualização detalhada de incidente: o alerta pai e o resumo da violação, responsáveis e assinantes, uma linha do tempo de atividade atribuída e uma thread de comentários](/agenteye/images/incident-detail.png)
+*Tudo o que aconteceu, em ordem, cada linha assinada por quem fez a ação.*
+
+Cada ação (aberto, reconhecido, resolvido, e assim por diante) é gravada nessa linha do tempo e nunca é editada. Cada entrada é atribuída: ao operador que a executou, por e-mail, ou como **automatizado** para qualquer coisa que o Failproof AI Observability fez por conta própria, como abrir o incidente na violação. Nada é anônimo e nada se perde, então a análise pós-incidente praticamente se escreve sozinha.
+
+## Como um incidente evolui
+
+```mermaid
+stateDiagram-v2
+    [*] --> firing
+    firing --> acknowledged: an operator acks
+    firing --> resolved: an operator resolves
+    acknowledged --> resolved: an operator resolves
+    resolved --> [*]
+```
+
+- **Aberto (firing):** a violação abre o incidente e notifica seus canais uma vez. Violações repetidas são incorporadas ao mesmo incidente e atualizam suas evidências em vez de notificá-lo repetidamente.
+- **Reconhecido (acknowledged):** um operador assume o incidente. Ele permanece aberto, e violações posteriores atualizam as evidências silenciosamente.
+- **Resolvido (resolved):** um operador encerra o incidente. A resolução automática quando a condição se normaliza está planejada, mas ainda não habilitada — portanto, um incidente permanece aberto até que um humano o resolva, o que mantém todos honestos sobre o que realmente foi resolvido. Um novo incidente pode ser aberto no mesmo alerta posteriormente.
+
+Um alerta mantém no máximo um incidente aberto por vez, portanto uma regra instável não pode te soterrar em duplicatas. Você também pode abrir um incidente manualmente: um independente para algo que nenhum alerta capturou, ou um vinculado a um alerta existente, se você tiver a permissão `incidents:write`.
+
+## Onde encontrar
+
+Os incidentes estão em `/<org-slug>/incidents`. Para visualizar, é necessária a permissão **`incidents:read`**; para abrir um incidente manual, **`incidents:write`**; para reconhecer, atribuir, comentar e resolver, **`incidents:ack`**. Chaves mais antigas que concediam a permissão descontinuada `alerts:ack` continuam funcionando, pois ela é tratada como `incidents:ack`, portanto sua rotação de plantão não precisa ser reemitida.
+
+## Relacionados
+
+- [Alertas](/pt-br/agenteye/alerts): as regras que abrem esses incidentes quando um limiar é ultrapassado.
+- [Rastreamento de erros](/pt-br/agenteye/error-tracking): veja todas as falhas em um único lugar e promova uma delas a um alerta.
+- [Auditorias](/pt-br/agenteye/audits): o analista agendado que encontra as falhas que nenhuma regra estava monitorando.

package/.next/standalone/docs-old/pt-br/agenteye/observability.mdx

@@ -0,0 +1,23 @@
+---
+title: "Observar"
+description: "As superfícies de observação são onde você acompanha o que seus agentes estão fazendo agora e analisa qualquer execução individual."
+---
+
+
+As superfícies de observação são onde você acompanha o que seus agentes estão fazendo agora e analisa qualquer execução individual. Tudo aqui é em tempo real, com escopo para sua organização e filtrável por intervalo de datas, ambiente, agente e sessão — para que você passe de "algo parece errado" para a execução exata em segundos.
+
+![O Event Stream ao vivo, com código de cores por tipo e filtrável por ambiente, agente e sessão](/agenteye/images/events-stream.png)
+
+Quatro superfícies, cada uma com sua própria página:
+
+- **[Event stream](/pt-br/agenteye/event-stream)**: o rastro ao vivo, passo a passo, de cada execução em todos os agentes, da mais recente para a mais antiga. É a página inicial da sua organização e o primeiro ponto de triagem.
+- **[Sessões e grafo de execução](/pt-br/agenteye/sessions)**: esses eventos consolidados em uma linha por execução, além de uma visualização no estilo git de como cada execução se desenrolou.
+- **[Métricas de desempenho](/pt-br/agenteye/telemetry)**: mapas de calor de latência e indicadores p50/p95/p99 para seus modelos, ferramentas e hooks, para que um pico na cauda se destaque da mediana.
+- **[Rastreamento de erros](/pt-br/agenteye/error-tracking)**: uma única superfície de triagem para tudo que deu errado, a um clique de um alerta disparado até a execução que falhou.
+
+## Relacionado
+
+- [Avaliações](/pt-br/agenteye/evaluations): pontue cada execução pela qualidade.
+- [Alertas](/pt-br/agenteye/alerts): transforme qualquer limite em uma regra de notificação.
+- [Auditorias](/pt-br/agenteye/audits): deixe a Observabilidade do Failproof AI encontrar padrões de falha entre sessões para você.
+- [CLI e agentes](/pt-br/agenteye/cli-and-agents): a mesma observabilidade a partir do seu terminal.

package/.next/standalone/docs-old/pt-br/agenteye/openclaw-capture.mdx

@@ -0,0 +1,49 @@
+---
+title: "Captura de sessão OpenClaw"
+description: "Envie as sessões locais OpenClaw da sua equipe para o AgentEye como sessões e eventos comuns — sem alterar a forma como o OpenClaw é executado."
+---
+
+Se sua equipe utiliza o [OpenClaw](https://docs.openclaw.ai), a captura de sessão OpenClaw traz essas sessões para o AgentEye como sessões e eventos comuns, permitindo que você pesquise, reproduza e avalie-as junto com tudo o mais que você observa. Ela complementa o [Python SDK](/pt-br/agenteye/python-sdk): o SDK instrumenta os agentes que você escreve, enquanto esta captura o trabalho OpenClaw que sua equipe já realiza — sem nenhuma alteração na forma como eles o executam.
+
+Um pequeno coletor em segundo plano lê os transcritos de sessão locais do OpenClaw conforme são gravados e os envia para o AgentEye. Ele funciona da mesma forma que a [captura do Codex](/pt-br/agenteye/codex-capture), e um único coletor pode capturar ambos ao mesmo tempo.
+
+---
+
+## O que é capturado
+
+Cada agente configurado na instalação OpenClaw de uma máquina é capturado pelo coletor dessa máquina — não é necessária nenhuma configuração por agente.
+
+Cada sessão OpenClaw se torna uma [sessão](/pt-br/agenteye/sessions) no AgentEye; suas mensagens de usuário e assistente, chamadas de ferramentas e resultados de ferramentas se tornam os [eventos](/pt-br/agenteye/event-stream) correspondentes.
+
+---
+
+## Como ativar
+
+A captura fica desativada até que você a habilite. Instale o coletor com uma chave de API que tenha a permissão `events:add` (consulte [Chaves de API](/pt-br/agenteye/api-keys)) e ative a captura OpenClaw:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --openclaw-enabled
+```
+
+Isso instala o coletor, registra-o como um serviço em segundo plano e inicia a captura. Confirme que está em execução:
+
+```bash
+agenteye-collector health
+```
+
+Capturando mais de um agente na mesma máquina? Adicione a flag de cada um ao mesmo comando — por exemplo, `--openclaw-enabled --codex-enabled`.
+
+Na primeira execução, suas sessões OpenClaw existentes são preenchidas retroativamente uma vez, e as novas atividades passam a ser transmitidas em segundos. Os próprios arquivos do OpenClaw são apenas lidos — nunca modificados, movidos ou excluídos — e cada sessão é enviada exatamente uma vez, mesmo entre reinicializações.
+
+---
+
+## Onde aparecem
+
+As sessões capturadas aparecem em **Sessões**, e seus eventos no fluxo de **Eventos**, da mesma forma que qualquer outro agente que você observa — portanto, [replay de sessão](/pt-br/agenteye/sessions), [pesquisa](/pt-br/agenteye/queries), [avaliações](/pt-br/agenteye/evaluations) e [alertas](/pt-br/agenteye/alerts) funcionam normalmente nelas. Filtre pelo agente OpenClaw para visualizá-las de forma isolada.
+
+---
+
+## Privacidade
+
+Os transcritos do OpenClaw contêm a sessão completa — incluindo saída de comandos, conteúdo de arquivos e tudo o que o agente leu ou escreveu — e podem conter segredos. As sessões capturadas são enviadas como estão, portanto, ative a captura somente em máquinas e para equipes onde centralizar esse conteúdo no AgentEye seja apropriado, e forneça ao coletor uma chave com escopo restrito a `events:add`. Consulte [Segurança](/pt-br/agenteye/security) para saber como seus dados são mantidos isolados.

package/.next/standalone/docs-old/pt-br/agenteye/overview.mdx

@@ -0,0 +1,108 @@
+---
+title: "Failproof AI: Observe Agentes em Busca de Falhas"
+description: "Failproof AI Observability é uma plataforma auto-hospedada para observar, avaliar e aprimorar seus agentes de IA em produção."
+---
+
+
+Failproof AI Observability é uma plataforma auto-hospedada para observar, avaliar e aprimorar seus agentes de IA em produção. Ela registra tudo o que seus agentes fazem (cada chamada de ferramenta, requisição ao modelo, hook e erro), pontua a qualidade de cada execução e expõe as falhas que você não sabia que precisava procurar — tudo em um dashboard que roda dentro da sua própria infraestrutura.
+
+Se você coloca agentes de IA em produção e está cansado de tentar adivinhar por que uma execução deu errado, este é o ponto de partida certo. Aqui você entende o que Failproof AI Observability oferece e como as peças se encaixam, antes mesmo de instalar qualquer coisa.
+
+> **Failproof AI Observability é um produto empresarial da Failproof AI.** Quer ver em ação? Solicite uma demonstração: envie um e-mail para [nikita@befailproof.ai](mailto:nikita@befailproof.ai).
+
+![Uma sessão do Failproof AI Observability representada como um grafo de execução no estilo git ao lado da sua linha do tempo de eventos, com um detalhamento por execução de ferramentas, modelos e hooks na coluna da direita](/agenteye/images/session-detail.png)
+
+*Cada execução de agente é representada como um grafo de execução no estilo git (esquerda) ao lado da sua linha do tempo de eventos. Sub-agentes paralelos recebem sua própria faixa; a coluna da direita detalha as ferramentas, modelos, hooks e consumo de tokens da execução.*
+
+---
+
+## Veja em ação
+
+Dois vídeos curtos mostram as duas coisas que as equipes buscam primeiro: rastrear uma execução e encontrar falhas automaticamente.
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/VWxukZc5k7s?autoplay=1&mute=1&loop=1&playlist=VWxukZc5k7s&rel=0&playsinline=1" title="Watch: Agent Tracing by Failproof AI (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*Rastreamento de agentes: acompanhe uma única execução passo a passo, do objetivo às ferramentas até a resposta final.*
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/C5nHKGQIqZQ?autoplay=1&mute=1&loop=1&playlist=C5nHKGQIqZQ&rel=0&playsinline=1" title="Watch: Automatically find where your agent is failing (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*Failproof Audit: deixe o Failproof AI Observability minerar seus logs entre sessões e identificar o que precisa ser corrigido.*
+
+---
+
+## Por que as equipes usam
+
+- **Veja o que seu agente realmente fez.** Cada execução se torna um grafo de execução legível no estilo git: quais ferramentas rodaram em paralelo, quais sub-agentes se ramificaram, onde travou e quanto consumiu.
+- **Detecte regressões de qualidade automaticamente.** Conecte um pequeno serviço de pontuação e o Failproof AI Observability pontua cada execução concluída — uma queda na utilidade ou um pico de alucinações aparece por conta própria.
+- **Encontre falhas para as quais você não escreveu uma regra.** Auditorias recorrentes mineram seus logs entre sessões em busca de clusters de erros, outliers de latência, pontuações baixas e execuções travadas, entregando descobertas classificadas e fundamentadas em evidências.
+- **Seja alertado quando importa.** Regras de threshold disparam sobre taxa de erro, latência, custo ou pontuações de avaliadores e abrem incidentes que você pode reconhecer, atribuir e resolver.
+- **Faça perguntas em linguagem natural.** Um assistente de IA integrado ao dashboard responde perguntas como "como está a qualidade em prod esta semana?" sobre seus próprios dados. Qualquer alteração que ele faça requer aprovação.
+- **Mantenha seus dados.** Failproof AI Observability é auto-hospedado: eventos, prompts e análises ficam na infraestrutura que você controla.
+
+---
+
+## O que você recebe
+
+Failproof AI Observability é organizado em torno de três ideias (**observe**, **analyze** e **admin**), refletidas na barra lateral esquerda do dashboard.
+
+**Observe** (a realidade bruta do que aconteceu):
+
+- **[Event stream](/pt-br/agenteye/event-stream)**: o rastro em tempo real, passo a passo, de cada execução (chamadas de ferramentas, chamadas ao modelo, hooks, erros).
+- **[Sessions](/pt-br/agenteye/sessions)**: esses eventos consolidados em uma linha por execução, cada uma pronta para ser pontuada, com um grafo de execução no estilo git.
+- **[Performance metrics](/pt-br/agenteye/telemetry)**: mapas de calor de latência por superfície e métricas p50/p95/p99 para modelos, ferramentas e hooks, de modo que um pico na cauda se destaque da mediana.
+- **[Error tracking](/pt-br/agenteye/error-tracking)**: uma superfície de triagem unificada para tudo que deu errado, a um clique de um alerta disparado.
+
+![A página de observação de Tools: um mapa de calor de latência, uma faixa de percentil e uma barra de distribuição de ferramentas ao longo de 24 intervalos de tempo](/agenteye/images/tools.png)
+
+*Cada superfície de observação combina um sparkline e métricas p50/p95/p99 com um mapa de calor de latência e uma faixa de percentil. Mostrado aqui: Tools.*
+
+**Analyze** (transforme atividade em respostas):
+
+- **[Queries](/pt-br/agenteye/queries)** e **[dashboards](/pt-br/agenteye/dashboards)**: SQL salvo sobre seus eventos e avaliações, transformado em dashboards compartilhados com escopo de organização.
+- **[Evaluations](/pt-br/agenteye/evaluations)**: pontuações de qualidade produzidas pelo seu próprio serviço de avaliação, com raciocínio por pontuação.
+- **[Audits](/pt-br/agenteye/audits)**: investigações recorrentes que expõem padrões de falha entre sessões.
+- **[Alerts](/pt-br/agenteye/alerts)** e **[incidents](/pt-br/agenteye/incidents)**: regras de threshold que alertam você, mais um fluxo de trabalho de incidentes para triagem.
+
+**Interfaces** (acesse seus dados do seu jeito):
+
+- **[CLI](/pt-br/agenteye/cli-and-agents)**: controle todo o seu deployment pelo terminal ou por um script, e deixe um agente de codificação fazer isso por você em linguagem natural.
+- **[AI assistant](/pt-br/agenteye/assistant)**: faça perguntas sobre seus agentes em linguagem natural, diretamente no dashboard.
+- **REST API**: tudo o que o dashboard e o CLI fazem é respaldado por uma REST API que você pode chamar diretamente com uma [chave de API](/pt-br/agenteye/api-keys) com escopo — ingira eventos, consulte sessões e avaliações, e gerencie dashboards, alertas, auditorias, usuários e chaves, para integrar o Failproof AI Observability às suas próprias ferramentas.
+
+**Admin** (gerencie para sua equipe):
+
+- **[API keys](/pt-br/agenteye/api-keys)**: tokens com escopo para o coletor, o dashboard e o assistente.
+- **Users**: login sem senha, baseado em e-mail, com lista de permissões.
+- **Settings**: configuração por organização, incluindo substituições de janela de contexto do modelo.
+
+---
+
+## Como as peças se encaixam
+
+Os dados fluem em uma única direção, do código do seu agente até o dashboard: seu agente (via SDK Python) emite eventos para o agenteye-collector, que os envia ao servidor, que serve o dashboard. Dois serviços opcionais completam o conjunto — um serviço de pontuação (avaliações) e um serviço de assistente de IA (o chat integrado ao dashboard).
+
+- **SDK Python**: você adiciona algumas chamadas `agenteye.event.*` ao seu agente; os eventos são armazenados em buffer localmente.
+- **agenteye-collector**: um daemon leve em cada máquina de agente que agrupa eventos em lotes e os envia ao servidor.
+- **Servidor**: ingere seus eventos, mantém o estado operacional nos seus próprios bancos de dados e serve a REST API utilizada pelo dashboard, CLI e suas próprias integrações.
+- **Dashboard**: onde você explora tudo.
+- **Serviços opcionais**: um serviço de pontuação (avaliações) e um serviço de assistente de IA (o chat integrado ao dashboard).
+
+Para o vocabulário usado ao longo da documentação (*event, session, evaluation, audit, finding, incident*), consulte [Concepts](/pt-br/agenteye/concepts).
+
+---
+
+## Obtendo o Failproof AI Observability
+
+Failproof AI Observability é um produto empresarial da Failproof AI e funciona em conjunto com o Failproof AI Enforcement — o produto de políticas e guardrails — sob a marca Failproof AI. Ele roda inteiramente no seu próprio ambiente. Se você ainda não tem acesso aos pacotes, solicite uma demonstração e entraremos em contato: envie um e-mail para [nikita@befailproof.ai](mailto:nikita@befailproof.ai).
+
+---
+
+## Próximos passos
+
+- [Concepts](/pt-br/agenteye/concepts): o vocabulário do Failproof AI Observability em um único lugar.
+- [Observability](/pt-br/agenteye/observability): acompanhe o que seus agentes fazem, execução por execução.
+- [Security](/pt-br/agenteye/security): como o Failproof AI Observability mantém seus dados isolados e sob seu controle.

package/.next/standalone/docs-old/pt-br/agenteye/python-sdk-skill.mdx

@@ -0,0 +1,136 @@
+---
+title: "Agent Skill Python SDK de Observabilidade do Failproof AI"
+description: "Saia de um agente sem instrumentação para eventos visíveis, com seu agente de código encontrando os pontos de instrumentação, escrevendo-os e provando que funcionaram."
+---
+
+Diga ao seu agente de código *"adicione Observabilidade do Failproof AI a este agente"* e deixe-o ler seu loop, identificar onde a instrumentação deve ficar, escrevê-la e verificar os eventos antes de declarar o trabalho concluído.
+
+A **skill Python SDK** (`agenteye-python-sdk`) é um *Agent Skill*: uma pasta de instruções que um agente de código como Claude Code ou Codex carrega sob demanda quando uma tarefa corresponde a ela. Ela ensina o agente a usar o [Python SDK](/pt-br/agenteye/python-sdk) — não é uma biblioteca e não muda nada sobre como o SDK funciona.
+
+## Instrumentação é fácil de escrever e fácil de errar silenciosamente
+
+O SDK é pequeno: treze métodos de eventos, todos com argumentos nomeados. Um agente de código pode ler a referência do [Python SDK](/pt-br/agenteye/python-sdk) e produzir instrumentação plausível em um minuto.
+
+O problema é que esse SDK não levanta exceções quando você erra, e uma instrumentação incorreta parece exatamente com uma correta — até alguém abrir um dashboard e encontrá-lo vazio. Os erros que custam tempo real são todos silêncios:
+
+| O erro | O que você vê |
+|---|---|
+| Sem `agent_start` | Todos os eventos chegam. Zero sessões. |
+| Ambiente nunca definido | Tudo funciona, arquivado como `dev`. |
+| `outcome="failure"` | A execução aparece como verde — apenas `failed`, `error`, `timeout`, `rejected` contam. |
+| Nome de campo com erro de digitação | Aceito e armazenado como um novo campo. |
+| Eventos emitidos de um thread pool | Descartados silenciosamente. |
+
+Nenhum desses levanta exceções. Nenhum aparece em testes. Cada um está na skill, declarado como um contrato com a verificação que o detecta.
+
+## O que ela faz, em ordem
+
+A skill executa os mesmos três passos que um engenheiro cuidadoso seguiria:
+
+1. **Planejar.** Ela lê seu loop de agente e faz as duas perguntas que só você pode responder: o que conta como uma execução (seu `session_id`) e quem são os atores distinguíveis (seu `agent_id`). Ela obtém essas respostas antes de escrever código, porque mudá-las depois divide seu histórico e quebra as tendências.
+2. **Escrever.** Ela vincula a identidade uma vez por execução em vez de passá-la por todos os pontos de chamada, e escolhe uma forma segura para concorrência — um detalhe que importa, porque o atalho óbvio silenciosamente mistura duas execuções sobrepostas em uma única sessão.
+3. **Verificar.** Ela executa seu agente e lê os arquivos de eventos resultantes, verificando se `agent_start` está presente, se o ambiente está correto e se uma execução produziu uma sessão.
+
+Esse terceiro passo é o que as pessoas pulam. O SDK grava eventos em arquivos locais, então uma integração completa pode ser provada em um laptop sem servidor, sem chave de API e sem rede — e é exatamente por isso que a skill insiste em fazê-lo.
+
+## Como ela se relaciona com as outras skills
+
+Três skills, uma divisão clara:
+
+| Skill | Use quando | O que ela toca |
+|---|---|---|
+| **Skill Python SDK** (esta página) | Você quer que seu agente *emita* telemetria — "adicionar observabilidade", "por que meu agente não está aparecendo?" | Escreve código no repositório do seu agente. Não lê nada. |
+| **[Skill Evaluator](/pt-br/agenteye/evaluator-skill)** | Você quer *pontuar* execuções — "o que devemos medir?" | Escreve código no seu repositório; lê telemetria |
+| **[Skill CLI](/pt-br/agenteye/cli-skill)** | Você quer *ler* o que aconteceu, ou operar seu deployment | Usa o CLI como você, incluindo alterações |
+
+Elas se encadeiam nessa ordem: esta skill faz os eventos fluírem, o evaluator os pontua, e o CLI os lê de volta. Não há nada para avaliar e nada para ler até que seu agente emita sessões — então, se você está começando do zero, comece aqui.
+
+## Pré-requisitos
+
+1. **Python 3.10+** e a base de código do agente que você deseja instrumentar.
+2. **O SDK.** Ele é distribuído aos clientes como um wheel privado, não de um índice público — seu onboarding cobre como obtê-lo e instalá-lo. A skill conhece o caminho de instalação e perguntará a você em vez de adivinhar, caso não consiga encontrá-lo.
+3. **Nada mais.** Sem login no dashboard, sem chave de API, sem rede. A skill verifica contra os arquivos de eventos que o SDK grava, portanto pode concluir e provar seu trabalho offline.
+
+## Onde encontrá-la
+
+A skill está na coleção pública [`FailproofAI/skills`](https://github.com/FailproofAI/skills):
+
+```bash
+npx skills add FailproofAI/skills --skill agenteye-python-sdk -a claude-code
+```
+
+Adicione `-g` para instalá-la em todos os projetos em vez de apenas no atual, e `--copy` se seu ambiente não suporta symlinks. Para Codex, passe `-a codex`.
+
+## Instalando manualmente
+
+Agent Skills são pastas contendo um `SKILL.md` mais referências. Se preferir não usar o instalador:
+
+- **Claude Code**: copie a pasta `agenteye-python-sdk/` para `~/.claude/skills/` (todos os projetos) ou `<seu-repositório>/.claude/skills/` (somente aquele repositório). Claude Code a descobre automaticamente — verifique a lista `/skills`, ou simplesmente pergunte algo que corresponda a ela.
+- **Codex**: o Codex lê o mesmo `SKILL.md`. O arquivo `agents/openai.yaml` incluído define `allow_implicit_invocation: true`, então ela é selecionada automaticamente quando uma tarefa corresponde; caso contrário, invoque-a como `$agenteye-python-sdk`.
+
+Execute seu agente **no repositório que contém o código que você deseja instrumentar** — a skill lê seu loop de agente antes de propor qualquer coisa.
+
+## Como uma sessão se parece
+
+```text
+você  ▸ Adicione Observabilidade do Failproof AI a este agente.
+
+agente▸ Li seu loop — um dispatcher de ferramentas em tools.py, um
+        wrapper do Anthropic em llm.py. Duas perguntas antes de
+        escrever qualquer coisa.
+
+        O que conta como uma execução? Você lida com requisições
+        concorrentemente, então eu usaria o id de requisição que você
+        já tem em ctx.request_id — assim uma sessão aqui e uma
+        requisição nos seus logs são a mesma string.
+
+        E quem são os atores? Vejo um caminho de planejador e um
+        caminho de pesquisador. Rotulo-os separadamente, ou é um único
+        agente para você?
+
+você  ▸ O id de requisição está certo. São um único agente, chame de
+        "assistant".
+
+agente▸ Pronto. Envolvi o dispatcher e o cliente LLM; agent_start e
+        agent_end delimitam handle_request, incluindo o caminho de erro.
+        Usei um context-local para identidade — seu dispatcher executa
+        ferramentas em um thread pool, e a abordagem mais simples teria
+        misturado execuções concorrentes em uma única sessão sem
+        reclamar.
+
+        Verificado contra uma execução real: 11 eventos em 4 arquivos —
+        agent_start, model_request/response, tool_use/tool_result x3,
+        agent_end (outcome=success). environment=production, uma sessão
+        por requisição, durações pareadas.
+
+        Uma coisa que eu NÃO fiz: seu worker pool em batch.py submete
+        diretamente ao executor, então eventos de lá seriam descartados.
+        Quer que eu corrija esses também?
+```
+
+O padrão a observar: ele leu o código antes de propor, fez apenas as perguntas que só você pode responder, reutilizou um id que você já tinha, escolheu a forma segura para concorrência *porque* viu um thread pool, e **verificou lendo os eventos reais** em vez de declarar sucesso — e então sinalizou o único lugar que sabia que falharia silenciosamente.
+
+## O que você pode pedir
+
+- *"Por que meu agente não está aparecendo no dashboard?"* → percorre a escada: os eventos estão sendo gravados, `agent_start` está lá, o ambiente está correto, o collector está lendo o mesmo lugar.
+- *"Tudo está chegando como dev."* → o ambiente nunca foi definido, ou foi redefinido por uma chamada posterior.
+- *"Adicione rastreamento de tokens."* → encontra seu wrapper LLM e registra modelo, motivo de parada e uso.
+- *"Instrumente os sub-agentes também."* → uma sessão, rótulos de agentes distintos, aninhados sob seu pai.
+- *"Escreva testes para a instrumentação."* → aponta o SDK para um diretório temporário e faz asserções sobre os eventos que ele gravou.
+
+## O que observar
+
+**Deixe-o verificar.** O passo que torna esta skill útil é o último — executar seu agente e ler os eventos de volta. Um agente que escreve instrumentação e para fez a metade fácil, e a metade que falha silenciosamente é a outra.
+
+**Concorde com os nomes antes do código.** `session_id` e `agent_id` são os eixos pelos quais toda superfície agrupa. Renomeá-los depois divide o histórico: execuções antigas mantêm os rótulos antigos e suas tendências se quebram. A skill vai perguntar; a resposta vale um minuto de reflexão.
+
+**Se seu agente propuser instalar o SDK de um índice público, a skill não carregou.** O SDK é distribuído de forma privada. Essa proposta é um sinal confiável de que seu agente de código está adivinhando em vez de seguir a skill — pare-o ali e verifique se a skill está instalada.
+
+Além disso, seu raio de ação é pequeno: ela escreve código no seu diretório de trabalho e arquivos de eventos onde você mandar. Não lê nada do seu deployment e não muda nada nele.
+
+## Próximos passos
+
+- **[Python SDK](/pt-br/agenteye/python-sdk)**: a referência completa de eventos — cada tipo de evento e campo — por trás do que esta skill automatiza.
+- **[Sessions](/pt-br/agenteye/sessions)**: o que sua instrumentação produz quando os eventos chegam.
+- **[Evaluator Agent Skill](/pt-br/agenteye/evaluator-skill)**: o próximo passo quando as execuções estiverem chegando — pontuá-las.
+- **[CLI Agent Skill](/pt-br/agenteye/cli-skill)**: lendo sua telemetria de volta.