Por que avaliar agentes em múltiplas rodadas é fundamentalmente diferente
A avaliação de interações single-turn (uma única rodada) segue um padrão bem estabelecido: você fornece uma entrada, coleta a saída e julga o resultado. Estruturas como o Strands Evaluation SDK sistematizam esse processo através de avaliadores que medem helpfulness (utilidade), faithfulness (fidelidade) e tool usage (uso de ferramentas). Publicações anteriores cobrem como construir suites de avaliação abrangentes para agentes de IA usando essas capacidades.
No entanto, as conversas em produção raramente param em uma única rodada. Usuários reais se envolvem em trocas que se desenrolam ao longo de múltiplas rodadas. Eles fazem perguntas de acompanhamento quando as respostas são incompletas, mudam de direção quando novas informações surgem e expressam frustração quando suas necessidades não são atendidas. Um assistente de viagens que funciona bem com “Compre um voo para Paris” isoladamente pode sofrer quando o mesmo usuário pergunta depois: “Na verdade, podemos olhar trens?” ou “E quanto a hotéis perto da Torre Eiffel?”
O desafio da escala em avaliações multi-rodada
Testar esses padrões dinâmicos exige mais do que casos de teste estáticos com entradas e saídas predefinidas. A dificuldade central é a escala: você não pode conduzir manualmente centenas de conversas multi-rodada toda vez que seu agente muda. Além disso, fluxos de conversa roteirizados o prendem a caminhos predeterminados que não refletem como usuários reais se comportam.
O que equipes de avaliação precisam é de uma forma de gerar usuários realistas e orientados por objetivos programaticamente, permitindo que eles conversem naturalmente com um agente ao longo de múltiplas rodadas. A AWS aborda esse desafio com o ActorSimulator no Strands Evaluation SDK, que oferece simulação estruturada de usuários integrada ao seu pipeline de avaliação.
O que torna um usuário simulado efetivo
A avaliação baseada em simulação é bem estabelecida em outras disciplinas de engenharia. Simuladores de voo testam respostas de pilotos a cenários que seriam perigosos ou impossíveis de reproduzir no mundo real. Engines de jogos usam agentes orientados por IA para explorar milhões de caminhos de comportamento de jogador antes do lançamento. O mesmo princípio se aplica a IA conversacional.
Um usuário simulado útil começa com uma persona consistente. Um que se comporta como especialista técnico em uma rodada e novato confuso na próxima produz dados de avaliação não confiáveis. Consistência significa manter o mesmo estilo de comunicação, nível de expertise e traços de personalidade em cada troca, assim como uma pessoa real faria.
Igualmente importante é o comportamento orientado por objetivos. Usuários reais chegam a um agente com algo que querem realizar. Eles persistem até alcançar o objetivo, ajustam sua abordagem quando algo não está funcionando e reconhecem quando o objetivo foi atingido. Sem objetivos explícitos, um usuário simulado tende a encerrar conversas muito cedo ou continuar perguntando indefinidamente, nenhum dos quais reflete o uso real.
O usuário simulado também deve responder adaptativamente ao que o agente diz, não seguir um script predeterminado. Quando o agente faz uma pergunta de esclarecimento, o ator deve respondê-la em caráter. Se a resposta for incompleta, o ator segue em relação ao que foi deixado de fora. Se a conversa se desviar do tópico, o ator a reconecta ao objetivo original. Esses comportamentos adaptativos tornam as conversas simuladas valiosas como dados de avaliação porque exercitam a mesma dinâmica de conversa que seu agente enfrenta em produção.
Como o ActorSimulator funciona
O ActorSimulator implementa essas qualidades de simulação através de um sistema que encapsula um Strands Agent configurado para se comportar como uma persona de usuário realista. O processo começa com geração de perfil. Dado um caso de teste contendo uma consulta de entrada e uma descrição de tarefa opcional, o ActorSimulator usa um Modelo de Linguagem Grande (LLM) para criar um perfil de ator completo.
Um caso de teste com entrada “Preciso de ajuda para reservar um voo para Paris” e descrição de tarefa “Completar reserva de voo dentro do orçamento” pode produzir um viajante consciente do orçamento com experiência iniciante e um estilo de comunicação casual. A geração de perfil dá a cada conversa simulada um caráter distinto e consistente.
Gerenciamento de conversa e rastreamento de objetivos
Com o perfil estabelecido, o simulador gerencia a conversa rodada por rodada. Ele mantém o histórico completo da conversa e gera cada resposta em contexto, mantendo o comportamento do usuário simulado alinhado com seu perfil e objetivos ao longo de todo o diálogo.
Quando seu agente aborda apenas parte do pedido, o usuário simulado naturalmente faz perguntas de acompanhamento sobre as lacunas. Uma pergunta de esclarecimento do agente recebe uma resposta que permanece consistente com a persona. A conversa se sente orgânica porque cada resposta reflete tanto a persona do ator quanto tudo o que foi dito até então.
O rastreamento de objetivo funciona junto com a conversa. O ActorSimulator inclui uma ferramenta integrada de avaliação de conclusão de objetivo que o usuário simulado pode invocar para avaliar se seu objetivo original foi atendido. Quando o objetivo é satisfeito ou o usuário simulado determina que o agente não pode completar seu pedido, o simulador emite um sinal de parada e a conversa termina. Se o máximo de rodadas for atingido antes do objetivo ser cumprido, a conversa também para. Isso oferece um indicador de que o agente pode não estar resolvendo as necessidades do usuário de forma eficiente.
Cada resposta do usuário simulado também inclui raciocínio estruturado ao lado do texto da mensagem. Você pode inspecionar por que o usuário simulado escolheu dizer o que disse, se estava seguindo informações faltantes, expressando confusão ou redirecionando a conversa. Essa transparência é valiosa durante o desenvolvimento da avaliação porque você pode ver o raciocínio por trás de cada rodada, facilitando o rastreamento de onde as conversas têm sucesso ou falham.
Iniciando com o ActorSimulator
Para começar, você precisará instalar o Strands Evaluation SDK usando:
pip install strands-agents-evalsPara instruções passo a passo, você pode consultar a documentação ou nosso post anterior para mais detalhes. Colocar esses conceitos em prática requer código mínimo. Você define um caso de teste com uma consulta de entrada e uma descrição de tarefa que captura o objetivo do usuário. O ActorSimulator cuida da geração de perfil, gerenciamento de conversa e rastreamento de objetivo automaticamente.
O exemplo a seguir avalia um agente assistente de viagens através de uma conversa simulada multi-rodada:
from strands import Agent
from strands_evals import ActorSimulator, Case, Experiment
# Define your test case
case = Case(
input="I want to plan a trip to Tokyo with hotel and activities",
metadata={"task_description": "Complete travel package arranged"}
)
# Create the agent you want to evaluate
agent = Agent(
system_prompt="You are a helpful travel assistant.",
callback_handler=None
)
# Create user simulator from test case
user_sim = ActorSimulator.from_case_for_user_simulator(
case=case, max_turns=5
)
# Run the multi-turn conversation
user_message = case.input
conversation_history = []
while user_sim.has_next():
# Agent responds to user
agent_response = agent(user_message)
agent_message = str(agent_response)
conversation_history.append({
"role": "assistant",
"content": agent_message
})
# Simulator generates next user message
user_result = user_sim.act(agent_message)
user_message = str(user_result.structured_output.message)
conversation_history.append({
"role": "user",
"content": user_message
})
print(f"Conversation completed in {len(conversation_history) // 2} turns")O loop de conversa continua até que has_next() retorne False, o que acontece quando os objetivos do usuário simulado são atingidos, o usuário simulado determina que o agente não pode completar o pedido, ou o limite máximo de rodadas é atingido. O conversation_history resultante contém a transcrição completa multi-rodada, pronta para avaliação.
Integração com pipelines de avaliação
Um loop de conversa standalone é útil para experimentos rápidos, mas a avaliação em produção exige capturar traces e alimentá-los em seu pipeline de avaliador. O próximo exemplo combina o ActorSimulator com coleta de telemetria OpenTelemetry e mapeamento de sessão do Strands Evals. A função de tarefa executa uma conversa simulada e coleta spans de cada rodada, depois os mapeia em uma sessão estruturada para avaliação:
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from strands import Agent
from strands_evals import ActorSimulator, Case, Experiment
from strands_evals.evaluators import HelpfulnessEvaluator
from strands_evals.telemetry import StrandsEvalsTelemetry
from strands_evals.mappers import StrandsInMemorySessionMapper
# Setup telemetry for capturing agent traces
telemetry = StrandsEvalsTelemetry()
memory_exporter = InMemorySpanExporter()
span_processor = BatchSpanProcessor(memory_exporter)
telemetry.tracer_provider.add_span_processor(span_processor)
def evaluation_task(case: Case) -> dict:
# Create simulator
user_sim = ActorSimulator.from_case_for_user_simulator(
case=case, max_turns=3
)
# Create agent
agent = Agent(
system_prompt="You are a helpful travel assistant.",
callback_handler=None
)
# Accumulate spans across conversation
all_target_spans = []
user_message = case.input
while user_sim.has_next():
memory_exporter.clear()
agent_response = agent(user_message)
agent_message = str(agent_response)
# Capture telemetry
turn_spans = list(memory_exporter.get_finished_spans())
all_target_spans.extend(turn_spans)
# Generate next user message
user_result = user_sim.act(agent_message)
user_message = str(user_result.structured_output.message)
# Map to session for evaluation
mapper = StrandsInMemorySessionMapper()
session = mapper.map_to_session(
all_target_spans, session_id="test-session"
)
return {"output": agent_message, "trajectory": session}
# Create evaluation dataset
test_cases = [
Case(
name="booking-simple",
input="I need to book a flight to Paris next week",
metadata={
"category": "booking",
"task_description": "Flight booking confirmed"
}
)
]
evaluator = HelpfulnessEvaluator()
dataset = Experiment(cases=test_cases, evaluator=evaluator)
# Run evaluations
report = Experiment.run_evaluations(evaluation_task)
report.run_display()
Essa abordagem captura traces completos do comportamento do seu agente ao longo de rodadas de conversa. Os spans incluem chamadas de ferramentas, invocações de modelo e informações de tempo para cada rodada na conversa simulada. Ao mapear esses spans em uma sessão estruturada, você disponibiliza a interação multi-rodada completa para avaliadores como GoalSuccessRateEvaluator e HelpfulnessEvaluator, que podem então avaliar a conversa como um todo, em vez de rodadas isoladas.
Perfis de ator personalizados para testes direcionados
A geração de perfil automático funciona bem para a maioria dos cenários de avaliação, mas alguns objetivos de teste exigem personas específicas. Você pode querer verificar se seu agente maneja um usuário especialista impaciente de forma diferente de um iniciante paciente, ou se ele responde apropriadamente a um usuário com necessidades específicas do domínio.
Para esses casos, o ActorSimulator aceita um perfil de ator totalmente definido que você controla:
from strands_evals.types.simulation import ActorProfile
from strands_evals import ActorSimulator
from strands_evals.simulation.prompt_templates.actor_system_prompt import (
DEFAULT_USER_SIMULATOR_PROMPT_TEMPLATE
)
# Define a custom actor profile
actor_profile = ActorProfile(
traits={
"personality": "analytical and detail-oriented",
"communication_style": "direct and technical",
"expertise_level": "expert",
"patience_level": "low"
},
context="Experienced business traveler with elite status who values efficiency",
actor_goal="Book business class flight with specific seat preferences and lounge access"
)
# Initialize simulator with custom profile
user_sim = ActorSimulator(
actor_profile=actor_profile,
initial_query="I need to book a business class flight to London next Tuesday",
system_prompt_template=DEFAULT_USER_SIMULATOR_PROMPT_TEMPLATE,
max_turns=10
)Ao definir traços como nível de paciência, estilo de comunicação e expertise, você pode testar sistematicamente como seu agente funciona em diferentes segmentos de usuários. Um agente que se sai bem com usuários pacientes e não-técnicos, mas mal com especialistas impacientes, revela uma lacuna de qualidade específica que você pode abordar. Executar o mesmo objetivo em múltiplas configurações de persona transforma a simulação de usuário em uma ferramenta para entender as forças e fraquezas do seu agente por tipo de usuário.
Melhores práticas para avaliação baseada em simulação
Essas melhores práticas ajudam a aproveitar ao máximo a avaliação baseada em simulação:
- Defina
max_turnscom base na complexidade da tarefa, usando 3-5 para tarefas focadas e 8-10 para workflows multi-etapa. Se a maioria das conversas atingir o limite sem completar o objetivo, aumente-o. - Escreva descrições de tarefa específicas que o simulador possa avaliar. “Ajude o usuário a reservar um voo” é muito vago para julgar a conclusão de forma confiável, enquanto “reserva de voo confirmada com datas, destino e preço” oferece um alvo concreto.
- Use perfis gerados automaticamente para ampla cobertura em tipos de usuários e perfis personalizados para reproduzir padrões específicos de seus logs de produção, como um especialista impaciente ou um usuário de primeira vez.
- Concentre-se em padrões em seu suite de testes em vez de transcritos individuais. Redirecionamentos consistentes do usuário simulado sugerem que o agente está se desviando do tópico, e taxas de conclusão de objetivo em declínio após uma mudança de agente apontam para uma regressão.
- Comece com um pequeno conjunto de casos de teste cobrindo seus cenários mais comuns e expanda para casos extremos e personas adicionais conforme sua prática de avaliação amadurece.
Conclusão
A AWS demonstra como o ActorSimulator no Strands Evals possibilita avaliação sistemática multi-rodada de agentes de IA conversacional através de simulação realista de usuários. Em vez de depender de casos de teste estáticos que capturam apenas trocas únicas, você pode definir objetivos e personas e deixar usuários simulados interagirem naturalmente com seu agente em conversas adaptativas.
Para começar, explore os exemplos funcionais no repositório de exemplos do Strands Agents. Para equipes que avaliam agentes implantados através do Amazon Bedrock AgentCore, o exemplo de avaliações do AgentCore demonstra como simular interações com agentes implantados. Comece com um punhado de casos de teste representando seus cenários de usuário mais comuns, execute-os através do ActorSimulator e avalie os resultados. Conforme sua prática de avaliação amadurece, expanda para cobrir mais personas, casos extremos e padrões de conversa.
Fonte
Simulate realistic users to evaluate multi-turn AI agents in Strands Evals (https://aws.amazon.com/blogs/machine-learning/simulate-realistic-users-to-evaluate-multi-turn-ai-agents-in-strands-evals/)
Leave a Reply