Testar apps de IA e deixar a IA testar os seus: as camadas, as ferramentas e quanto custam

Testes agora andam em duas direções. Se você lança um recurso de IA, precisa de testes para algo que dá uma resposta um pouco diferente a cada vez. Se você lança software comum, ferramentas de IA agora se oferecem para escrever e manter seus testes. Os dois mercados estão lotados, os dois têm preços que escondem a conta real, e os dois têm um modo de falha que parece um build verde. Aqui está como pensar nas camadas, qual das 16 ferramentas que analisamos serve para qual trabalho, e uma configuração inicial que um líder de equipe consegue defender.

O mapa: dois trabalhos, sete camadas

A maior parte da confusão vem de comparar ferramentas que fazem trabalhos diferentes. Uma biblioteca de métricas de RAG e um agente de navegador se chamam de "testes com IA", e nenhuma substitui a outra. Organize o trabalho primeiro.

Testar um app ou agente de IA tem quatro camadas:

• Evals: entradas fixas, saídas pontuadas. A resposta continua fiel às fontes, a chamada de ferramenta vai para a função certa. Esse é o seu teste unitário.
• Conversas simuladas: um segundo modelo faz o papel do usuário por vários turnos, porque agentes falham no turno quatro, não no turno um.
• Regressão de red team: ataques gerados (injeção de prompt, vazamento de dados, saídas nocivas) executados de novo a cada mudança, para que uma falha corrigida continue corrigida.
• Pontuação em produção: os mesmos avaliadores rodam sobre traces reais, e respostas ruins de usuários reais viram novos casos de teste.

A IA testando software comum tem três:

• Gravar e reproduzir para backends: capturar chamadas reais de API e as respostas do banco de dados por trás delas, e reproduzi-las como testes.
• Gravar e reproduzir para front ends: capturar sessões reais e comparar a aparência das telas antes e depois de uma mudança.
• Agentes de navegador: uma IA que planeja, escreve, executa e conserta testes de ponta a ponta, no seu repositório ou na nuvem de um fornecedor.

Testando o seu app de IA

Evals: a camada a construir primeiro

promptfoo (4,5) é o caminho mais curto de nenhum teste de LLM para testes em CI: um arquivo YAML de prompts, provedores e asserções, e um comando que mostra uma matriz de comparação. Exige Node.js 22.22 ou mais recente. Um ponto a pesar: em 9 de março de 2026 a OpenAI anunciou que compraria o promptfoo, e a empresa agora diz que faz parte da OpenAI. Continua sob licença MIT e aceita outros provedores, mas algumas equipes não vão querer que seu avaliador pertença a um fornecedor que elas estão avaliando.

DeepEval (4,2) serve a equipes de Python que querem evals dentro da suíte de testes que já têm. Os testes parecem pytest, rodam com deepeval test run e quebram o build quando a fidelidade ou a conclusão de tarefas cai abaixo de um limite. Seu catálogo de métricas está entre os mais amplos do código aberto e chega a planejamento de agentes e voz.

Giskard (4,0) reúne verificações determinísticas, verificações julgadas por LLM, geração de conjuntos de teste de RAG e uma varredura de red team em uma única biblioteca Apache-2.0. A versão 3 é uma reescrita que exige Python 3.12 ou mais recente e abandona a varredura de modelos tabulares em que os usuários da v2 confiavam.

Duas que talvez você já tenha. Ragas (3,4) deu à avaliação de RAG o seu vocabulário (fidelidade, precisão de contexto) e ainda soma cerca de 1,05 milhão de downloads por mês no PyPI, mas ninguém faz commit nele desde 24 de fevereiro de 2026. Mantenha-o se funciona; não comece projetos novos com ele. Inspect (4,4), do UK AI Security Institute, é a estrutura que os institutos públicos de segurança de IA usam, com mais de 200 evals prontas. É a ferramenta certa para benchmarks de modelos e mais framework do que uma equipe de produto que verifica prompts em CI precisa.

Conversas simuladas

Evals de um único prompt não pegam o agente que responde bem à primeira pergunta e, três turnos depois, esquece uma restrição. LangWatch Scenario (3,9) testa isso conversando com o seu agente: um modelo faz o papel do usuário, outro julga cada turno, e tudo roda como um teste comum de pytest ou vitest. Você pode fixar a mensagem inicial, injetar o resultado simulado de uma ferramenta, verificar que uma ferramenta específica foi chamada e deixar o simulador continuar. Agentes de voz também são cobertos, com injeção de ruído e latência p50 e p95. É um projeto pequeno, cerca de 1.000 estrelas com 165 issues abertas, e funciona melhor ao lado de uma biblioteca de evals do que no lugar dela.

Regressão de red team em CI

Uma varredura de red team feita uma vez antes do lançamento é uma auditoria. Repetida a cada pull request, vira um teste de regressão. O promptfoo gera ataques de injeção de prompt, jailbreak e exfiltração de dados; por padrão essa geração roda no serviço hospedado dele, e o plano gratuito Community limita o red teaming a 10.000 sondagens por mês. A varredura do Giskard escreve uma suíte adversária a partir de uma descrição em linguagem simples do que o seu agente deve e não deve fazer, mapeada para o OWASP LLM Top 10. O RedTeamAgent do Scenario troca o usuário simulado educado por um atacante que escala ao longo de vários turnos, o que se parece mais com jailbreaks reais do que um único prompt hostil.

Pontuação em produção

Testes antes do lançamento só cobrem as entradas em que você pensou. Braintrust (4,3) foi construído em torno da pergunta sobre se a última mudança melhorou as coisas: experimentos, conjuntos de dados e pontuação online compartilham um único modelo de dados, então uma resposta ruim em produção vira caso de teste em poucos cliques, e o mesmo avaliador roda no CI e no tráfego real. Langfuse (4,6) é o caminho de código aberto, com tracing, conjuntos de dados, experimentos e pontuação com LLM como juiz em uma edição auto-hospedada gratuita, ao custo de você mesmo operar Postgres, ClickHouse, Redis e armazenamento de objetos.

Deixando a IA testar o seu software

Gravar e reproduzir

Keploy (4,0) é para o backend sem testes. Você roda o serviço sob keploy record, percorre os fluxos e ele captura as chamadas de API junto com o tráfego de PostgreSQL, MySQL, MongoDB, Redis, Kafka ou RabbitMQ que elas causaram. keploy test reproduz as requisições e serve as dependências gravadas como mocks, então o CI não precisa de banco de dados de teste. No Linux ele faz isso com eBPF, o que significa nenhuma mudança de código, mas exige root e kernel 5.10 ou mais recente; as versões nativas para macOS e Windows só reproduzem HTTP, MySQL e MongoDB de forma confiável.

Meticulous (3,7) faz o mesmo para front ends. Um script de gravação em builds de staging ou de pré-visualização captura sessões e as respostas do backend que elas receberam; a cada pull request ele as reproduz contra o código antigo e o novo e agrupa as telas que mudaram de aparência. Você revisa uma lista de mudanças visuais em vez de escrever código de teste. Ele verifica a aparência da tela, não se o pedido chegou ao seu banco de dados.

Agentes de navegador

Este é o canto mais movimentado, e as quatro opções diferem principalmente em quem é dono dos testes e quem os executa.

Playwright Test Agents (4,1) vêm de graça com o Playwright. Um planejador explora o seu app e escreve um plano de testes em Markdown, um gerador transforma o plano em testes Playwright no seu repositório, e um reparador conserta testes que falham, um de cada vez. Eles rodam dentro do agente de programação que você já usa (VS Code, Claude Code, Codex ou opencode) e chamam o Playwright MCP (4,7) para controlar o navegador. O resultado é código Playwright comum, sem nenhum fornecedor no meio.

Momentic (4,0) deixa você escrever um teste como uma frase, salva-o como YAML no seu repositório e o executa em navegadores hospedados, emuladores Android ou simuladores iOS. Quando um botão muda de lugar, o auto-heal o encontra de novo e propõe uma edição para você revisar.

TestSprite (3,7) fica atrás do seu agente de programação: lê o código ou um documento de requisitos, escreve testes de frontend e backend, executa-os na nuvem dele e devolve um pacote de falha com capturas de tela, a estrutura da página e uma correção sugerida.

QA Wolf (4,1) vende o trabalho, não a ferramenta. Seus agentes escrevem e executam testes Playwright e Appium, decidem se uma falha é um teste desatualizado ou um bug real e registram bugs com vídeo no Linear ou no Jira; no plano gerenciado, engenheiros de QA humanos examinam cada falha em até 24 horas. O código pode ser exportado.

Um alerta sobre testes unitários gerados por IA. Qodo (3,8), a empresa antes chamada CodiumAI e conhecida primeiro por gerar testes, descontinuou neste outono seu comando de geração de testes sem substituto e agora vende revisão de pull requests. Agentes de programação escrevem testes unitários de bom grado quando pedidos; o risco é que um teste escrito a partir do código verifique o que o código faz, não o que deveria fazer. Deixe que uma pessoa escreva ou aprove a asserção.

Qual ferramenta para qual trabalho

Trabalho	Comece com	Nossa nota	Quanto custa
Testes de regressão de prompts e RAG em CI	promptfoo ou DeepEval	4,5 / 4,2	Grátis; você paga tokens do juiz e do modelo
Verificações, perguntas de RAG e varredura de red team em uma biblioteca Python	Giskard	4,0	Grátis; tokens do juiz, gpt-4o-mini por padrão
Comportamento de agentes em vários turnos	LangWatch Scenario	3,9	Grátis; duas chamadas de LLM por turno por teste
Benchmarks de modelos e evals de segurança	Inspect	4,4	Grátis; tokens e computação de sandbox
Pontuar tráfego de produção, hospedado	Braintrust	4,3	Plano gratuito; Pro US$ 249 por mês
Tracing e evals que você mesmo hospeda	Langfuse	4,6	Grátis auto-hospedado; nuvem a partir de US$ 29 por mês
Backend sem testes	Keploy	4,0	CLI grátis; Pro US$ 19 por usuário por mês
Regressões visuais em um front end movimentado	Meticulous	3,7	Não publicado
Testes de ponta a ponta próprios, já em Playwright	Playwright Test Agents	4,1	Grátis; tokens do agente de programação
Testes de ponta a ponta em linguagem simples, web e mobile	Momentic	4,0	US$ 50 de uso grátis; Scale US$ 500 por mês
Um agente de programação que confere o próprio trabalho em um navegador	TestSprite	3,7	A partir de US$ 19 por mês em créditos
Entregar os testes de ponta a ponta para outra pessoa	QA Wolf	4,1	US$ 1 por execução web, US$ 2 por execução mobile

Quanto custa de verdade

Quase toda ferramenta de evals de código aberto é grátis para instalar e cobrada em tokens para rodar. DeepEval, Ragas e Giskard pontuam a maioria das métricas com um juiz LLM, então a conta é mais ou menos casos de teste vezes métricas vezes execuções. Algumas centenas de casos a cada pull request se acumulam, e o Scenario dobra isso, porque um simulador e um juiz falam a cada turno. Rode a suíte completa toda noite e um pequeno conjunto de smoke tests a cada pull request.

Plataformas hospedadas medem de outro jeito, e o medidor decide para quem elas servem. O Braintrust cobra por dados e pontuações, não por assentos: o Pro a US$ 249 por mês cobre 5 GB e 50.000 pontuações, depois US$ 1,50 por 1.000 pontuações, então julgar cada requisição de produção é a linha que mais cresce. O próprio exemplo do Langfuse põe o Pro com 5 milhões de unidades em US$ 551 por mês. A nuvem da LangWatch custa €29 por assento no Growth, e o Confident AI, do DeepEval, salta de Free para US$ 200 por mês.

Em testes de navegador, a unidade é a execução ou o passo. O próprio exemplo da QA Wolf, 50 testes web a cada dia útil, dá cerca de US$ 1.083 por mês, e rodar os mesmos testes a cada pull request multiplica isso. O Momentic cobra US$ 0,0125 por passo normal e US$ 0,025 por um passo que a IA teve de descobrir; os US$ 50 grátis equivalem a cerca de 4.000 passos, e quando o saldo acaba os testes pausam em vez de gastar além. O Starter do TestSprite custa US$ 19 por 400 créditos, mas a página de preços nunca diz o que um crédito compra. O Pro do Keploy inclui 400 execuções de teste e depois US$ 0,22 cada. O Meticulous não publica preço nenhum; estimativas em sites de avaliação vão de cerca de US$ 2.000 por ano a US$ 600 por mês.

Onde essas ferramentas enganam você

• Juízes instáveis. Um juiz é um modelo, e falha como um. Entre as issues mais discutidas do DeepEval estão juízes que devolvem JSON inválido, o que faz o teste falhar por um motivo que nada tem a ver com o seu app. As pontuações também mudam quando o modelo juiz muda, então fixe a versão do juiz e trate uma atualização dele como a de uma dependência: rode a linha de base de novo antes de comparar.
• Não determinismo. Seu app varia, o usuário simulado varia e o juiz varia. O cache_key do Scenario faz o usuário simulado se repetir, mas um prompt alterado invalida o cache. Meça taxas de aprovação ao longo de várias execuções e alerte quando caírem, em vez de quebrar o build por uma única amostra vermelha.
• Autorreparo que esconde bugs. O trabalho de um reparador é deixar verde um teste vermelho, e às vezes o resultado correto é vermelho. A documentação do Playwright diz que o reparador pode decidir que um recurso está quebrado e pular o teste, o que uma equipe ocupada pode confundir com aprovação. O Momentic propõe correções para revisão em vez de aplicá-las em silêncio, e os agentes da QA Wolf tentam separar testes desatualizados de bugs reais. Seja o que for que você comprar, leia cada diff reparado e conte testes pulados como falhas.
• Gravações só conhecem o passado. Keploy e Meticulous cobrem apenas o que alguém fez durante a gravação, e respostas gravadas ficam desatualizadas quando o esquema muda. Uma suíte de reprodução verde não diz nada sobre o fluxo em que ninguém clicou.
• Seus dados saem de casa. O TestSprite executa testes na nuvem dele, então as páginas e capturas de tela do seu app passam pela infraestrutura dele. O gravador do Meticulous captura teclas digitadas e respostas de rede; senhas são ocultadas por padrão, outros dados pessoais precisam de regras que você escreve. A telemetria vem ligada por padrão no promptfoo, no DeepEval, no Ragas e no Giskard, e cada chamada ao juiz envia seus prompts de teste ao provedor que você configurar.

Uma configuração inicial

Para uma equipe com um recurso de IA e um app web comum, isto cobre a maior parte do risco por pouco mais que o custo em tokens:

1. Escreva de 30 a 50 casos de eval a partir de perguntas reais de usuários no promptfoo ou no DeepEval, com asserções determinísticas sempre que a resposta permitir e um juiz LLM só onde não permitir. Rode-os a cada pull request que mexa em um prompt ou modelo.
2. Adicione uma varredura de red team (promptfoo ou Giskard) ao build noturno e transforme cada ataque que passar em um caso de teste permanente.
3. Se o recurso for um agente, adicione de três a cinco testes do Scenario para as conversas que já deram errado antes, com o usuário simulado em cache.
4. Envie os traces de produção para o Langfuse ou o Braintrust e passe toda semana um punhado de respostas ruins para o conjunto de evals.
5. Para o resto do app, cubra os cinco fluxos que nunca podem quebrar (cadastro, checkout, a exportação de que um cliente grande depende) com Playwright Test Agents se você já usa Playwright, ou com o plano gratuito do Momentic se não usa. Peça a alguém que revise cada plano e cada teste reparado.
6. Configure as opções de desativação de telemetria (PROMPTFOO_DISABLE_TELEMETRY, DEEPEVAL_TELEMETRY_OPT_OUT=1, DO_NOT_TRACK=1) antes da primeira execução, não depois.

O porém: cada camada aqui torna mais barato produzir uma suíte de testes, e nenhuma decide o que significa correto. Um conjunto de evals que só faz perguntas fáceis passa, um reparador que reescreve asserções passa, e uma reprodução do tráfego do mês passado passa. A parte cara de testar sempre foi decidir o que verificar, e esse trabalho continua com a sua equipe.

Nossa opinião: trate a IA nos testes como um contratado novo e rápido. Deixe que ela escreva os casos, rode-os e sugira correções, e mantenha com uma pessoa a lista do que precisa ser verdade e a aprovação de qualquer teste que ela altere. Pague por um serviço hospedado só quando a conta for menor que o tempo que alguém da sua equipe gasta para manter viva a versão gratuita.