Você escreveu cinquenta linhas de Python. Um system prompt, uma lista de tools, uma chamada ao modelo. Seu agente agenda reuniões, consulta bancos de dados, envia emails. Funciona lindamente no seu terminal. Bora mandar pra produção?

Abra seu arquivo de teste primeiro. Vai lá. Tenta escrever um teste pra algo que dá uma resposta diferente toda vez que você pergunta.

O problema do não-determinismo que ninguém quer discutir

Um teste normal em Python se parece com isso:

def test_add():
    assert add(2, 2) == 4  # determinístico. sempre 4.

Um teste de agente se parece com isso:

def test_booking_agent():
    result = agent.run("Reserve uma sala pra amanhã às 14h")
    assert result == ???  # o que vai aqui?
    # O agente pode dizer "Pronto! Sala A reservada às 14h"
    # ou "Reservei a sala de reuniões A para amanhã às 14:00"
    # ou "Feito! Sala A, 27 de abril, 14:00"
    # Todas corretas. Todas strings diferentes.

Um LLM — o cérebro por trás do ChatGPT, Claude, Gemini — é não-determinístico. Mesma entrada, saída diferente. Toda vez. Seu assertEqual é inútil. Isso não é um bug. É a propriedade fundamental que torna agentes úteis. E torna praticamente impossível testá-los com as ferramentas que engenheiros usam há décadas.

Três SDKs lançados este mês. Zero comandos de teste.

Três SDKs de agentes de peso — kits de ferramentas para construir agentes de IA — foram lançados em abril. A Anthropic lançou a Managed Agents API em 8 de abril. A OpenAI atualizou seu Agents SDK em 15 de abril. O Google lançou o ADK 1.0 junto com o Agent Simulation no Cloud Next em 22 de abril. Todos três te entregam primitivas de build e run. Nenhum inclui um comando de teste.

Isso não é uma comparação entre três vendors. É um padrão. A indústria inteira — todo grande laboratório de IA — decidiu que testar é problema seu.

O que eles oferecem no lugar

O Google chegou mais perto. No Cloud Next, anunciaram o Agent Evaluation — um serviço na nuvem que avalia seu agente em conclusão de tarefas, uso de ferramentas e segurança. Genuinamente útil para métricas de sistema. Mas roda no Vertex AI, custa aproximadamente US$0,50–2,00 por avaliação dependendo da complexidade, e leva minutos para completar. Rode isso por pull request num repositório movimentado e você tá olhando pra US$300+ por mês só em taxas de avaliação — antes do uso real da API. Isso não é um teste unitário. É um evento de cobrança.

A Managed Agents API da Anthropic oferece tracing — um log de cada passo que seu agente deu — mas zero utilitários de teste. Nenhum mock de modelo, nenhuma gravação de respostas, nenhum helper de asserção.

A OpenAI oferece um parâmetro seed para reprodutibilidade parcial, mas "parcial" significa "às vezes a mesma saída, às vezes não". Tenta construir CI/CD — pipelines automatizados de deploy — em cima de "às vezes".

O padrão de asserção comportamental

A comunidade encontrou um workaround. Em vez de fazer asserção no texto exato, asserte no padrão de comportamento — quais tools o agente chamou, em que ordem, e se ele parou quando deveria:

def test_booking_agent_behavior(recorded_responses):
    trace = agent.run("Reserve uma sala pra amanhã às 14h")
    
    # Asserte nas chamadas de tool, não no texto de saída
    assert trace.tool_calls[0].name == "check_availability"
    assert trace.tool_calls[1].name == "create_booking"
    assert "room" in trace.tool_calls[1].args
    assert trace.completed  # não ficou em loop infinito

Projetos open-source como DeepEval e Promptfoo são pioneiros dessa abordagem. Nenhum se integra nativamente com qualquer um dos três SDKs. Você vai colar tudo na mão.

Todo workaround tem um preço

Mockar o modelo? Você perde o raciocínio do LLM que torna agentes valiosos — você tá testando um fantoche, não um agente. Testes de snapshot — gravar uma resposta exata e comparar depois? Quebram em toda atualização de modelo ou ajuste de prompt. Avaliações na nuvem? Minutos e dólares por pull request. Asserções comportamentais? Difíceis de escrever, mais difíceis de manter, e basicamente você tá criando um framework de teste do zero pra cada projeto.

A tensão fundamental: engenheiros construíram ferramentas de teste para software determinístico. Agentes não são determinísticos nem, a rigor, software no sentido tradicional. São sistemas estocásticos vestindo fantasia de software.

O que fazer de verdade agora

Nenhum vendor vai te salvar. Aqui está o que funciona, com toda a absurdidade reconhecida — você tá inventando infraestrutura de teste em 2026 porque três empresas trilionárias não se deram ao trabalho:

  1. Grave respostas reais do LLM como golden fixtures — respostas salvas conhecidas que você reproduz nos testes em vez de chamar o modelo toda vez. Sim, você tá construindo na mão a infraestrutura que o SDK deveria ter mandado de fábrica. Não, a ironia não passou despercebida.

  2. Asserte em sequências de tool-calls, não no texto final. O agente chamou check_availability antes de create_booking? Bom o suficiente. Seu cérebro treinado em assertEqual vai gritar. Deixa.

  3. Rode smoke tests contra modelos reais num cron diário, não por pull request. Capture drift de modelo sem torrar seu orçamento de CI.

  4. Trate testes de agente como testes de integração — mais lentos, menos numerosos, mais valiosos — não como testes unitários. Cinco bons testes comportamentais vencem cinquenta testes de snapshot frágeis. Quem te diz pra "só escrever mais testes" nunca tentou testar algo que gera um haiku diferente sobre reserva de salas a cada execução.

# Prático: padrão record & replay
import json

def record_golden_fixture(agent, prompt, path):
    """Roda uma vez contra o modelo real, salva o trace."""
    trace = agent.run(prompt)
    with open(path, "w") as f:
        json.dump(trace.to_dict(), f)
    return trace

def test_from_fixture(mock_agent, fixture_path):
    """Reproduz trace salvo, asserte na estrutura."""
    with open(fixture_path) as f:
        golden = json.load(f)
    mock_agent.load_trace(golden)
    result = mock_agent.replay()
    assert [c["name"] for c in result.tool_calls] == [
        "check_availability", "create_booking"
    ]

O vendor que lançar agent test primeiro vence

O Django capturou devs web com manage.py test. O Rails fez isso com rails test. O primeiro SDK de agentes que tornar testes uma primitiva padrão — não um upsell na nuvem a US$0,50 por execução, não um addon de terceiros, mas um comando local que funciona offline — captura a camada de desenvolvedores acima de qualidade de modelo e quantidade de ferramentas.

O agente intestável é o novo microsserviço sem testes. Todo mundo faz deploy. Todo mundo se arrepende seis meses depois. Agora mesmo, aquele comando agent test não existe em nenhum dos três principais SDKs.

Seu arquivo de teste continua vazio.