Дата публикации
ai_products

AgentEval: как .NET‑разработчикам перестать гадать, работает ли их AI‑агент

Что нового

AgentEval — это open source‑набор для оценки AI‑агентов в .NET, MIT‑лицензия, пакеты уже лежат на NuGet. Инструмент ориентирован на Microsoft Agent Framework (MAF) и Microsoft.Extensions.AI, но работает и с любым IChatClient.

Ключевые новинки и цифры:

  • Публичная бета, уже «обкатанная» .NET‑сообществом.
  • 30+ готовых примеров использования.
  • 192 red‑team атакующих сценария по 9 типам атак, закрывающим 6 из 10 пунктов OWASP LLM Top 10 (2025), с маппингом на 6 техник MITRE ATLAS.
  • 5 метрик памяти и 5 пресетов бенчмарков (от Quick до Overflow на 192K токенов), включая полную .NET‑реализацию академического бенчмарка LongMemEval (ICLR 2025).
  • Экспорт результатов в JSON, JUnit XML, Markdown, SARIF и PDF.
  • Нативная интеграция с MAF: AIAgent, IChatClient, AIContextProvider, ChatHistoryProvider, CompactionStrategy.
  • Универсальный адаптер для любых OpenAI‑совместимых провайдеров: Azure OpenAI, OpenAI, Foundry Local, Ollama, Groq, vLLM, LM Studio, Together.ai и другие.
  • Stochastic‑оценка (многократные прогоны с подсчётом процента успешных запусков и дисперсии результатов).
  • Сравнение моделей с автоматическим лидербордом по точности, стоимости и латентности.
  • CLI‑утилита AgentEval.Cli для работы без C#‑кода и для CI/CD.
  • HTML‑отчёт по памяти в виде «пятиугольника», который позволяет накладывать несколько моделей и сравнивать их визуально.

Автор проекта встроил в AgentEval не только классические метрики качества ответа, но и:

  • проверки цепочек инструментов (tool calls) с fluent‑ассерциями;
  • автоматический подсчёт токенов, стоимости и латентности;
  • red‑teaming с Attack Success Rate (ASR);
  • проверку токсичности, предвзятости и дезинформации;
  • тестирование multi‑agent workflow‑ов в MAF.

Как это работает

Интеграция с Microsoft AI‑стеком

AgentEval «подсаживается» на тот же IChatClient, который вы используете для агента, и превращает его в «оценимый» агент:

var agent = chatClient.AsEvaluableAgent(
    name: "PolicyAssistant",
    systemPrompt: SYSTEM_PROMPT);
 
services.AddAgentEval();   // DI-friendly setup

chatClient может указывать на Azure OpenAI, OpenAI, Foundry Local, Ollama, Groq, vLLM и любой другой сервис, который реализует OpenAI‑совместимый API и интерфейс IChatClient. Код оценок при этом не меняется — вы просто подменяете провайдера.

AgentEval автоматически:

  • отслеживает вызовы инструментов (какие функции вызваны, в каком порядке, с какими аргументами);
  • собирает статистику по токенам, стоимости и задержкам;
  • записывает трассировки выполнения в JSON, чтобы потом воспроизводить их детерминированно в CI без реальных API‑запросов.

Есть мост к Semantic Kernel через AIFunctionFactory.Create(), который позволяет видеть SK‑функции как инструменты MAF и проверять их так же, как «родные» тулзы.

Fluent‑ассерции для цепочек инструментов

AgentEval даёт fluent‑API, которое превращает требования к работе агента в читаемые проверки. Например, вы можете зафиксировать, что сначала должна пройти аутентификация, потом запрос данных, а уведомление должно отправиться хотя бы один раз:

result.ToolUsage!.Should()
    .HaveCalledTool("AuthenticateUser", because: "security first")
        .BeforeTool("FetchUserData")
        .WithArgument("method", "OAuth2")
    .And()
    .HaveCalledTool("SendNotification").AtLeastTimes(1)
    .And()
    .HaveNoErrors();

Вместо ручного поиска по логам вы описываете поведение агента как спецификацию — и проверяете её на каждом прогоне.

Борьба с галлюцинациями: отдельный «судья»

AgentEval предлагает использовать отдельный LLM‑«судью» для оценки ответа агента по нескольким метрикам: faithfulness (опора на контекст), релевантность, корректность. Судья получает только контекст и ответ, но не всю историю диалога, чтобы не унаследовать возможные ошибки агента.

Пример проверки «приземлённости» ответа на retrieved‑контекст:

var faithfulness = await new FaithfulnessMetric(evaluator).EvaluateAsync(context);
if (faithfulness.Score < 70)
    throw new HallucinationDetectedException($"Faithfulness: {faithfulness.Score}");

Ключевая идея — два разных IChatClient: один для агента, другой для оценщика. Это снижает риск того, что модель‑судья повторит ту же галлюцинацию.

Стохастическая оценка: не «прошло/не прошло», а «как часто проходит»

LLM по определению недетерминированы. Один и тот же запрос с одинаковыми данными может дать разные ответы. AgentEval предлагает смотреть на частоту успеха и разброс, а не на один запуск.

Пример:

var result = await stochasticRunner.RunStochasticTestAsync(agent, testCase,
    new StochasticOptions(Runs: 20, SuccessRateThreshold: 0.85, ScoreThreshold: 75));
result.Statistics.Mean.Should().BeGreaterThan(80);
result.Statistics.StandardDeviation.Should().BeLessThan(10);

Вы запускаете один и тот же тест 20 раз, задаёте порог доли успешных прогонов и минимальный средний балл, а потом проверяете среднее и стандартное отклонение. Такой подход показывает, насколько «шатается» агент от запуска к запуску и помогает сравнивать архитектуры: с планировщиком или без, с разными system‑prompt‑ами, с GPT‑4o или GPT‑4o‑mini.

Сравнение моделей и SLO как код

AgentEval умеет прогонять один и тот же набор тестов через несколько моделей и считать лидерборд по метрикам:

var result = await comparer.CompareModelsAsync(
    factories: new[] { gpt4o, gpt4oMini, claude },
    testCases: testSuite,
    metrics: new[] { new ToolSuccessMetric(), new RelevanceMetric(eval) },
    options: new ComparisonOptions(RunsPerModel: 5));
Console.WriteLine(result.ToMarkdown());

В отчёте вы видите:

  • долю успешных ответов;
  • средние баллы по метрикам;
  • латентность;
  • оценочную стоимость.

На этом уровне уже можно объяснить команде, почему вы платите за GPT‑4o, а не за GPT‑4o‑mini: у вас есть отчёт, а не ощущения.

Пороговые значения по латентности, стоимости и количеству токенов можно зашить прямо в тесты:

result.Performance!.Should()
    .HaveFirstTokenUnder(TimeSpan.FromMilliseconds(500))
    .HaveEstimatedCostUnder(0.05m)
    .HaveTokenCountUnder(2000);

Если UX требует time‑to‑first‑token меньше 500 мс и цену ниже $0.05 за запрос — вы фиксируете это в коде. При нарушении сборка падает.

Red‑teaming и безопасность

AgentEval включает 192 атакующих сценария по 9 типам атак:

  • prompt injection;
  • jailbreak;
  • утечка PII;
  • чрезмерная автономность (excessive agency);
  • небезопасная обработка вывода;
  • извлечение system‑prompt‑а;
  • косвенные инъекции (indirect injection);
  • злоупотребление инференсом (inference abuse);
  • обходы через кодировки (encoding evasion).

Покрытие соответствует 6 пунктам из OWASP LLM Top 10 (2025), при этом атаки связаны с техниками MITRE ATLAS.

Быстрый прогон red‑team‑скана выглядит так:

var result = await agent.QuickRedTeamScanAsync();
result.Should()
    .HavePassed()
    .And().HaveMinimumScore(80)
    .And().HaveASRBelow(0.05);   // Attack Success Rate under 5%

Если нужно, вы настраиваете пайплайн атак через AttackPipeline.Create(), выбираете типы атак и интенсивность, а результат выгружаете в SARIF и отправляете в GitHub Security.

Практический пример: Microsoft MVP Jernej Kavka прогнал AgentEval на своём агенте за один вечер. Стартовый system‑prompt пропускал 40% атак. После доработки промпта и повторного скана Attack Success Rate упал до 0%.

Ответственная AI‑оценка: токсичность, предвзятость, дезинформация

AgentEval добавляет метрики, которые обычно живут в исследованиях и этических гайдлайнах, прямо в ваш тест‑сьют:

  • токсичность;
  • bias (в том числе через контрфактические тесты);
  • склонность к распространению дезинформации.

Контрфактический тест bias по полу выглядит так:

var bias = await new BiasMetric(evaluator)
    .EvaluateCounterfactualAsync(originalContext, counterfactualContext, "gender");

Идея простая: вы меняете в контексте только один фактор (например, gender) и смотрите, насколько меняется ответ. Эти проверки живут рядом с качественными метриками, потому что токсичность и предвзятость — это тоже про качество продукта.

Multi‑agent‑workflow‑ы как объект тестирования

MAF всё чаще используют для построения графов из нескольких агентов. AgentEval умеет тестировать такие workflow‑ы целиком: порядок исполнения, переходы по рёбрам, использование инструментов.

Пример теста для сценария планирования поездки:

var testCase = new WorkflowTestCase {
    Name = "TripPlanner",
    ExpectedExecutors  = ["TripPlanner", "FlightReservation", "HotelReservation", "Presenter"],
    StrictExecutorOrder = true,
    ExpectedTools = ["SearchFlights", "BookHotel"],
};

var result = await new WorkflowEvaluationHarness()
    .RunWorkflowTestAsync(workflowAdapter, testCase);

result.ExecutionResult!.Should()
    .HaveExecutedInOrder("TripPlanner", "FlightReservation", "HotelReservation", "Presenter")
    .HaveTraversedEdge("TripPlanner", "FlightReservation")
    .HaveAnyExecutorCalledTool("SearchFlights")
    .HaveCompletedWithin(TimeSpan.FromMinutes(2));

Один тест проверяет сразу четыре агента, реальные WorkflowBuilder‑графы, порядок исполнения и SLA по времени.

Память: LongMemEval и собственные метрики

AgentEval.Memory отвечает на неприятный вопрос: ваш агент правда помнит, или просто звучит уверенно.

Под капотом:

  • полная .NET‑реализация LongMemEval (ICLR 2025);
  • 5 метрик памяти: удержание фактов, глубина воспоминаний, временное рассуждение, обновление фактов, кросс‑сессионная память и устойчивость к шуму;
  • 5 пресетов бенчмарка: от быстрого до сценария Overflow на 192K токенов;
  • HTML‑отчёт‑пятиугольник, который показывает, где модель сильна, а где проваливается.

Пример запуска стандартного бенчмарка:

var runner = MemoryBenchmarkRunner.Create(chatClient);
var result = await runner.RunBenchmarkAsync(agent, MemoryBenchmark.Standard);

Console.WriteLine($"Memory: {result.OverallScore:F1}% ({result.Grade})");
await result.ExportHtmlReportAsync("memory-report.html");

AgentEval подключается к AIContextProvider, ChatHistoryProvider и CompactionStrategy в MAF и позволяет увидеть, какие факты «выпадают» при сжатии истории и на каких глубинах агент начинает противоречить себе.

CLI: те же проверки без C#‑кода

Для тех, кто не пишет на C#, есть AgentEval.Cli. Это dotnet‑tool, который запускает те же оценки через YAML‑описания датасетов и сценариев. CLI хорошо подходит для CI/CD.

Установка:

dotnet tool install -g AgentEval.Cli --prerelease

Инициализация датасета:

agenteval init -o agenteval.yaml

Вы получаете YAML‑шаблон, где описываете входы, ожидаемое поведение и критерии оценки. Файл можно хранить в репозитории, ревьюить и версионировать как обычный тестовый набор.

Запуск оценки для разных провайдеров:

# Against Azure OpenAI
agenteval eval --azure \
    --endpoint https://myresource.openai.azure.com/ \
    --deployment-name gpt-4o \
    --dataset agenteval.yaml --runs 5 --success-threshold 0.9

# Against OpenAI directly
agenteval eval --endpoint https://api.openai.com/v1 \
    --model gpt-4o --dataset agenteval.yaml

# Against a local Ollama model — no API key needed
agenteval eval --endpoint http://localhost:11434/v1 \
    --model llama3 --dataset agenteval.yaml

Red‑team‑скан через CLI:

# All 9 attack types at moderate intensity
agenteval redteam --azure \
    --endpoint https://myresource.openai.azure.com/ \
    --deployment-name gpt-4o --intensity moderate

# Or pick specific attacks and export SARIF for GitHub Security
agenteval redteam --azure \
    --endpoint https://myresource.openai.azure.com/ \
    --deployment-name gpt-4o \
    --attacks PromptInjection,Jailbreak --format sarif

CLI экспортирует результаты в JSON, Markdown, JUnit XML, SARIF и PDF, так что вы можете:

  • подсвечивать провалы как тесты в GitHub Actions или Azure DevOps;
  • отправлять отчёты в GitHub Security;
  • собирать дашборды и отчёты для комплаенса.

Что это значит для вас

Кому AgentEval действительно пригодится

  1. .NET‑командам, которые уже запускают AI‑агентов в проде.

    • Вы можете превратить поведение агента в набор тестов и гонять их на каждом pull request.
    • Галлюцинации, регрессии в цепочках инструментов, уязвимости prompt injection и jailbreak перестают быть «сюрпризами пользователей».

  2. Инженерам, которые строят сложные агентные архитектуры.

    • Stochastic‑оценки показывают, какие архитектурные решения делают систему стабильнее.
    • Можно экспериментировать: добавить планировщик, изменить system‑prompt, переключиться с GPT‑4o на GPT‑4o‑mini и посмотреть, как меняется variance.

  3. Командам безопасности и комплаенса.

    • Red‑teaming с 192 атаками даёт реальную картину устойчивости агента.
    • Экспорт в SARIF позволяет встроить результаты в существующие security‑пайплайны и отчётность.

  4. Продуктовым командам, считающим деньги и SLA.

    • Вы задаёте лимиты по цене, латентности и количеству токенов как часть тестов.
    • Отчёты по сравнению моделей помогают аргументировать выбор провайдера и конфигурации.

  5. Преподавателям и исследователям.

    • LongMemEval в .NET даёт возможность получать результаты, сопоставимые с академическими статьями.
    • Можно строить курсы по Agentic Engineering с реальными бенчмарками памяти и качества.

Где AgentEval особенно полезен

  • Финтех и трейдинг — там, где ошибка агента не просто портит UX, а стоит денег. История автора с автоинвест‑системой показывает, как тихие несогласованности в ответах могут смещать решения.
  • Юридические и медицинские ассистенты — любые галлюцинации и дезинформация критичны, а bias и токсичность недопустимы.
  • Корпоративные ассистенты с доступом к внутренним данным — red‑teaming по OWASP LLM Top 10 помогает не допустить утечек и злоупотреблений.
  • Образовательные продукты — память, устойчивость к шуму и корректность обновления фактов важны не меньше, чем точность ответа здесь и сейчас.

Где AgentEval может быть избыточен

  • Простые чат‑боты без доступа к инструментам и чувствительным данным.
  • Прототипы и хакатонные проекты, где важна скорость, а не стабильность и безопасность.
  • Сценарии без .NET: да, есть CLI, но если стек полностью Python, вам, вероятно, будет проще с RAGAS, DeepEval или PromptFoo.

Важные ограничения и практические нюансы

  • AgentEval не «чинит» модель. Он показывает, где и как агент ломается, но править придётся вам: промпты, архитектуру, выбор модели.
  • Для многих сценариев нужен доступ к внешним LLM‑провайдерам (GPT‑4o, GPT‑4o‑mini, Claude и др.). В российских реалиях это часто означает VPN или корпоративные обходные пути.
  • Стоимость: stochastic‑прогоны, сравнение моделей и LongMemEval‑бенчмарки могут быть дорогими. Их имеет смысл запускать в nightly‑пайплайнах, а не на каждом коммите.

Место на рынке

Экосистема .NET против Python

В Python уже давно живут RAGAS, DeepEval, PromptFoo и другие библиотеки для оценки LLM. Автор AgentEval прямо говорит: в .NET аналогичного по охвату инструмента не хватало, поэтому он его и написал.

По функциональности AgentEval занимает примерно ту же нишу для .NET, что RAGAS и DeepEval для Python:

  • метрики качества ответа и faithfulness;
  • работа с retrieval‑контекстом;
  • поддержка разных провайдеров;
  • интеграция в CI.

Отличия в деталях:

  • AgentEval «родным» образом встроен в Microsoft Agent Framework и Microsoft.Extensions.AI.
  • Есть полный бенчмарк LongMemEval для памяти в .NET.
  • Много внимания уделено tool‑call‑цепочкам и multi‑agent workflow‑ам MAF.

Сравнение с существующими инструментами

Прямых численных сравнений с RAGAS, DeepEval или PromptFoo в исходном материале нет. Автор не приводит конкретных процентов по скорости или точности относительно конкурентов.

Можно зафиксировать только факты:

  • В Python уже есть зрелые библиотеки для оценки LLM‑систем.
  • В .NET до AgentEval подобных по широте охвата инструментов не было.
  • AgentEval закрывает потребности .NET‑разработчиков, которые раньше приходилось решать самописными тестами и скриптами.

Где AgentEval особенно силён

  • Глубокая интеграция с MAF и MEAI — это не просто обёртка вокруг HTTP‑запросов к GPT‑4o, а часть стека Microsoft AI.
  • Red‑teaming с привязкой к OWASP LLM Top 10 (2025) и MITRE ATLAS — важный аргумент для security‑команд.
  • Память и LongMemEval — редкая история для production‑инструмента, а не только для research‑кода.

Установка

AgentEval доступен как NuGet‑пакеты и как CLI‑утилита.

Основные ссылки:

  • Репозиторий: https://github.com/AgentEvalHQ/AgentEval
  • CLI: https://github.com/AgentEvalHQ/AgentEval.Cli
  • Документация: https://agenteval.dev
  • NuGet: https://www.nuget.org/packages/AgentEval

Для быстрого старта с CLI автор предлагает «5 минут, 4 команды»:

  1. Установка CLI:
dotnet tool install -g AgentEval.Cli --prerelease
  1. Генерация датасета:
agenteval init -o agenteval.yaml
  1. Запуск оценки:
agenteval eval --endpoint https://api.openai.com/v1 --model gpt-4o --dataset agenteval.yaml
  1. Запуск red‑team‑скана:
agenteval redteam --endpoint ... --model gpt-4o --intensity quick

Для SDK‑варианта достаточно добавить пакеты AgentEval через NuGet и зарегистрировать services.AddAgentEval() в DI.

Как запустить и использовать на практике

Простейшая интеграция с агентом

var agent = chatClient.AsEvaluableAgent(
    name: "PolicyAssistant",
    systemPrompt: SYSTEM_PROMPT);
 
services.AddAgentEval();

Дальше вы описываете тест‑кейсы и ассерты — от цепочек инструментов до метрик качества, памяти и безопасности.

Встраивание в CI/CD

Автор рекомендует:

  • писать оценки как xUnit‑тесты и запускать их на каждый pull request;
  • экспортировать результаты в JUnit XML, чтобы видеть их в GitHub Actions / Azure DevOps рядом с обычными юнит‑тестами;
  • экспортировать red‑team‑результаты в SARIF, чтобы получать security‑флаги в GitHub Security;
  • сохранять трассировки неудачных запусков и воспроизводить их локально без затрат на API.

Смысл прост: чем раньше вы ловите галлюцинации, регрессии в tool‑calls и уязвимости prompt injection, тем дешевле обходится исправление.

Куда двигаться дальше

Если вы хотите попробовать AgentEval:

  • ⭐ Поставьте звёздочку репозиторию: https://github.com/AgentEvalHQ/AgentEval
  • 🧰 Посмотрите исходники CLI: https://github.com/AgentEvalHQ/AgentEval.Cli
  • 📖 Прочитайте документацию: https://agenteval.dev
  • 🎓 Подумайте, как встроить LongMemEval и метрики памяти в учебные курсы или исследовательские проекты.
  • 🤝 Поддержите проект: новые идеи для атак, примеры, pull‑request‑ы приветствуются.

Практический разбор от Jernej Kavka — «Testing .NET AI Agents with AgentEval» — показывает, как за один вечер найти реальные проблемы в агенте и довести Attack Success Rate с 40% до 0%.

AgentEval не заменит архитектурное мышление, но даёт .NET‑разработчикам то, чего давно не хватало: способ не гадать, работает ли агент, а доказывать это цифрами и тестами.

Читайте также

#ии-агенты#open-source#microsoft#кибербезопасность#разработка
🔗 Источник: https://techcommunity.microsoft.com/t5/educator-developer-blog/stop-hallucinating-start-evaluating-a-tour-of-agenteval/ba-p/4519068
← Все новости