AI-agents evalueren en testen

Waarom agent-evaluatie anders is

Een gewone LLM-aanroep evalueer je op de output: klopt het antwoord? Een agent heeft een pad, namelijk de reeks stappen die het nam om tot een antwoord te komen. Een agent kan het juiste antwoord bereiken via het verkeerde pad (inefficient, duur) of het verkeerde antwoord via het juiste pad (logisch maar fout startpunt). Je evalueert daarom beide.

Platforms die alleen de eindoutput scoren, missen het grootste deel van de faalmomenten die middenin de uitvoering ontstaan: een verkeerde tool-keuze, een mislukte retry of een planner die de taak verkeerd opknipt. Evalueer dus elke stap in het traject apart.

Testset opbouwen

Begin met het verzamelen van representatieve taken. Voor betrouwbare geaggregeerde metrics is een richtgetal van enkele honderden cases gangbaar, maar begin klein met een handvol scherpe gevallen en breid uit.

interface AgentTestCase {
  id: string;
  user_input: string;
  expected_tools: string[];
  expected_outcome_description: string;
  ground_truth?: string;
  difficulty: "easy" | "medium" | "hard";
}

const testCases: AgentTestCase[] = [
  {
    id: "TC001",
    user_input: "Zoek het meest recente rapport over Q3 verkopen en maak een samenvatting",
    expected_tools: ["search_drive", "read_file"],
    expected_outcome_description: "Samenvatting van het Q3-verkooprapport met kernpunten",
    difficulty: "medium",
  },
  {
    id: "TC002",
    user_input: "Stuur een e-mail naar jan@bedrijf.nl met de agenda van aanstaande maandag",
    expected_tools: ["list_upcoming_events", "send_email"],
    expected_outcome_description: "Bevestiging dat e-mail is verstuurd met agenda-inhoud",
    difficulty: "medium",
  },
];

Tool-gebruik evalueren

interface AgentRun {
  test_case_id: string;
  tool_calls: { name: string; input: Record<string, unknown>; output: string }[];
  final_response: string;
  total_tokens: number;
  duration_ms: number;
}

function evaluateToolUsage(run: AgentRun, testCase: AgentTestCase): ToolEvalResult {
  const usedTools = new Set(run.tool_calls.map(tc => tc.name));
  const expectedTools = new Set(testCase.expected_tools);

  const precision = [...usedTools].filter(t => expectedTools.has(t)).length / usedTools.size;
  const recall = [...expectedTools].filter(t => usedTools.has(t)).length / expectedTools.size;
  const f1 = precision + recall > 0 ? (2 * precision * recall) / (precision + recall) : 0;

  return {
    precision,
    recall,
    f1,
    extra_tools: [...usedTools].filter(t => !expectedTools.has(t)),
    missing_tools: [...expectedTools].filter(t => !usedTools.has(t)),
  };
}

Precision laat zien hoeveel van de aangeroepen tools daadwerkelijk verwacht waren, recall hoeveel van de verwachte tools ook echt zijn aangeroepen. De F1-score combineert beide tot een enkel getal dat je makkelijk over runs heen kunt volgen.

LLM-as-judge voor eindresultaat

async function judgeOutcome(
  userInput: string,
  expectedDescription: string,
  actualResponse: string
): Promise<{ score: number; reasoning: string }> {
  const response = await anthropic.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 500,
    messages: [{
      role: "user",
      content: `Beoordeel de kwaliteit van dit agent-antwoord.

Gebruikersvraag: ${userInput}
Verwacht resultaat: ${expectedDescription}
Feitelijk antwoord: ${actualResponse}

Geef een score van 1-5:
1 = Volledig onjuist of irrelevant
2 = Gedeeltelijk relevant maar mist kern
3 = Correct maar onvolledig
4 = Correct en compleet
5 = Uitstekend, overtreft verwachting

Antwoord als JSON: {"score": <1-5>, "reasoning": "<korte uitleg>"}`,
    }],
  });
  return JSON.parse(extractText(response));
}

Efficiency-metrics

function calculateEfficiency(run: AgentRun): EfficiencyMetrics {
  return {
    tool_calls_count: run.tool_calls.length,
    unique_tools_used: new Set(run.tool_calls.map(tc => tc.name)).size,
    duplicate_calls: run.tool_calls.length - new Set(
      run.tool_calls.map(tc => `${tc.name}:${JSON.stringify(tc.input)}`)
    ).size,
    total_tokens: run.total_tokens,
    duration_ms: run.duration_ms,
    tokens_per_step: run.total_tokens / run.tool_calls.length,
  };
}

Let vooral op duplicate_calls: identieke tool-aanroepen wijzen op een agent die in een lus zit of zijn eigen werk niet onthoudt. Dat is duur en traag, en vaak een teken dat je system prompt of tool-output beter moet.

Testpipeline automatiseren

async function runEvaluationSuite(
  testCases: AgentTestCase[],
  agent: AgentFunction
): Promise<EvaluationReport> {
  const results = await Promise.all(
    testCases.map(async (tc) => {
      const run = await agent(tc.user_input);
      const toolEval = evaluateToolUsage(run, tc);
      const outcomeScore = await judgeOutcome(
        tc.user_input,
        tc.expected_outcome_description,
        run.final_response
      );
      const efficiency = calculateEfficiency(run);
      return { test_case: tc, run, tool_eval: toolEval, outcome_score: outcomeScore, efficiency };
    })
  );

  return {
    total_cases: testCases.length,
    avg_outcome_score: average(results.map(r => r.outcome_score.score)),
    avg_tool_f1: average(results.map(r => r.tool_eval.f1)),
    avg_duplicate_calls: average(results.map(r => r.efficiency.duplicate_calls)),
    results,
  };
}

Regressietests

Voeg bij elke agent-update een regressietest toe, zodat een verbetering op het ene scenario geen onverwachte achteruitgang op een ander veroorzaakt:

describe("Agent regression tests", () => {
  it("lost een e-mail-plus-agenda-taak op", async () => {
    const result = await agent("Stuur de agenda van morgen naar mijn team");
    expect(result.tool_calls.map(tc => tc.name)).toContain("list_upcoming_events");
    expect(result.tool_calls.map(tc => tc.name)).toContain("send_email");
    expect(result.final_response).toMatch(/verstuurd|verzonden/i);
  });
});