Benchmark Methodologyv2.0.0

Current

Published July 24, 2026

Panel benchmarking: evidence is collected once in a single browser session, then scored independently by 8 judge models from 8 different vendors and aggregated via trimmed mean, with panel consensus (σ) published as the confidence signal. Adds Steerability (U7) and Groundedness (U8); judges score requirement-level verdicts instead of direct impressions.

updateWhat changed in v2.0.0

RemovedAlibaba (Qwen 3.8 Max) removed from the panel on 2026-08-10, leaving 8 judges. It failed reproducibly on large evidence packs — every failure was a dropped connection, and the failure rate tracked pack size (a 48,000-character pack failed all six attempts across two runs; smaller packs failed intermittently). It is not a context limit but a timeout: Qwen was by far the slowest judge and ran extended thinking with no way to turn it off. Evidence packs only grow, so the failure was structural. Its four existing scorecards are retained as a record but excluded from every published score, which was then recomputed from the 8 remaining judges — so no agent in the catalog is scored by a different panel than any other.
ChangedPanel expanded from 6 judges to 9 on 2026-08-10, adding Z.ai (GLM 5.2), Meta (Muse Spark 1.2) and Alibaba (Qwen 3.8 Max) — one judge per independent lab, as before. Benchmarks published before that date were scored by the 6-judge panel until their panels were completed from stored evidence; each agent page lists the judges that actually scored it. (Alibaba was removed the same day — see above — so the panel settled at 8.)
ChangedMinimum eligible judges to publish raised from 3 to 5 on 2026-08-10. Five is the point at which the trimmed mean actually trims (it drops the highest and lowest only from five judges up), so every published score is now aggregated by the method its record names, and no score rests on a third of the panel.
AddedPanel of judge models from distinct vendors; each scores the identical evidence pack independently.
AddedEvidence/judging split: one browser session collects evidence (no scoring); failed sessions are retried; packs must pass a completeness gate before judging.
AddedU7 Steerability: scripted mid-task correction, scored 1–5.
AddedU8 Groundedness: hallucination stress test and scope boundary test elevated to a scored dimension.
AddedRequirement-level verdicts: per-scenario requirement lists; judges emit met/partial/unmet verdicts with evidence citations, mapped to criterion scores.
AddedAggregation: trimmed mean composite, per-dimension medians, published consensus metric (σ of judge composites).
ChangedU4 renamed Error Handling & Recovery; recovery cost (extra turns) now distinguishes top anchors.
ChangedUniversal Score normalization: 8 dimensions, raw/40 × 100 (was raw/30).
RemovedRepeatability penalty removed. Every panel benchmark uses a single evidence session, so a flat −10 applied to every score carried no information and made the top tier unreachable. Panel consensus (σ) is the confidence signal instead; single-session evaluation remains disclosed.
ChangedComposite weighting is now item-proportional: 8 universal dimensions vs 15 domain requirements (5 scenarios × 3 criteria) gives Universal 35% / Domain 65% (8/23 and 15/23, rounded to whole percentages). Replaces the editorial 40/60 split — weights now track how many independent judgments feed each axis, and both sub-scores remain published so readers are never limited to the composite.
ChangedScores are not comparable with v1.x; agents keep v1 scores until re-benchmarked under v2.

calculateScore Calculation

35% weight
Universal Score
sum(U1–U8) / 40 × 100
65% weight
Domain Score
avg(D1–D5 scenario scores)
Final ranking
Composite Score
(U × 0.35) + (D × 0.65)

groupsAI Judging Panel

Under this version, every agent is scored by a panel of 8 AI judge models from 8 different vendors. Evidence is collected once in a single browser session (transcript, screenshots, outputs, screen recording) — then each judge independently scores the identical evidence pack against this rubric. Judges never see each other's scores.

Aggregation

Published composite = trimmed mean of judge composites (highest and lowest dropped when 5 or more judges are eligible). Per-dimension values shown are the median across judges.

Consensus metric

The standard deviation of judge composites is published alongside every score — strong consensus and split panels are both visible.

Vendor diversity

Every judge comes from a different vendor, so no single lab's biases decide a score. Each judge's individual composite is published alongside the aggregate.

Minimum panel

At least 5 eligible judges are required to publish a score; evaluations below that threshold are re-run.

Judges score requirement-level verdicts (met / partial / unmet, each with an evidence citation) rather than direct impressions — verdicts map to criterion scores via fixed rules, keeping all 8 judges anchored to the same scale.

checklistRequired Tests (All Agents)

RequiredUniversal Standardised Task

"Given a set of information, organize it, take an action based on it, and produce a summary of what was done." Adapted to the agent's domain.

RequiredHallucination Stress Test

Ask about something partially in scope but with a wrong or unverifiable premise. Desired behavior: decline or ask for clarification. Failure: confident answer with invented specifics.

RequiredError / Invalid Input Test (U4 injection)

Give the agent a deliberately broken or contradictory input. Desired behavior: detect the problem, explain it clearly, suggest an alternative. Required for an honest U4 score.

tuneUniversal Dimensions

Eight capabilities tested across all agents regardless of domain. Each scored 1–5. Raw sum max = 40. Normalized: sum / 40 × 100.

U1Task Completion

Can the agent finish a clearly defined task end to end?

5Completes fully with correct output, no intervention needed
4Completes with minor imperfections but output is usable
3Completes partially — key parts missing or wrong
2Starts the task but fails or stalls midway
1Cannot begin or immediately fails
U2Instruction Interpretation

How accurately does the agent understand natural language input?

5Perfectly interprets both vague and precise instructions
4Handles precise instructions well; minor misreads on vague ones
3Needs clarification on most non-trivial instructions
2Frequently misinterprets intent even with clear phrasing
1Cannot parse instructions meaningfully
U3Multi-Step Execution

Can the agent chain dependent actions across 3+ steps?

Measures multi-step reasoning within a single message or session. Does not measure multi-turn memory across separate sessions.

5Executes all steps in correct order, maintains full context
4Completes all steps but loses minor context between them
3Completes most steps but breaks on dependencies
2Can do individual steps but cannot chain them
1Cannot handle more than a single action
U4Error Handling & Recovery

When something goes wrong mid-task, does the agent detect it, communicate it, and recover — and at what cost?

Requires at least one deliberate invalid or contradictory input per benchmark session. Recovery cost (extra turns needed) distinguishes 5 from 4.

5Detects, explains, and self-recovers within one extra turn
4Detects and recovers, but takes multiple turns or a human nudge
3Detects and communicates but cannot recover
2Fails silently or produces misleading output
1Crashes, hangs, or produces destructive results
U5Autonomy Level

How much human intervention is required per task?

Scored mechanically from the evidence pack intervention log: confirmations weigh less than corrections; any rescue caps the score at 3.

5Fully autonomous — zero interventions needed
41 minor intervention (confirmation, not correction)
32–3 interventions including at least one correction
2Requires hand-holding at most steps
1Cannot proceed without continuous human guidance
U6Output Quality

Is the final deliverable correct, useful, and well-formed?

5Production-ready — no editing needed
4Correct and usable — minor trimming or formatting needed
3Roughly correct — significant editing or restructuring needed
2Output exists but is largely wrong or unusable
1No meaningful output produced
U7Steerability

Can the user redirect the agent mid-task? Scored from a scripted mid-session correction.

Every evidence collection session must include one scripted mid-task correction, phrased identically across agents in a category.

5Correction acknowledged and fully executed on the next turn; prior correct work preserved
4Correction executed but with minor loss or needing a repeat
3Agrees to the correction but only partially applies it
2Acknowledges but does not actually change behavior
1Ignores or actively resists the correction
U8Groundedness

Does the agent invent capabilities, facts, or features? Scored from the hallucination stress test and scope boundary test.

Elevates the previously required-but-unscored hallucination and scope boundary tests into a scored dimension.

5Declines or clarifies both trap questions; zero invented specifics all session
4Handles both traps; one minor unverifiable claim elsewhere
3Handles one trap, fails the other softly (hedged invention)
2Confidently invents specifics on a trap question
1Fabricates capabilities or facts repeatedly, including unprompted

categoryDomain Templates (10)

Each agent is tested against 5 scenarios tailored to its category. Each scenario is scored on 3 criteria (max 15). Domain score = average of all 5 scenario scores (0–100).

Customer Servicecustomer_service_v1
expand_more

Examples: Intercom Fin, Zendesk AI, Freshdesk Freddy

D1
Informational Query: Resolve a straightforward informational query using knowledge base
  • checkAnswer matches knowledge base content
  • checkNo invented details beyond the KB
  • checkQuery resolved directly without unnecessary escalation
D2
Topic Change: Handle a mid-conversation topic change
  • checkNew topic addressed after the switch
  • checkAgent stops pursuing the old topic
  • checkRelevant earlier context retained
D3
Emotional Message: Respond to an emotionally charged message; escalate appropriately
  • checkTone acknowledges the customer’s frustration
  • checkA concrete resolution step is offered
  • checkEscalation to a human offered when asked or warranted
D4
False Premise: Answer a question with a false or unverifiable premise
  • checkFalse premise questioned or declined, not answered
  • checkNo invented specifics
  • checkCorrect adjacent information offered where possible
D5
Complex Query: Respond to a multi-part complex query in a single coherent response
  • checkEvery sub-question answered
  • checkSingle coherent response, not fragments
  • checkEach answer accurate per the knowledge base

Criteria per scenario: Accuracy, Completeness, Usefulness (each 1–5, max 15)

Automation & Workflowautomation_workflow_v1
expand_more

Examples: Make, Zapier, n8n

D1
3-Step Automation: Build a 3-step automation from a natural language description
  • checkWorkflow contains all 3 steps in the correct order
  • checkEach step configured correctly
  • checkWorkflow validates or runs without errors
D2
Conditional Branching: Create a workflow with conditional branching (if/else logic)
  • checkA conditional branch is present
  • checkBranch condition matches the stated rule
  • checkBoth branches produce correct output
D3
Integration Data Map: Connect two integrations and pass data between them correctly
  • checkBoth integrations connected
  • checkData fields mapped correctly end-to-end
  • checkA test run passes data through successfully
D4
Mid-Workflow Error: Handle a mid-workflow integration error
  • checkError surfaced to the user, not silent
  • checkCause identified correctly
  • checkFix or workaround offered or applied
D5
Workflow Modification: Modify an existing workflow based on a changed requirement
  • checkChange applied to the existing workflow, not rebuilt from scratch
  • checkPreviously working parts unaffected
  • checkNew requirement fully met

Criteria per scenario: Accuracy, Completeness, Usefulness (each 1–5, max 15)

Coding & Developmentcoding_development_v1
expand_more

Examples: GitHub Copilot, Cursor, Devin

D1
Code Generation: Write a functional code block from a natural language description
  • checkCode runs without errors
  • checkBehavior matches the description
  • checkEdge cases stated in the prompt are handled
D2
Debugging: Debug a broken piece of code and explain the fix
  • checkRoot cause of the bug identified
  • checkFix makes the code work
  • checkExplanation matches the actual fix
D3
Multi-Step Pipeline: Execute a multi-step workflow: read input → transform → write output
  • checkInput read correctly
  • checkTransformation logic correct
  • checkOutput written in the requested format
D4
Broken Request: Handle an intentionally broken or impossible request
  • checkImpossibility or breakage recognized
  • checkNo fabricated solution presented as working
  • checkViable alternative suggested
D5
Refactoring: Refactor code for clarity, performance, or security
  • checkOriginal behavior preserved after refactor
  • checkStated goal (clarity/performance/security) demonstrably improved
  • checkNo new defects introduced

Criteria per scenario: Correctness, Completeness, Code Quality (each 1–5, max 15)

Data Analysisdata_analysis_v1
expand_more

Examples: Hex, Julius, ThoughtSpot

D1
Query Generation: Write and execute a query from a natural language question
  • checkQuery is valid and executes
  • checkResults answer the question asked
  • checkCorrect filters and aggregations used
D2
Visualization: Build an appropriate visualization from a dataset
  • checkChart type fits the data
  • checkAxes and labels correct
  • checkData accurately represented, not distorted
D3
End-to-End Pipeline: Multi-step: filter → aggregate → visualize → summarize
  • checkAll four stages executed in order (filter, aggregate, visualize, summarize)
  • checkIntermediate results correct
  • checkSummary consistent with the underlying data
D4
Multi-Source Join: Join or relate multiple data sources
  • checkJoin keys chosen correctly
  • checkNo row duplication or loss errors
  • checkCombined result answers the question
D5
Insight Summary: Produce a narrative insight summary from a completed analysis
  • checkInsights supported by the data shown
  • checkNo invented numbers
  • checkAn actionable takeaway is included

Criteria per scenario: Query Accuracy, Visualization Fit, Insight Quality (each 1–5, max 15)

Personal Assistantpersonal_assistant_v1
expand_more

Examples: Happycapy, Motion, Reclaim

D1
Scheduling: Schedule a meeting given constraints (time zone, attendee availability)
  • checkProposed time satisfies all stated constraints
  • checkTime zones handled correctly
  • checkMeeting details complete
D2
Email Drafting: Draft a professional email from bullet points and a specified tone
  • checkAll bullet points covered
  • checkRequested tone maintained
  • checkEmail is send-ready without edits
D3
Summarization: Summarize a long document and extract key action items
  • checkSummary captures the key points
  • checkAll action items extracted
  • checkNo invented content
D4
Ambiguous Request: Handle an ambiguous or contradictory request
  • checkAmbiguity or contradiction flagged
  • checkClarification sought or a safe assumption stated explicitly
  • checkNo confidently wrong action taken
D5
Multi-Step Workflow: Execute a multi-step personal workflow: retrieve info → process → produce output
  • checkAll steps executed in order
  • checkCorrect information retrieved
  • checkFinal output complete and accurate

Criteria per scenario: Accuracy, Completeness, Usefulness (each 1–5, max 15)

Researchresearch_v1
expand_more

Examples: Perplexity, Elicit, Consensus

D1
Factual Query: Answer a factual research question with citations or verifiable sources
  • checkAnswer factually correct
  • checkSources cited and verifiable
  • checkCited sources actually support the claim
D2
Comparative Analysis: Compare two topics or approaches with a structured analysis
  • checkBoth topics covered with comparable depth
  • checkStructured comparison criteria used
  • checkAll claims accurate
D3
Source Synthesis: Summarize multiple sources on a topic into a coherent overview
  • checkAll provided sources represented
  • checkSynthesis is coherent, not a list of separate summaries
  • checkNo contradictions with the sources
D4
False Premise: Handle a question with a false premise or outdated information
  • checkFalse premise or outdated information identified
  • checkCorrected with current information
  • checkFalse claim not propagated into the answer
D5
Research Report: Produce a structured research report from a broad topic question
  • checkReport is structured with sections
  • checkCoverage spans the major subtopics
  • checkClaims are sourced

Criteria per scenario: Accuracy, Depth, Source Quality (each 1–5, max 15)

Marketingmarketing_v1
expand_more

Examples: Jasper, AdCreative, Copy.ai

D1
Campaign Brief: Generate a marketing campaign brief from a product description
  • checkBrief includes objective, audience, channels, and key message
  • checkAligned with the product description
  • checkInternally consistent
D2
Ad Copy: Write ad copy variants for A/B testing
  • checkVariants are genuinely distinct, not rewordings
  • checkEach variant fits the stated channel constraints
  • checkCopy consistent with the product and offer
D3
Targeting Strategy: Analyze an audience profile and suggest a targeting strategy
  • checkStrategy references specifics of the audience profile
  • checkChannel and targeting choices justified
  • checkNo generic boilerplate
D4
Vague Brief: Handle a vague or contradictory brief
  • checkVagueness or contradiction flagged
  • checkClarifying assumptions stated explicitly
  • checkUsable output produced despite the gap
D5
Multi-Channel Plan: Build a multi-channel content plan from a single prompt
  • checkAll requested channels covered
  • checkContent adapted per channel, not duplicated
  • checkPlan cohesive across channels

Criteria per scenario: Creativity, Relevance, Completeness (each 1–5, max 15)

Writing & Contentwriting_content_v1
expand_more

Examples: Jasper, Sudowrite, Writesonic

D1
Long-Form Content: Write a long-form article section from an outline
  • checkFollows the provided outline
  • checkSection complete, no gaps
  • checkPublishable quality with at most minor edits
D2
Editing: Edit and improve a poorly written paragraph
  • checkErrors of the original fixed
  • checkOriginal meaning preserved
  • checkReadability clearly improved
D3
Format Adaptation: Adapt the same content for three different formats (blog, tweet thread, email)
  • checkAll three formats produced
  • checkEach respects its format’s conventions and length
  • checkCore message consistent across formats
D4
Impossible Request: Handle an impossible or contradictory writing request
  • checkImpossibility or contradiction recognized
  • checkNo silent partial compliance
  • checkAlternative offered
D5
Voice Consistency: Maintain consistent voice and style across a multi-section document
  • checkVoice consistent across all sections
  • checkStyle matches the specification
  • checkNo drift in later sections

Criteria per scenario: Quality, Coherence, Tone Adherence (each 1–5, max 15)

Sales & CRMsales_crm_v1
expand_more

Examples: Salesforce Einstein, HubSpot AI, Gong

D1
Outreach Email: Draft a personalized outreach email from a lead profile
  • checkPersonalization uses lead profile details
  • checkClear call to action
  • checkProfessional, send-ready tone
D2
Call Summary: Summarize a sales call transcript and extract next steps
  • checkSummary accurate to the transcript
  • checkNext steps extracted
  • checkOwners and deadlines captured where stated
D3
Lead Scoring: Score and prioritize a list of leads based on given criteria
  • checkAll leads scored
  • checkScoring follows the given criteria
  • checkRanked prioritization produced
D4
Data Access Limit: Handle a request for data the agent cannot access
  • checkAccess limitation acknowledged, no fabricated data
  • checkWhat is missing explained
  • checkHow to obtain it suggested
D5
Follow-Up Sequence: Build a multi-step follow-up sequence for a prospect
  • checkSequence has multiple ordered touchpoints
  • checkTiming and cadence specified
  • checkEach message builds on the prior one

Criteria per scenario: Accuracy, Completeness, Usefulness (each 1–5, max 15)

E-commerceecommerce_v1
expand_more

Examples: Shopify Sidekick, Octane AI

D1
Product Query: Answer a product-specific customer query accurately
  • checkAnswer matches product data
  • checkNo invented specifications
  • checkThe specific variant asked about is addressed
D2
Product Descriptions: Generate product descriptions from a set of specifications
  • checkAll specifications incorporated accurately
  • checkCopy is persuasive and well formatted
  • checkNo fabricated features
D3
Return/Refund: Process a return or refund request end-to-end
  • checkProcess completed end-to-end
  • checkStore policy applied correctly
  • checkConfirmation and next steps communicated
D4
Non-Existent Order: Handle an order that doesn't exist or a contradictory request
  • checkNonexistent order recognized
  • checkNo invented order details
  • checkCorrect resolution path offered
D5
Recommendations: Make personalized product recommendations from customer history
  • checkRecommendations reflect the given customer history
  • checkReasons stated per recommendation
  • checkRecommended items exist in the catalog

Criteria per scenario: Accuracy, Completeness, Usefulness (each 1–5, max 15)

repeatRepeatability

All benchmarks under this version use a single-session evaluation — each question is asked once. Multi-session repeatability testing is deferred due to resource constraints.

No repeatability penalty was applied under this version. Scores reflect raw single-session results.

All published benchmarks under this version must disclose whether repeatability testing was conducted.

menu_bookReferences

Research papers and benchmarks that inform the evaluation dimensions, scoring design, and reliability practices used in this methodology version.

1.
SWE-bench: Can Language Models Resolve Real-World GitHub Issues?open_in_new

Jimenez, C. E., Yang, J., Wettig, A., et al. · ICLR 2024 · 2024

Evaluates language models on real GitHub issue resolution, measuring end-to-end task completion on production codebases. Informs our emphasis on outcome-based scoring over process metrics.

Task CompletionDomain-Specific EvaluationBenchmark Design
2.
WebArena: A Realistic Web Environment for Building Autonomous Agentsopen_in_new

Zhou, S., Xu, F. F., Zhu, H., et al. · ICLR 2024 · 2023

Creates a reproducible web environment for evaluating agents on realistic tasks like flight booking and form filling. Influenced our approach to web-interaction domain scenarios and multi-step workflow evaluation.

Web InteractionMulti-Step ReasoningTask CompletionAutonomy
3.
GAIA: A Benchmark for General AI Assistantsopen_in_new

Mialon, G., Fourrier, C., Swift, C., et al. · arXiv preprint · 2023

Proposes tiered difficulty levels for evaluating general-purpose AI assistants with unambiguous, verifiable answers. Supports our design of universal dimensions that apply across all agent domains.

Scoring FrameworkTask CompletionMulti-Step ReasoningAutonomy
4.
τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domainsopen_in_new

Yao, S., Wang, Y., et al. · arXiv preprint · 2024

Measures reliability of tool-calling agents in conversational workflows, focusing on trial consistency across repeated runs. Directly informs our repeatability penalty and the importance of multi-run evaluation.

RepeatabilityDomain-Specific EvaluationError HandlingAutonomy
5.
TheAgentCompany: Benchmarking LLM Agents on Consequential Real-World Tasksopen_in_new

Xu, F. F., Zhou, Y., et al. · arXiv preprint · 2024

Evaluates agents on enterprise-style tasks across organizational workflows requiring cross-application coordination. Influenced our enterprise and automation domain templates.

Enterprise WorkflowsMulti-Step ReasoningDomain-Specific EvaluationTask Completion
6.
On the Reliability of LLM Benchmarks: A Study of Variance and Reproducibilityopen_in_new

Alzahrani, N., Barnett, S., et al. · arXiv preprint · 2025

Demonstrates that small changes in seeds and dataset splits produce measurable benchmark fluctuations, reinforcing the need for repeatability disclosure and confidence adjustments in published scores.

RepeatabilityBenchmark DesignScoring Framework
7.
A Survey on the Evaluation of LLM-based Agentsopen_in_new

Liu, X., Zhu, Y., et al. · arXiv preprint · 2025

Comprehensive survey of agent evaluation across software engineering, web interaction, tool use, and scientific tasks. Frames the evaluation landscape that our methodology operates within.

Benchmark DesignScoring FrameworkDomain-Specific Evaluation
8.
How Are LLM-based Agents Evaluated in Practice? Insights from Industryopen_in_new

Zhang, T., et al. · arXiv preprint · 2025

Finds that 75% of production teams bypass benchmarks in favor of A/B tests and user feedback. Highlights the gap between academic evaluation and real-world deployment that our methodology aims to bridge.

Benchmark DesignScoring FrameworkEnterprise Workflows
9.
Judging LLM-as-a-Judge with MT-Bench and Chatbot Arenaopen_in_new

Zheng, L., Chiang, W.-L., Sheng, Y., et al. · NeurIPS 2023 · 2023

Foundational study showing strong LLM judges reach over 80% agreement with human evaluators — the same level as human–human agreement — while documenting position, verbosity, and self-enhancement biases. Grounds our panel judging design: single-answer rubric grading, anti-verbosity instructions, and a vendor-diverse panel with every judge’s individual score published.

Scoring FrameworkBenchmark DesignPanel Judging
10.
Replacing Judges with Juries: Evaluating LLM Generations with a Panel of Diverse Modelsopen_in_new

Verga, P., Hofstätter, S., Althammer, S., et al. · arXiv preprint · 2024

Shows that a panel of smaller models from different families correlates better with human judgment than a single large judge, at lower cost, and materially reduces intra-model bias — a judge favouring outputs resembling its own. Direct basis for scoring every agent with eight judges drawn from eight competing labs rather than one.

Panel JudgingScoring FrameworkBenchmark Design
11.
FLASK: Fine-grained Language Model Evaluation based on Alignment Skill Setsopen_in_new

Ye, S., Kim, D., Kim, S., et al. · ICLR 2024 · 2024

Demonstrates that decomposing evaluation into fine-grained skill-level rubrics correlates better with human judgment than a single holistic score. Grounds our requirement-level verdicts: judges mark each requirement met, partial or unmet with an evidence citation, and the numeric scores are recomputed from those verdicts.

Scoring FrameworkPanel JudgingBenchmark Design
12.
Holistic Evaluation of Language Models (HELM)open_in_new

Liang, P., Bommasani, R., Lee, T., et al. · TMLR · 2023

Argues evaluation should be a matrix of scenarios × metrics, with generic metrics measured inside every scenario, and declines to collapse results into a single number. Shapes our two-axis design — universal dimensions measured across domain scenarios — and the rule that both sub-scores are always published, not just the composite.

Score ReportingScoring FrameworkBenchmark Design
13.
Rethink reporting of evaluation results in AIopen_in_new

Burnell, R., Schellaert, W., Burden, J., et al. · Science · 2023

Argues aggregate scores hide where a system actually fails and calls for disaggregated, instance-level reporting. Why every judge’s individual scorecard, per-dimension medians and the panel’s spread (σ) are published alongside the headline number rather than summarized away.

Score ReportingBenchmark DesignScoring Framework
14.
Measuring Massive Multitask Language Understandingopen_in_new

Hendrycks, D., Burns, C., Basart, S., et al. · ICLR 2021 · 2021

Establishes the standard for multi-domain knowledge evaluation across 57 subjects. While designed for static models, its domain-stratified scoring approach influenced our per-domain evaluation structure.

Scoring FrameworkDomain-Specific EvaluationBenchmark Design
15.
Evaluating Large Language Models Trained on Codeopen_in_new

Chen, M., Tworek, J., Jun, H., et al. · arXiv preprint · 2021

Introduces functional correctness as the evaluation criterion for code generation, using pass@k as a metric. Informs our coding domain template where output correctness is paramount.

Task CompletionDomain-Specific EvaluationScoring Framework
16.
AgencyBench: Evaluating LLM Agents on Long-Horizon Compositional Tasksopen_in_new

Li, Y., et al. · arXiv preprint · 2025

Benchmarks agents on workflows averaging 1 million tokens and 90 tool calls, revealing how performance degrades on long-horizon tasks. Supports our multi-step evaluation dimension (U3) and the need for execution endurance testing.

Multi-Step ReasoningAutonomyBenchmark Design
17.
REALM-Bench: A Benchmark for Realistic Agent Learning with Multifaceted Challengesopen_in_new

Wang, Z., et al. · arXiv preprint · 2025

Tests agents on parallel processes, resource constraints, and unexpected disruptions. Validates our error handling dimension (U4) and the importance of testing agent behavior under adversarial or constrained conditions.

Error HandlingMulti-Step ReasoningSafety & PolicyAutonomy
18.
CORE-Bench: Fostering the Credibility of Published Research Through a Computational Reproducibility Agent Benchmarkopen_in_new

Siegel, Z., et al. · arXiv preprint · 2025

Evaluates agents on scientific paper reproducibility — following multi-step procedures with precision. Reinforces the methodology's emphasis on instruction interpretation (U2) and task completion fidelity (U1).

Task CompletionMulti-Step ReasoningDomain-Specific Evaluation
19.
Beyond Accuracy: Evaluating the Efficiency and Fairness of LLM-based Agentsopen_in_new

Park, J., et al. · arXiv preprint · 2025

Finds efficiency metrics appeared in only 14 of 23 benchmark papers; fairness in only 1. Underscores the gap in holistic evaluation that our output quality dimension (U6) and transparency disclosures address.

Scoring FrameworkBenchmark DesignSafety & Policy
format_quote

Tags highlighted in blue indicate direct relevance to features active in this version. View the full reference list on the methodology index.