O desafio de validar agentes de IA em ambiente de produção
Quando se trabalha com agentes de inteligência artificial, surge um problema que os testes tradicionais de software não conseguem resolver de forma adequada. Diferentemente de aplicações convencionais, onde uma entrada específica sempre produz a mesma saída, agentes de IA possuem características fundamentalmente diferentes: são flexíveis, adaptáveis e conscientes do contexto em que operam.
Considere uma pergunta simples: “Qual é a previsão do tempo em Tóquio?” Um agente bem projetado poderia responder informando a temperatura em Celsius ou Fahrenheit, incluindo umidade e vento, ou focando apenas na temperatura. Todas essas respostas podem ser corretas e úteis — mas como você avalia sistematicamente algo que não segue um padrão determinístico?
O problema se torna ainda mais complexo quando consideramos que agentes não apenas geram texto, mas também tomam ações. Um agente bem-projetado utiliza ferramentas, recupera informações e toma decisões durante toda uma conversa. Avaliar apenas a resposta final ignora se o agente seguiu passos apropriados para chegar àquele resultado.
Além disso, conversas multi-turnos adicionam outra camada de complexidade. Quando usuários interagem com um agente ao longo de múltiplas trocas, respostas anteriores influenciam as posteriores. Um agente pode responder bem a perguntas isoladas, mas falhar em manter contexto coerente ao longo de uma conversa inteira.
Por que a avaliação de agentes é diferente
Essas características criam uma necessidade que os testes baseados em asserções simples não conseguem atender. A avaliação baseada em modelos de linguagem de grande escala (LLM — Large Language Model) surge como resposta, permitindo que se avaliem qualidades como utilidade, coerência e fidelidade que resistem a verificações mecânicas.
A AWS apresenta o Strands Evals, um framework projetado especificamente para este desafio. Ele fornece um conjunto integrado de avaliadores baseados em LLM, ferramentas de simulação de usuários e capacidades de relatório, permitindo que equipes de desenvolvimento validem agentes de forma rigorosa e repetível.
Conceitos fundamentais do Strands Evals
O framework funciona seguindo um padrão familiar para quem já escreveu testes unitários, mas adaptado para a avaliação baseada em julgamento que agentes de IA exigem. Três conceitos formam a base:
Cases
Um Case representa um cenário único de teste. Contém a entrada que você deseja testar — por exemplo, uma pergunta do usuário — além de saídas esperadas opcionais, sequências de ferramentas esperadas (trajetórias) e metadados. Cases são a unidade atômica de avaliação.
from strands_evals import Case
case = Case(
name="Weather Query",
input="What is the weather like in Tokyo?",
expected_output="Should include temperature and conditions",
expected_trajectory=["weather_api"]
)Experiments
Um Experiment agrupa múltiplos Cases com um ou mais avaliadores. É o equivalente a um conjunto de testes (test suite) nos testes tradicionais. O Experiment orquestra o processo de avaliação: pega cada Case, executa o agente nele e aplica os avaliadores configurados para gerar pontuações.
Evaluators
Avaliadores funcionam como juízes. Examinam o que seu agente produziu e comparam contra o que era esperado. Diferentemente de verificações de asserção simples, os avaliadores no Strands Evals são principalmente baseados em LLM, usando modelos de linguagem para fazer julgamentos sofisticados sobre qualidade, relevância e utilidade.
Task Function
Uma Task Function é um elemento executável que você fornece ao Experiment. Recebe um Case e retorna os resultados da execução desse caso no seu sistema. Essa interface permite dois padrões fundamentalmente diferentes de avaliação.
Avaliação online: invoca o agente ao vivo durante a avaliação. Sua Task Function cria um agente, envia a entrada do Case, captura a resposta e o rastreamento de execução, retornando-os para avaliação. Este padrão é recomendado durante desenvolvimento para feedback rápido ou em pipelines de CI/CD (Integração e Entrega Contínua).
from strands import Agent
def online_task(case):
agent = Agent(tools=[search_tool, calculator_tool])
result = agent(case.input)
return {
"output": str(result),
"trajectory": agent.session
}Avaliação offline: trabalha com dados históricos. Em vez de invocar um agente, sua Task Function recupera rastreamentos gravados anteriormente de logs, bancos de dados ou sistemas de observabilidade. Este padrão funciona bem quando você precisa avaliar tráfego de produção, realizar análise histórica ou comparar versões de agentes contra o mesmo conjunto de interações reais.
def offline_task(case):
trace = load_trace_from_database(case.session_id)
session = session_mapper.map_to_session(trace)
return {
"output": extract_final_response(trace),
"trajectory": session
}Avaliadores integrados para avaliação abrangente
O Strands Evals fornece dez avaliadores integrados, cada um projetado para avaliar uma dimensão diferente da qualidade do agente.
Avaliadores baseados em rubrica
Os avaliadores mais flexíveis permitem que você defina critérios personalizados através de rubricas em linguagem natural. O OutputEvaluator julga a resposta final que seu agente produz. Você fornece uma rubrica descrevendo o que é “bom”, e o avaliador usa um LLM para pontuar a saída contra esses critérios.
O TrajectoryEvaluator estende isso para examinar a sequência de ações que o agente tomou. Além de apenas olhar para a resposta final, você pode verificar se o agente usou ferramentas apropriadas em uma ordem lógica. O avaliador inclui três funções de pontuação integradas: correspondência exata, correspondência em ordem e correspondência em qualquer ordem.
O InteractionsEvaluator lida com sistemas de múltiplos agentes onde vários componentes se comunicam, avaliando sequências de interações entre agentes ou componentes do sistema.
Avaliadores semânticos
Algumas dimensões de qualidade são comuns o suficiente para que o Strands Evals forneça avaliadores pré-construídos com prompts cuidadosamente projetados.
O HelpfulnessEvaluator avalia respostas da perspectiva do usuário usando uma escala de sete pontos, desde “não útil” até “acima e além”. O FaithfulnessEvaluator verifica se a resposta está fundamentada no histórico da conversa — particularmente importante para sistemas RAG (Recuperação Aumentada de Geração), onde você precisa garantir que o agente não fabrique informações.
O HarmfulnessEvaluator realiza verificações de segurança, ajudando a determinar se as respostas contêm conteúdo prejudicial ou inadequado.
Avaliadores em nível de ferramenta
Quando seu agente usa ferramentas, frequentemente você precisa avaliar não apenas o resultado final, mas a qualidade de invocações individuais de ferramentas. O ToolSelectionAccuracyEvaluator examina cada chamada de ferramenta em contexto e julga se selecionar aquela ferramenta em particular era justificado. O ToolParameterAccuracyEvaluator vai além, verificando se os parâmetros passados a cada ferramenta estavam corretos e apropriados.
Avaliadores em nível de sessão
O GoalSuccessRateEvaluator adota a visão mais ampla, avaliando sessões de conversa inteiras para determinar se o usuário finalmente alcançou seu objetivo. Para agentes orientados por tarefas, sucesso é definido por resultados em vez de uma única resposta.
Simulando usuários para testes multi-turnos
Os avaliadores mencionados funcionam bem para interações de turno único. Conversas multi-turnos apresentam um desafio maior: usuários reais não seguem scripts. Fazem perguntas de acompanhamento, mudam de direção e expressam confusão.
O Strands Evals inclui um ActorSimulator que cria usuários simulados alimentados por IA para conduzir conversas multi-turnos com seu agente. O simulador começa com um Case que define o que o usuário quer alcançar. A partir disso, ele gera um perfil de usuário realista usando um LLM, incluindo traços de personalidade, nível de expertise, estilo de comunicação e uma meta específica.
from strands_evals import Case, ActorSimulator
from strands import Agent
case = Case(
input="I need help setting up a new bank account",
metadata={"task_description": "Successfully open a checking account"}
)
user_sim = ActorSimulator.from_case_for_user_simulator(
case=case,
max_turns=10
)
agent = Agent(system_prompt="You are a helpful banking assistant.")
user_message = case.input
while user_sim.has_next():
agent_response = agent(user_message)
user_result = user_sim.act(str(agent_response))
user_message = str(user_result.structured_output.message)Durante a interação, o usuário simulado envia mensagens ao agente, recebe respostas e decide o que dizer em seguida. Este ciclo continua até que o objetivo seja alcançado ou o número máximo de turnos seja atingido. Você pode então passar a transcrição da conversa resultante para avaliadores em nível de sessão para avaliar se seu agente ajudou com sucesso o usuário simulado a alcançar sua meta.
Estrutura hierárquica de avaliação
Diferentes avaliadores operam em diferentes granularidades. O Strands Evals usa um TraceExtractor para analisar dados de sessão no formato que cada avaliador precisa.
Avaliação em nível de sessão: analisa a conversa completa do início ao fim. O avaliador recebe o histórico completo, as execuções de ferramentas e entende todo o contexto. O GoalSuccessRateEvaluator funciona neste nível porque determinar alcance de objetivos requer entender a interação inteira.
Avaliação em nível de rastreamento: foca em turnos individuais — cada par de pergunta do usuário e resposta do agente. Avaliadores neste nível recebem o histórico da conversa até aquele ponto e julgam a resposta específica. Helpfulness, Faithfulness e Harmfulness funcionam aqui.
Avaliação em nível de ferramenta: desce para invocações individuais de ferramentas. Cada chamada é avaliada em contexto, com acesso às ferramentas disponíveis, a conversa até aquele ponto, e os argumentos específicos passados.
Integração na prática
Um fluxo de avaliação típico começa com a definição de casos de teste representando cenários que você quer que seu agente manipule bem. Eles podem vir de consultas de usuários reais, geração sintética ou casos extremos que você identificou:
from strands_evals import Experiment, Case
from strands_evals.evaluators import OutputEvaluator, TrajectoryEvaluator
cases = [
Case(
name="Weather Query",
input="What is the weather like in Tokyo?",
expected_output="Should include temperature and conditions",
expected_trajectory=["weather_api"]
),
Case(
name="Calculator Usage",
input="What is 15% of 847?",
expected_output="127.05",
expected_trajectory=["calculator"]
)
]Em seguida, você configura avaliadores com rubricas ou configurações apropriadas e cria um Experiment agrupando Cases e avaliadores. Finalmente, executa a avaliação com sua Task Function e examina os resultados através de relatórios detalhados.
Para conjuntos de testes maiores, o Strands Evals suporta avaliação assíncrona com paralelismo configurável, permitindo escalar o processo de teste conforme suas necessidades crescem.
Gerando casos de teste em escala
O fluxo anterior assume que você já tem casos de teste prontos. Criar suites de teste abrangentes manualmente fica tedioso conforme as capacidades do seu agente crescem. O Strands Evals inclui um ExperimentGenerator que usa LLMs para criar casos de teste e rubricas de avaliação a partir de descrições de alto nível.
O gerador cria casos de teste diversos cobrindo diferentes aspectos do contexto especificado, com níveis de dificuldade apropriados. Casos gerados são particularmente valiosos durante desenvolvimento inicial quando você quer cobertura ampla mas ainda não identificou padrões de falha específicos. Conforme sua prática de avaliação amadurece, complemente Cases gerados com cenários feitos à mão visando casos extremos conhecidos.
Boas práticas para avaliação de agentes
Comece pequeno e itere: inicie com poucos casos de teste cobrindo seus cenários de usuário mais críticos. Conforme observa como seu agente falha na prática, adicione casos direcionados que abordem esses modos de falha específicos.
Escolha avaliadores que correspondam aos seus objetivos: selecione avaliadores que meçam diretamente o que importa para seu caso de uso. Um agente voltado para clientes pode priorizar Helpfulness e Goal Success, enquanto um assistente de pesquisa pode valorizar mais Faithfulness.
Escreva rubricas claras e específicas: avaliadores baseados em rubricas são tão bons quanto as rubricas que você fornece. Evite critérios vagos em favor de padrões específicos e mensuráveis. Inclua exemplos do que constitui pontuações altas, médias e baixas.
Combine avaliação online e offline: use avaliação online durante desenvolvimento para feedback rápido em mudanças de código. Complemente com avaliação offline de rastreamentos de produção para capturar problemas que só aparecem com comportamento real de usuários.
Defina limiares significativos: defina limiares de aprovação/falha baseados em seus requisitos reais de qualidade. Analise resultados de avaliação para entender quais pontuações se correlacionam com bons resultados de usuários, então defina limiares correspondentes.
Rastreie tendências ao longo do tempo: execuções individuais de avaliação fornecem snapshots, mas tendências revelam a trajetória. Armazene resultados de avaliação e rastreie métricas-chave entre lançamentos. Degradação gradual pode ser mais difícil de notar que falhas repentinas, mas igualmente prejudicial.
Invista em diversidade de casos de teste: cubra a faixa completa de entradas que seu agente encontrará: consultas comuns, casos extremos, entradas adversariais e conversas multi-turnos.
Avalie em múltiplos níveis: sucesso em nível de sessão pode mascarar problemas em nível de ferramenta, e vice-versa. Um agente pode alcançar metas de usuários através de passos intermediários ineficientes ou incorretos. Componha suites de avaliação que verifiquem qualidade em níveis de sessão, rastreamento e ferramenta para obter uma visão completa.
Conclusão
Construir agentes de IA confiáveis exige mais que intuição e verificações pontuais. Requer avaliação sistemática que rastreie qualidade através de múltiplas dimensões ao longo do tempo. O Strands Evals fornece uma fundação através de um framework projetado especificamente para os desafios únicos da avaliação de agentes.
A separação entre invocação de agente e lógica de avaliação permite tanto testes online durante desenvolvimento quanto análise offline de rastreamentos de produção. Avaliadores baseados em LLM fornecem o julgamento que avaliação de qualidade exige. Níveis de avaliação hierárquicos permitem validação em múltiplas granularidades, desde chamadas individuais de ferramentas até sessões de conversa completas.
Para explorar o Strands Evals, a documentação com exemplos práticos contém amostras que você pode adaptar para seus próprios casos de uso. Comece com poucos casos de teste representando seus cenários de usuário mais importantes, adicione avaliadores que correspondam a seus critérios de qualidade e execute avaliações como parte de seu fluxo de desenvolvimento. Ao longo do tempo, expanda sua suite de testes para cobrir mais cenários. Avaliação sistemática é a fundação que o ajuda a entregar agentes de IA com confiança.
Fonte
Evaluating AI agents for production: A practical guide to Strands Evals (https://aws.amazon.com/blogs/machine-learning/evaluating-ai-agents-for-production-a-practical-guide-to-strands-evals/)
Leave a Reply