README.md

metadata

license: mit
task_categories:
  - text-generation
  - question-answering
language:
  - en
tags:
  - hermes-agent
  - nous-research
  - generative-ui
  - agent-evals
  - interactive-micro-apps
  - human-in-the-loop
  - active-learning
pretty_name: Agent Generative UI Evaluation Suite
size_categories:
  - n<1K

Hermes Agent — Generative UI (Interactive Micro-Apps) Evaluation Suite

Dataset Summary

hermes-genui-evals is an Eval-Driven Development (EDD) benchmark designed to evaluate Bidirectional Generative UI (Interactive Micro-Apps) plugins for Hermes Agent by Nous Research.

While Hermes Agent excels at backend execution, persistent memory (MEMORY.md), cron scheduling, and multi-channel messaging, complex cognitive workflows—such as studying a technical topic in depth, what-if parameter simulations, and Human-in-the-Loop (HITL) batch triage—suffer when constrained to static walls of Markdown text.

This evaluation suite tests an agent's ability to:

1. Recognize when to trigger (or abstain from triggering) an interactive micro-app across varying levels of prompt explicitness (explicit_ui, semi_guided, and implicit_intent).
2. Ground the generated UI in real tool outputs (read_file, web_search, execute_command, memory_read) without hallucinating data.
3. Generate self-contained, error-free HTML/JS micro-apps that execute cleanly in a headless browser (Playwright).
4. Maintain a bidirectional state contract via window.hermes.sendAction(payload), feeding user interactions (e.g., quiz diagnostic weak spots, confirmed file deletions, cron schedules) back into Hermes Agent's execution loop.

---

Evaluation Methodology (Anthropic Agent Evals Framework)

This dataset is structured following the nomenclature and best practices from Anthropic's paper "Demystifying evals for AI agents":

• Agent Harness: Hermes Agent equipped with the Generative UI plugin (render_micro_app tool + SKILL.md).
• Evaluation Harness: An automated Python + Playwright runner that executes $k$ Trials per Task, captures the Transcript (tool call trace) and the Outcome (rendered DOM state + bidirectional callback payload), and runs three tiers of Graders:
  1. Code-Based Graders (Deterministic):
     • Transcript Check: Verifies render_micro_app invocation (expected_tool_trigger) to measure both undertriggering and overtriggering.
     • Outcome DOM Check: Loads the generated micro-app in headless Chromium, asserts zero runtime console/page errors (zero_js_errors), verifies data grounding (must_contain_strings), and checks interactive controls (required_selectors).
     • Outcome Callback Check: Executes outcome_interaction_steps in Playwright and validates the resulting window.hermes.sendAction(...) payload against expected_callback_schema (JSON Schema).
  2. Model-Based Graders (Binary PASS/FAIL Rubrics):
     • Instead of noisy 1–5 Likert scales, an LLM judge evaluates the rendered UI and code against strict binary (PASS/FAIL) rubrics (model_grader_rubrics) assessing pedagogical scaffolding, active recall enforcement, and autonomous UI selection.
  3. Reference Solutions:
     • Every task includes a verified reference_solution that passes 100% of the deterministic and model-based graders to guarantee task solvability and grader calibration.

Target Metrics: pass@k vs pass^k

• pass@k ($1 - (1 - p)^k$): Measures the agent's capability ceiling (at least 1 successful trial out of $k$).
• pass^k ($p^k$): Measures production reliability and consistency ($k$ out of $k$ consecutive trials succeeding without a single JS error or broken callback).

---

Dataset Taxonomy & Distribution (v1 — 20 Tasks)

1. By Suite Type (suite_type)

• capability (10 tasks): Challenging tasks testing multi-step interactive simulations, literature contradiction matrices, and autonomous pedagogical UI initiative (implicit_intent).
• regression (10 tasks): Core functional tasks (6 positive explicit_ui tasks + 4 negative_control tasks) that must maintain a ~100% pass rate across plugin iterations.

2. By Functional Category (category)

• topic_study (11 tasks — Core Focus): Interactive learning environments coupled with Hermes's long-term memory and cron scheduler:
  • Explorable Explanations & Mathematical Simulators (e.g., pass@k vs pass^k, Softmax Temperature, Neural Network Backpropagation).
  • Active Recall & Gap Diagnostics (e.g., Flashcards & quizzes with hidden answers that send weak_concepts back to MEMORY.md).
  • Concept Graph Explorers (e.g., Distributed consensus Raft state & Pre-Vote exploration).
  • Literature Comparison Matrices (e.g., Cross-examining RAG evaluation papers like RAGAS vs ARES).
  • Spaced Repetition Planners (e.g., Turning memory weak spots into automated Telegram review crons).
• human_in_the_loop (2 tasks): Safe destructive file cleanup (~/Downloads) and batch email triage with editable draft replies.
• what_if_simulation (1 task): Cloud GPU (RunPod A100) vs Local Hardware (Mac Studio) break-even calculator.
• ops_monitoring (1 task): Visual process manager (ps aux) isolating runaway processes while protecting production databases.
• workflow_builder (1 task): Visual Cron & delivery channel configurator for automated ArXiv digests.
• negative_control (4 tasks): Simple factual questions, CLI lookups, and unambiguous single-step commands where spawning a micro-app is over-engineering (expected_tool_trigger: false).

3. By Prompt Explicitness (prompt_explicitness)

A critical dimension of this benchmark is evaluating whether the agent only builds UIs when explicitly told which widgets to render, or whether it can diagnose a user's cognitive bottleneck on its own:

• explicit_ui (7 tasks): The user explicitly requests an interactive component (tests pure code & callback implementation).
• semi_guided (6 tasks): The user expresses an intent to practice, compare, or triage without naming specific UI widgets (tests archetype mapping).
• implicit_intent (3 positive tasks + 4 negative controls): The user states a raw problem or learning bottleneck with zero mention of UI (e.g., "I have my midterm tomorrow and I still get confused about Raft split votes..."). Tests true agentic initiative vs. overtriggering.

---

Schema & Column Definitions (13 Columns)

Column	Type	Description
task_id	string	Unique identifier for the task (e.g., study_cap_06, hitl_reg_01, neg_reg_01).
suite_type	string	Evaluation suite classification: "capability" or "regression".
category	string	Functional domain ("topic_study", "human_in_the_loop", "what_if_simulation", "ops_monitoring", "workflow_builder", "negative_control").
prompt_explicitness	string	Level of UI guidance in the prompt: "explicit_ui", "semi_guided", or "implicit_intent".
acceptable_ui_archetypes	string (JSON list)	List of valid UI patterns for the task (allows flexibility on implicit_intent prompts, or ["none"] for negative controls).
user_prompt	string	The natural language prompt sent to Hermes Agent.
mock_tool_context	string (JSON list)	Simulated outputs from prior Hermes tools (read_file, web_search, execute_command, memory_read) that must ground the micro-app.
expected_tool_trigger	bool	Transcript Grader: true if the agent should invoke render_micro_app, false for negative controls.
outcome_dom_assertions	string (JSON dict)	Outcome Grader (Playwright): Deterministic checks (zero_js_errors, must_contain_strings, required_selectors, min_interactive_elements).
outcome_interaction_steps	string (JSON list)	Sequential Playwright actions (click, set_range) executed to test reactivity and trigger the callback.
expected_callback_schema	string (JSON Schema)	Bidirectional Outcome Grader: JSON Schema validating the payload sent via window.hermes.sendAction(payload).
model_grader_rubrics	string (JSON list)	Model-Based Grader: Strict binary (PASS/FAIL) rubrics evaluated by an LLM judge.
reference_solution	string	Verified self-contained HTML/JS micro-app (or plain text response for negative controls) that passes 100% of the task's graders.

---

Quick Usage

import json
from datasets import load_dataset

# Load the dataset from Hugging Face Hub
dataset = load_dataset("Agenticaa/genui_benchmark", split="train")

for task in dataset:
    print(f"[{task['task_id']}] ({task['suite_type']} | {task['prompt_explicitness']})")
    print(f"Prompt: {task['user_prompt']}")
    dom_checks = json.loads(task["outcome_dom_assertions"])
    rubrics = json.loads(task["model_grader_rubrics"])
    print(f"Expected Trigger: {task['expected_tool_trigger']} | Rubrics: {[r['id'] for r in rubrics]}\n")