Contents
  1. Purpose and useful performance
    1. What an evaluation establishes
      1. Three different claims
    2. Define worthwhile improvement
      1. Keep unlike outcomes separate
  2. Cases and shared comparisons
    1. Specify the case and its outcome
      1. Define unsuccessful and unresolved runs
    2. Sample the intended work
    3. What benchmarks standardize
      1. Must-know developments
  3. Measurement and assessment
    1. Choose checks that match the requirement
      1. Requirement, evidence, and remaining gap
    2. Keep denominators visible
      1. Assessment coverage belongs beside performance
    3. Build a human reference
      1. A defensible procedure
    4. Validate the model judge
      1. Known nuisance variables
  4. Independent and reproducible evidence
    1. Protect the independent assessment
      1. Practical separation
    2. Preserve the run and the assessment
      1. Evaluation manifest
      2. Rerun versus rescore
  5. Uncertainty and comparison
    1. Identify the sources of uncertainty
      1. A basic sample-size effect
    2. Compare changes on matched work
    3. State the attempt policy
      1. One record, different questions
  6. Confidence and review
    1. Interpret probability forecasts
      1. A probability scoring rule
    2. Evaluate deferral as a policy
      1. Threshold decisions need both sides
  7. From offline results to live outcomes
    1. Understand simulation and replay
    2. Account for incomplete feedback
    3. Choose the live experiment
      1. What each design supports
  8. Failure analysis and change decisions
    1. Test the failure explanation
      1. Test the feedback hypothesis
    2. Make and maintain the decision
      1. Evidence pattern to justified action
      2. Decision record
  9. Check understanding
  10. Open questions
  11. Selected talks
  12. References
  13. Talk library
← All topics

Evals and Benchmarks: Turning “It Seems Better” Into Repeatable Tests

Evals turn expectations about an AI system into tasks, measurements and comparisons that can be run again. They help teams decide whether a change improves useful behavior, introduces regressions or merely looks convincing in a few examples. Benchmarks provide shared comparison tasks; application evals test the work a particular product must do. This chapter explains how to choose cases, grade outcomes, handle variation and use results to guide development.

Purpose and useful performance

What an evaluation establishes

An evaluation systematically assesses behavior against an intended purpose. Before asking how well a system scored, state what system was evaluated, what work it was expected to do, what information and actions it could use, who could be affected, and what failures matter. A learned model—behavior fitted from examples rather than fully specified by code—adds variability, but it does not remove the need to test deterministic software around it. Machine Learning Fundamentals develops that learning process; here the concern is the evidence about the resulting system.

Three different claims

  • Acceptable outputThe produced answer satisfies the properties that the grader checked.
  • Completed taskThe application achieved the required final state and obeyed any required process conditions.
  • Improved workflowUsing the system improved outcomes such as completed work, consequential errors, total human effort, time, or cost relative to a baseline.

Evidence for one claim does not automatically establish the next. A parser can confirm valid JSON without confirming that its fields are true; a database check can confirm a reservation without proving that the user authorized it. These are questions of construct validity: whether the chosen observations measure the property the claim names. A correct reservation can still impose enough review or delay to make the workflow worse. External validity is the separate question of how far a supported conclusion extends beyond the cases, conditions, people, and outcomes that were examined.

Define worthwhile improvement

A baseline is the reference approach that the candidate must improve: the incumbent workflow, a simple rule, an earlier model, or sometimes no automation. The strongest baseline is not necessarily the most sophisticated model. It is the credible alternative for the same job. Acceptance criteria turn the intended benefit and its limits into observable conditions, while construct validity asks whether those observations really capture the property the decision concerns.

Keep unlike outcomes separate

Decision concernObservable outcomeExample acceptance condition
Useful completionTasks completed to the agreed standardCandidate is better than the incumbent by a predeclared meaningful amount
Consequential mistakesSeverity-specific errors and required correctionsNo unacceptable regression in a critical slice
Human workReview, correction, escalation, and waiting timeTotal effort remains within the operating budget
ResourcesLatency, model calls, retries, and monetary costResource limits hold for the complete configuration

These dimensions can disagree. In METR’s bounded early-2025 study, 16 experienced developers completed 246 issues in familiar open-source repositories; allowing the tested AI tools was associated with 19% longer completion time even though participants later believed the tools had accelerated them. That historical result does not generalize to current tools or all developers. It demonstrates the narrower lesson: perceived speed and measured completion time are different constructs, so an adoption decision should measure the workflow outcome it actually values.

Cases and shared comparisons

Specify the case and its outcome

An evaluation case defines the input, information available at decision time, initial state, permitted resources and actions, stopping conditions, and assessment criteria. A trial is one execution of that case. An evaluation harness runs trials and records their artifacts. A grader inspects specified evidence and assigns an assessment. These roles should stay separate: a harness can execute correctly while a grader is wrong, and a grader can be correct about an output produced by a broken environment.

The scored unit may be one answer, one extracted record, a conversation, or a complete task. For a reservation task, a fluent “Booked” message is evidence only about the response. The authoritative reservation record is evidence about the final state. If policy requires explicit confirmation, the recorded interaction must be checked separately. Agent Engineering’s outcome section explains how an acting system establishes what it accomplished.

Different requirements need different evidence

Example

A valid final state and a compliant process are complementary checks; neither implies the other.

Completion requires both the recorded confirmation process and the authoritative final state. Each evidence branch checks a different requirement; arrows show requirements and evidence, not elapsed time.
Read the diagram as text
  • Reservation task. Create the requested reservation after required confirmation.
  • Recorded interaction. Messages and actions from the trial.
  • Reservation record. Authoritative observed final state.
  • Confirmation check. Assesses the required process condition.
  • Final-state check. Assesses whether the requested reservation exists.
  • Completion assessment. Requires both process compliance and the intended outcome.
  • Reservation taskRecorded interaction: requires recorded process.
  • Reservation taskReservation record: requires resulting state.
  • Recorded interactionConfirmation check: observed evidence.
  • Reservation recordFinal-state check: observed evidence.
  • Confirmation checkCompletion assessment: process verdict.
  • Final-state checkCompletion assessment: outcome verdict.

Define unsuccessful and unresolved runs

DispositionMeaning
Task failureThe run completed, but checked requirements were not satisfied.
Invalid outputThe output violated the declared machine-readable contract.
Timeout or budget exhaustionThe operating policy ended the trial before successful completion.
Harness failureInfrastructure or runner behavior prevented a valid trial.
Grader failureThe run exists, but the specified assessment could not be completed.
Partial completionOnly explicitly named requirements were satisfied; the case is not silently promoted to success.

Sample the intended work

The task population is the work to which the conclusion should apply. A slice is a meaningful subset, such as a language, customer type, document source, task family, or risk category. Representative assessment samples the intended population or applies justified weights to recover its mix. A challenge set instead concentrates difficult or consequential conditions to discover weaknesses. Its failure rate is diagnostic; without population weights, it is not an estimate of how often those failures occur in deployment.

Population weights describe the intended work, not the evaluation team’s choice to oversample difficult cases. In this example, both populations retain the same slice success rates; only their mix changes.

The task mix changes the aggregate

Same slice success in both populations: routine 90% · complex 60%.

Bar length shows population weight; it does not show success.

Population A

84% overall success

Routine contribution
80% × 90% = 72 points
Complex contribution
20% × 60% = 12 points
Population B

69% overall success

Routine contribution
30% × 90% = 27 points
Complex contribution
70% × 60% = 42 points
The same slice performance yields different overall results because the populations assign different weights. The enriched challenge set remains a separate diagnostic result.

Independence is about the generating unit, not the spreadsheet row. Paraphrases from one template, turns from one conversation, records from one customer, or passages from one source document can leak information across a random row split. Grouped splits keep related cases together; temporal splits keep later cases out of development when the intended claim concerns future work. Neither repair a sampling frame that excludes important users or conditions. Synthetic cases can broaden controlled coverage, but their generator can also impose unrealistic language, behavior, or shortcuts.

What benchmarks standardize

A benchmark combines reusable tasks with an assessment protocol. Comparability depends on more than sharing inputs: the reference judgments, prompts, resource limits, allowed tools, attempt policy, aggregation, access rules, and benchmark version must also be compatible. A published ranking therefore describes performance under one protocol; it does not establish usefulness for a different application population or workflow.

Must-know developments

Must-know benchmark developments

  1. November 1992Text Retrieval Conference (TREC)Coordinated retrieval comparisons using common collections, evaluation methods, and pooled relevance judgments.Sources & context

    Contributors: TREC organizers and participating retrieval groups

    What changed: Made larger shared retrieval tests practical while leaving pooled judgments explicitly non-exhaustive.

  2. 2018General Language Understanding Evaluation (GLUE)Combined nine varied language-understanding tasks, task-specific metrics, and a diagnostic collection.Sources & context

    Contributors: GLUE benchmark team

    What changed: Extended shared comparison beyond a single dataset and exposed capability details that an aggregate score could hide.

  3. 2019SuperGLUEIntroduced harder tasks and broader formats as performance reduced GLUE’s remaining headroom.Sources & context

    Contributors: SuperGLUE benchmark team

    What changed: Restored room to distinguish progress without treating benchmark saturation as proof that language understanding was solved.

  4. 2022Holistic Evaluation of Language Models (HELM)Organized scenarios and multiple desired properties under standardized adaptation and evaluation conditions.Sources & context

    Contributors: HELM research team

    What changed: Made correctness, calibration, robustness, efficiency, and missing coverage visible as separate concerns.

  5. 2024τ-benchEvaluated tool-agent-user interaction, final state, conveyed information, and consistency across repeated trials.Sources & context

    Contributors: τ-bench research team

    What changed: Distinguished successful outcomes from compliant processes and reliable repeated completion.

Shared evaluation expanded from coordinated retrieval collections to multi-task language evaluation, renewed benchmark headroom, multi-property coverage, and repeated tool-agent interaction. Later benchmarks broadened what could be compared without making focused earlier tests obsolete. Spacing is not to scale.

TREC built on the earlier Cranfield tradition of using shared test collections for comparative retrieval evaluation. The broader development was not a replacement sequence: shared experiments expanded the properties and conditions that could be compared, while focused tests remained useful for narrower questions. Maintenance is part of the measurement work. Correcting underspecified tasks or faulty verifiers improves the benchmark rather than the evaluated model. The Art & Science of Benchmarking Agents develops practical choices around task quality, deliberate coverage, and benchmark usability.

Measurement and assessment

Choose checks that match the requirement

A test oracle is the procedure used to distinguish acceptable from unacceptable behavior. Creating inputs does not solve the separate problem of deciding whether their outputs are right. Complete executable specifications are rare, so most suites combine partial oracles whose guarantees must be stated narrowly.

Requirement, evidence, and remaining gap

Required propertySuitable checkWhat still is not established
Exact canonical valueNormalized exact match against accepted referencesCorrect references may be incomplete; normalization can erase meaningful distinctions.
Numeric agreementDeclared absolute or relative toleranceThe tolerance itself must be justified by the task.
Structured contractSchema validation and field assertionsValid structure does not prove truthful values.
Executable behaviorTests or property checks on generated artifactsFinite checks cover only encoded properties and sampled inputs.
External effectRead authoritative resulting stateThe observation may not prove authorization or every downstream effect.
Behavioral relationInvariance or directional check after a valid transformationPassing the relation does not prove either answer is independently correct.

Ribeiro and colleagues’ 2020 CheckList crossed capabilities with minimum-functionality, invariance, and directional tests. For example, changing an irrelevant location name should preserve a sentiment judgment if the transformation truly preserves the task’s meaning. Such metamorphic relations are useful when a complete answer is unavailable, but the relation itself is still a human specification. The converse failure is specification gaming: an optimizer satisfies an implemented proxy while violating the intended task. DeepMind’s block-stacking example rewarded the bottom face’s height, allowing a block flip to collect reward without stacking. The optimization worked; the measurement did not express the goal.

Use deterministic code for structure and precisely observable state, human assessment for criteria requiring expertise or preference, and model judges for scalable semantic assessment only after validation. A domain may require several fidelity layers; Document Understanding and OCR shows why transcription, structure, source location, and whole-document readiness are distinct properties.

Keep denominators visible

A metric is a numerical summary of an observed property. Its numerator, denominator, positive class, aggregation unit, and handling of missing results are part of its meaning. Suppose “positive” means accepting an output. A true positive is a valid output accepted; a false positive is an invalid output accepted; a false negative is a valid output rejected; and a true negative is an invalid output rejected.

precision=TPTP+FP,recall=TPTP+FN,false acceptance rate=FPFP+TN.\mathrm{precision}=\frac{TP}{TP+FP},\qquad \mathrm{recall}=\frac{TP}{TP+FN},\qquad \mathrm{false\ acceptance\ rate}=\frac{FP}{FP+TN}.

Precision asks what fraction of accepted outputs were valid. Recall asks what fraction of valid outputs were accepted. False acceptance rate asks what fraction of invalid outputs slipped through; it is not generally 1precision1-\mathrm{precision}. If a denominator is zero, the corresponding metric is undefined, not perfect. Precision also depends on prevalence: when invalid cases become rarer, accepted outputs can have higher precision even if the conditional acceptance behavior is unchanged.

Assessment coverage belongs beside performance

CountWhy report it
Eligible casesDefines the intended denominator.
Attempted casesExposes exclusions before execution.
Completed trialsSeparates task execution from infrastructure interruption.
Assessed trialsShows the population on which the score was computed.
Harness and grader errorsPrevents missing evidence from becoming an ordinary task result.
Unresolved human labelsPreserves ambiguity rather than forcing false certainty.

Aggregation changes the question. Pooled success weights slices by case count; equal-slice mean success gives every nonempty slice equal weight. Neither automatically represents deployment. Severity-specific outcomes should remain visible when a few consequential failures could be hidden by a large routine slice. Retry policy also changes the measured protocol: repeatedly retrying only cases that trigger a runner bug gives those inputs additional chances and can distort the aggregate.

Build a human reference

Human assessment means people apply explicit criteria to observed system behavior. A rubric defines those criteria, decision boundaries, and representative examples. Separate criteria such as factual correctness, policy compliance, usefulness, and style instead of asking for an unexplained overall impression. Reference answers can illustrate valid outcomes without implying that only one wording is acceptable.

A defensible procedure

  • Choose relevant assessorsDomain correctness and user preference require different qualifications.
  • Hide irrelevant identityBlind candidate names and randomize or counterbalance presentation order where feasible.
  • Judge independently firstInitial labels reveal ambiguity that post-discussion consensus would conceal.
  • Capture reasonsShort criterion-specific explanations make disagreements diagnosable.
  • Adjudicate causesCheck mistakes, unclear instructions, unequal knowledge, and genuine interpretive differences.
  • Retain ambiguityIf evidence cannot settle a case, mark it unresolved with a reason instead of forcing a binary label.

Inter-rater agreement measures consistency under the protocol; it does not establish truth. Majority vote can conceal a shared misunderstanding, and authoritative adjudication can conceal a defective rubric. Pairwise assessment can be easier than assigning an absolute score, but it still needs ties and “not comparable” outcomes when appropriate. How Evals and Prompts Shape Agent Behavior describes how edge cases exposed disagreements within a team and motivated clearer examples for raters.

Validate the model judge

A model judge is a learned model used as a measurement instrument. Its behavior is defined by the model version, rubric, reference material, candidate presentation, examples, decoding configuration, and result categories. A reference-based judge compares against supplied evidence or answers; a reference-free judge relies on its own learned knowledge and the rubric. Pairwise judging compares candidates; absolute judging assigns each candidate a category or score.

Faithfulness asks whether claims follow from supplied material. It does not establish that the material is true or complete. Conversely, a true statement absent from the supplied context may fail a strict faithfulness check. Retrieval-Augmented Generation owns the full evidence-to-answer pipeline. Here the lesson is to give the judge the information required by the criterion and not silently substitute one property for another.

Validate a frozen judge on independent human-assessed cases. Report its confusion matrix, ties or abstentions, uncertainty, and errors by consequential slice. Overall agreement can hide a judge that works on routine writing but falsely accepts policy violations. Review disagreements before changing either the application or the judge.

Known nuisance variables

The 2023 MT-Bench and Chatbot Arena study compared model judgments with human preferences and tested order swaps, verbosity, and reference-guided judging. It showed that candidate order can change a verdict and that a judge can reproduce an error present in a candidate’s reasoning. A separate 2024 summarization study found tested models preferred their own generations more than human quality differences explained. These are scoped findings, not universal bias rates. They motivate controls in the actual harness: swap order, test style-only changes, use independent references where appropriate, and revalidate after changing the judge. A persuasive generated explanation is diagnostic text, not independent proof of why the verdict occurred.

Labeled examples can sharpen a judge’s boundary, but they also become part of its input. Prompting and In-Context Learning explains how demonstrations affect behavior without changing weights. Keep those examples separate from the final validation set, and record their order and content in the evaluation manifest.

Independent and reproducible evidence

Protect the independent assessment

Contamination occurs when evaluation information reaches training or another path that violates the intended test. Direct routes include duplicate tasks, paraphrased questions, published solutions, prompt demonstrations, retrieval sources, and evaluator examples. Whether access is improper depends on the task contract: web access may be the capability under test in one benchmark and prohibited leakage in another.

Adaptive overfitting is different. Repeatedly choosing prompts, models, thresholds, or tools after inspecting the same holdout makes the selected system dependent on that holdout even if its examples never enter training. Dwork and colleagues’ 2015 work formalized this problem in adaptive data analysis and developed reusable-holdout methods that restrict validation feedback under stated assumptions. An ordinary hidden set with unrestricted score feedback receives no such guarantee.

How a holdout can enter development

Example

Score feedback can make later candidates dependent on protected cases even when the cases and answers remain hidden.

Direct disclosure exposes protected tasks or answers. Repeated score-guided selection can create dependence without revealing the cases. Whether either route violates the evaluation depends on its declared information contract.
Read the diagram as text
  • Protected cases. Cases intended for independent assessment.
  • Disclosed tasks or answers. Direct exposure through data, prompts, retrieval, or evaluator examples.
  • Score feedback. Information returned from an assessment round.
  • Candidate revision. A prompt, model, tool, or threshold selected after feedback.
  • Final assessment. The protected measurement used for the decision.
  • Protected casesDisclosed tasks or answers: direct disclosure.
  • Disclosed tasks or answersCandidate revision: development input.
  • Protected casesScore feedback: assessment output.
  • Score feedbackCandidate revision: adaptive selection.
  • Candidate revisionFinal assessment: candidate under test.
  • Protected casesFinal assessment: cases and rubric.

Practical separation

  • Development dataMay guide prompts, code, model selection, and rubric design.
  • Validation dataSupports bounded iteration, with reuse and feedback recorded.
  • Protected final assessmentIs consulted only under a predeclared decision protocol and retained for independent confirmation.
  • Group and time controlsKeep related templates, documents, users, and future periods out of development together.
  • Refresh and versioningAdd or replace cases deliberately, preserving old results and the exact benchmark version.

Freshness helps but does not prove independence when training corpora are unknown or runtime lookup is allowed. LiveBench’s 2024 design combined recent sources, automatically checkable answers, and planned updates, but the authors acknowledged that checkability excludes valuable open-ended tasks and that prompts still matter. Protection, coverage, and maintainability remain tradeoffs rather than a permanent “contamination-free” state.

Preserve the run and the assessment

Operational reproducibility means preserving enough artifacts and conditions to test the reported computation again and interpret expected variation. It is not necessarily byte-identical output. The National Academies distinguishes computational reproducibility using the same data and methods from replication using newly collected data to address the same question. Generalization to another population is a further claim.

Evaluation manifest

RecordExamples
CasesDataset version, case IDs, inputs, targets, and exclusions
System and environmentModel, prompts, harness revision, tools, sandbox, and source revision
Execution and assessmentGeneration settings, limits, retries, rubric, graders, and thresholds
Raw evidenceOutputs, scores, errors, timing, usage, and final-state observations
Unavailable dependenciesMissing snapshots or mutable services that constrain rerunning

Inspect’s documented records connect task and model versions, execution settings, outputs, scores, errors, timing, and usage. Those records aid interpretation, but an identifier does not make a dependency immutable or recoverable. OpenAI’s archived 2023 seed documentation likewise described only best-effort consistency: matching parameters and a backend fingerprint still did not guarantee identical responses. A seed alone is not an environment snapshot.

Rerun versus rescore

OperationRegeneratedCan support
RerunNew system execution and new output under recorded or updated conditionsA claim about execution behavior under those conditions
RescoreA new assessment of stored output; execution is unchangedA claim about how a different grader interprets historical artifacts

Keep harness, task, and grader failures separately labeled rather than deleting inconvenient samples. The raw per-task and per-attempt records will later determine the correct unit for uncertainty and paired comparison.

Uncertainty and comparison

Identify the sources of uncertainty

Measured performance can vary because different tasks are sampled, repeated executions take different paths, or assessors disagree or err. These are distinct sources. A confidence interval is produced by a procedure designed to cover a fixed population parameter at a stated rate over repeated samples under its assumptions. It is not the probability that one answer is correct, and a narrow interval does not remove sampling bias, grader bias, or distribution shift.

A basic sample-size effect

For binary independent trials with a common failure probability, an exact one-sided 95% binomial bound after zero observed failures is 1 − 0.05^(1/n). With 20 independent trials and no failures, the upper bound is about 13.9%; with 200, it is about 1.5%. The larger sample narrows uncertainty, but neither result establishes zero future risk. This calculation assumes independent trials with one common probability. Heterogeneous or clustered tasks require a sampling model that preserves their structure; repeatedly executing one task estimates that task’s stochastic behavior instead of enlarging the task population.

A bootstrap repeatedly resamples the independent observational units with replacement and recomputes the statistic. If cases are clustered by user, template, or scenario, resample appropriate clusters rather than pretending every row is independent. DigiWorld illustrates a nested target: apps contain scenarios, configurations, and stochastic rollouts. Its hierarchical bootstrap follows that structure to estimate variation within a fixed curated suite; it does not turn the chosen apps into a random sample of all deployment environments.

More samples address random uncertainty only under the sampling model. They cannot fix systematically wrong reference labels, an incomplete oracle, omitted user groups, or a judge that shares the candidate’s error. Those defects require measurement repair.

Compare changes on matched work

A paired comparison evaluates baseline and candidate on the same sampled tasks. For task ii, first summarize each version’s prespecified repeated outcomes as AiA_i and BiB_i. The task-level difference is di=BiAid_i=B_i-A_i, and an equal-task-weight effect estimate is dˉ=1Nidi\bar d=\frac{1}{N}\sum_i d_i. Resampling task indices while carrying both versions together preserves the pairing. Related tasks still require a suitable cluster design.

di=BiAi,dˉ=1Ni=1Ndi.d_i=B_i-A_i,\qquad \bar d=\frac{1}{N}\sum_{i=1}^{N}d_i.

The effect size is the magnitude of the difference in the units that matter: percentage points of task success, minutes of human correction, or cost per completed valid task. Statistical detectability is not practical importance. Before comparison, define a smallest worthwhile improvement or an acceptable-loss margin from the intended use. For a higher-is-better outcome and d=candidatebaselined=\mathrm{candidate}-\mathrm{baseline}, a non-inferiority claim asks whether the data exclude dmd\le -m, where m>0m>0 is the largest acceptable loss. A favorable point estimate with an interval crossing m-m remains inconclusive.

Point estimates, uncertainty, and an acceptable loss

Example

A positive estimate can remain inconclusive if its interval includes an unacceptable loss; a precisely measured tiny gain may still be below practical importance.

Illustrative paired differences

Horizontal intervals are invented teaching data, not measured benchmark results.

-6-2.514.5801234Candidate minus baseline (percentage points)Illustrative comparison (dimensionless)No differenceAcceptable-loss boundaryExample A intervalExample A estimateExample B intervalExample B estimateExample C intervalExample C estimateA: non-inferiorB: inconclusiveC: small gain
  • 1. No difference
  • 2. Acceptable-loss boundary
  • 3. Example A interval
  • 4. Example A estimate
  • 5. Example B interval
  • 6. Example B estimate
  • 7. Example C interval
  • 8. Example C estimate
Read coordinates and regions as data

X: -68 percentage points; Y: 04 dimensionless, increasing up. Axes scaled independently; screen angles and distances are not comparable.

No difference (polyline)

(0, 0.3); (0, 3.7)

Acceptable-loss boundary (polyline)

(-2, 0.3); (-2, 3.7)

Example A interval (polyline)

(-1, 3); (4, 3)

Example A estimate (points)

(1.5, 3)

Example B interval (polyline)

(-4, 2); (6, 2)

Example B estimate (points)

(1, 2)

Example C interval (polyline)

(0.1, 1); (0.9, 1)

Example C estimate (points)

(0.5, 1)

A: non-inferior: (4.3, 3)

B: inconclusive: (6.3, 2)

C: small gain: (1.2, 1)

Three invented comparison outcomes share a candidate-minus-baseline axis. Zero marks no difference; −2 percentage points is the declared acceptable-loss boundary. A excludes −2 and supports non-inferiority without proving a positive gain. B includes unacceptable loss and remains inconclusive. C shows a precise small gain whose practical importance depends on the predeclared criterion.

Inspect individual gains and regressions as well as the aggregate. Improvements on routine cases can offset a critical slice regression numerically without making it acceptable. Also distinguish an equal-resource capability comparison from a whole-workflow comparison: changing models, retries, tool access, review effort, or latency may be the product configuration, but the resulting difference is not a model-only effect.

Repeatedly testing many candidates and reporting the best one creates selection bias. Predeclare the main comparison and decision rule, control or disclose multiple comparisons, and confirm the selected change on protected evidence. Failure to detect a difference establishes neither equality nor acceptable equivalence.

State the attempt policy

Success on one attempt, success at least once, and consistent repeated success are different operating claims. HumanEval introduced an executable code benchmark and pass@k, which asks whether at least one of kk sampled candidates passes its tests. It does not mean every attempt succeeds or that a user can identify the passing candidate without a checker. With nn sampled candidates and cc passing candidates, its estimator is 1(nck)/(nk)1-\binom{n-c}{k}/\binom{n}{k}, averaged across tasks.

pass@k^=1(nck)(nk).\widehat{\mathrm{pass@}k}=1-\frac{\binom{n-c}{k}}{\binom{n}{k}}.

By contrast, τ-bench’s pass^k asks whether all kk independent trials succeed. Mean success asks what fraction of attempts succeed. The same trial record can therefore support three different summaries. Adaptive retries, repairs informed by previous failures, correlated sampling, and variable budgets define yet another policy. Record the checker, attempt budget, selection rule, latency, and cost. Reasoning and Test-Time Compute owns the mechanisms for sampling and searching candidate solutions.

One record, different questions

Trial outcomesMean successAny of 3All 3
pass, fail, pass2/3yesno
pass, pass, pass1yesyes
fail, fail, fail0nono

Confidence and review

Interpret probability forecasts

Calibration means predicted probabilities for a specified event match observed event frequencies. If a system assigns probability 0.8 to “this automatically accepted answer is valid,” then among comparable cases receiving about 0.8, roughly 80% should be valid. Calibration differs from accuracy, the ability to rank easier cases ahead of harder ones, and uncertainty in an aggregate performance estimate.

A reliability diagram groups predictions and plots each group’s average forecast against its observed event frequency. Counts must accompany the bins: a point based on three cases is not as informative as one based on three hundred, and different binning can change the picture. A diagonal pattern indicates empirical calibration for the tested population, not proof that the probabilities transfer under changed conditions.

Calibration compares forecasts with outcomes

Example

A forecast of 0.8 is calibrated only when the specified event occurs about 80% of the time among comparable forecasts.

Illustrative reliability diagram

Valid answers / bin count, from low to high forecast: 3/40, 17/60, 35/80, 29/50, and 17/25. Observed rates are rounded to two decimals.

00.250.50.75100.250.50.751Mean predicted probability (dimensionless)Observed event frequency (dimensionless)Perfect calibrationObserved binsBin trendn=40n=60n=80n=50n=25
  • 1. Perfect calibration
  • 2. Observed bins
  • 3. Bin trend
Read coordinates and regions as data

X: 01 dimensionless; Y: 01 dimensionless, increasing up. Equal scale on both axes.

Perfect calibration (polyline)

(0, 0); (1, 1)

Observed bins (points)

(0.1, 0.08); (0.3, 0.28); (0.5, 0.44); (0.7, 0.58); (0.9, 0.68)

Bin trend (polyline)

(0.1, 0.08); (0.3, 0.28); (0.5, 0.44); (0.7, 0.58); (0.9, 0.68)

n=40: (0.1, 0.14)

n=60: (0.3, 0.34)

n=80: (0.5, 0.5)

n=50: (0.7, 0.64)

n=25: (0.9, 0.74)

For the event “the automatically accepted answer is valid,” the high-confidence bins fall below the identity line: forecasts are overconfident in this invented population. Observed rates are rounded to two decimals. Counts show how much evidence supports each bin.

A probability scoring rule

Brier=1Ni=1N(piyi)2,yi{0,1}.\mathrm{Brier}=\frac{1}{N}\sum_{i=1}^{N}(p_i-y_i)^2,\qquad y_i\in\{0,1\}.

The customary binary Brier loss ranges from 0 to 1, with lower values better. It reflects more than calibration, so a lower Brier value does not alone prove a better reliability diagram. Record the normalization when comparing libraries: an unscaled sum across two complementary binary classes is twice this customary form.

Token likelihood, verbal certainty, a judge’s rating, and probability of task correctness are not interchangeable. Verbal-confidence studies have found that calibration depends on the model, task, and elicitation method. The vocabulary probabilities described in Transformers and Attention concern next-token prediction; a separate validated construction is needed to interpret them as probabilities of complete-task success. Fit any calibrator on data independent of the underlying predictor’s training cases, and reassess after distribution shift.

Evaluate deferral as a policy

Abstention means declining automatic completion. Coverage is the fraction of eligible cases accepted automatically, while selective risk is expected error conditional on acceptance. A threshold can use a ranking score even when that score is not a calibrated probability, but the selected policy still needs independent evaluation.

coverage=#accepted#eligible,selective risk=#errors among accepted#accepted.\mathrm{coverage}=\frac{\#\,\mathrm{accepted}}{\#\,\mathrm{eligible}},\qquad \mathrm{selective\ risk}=\frac{\#\,\mathrm{errors\ among\ accepted}}{\#\,\mathrm{accepted}}.

Choose the acceptance threshold as an operating policy: it decides which eligible cases finish automatically and which enter review. Lowering coverage often reduces accepted-case error because the system retains easier cases, but can increase review burden. Report capacity, reviewer accuracy, waiting time, unresolved cases, and failures after escalation. At zero coverage, accepted-case risk is undefined and the system delivers no automatic work.

A stricter threshold moves work into review

Ten invented eligible cases: six routine and four complex. Scores rank automatic answers; they are not calibrated probabilities. Deferred cases use a fixed review protocol with possible errors and unresolved outcomes.

Move the threshold to route the same ten cases. All other case properties stay fixed.

Automatic: 6/10, 60.0% coverage, 1 errors, 16.7% selective risk. Review: 4 cases, 20 minutes of effort, 0 errors and 2 unresolved.

Automatic risk versus coverageEach circle is a distinct accepted population. The square marks the current policy: 60.0% coverage and 16.7% selective risk. Zero coverage has no defined risk and no plotted point. Values are also provided in the table.0%0%50%50%100%100%Errors / automatically acceptedAutomatic coverage (accepted / 10 eligible)

Square: current threshold. Circles: distinct accepted populations. Connecting lines guide the eye; cases change discretely.

Same eligible population at threshold 70
PopulationAutomatic / eligibleCoverageErrors / automaticSelective riskTo reviewReview: correct / error / unresolvedReview effort
All cases6/1060.0%1/616.7%42 / 0 / 220 min
Routine5/683.3%1/520.0%11 / 0 / 02 min
Complex1/425.0%0/10.0%31 / 0 / 218 min

Whole workflow: 7 correct + 1 incorrect + 2 unresolved = 10 eligible cases.

Review effort is two minutes per routine case and six per complex case, including unresolved reviews. It measures work demanded, not waiting time or a queue simulation. Review outcomes are assumed fixed; capacity limits and fatigue are not modeled.

Inspect the ten fixed cases
Case / scoreAutomatic answerIf reviewedCurrent route
R1 · routine · 96Correctcorrect · 2 minAutomatic
R2 · routine · 91Correctcorrect · 2 minAutomatic
R3 · routine · 84Incorrectcorrect · 2 minAutomatic
R4 · routine · 78Correctincorrect · 2 minAutomatic
R5 · routine · 72Correctcorrect · 2 minAutomatic
R6 · routine · 64Correctcorrect · 2 minReview
C1 · complex · 87Correctcorrect · 6 minAutomatic
C2 · complex · 69Incorrectunresolved · 6 minReview
C3 · complex · 48Incorrectcorrect · 6 minReview
C4 · complex · 25Incorrectunresolved · 6 minReview
At 90, automatic risk reaches zero for just two of ten cases, while review still produces an error and two unresolved outcomes. Judge the complete workflow, not only the accepted subset.

Threshold decisions need both sides

Automatic sideReview side
CoverageCases sent to review
Error among accepted casesReviewer accuracy and unresolved fraction
Latency and cost of automatic handlingQueue time, reviewer effort, and escalation cost
Performance by task sliceCapacity by task slice and expertise

From offline results to live outcomes

Understand simulation and replay

Offline evaluation assesses prepared cases outside the active workflow. A simulation generates interactions or environment changes under a model of users and state. Replay feeds captured artifacts into some part of the system again. Transfer can fail when task mix, available information, user behavior, external state, or human intervention differs from production—a form of distribution shift developed more fully in Machine Learning Fundamentals.

A user simulator is part of the measurement instrument. In Lyft’s evaluation account, an initial simulated user patiently supplied complete explanations unlike frustrated production users. Incorporating production examples and a user model closer to customer language made the evaluation harder and lowered the reported score. The decrease alone did not prove predictive validity; it exposed how simulator behavior changes the task presented to the agent. A separate 2025 user-model study likewise found materially different assistant success under different simulators, while cautioning that lower scores do not by themselves establish realism.

Replay has a causal boundary. Re-executing a parser or grader on captured input can test that component. Replacing an action in a stateful workflow changes the next state and therefore later observations. Feeding the original future observations to the changed policy generally does not simulate its outcome. Counterfactual replay needs a valid environment model and controlled external factors to recompute the divergent branch. RL Environments and Simulators owns environment construction and fidelity.

A changed action creates a different future

Example

Captured history supports a common starting point, but it does not contain the observations produced by an alternative action.

The common starting state is recorded. Only the historical branch has an observed successor and next observation. The alternative successor and observation require a valid environment model or new execution; copying the recorded future does not evaluate the changed action.
Read the diagram as text
  • Recorded state s₀. State and information available before the action.
  • Recorded action a. Action taken in the historical execution.
  • Alternative action a′. Changed action being evaluated.
  • Observed successor s₁. The state actually produced by the recorded action.
  • Modeled successor s′₁. Must be generated by a valid environment model or new execution.
  • Recorded observation o₁. Observation produced from the historical successor.
  • Alternative observation o′₁. Observation derived from the alternative successor, not copied from history.
  • Recorded state s₀Recorded action a: historical choice.
  • Recorded state s₀Alternative action a′: counterfactual choice.
  • Recorded action aObserved successor s₁: actual transition.
  • Alternative action a′Modeled successor s′₁: modeled transition.
  • Observed successor s₁Recorded observation o₁: generates observation.
  • Modeled successor s′₁Alternative observation o′₁: generates observation.

Account for incomplete feedback

Production labels are often selected by the workflow. Selective labels arise when existing decisions determine which outcomes become observable. If only escalated cases receive expert review, automatic cases may lack a comparable correctness label. If users complain only about visible failures, silence is not proof of success. A click reflects exposure and presentation as well as usefulness; an accepted suggestion may still require later correction.

Delayed feedback creates another distinction: an event may not have occurred, or it may not yet have been observed. Chapelle’s 2014 advertising study modeled eventual conversion separately from conversion delay because a short labeling window misclassified later purchases as negatives, while waiting longer made the data older. Its 30-day attribution rule was specific to that study, not a universal evaluation window. Every application must define follow-up and how unresolved outcomes enter denominators.

Routing decisions can change apparent quality without changing underlying behavior. Nubank’s support report separates post-interaction satisfaction from self-service without human escalation and notes that sending difficult cases to people can improve satisfaction while reducing self-service. Report the full workload: eligible cases, automatic cases, escalations, reviewed cases, observed outcomes, and outcomes still unavailable. Production feedback should become a review candidate, not automatic ground truth.

Choose the live experiment

Live designs answer different residual questions. A shadow evaluation copies current inputs to a candidate while production still supplies the user-visible result. It exposes compatibility and candidate outputs under current traffic, but it does not measure the consequences of applying those outputs. Shadow tools must have isolated state or denied production mutations; discarding a response does not undo side effects. A canary exposes a bounded live population to the candidate and checks prespecified operating and quality criteria. A randomized comparison assigns eligible units to control or candidate and can estimate an intervention effect under its assumptions.

What each design supports

DesignCandidate affects workflow?Strongest typical claim
ShadowNo, if side effects are isolatedBehavior and compatibility on current inputs
Limited rollout or canaryYes, for a bounded populationOperational behavior and bounded live outcomes under the exposure policy
Randomized comparisonYes, by assigned armAverage treatment-control difference for the assigned population and observation window, subject to assumptions
Before and afterYesObserved temporal association; concurrent changes remain plausible explanations

Choose the assignment unit that matches dependence. Request-level assignment can contaminate a user’s experience across turns; user-level assignment can still suffer interference through shared marketplaces, teams, or infrastructure; workflow-level assignment may reduce interference but reduce effective sample size. Cluster randomization and switchbacks are design options, not universal cures. Define primary outcomes, constraints, exposure, follow-up, and stop conditions before looking at results. Repeatedly applying an ordinary fixed-horizon test while watching for significance can invalidate its false-positive guarantee; valid sequential methods require their own protocol.

METR’s later 2026 update documents how selection before randomization, changed task choices, differential completion, and difficulty attributing time during concurrent agent use weakened inference in a follow-up productivity experiment. Random assignment does not repair who declines to enter the experiment or which tasks are withheld. Measure completed work and total human effort, not only generated output or satisfaction. Forward Deployed Engineering develops how customer benefit is established in field delivery.

Rollback stops further candidate exposure; it cannot undo effects already delivered. In irreversible or safety-critical workflows, stronger pre-exposure evidence and narrower authority may be required because the normal “ship, observe, and roll back” assumption does not hold.

Failure analysis and change decisions

Test the failure explanation

Error analysis begins with inspected cases, not a universal taxonomy. First decide what failed: the task, the reference label, the rubric, the automated judge, the harness, or the environment. Then group cases by observed mechanisms and meaningful slices. Prioritization should consider exposure, frequency, severity, and uncertainty separately; multiplying them into a single unsupported score can hide the material driver.

A trace is a recorded sequence of operations. It can reveal what information, tool calls, and transitions preceded an outcome, but collection is not judgment and temporal order is not causal proof. Observability owns instrumentation and operational diagnosis. Evaluation supplies the required outcome and the criteria by which the trace or final state is interpreted.

Sometimes the measurement needs repair before the application. In the 2024 EvalGen study, participants examining entity-extraction outputs disagreed about names embedded in hashtags: one wanted exclusion, while another wanted the name retained without the hash. The same assertion could not satisfy both intended criteria. More labels cannot rescue an implementation that encodes the wrong requirement; clarify the criterion and reconsider affected annotations first.

Test the feedback hypothesis

An ablation deliberately removes or changes a component. Here only feedback differs, and outcomes are independently assessed. Improvement supports the feedback hypothesis under these controls; it does not prove unchanged components faultless or exclude interactions.
ElementCondition ACondition BRole in inference
Task and initial stateIdenticalIdenticalPreserve the starting problem
Model, instructions, tool implementation, budgetIdenticalIdenticalHold other system factors fixed
FeedbackSuspected faulty feedbackVerified replacement feedbackChange only the hypothesized influence
Repeated executionRandomized run orderRandomized run orderReduce order effects and expose variability
Outcome assessmentIndependent assessment; same criterionIndependent assessment; same criterionMeasure the resulting task state
Matched comparisonBaseline outcomesReplacement-feedback outcomesImprovement supports the tested explanation

Treat model-generated explanations as hypotheses. In controlled 2023 experiments, models often changed answers in response to introduced position patterns or suggested answers and then supplied plausible rationales without acknowledging those influences. Explanations can guide interventions, but only independent controls test the proposed cause.

Make and maintain the decision

A release decision combines the intended improvement, paired evidence, uncertainty, critical regressions, review burden, live outcomes, and consequences of being wrong. More evaluation is useful when uncertainty is the obstacle and additional representative evidence can narrow it. More trials do not repair a wrong metric, biased sampling frame, broken grader, or invalid environment.

Evidence pattern to justified action

Evidence patternNext justified actionRemaining question
Meaningful gain supported; constraints and critical slices acceptableRelease or expand within the evaluated conditionsDoes production monitoring remain consistent with the claim?
Favorable estimate, but unacceptable loss remains plausibleGather more appropriate evidence or retain the baselineCan added data resolve uncertainty at reasonable cost?
Average gain with critical slice regressionRestrict, redesign, or reject for that scopeCan the failure be removed without creating another regression?
Accepted-case quality improves but review capacity is exceededChange the deferral policy or add qualified capacity before expansionWhat happens to rejected and unresolved work?
Reference, grader, or harness is invalidRepair and revalidate the measurement before changing the applicationWhich historical conclusions must be withdrawn or rescored?
Live workflow outcome fails despite offline successInvestigate transfer assumptions and restrict exposureWhich production condition was absent offline?

Capability suites explore behavior that is still difficult; regression suites protect behavior that already works. Incident-derived cases are valuable regression and diagnostic evidence, but adding many rare failures changes the interpretation of an aggregate unless representative estimates remain separately weighted. A local repair also needs broader regression testing: the illustrative stop-sign example in From Self-driving to Autonomous Voice Agents asks whether a fix that stops at the target sign accidentally makes the system stop everywhere.

An evaluation gate ties a criterion to an action and a responsible owner. A score that changes no decision and routes no regression to an owner does not close the loop. Lyft’s account recommends offline launch criteria, production regression detection, and clear ownership; it does not establish a universal threshold or completed automated gate.

Decision record

  • ActionRelease, restrict, revise, gather evidence, repair measurement, or reject.
  • Supported resultThe paired or live comparison, uncertainty, and relevant slice outcomes.
  • ConditionsExact evaluated configuration, population, attempt policy, grader, and observation window.
  • Material limitationsUnobserved outcomes, unresolved labels, missing conditions, or nonrecoverable dependencies.
  • OwnerThe person or team responsible for the action and regressions.
  • Reassessment triggerA system, rubric, judge, benchmark, population, dependency, or risk change that expires the claim.

Preserve old manifests, outputs, and decisions when changing the system or measurement. Rescoring historical outputs can answer how a new rubric views old behavior; only new execution assesses the changed system. Continuous evaluation is therefore not one endlessly growing score. It is a maintained set of scoped claims whose evidence, conditions, and expiration triggers remain visible.

Open questions

  1. How can evaluation suites remain independent when developers, automated optimizers, and model providers repeatedly receive score feedback? Progress would require practical information-limited protocols that preserve useful debugging while making adaptive reuse auditable.

  2. How should teams estimate performance when tasks are nested within users, templates, environments, and repeated stochastic trials? The hard part is identifying the actual independent sampling units; progress would look like evaluation tools that encode the sampling design and produce matched, hierarchical uncertainty by default.

  3. How can model judges be validated for unfamiliar domains, adversarial candidate text, and changing model versions without making human review as expensive as the work being automated? Useful progress would combine targeted expert labels, abstention, slice-specific error monitoring, and cheap revalidation after judge changes.

  4. How can simulators predict live behavior when users, tools, and external state respond to the system’s actions? Better progress would be measured by prospective prediction of live outcomes across held-out deployments, not simply lower simulated scores or more realistic-looking conversations.

  5. How should delayed, selectively observed, and human-mediated outcomes enter continuous evaluation? Progress would require explicit observation windows, missing-outcome accounting, and designs that separate improved system behavior from changes in routing, exposure, or review.

Follow the curated reading path through the speakers and demonstrations behind this entry.

Explore more talks

The rest of the library, beyond the curated path. Cited talks support this entry; reviewed transcripts were processed in full. Metadata candidates have not been reviewed as sources or verified as topic members.

581 matching talks

TalkSpeakerEventYear
Sayash KapoorAI Engineer Summit 20252025
Nick NisiAI Engineer Europe 20262026
Philipp SchmidAI Engineer World's Fair 20262026
Lukas PeterssonAI Engineer World's Fair 20262026
Kam LasaterAI Engineer Summit 20252025
Alex Shaw, Ryan MartenAI Engineer World's Fair 20262026
Rayan GargAI Engineer World's Fair 20262026
Al HarrisAI Engineer Code 20252025
How to Kill the Code Review

Transcript reviewed

Ankit JainAI Engineer World's Fair 20262026
fighting slop with slop

Transcript reviewed

Vaibhav GuptaAI Engineer World's Fair 20262026
Vision: Zero Bugs

Transcript reviewed

Johann Schleier-SmithAI Engineer Code 20252025
Mahmoud MabroukAI Engineer Europe 20262026
Ending AI Slop

Transcript reviewed

Thais Castello BrancoAI Engineer World's Fair 20262026
Vinoth GovindarajanAI Engineer World's Fair 20262026
Jesse HuAI Engineer Code 20252025
2025 in LLMs so far

Transcript reviewed

Simon WillisonAI Engineer World's Fair 20252025
Prasenjit SarkarAI Engineer Europe 20262026
Dat Ngo, Aman KhanAI Engineer World's Fair 20252025
Nishant GuptaAI Engineer World's Fair 20262026
Sumaiya ShrabonyAI Engineer World's Fair 20262026
Angel Ortmann LeeAI Engineer World's Fair 20262026
Nick HeinerAI Engineer World's Fair 20262026
Will BrownAI Engineer World's Fair 20262026
Balázs HorváthAI Engineer World's Fair 20262026
Rachel Lee Nabors (RL Nabors)AI Engineer World's Fair 20262026
Vincent KocAI Engineer Europe 20262026
Aparna Dhinkaran, Aparna DhinakaranAI Engineer Summit 20252025
Mohak SharmaAI Engineer Summit 20252025
Doug GuthrieAI Engineer World's Fair 20252025
Yegor Denisov-BlanchAI Engineer Code 20252025
Anna Marie BenzonAI Engineer World's Fair 20262026
Steven WillmottAI Engineer Europe 20262026
Phil HetzelAI Engineer Europe 20262026
Prompt Engineering is Dead

Cited in this entry

Nir GazitAI Engineer World's Fair 20252025
Nathaniel Whittemore (NLW)AI Engineer Code 20252025
Kuba RogutAI Engineer Europe 20262026
David KaramAI Engineer World's Fair 20252025
Darius EmraniAI Engineer World's Fair 20252025
Kobie CrawfordAI Engineer Europe 20262026
Evaling Video Slop

Transcript reviewed

Maor BrilAI Engineer World's Fair 20262026
Nicholas Kang, Michael AaronAI Engineer Europe 20262026
Shreya Rajpal, Aman GuptaAI Engineer World's Fair 20262026
Danny Gollapalli, Ben Hylak, Zubin KotichaAI Engineer Europe 20262026
Mukuntha Narayanan, Han WangAI Engineer World's Fair 20252025
Joel BeckerAI Engineer Code 20252025
Beyang LiuAI Engineer World's Fair 20242024
Jared JoselowitzAI Engineer World's Fair 20262026
Kobie CrawfordAI Engineer Europe 20262026
Ibragim BadertdinovAI Engineer Europe 20262026
Rustem FeyzkhanovAI Engineer World's Fair 20262026
Judging LLMs

Transcript reviewed

Alex VolkovAI Engineer World's Fair 20242024
Agents Building Agents

Transcript reviewed

Alfonso GrazianoAI Engineer World's Fair 20262026
Rashi AgrawalAI Engineer World's Fair 20262026
Akele Reed, Dave Revere, Doug KellerAI Engineer World's Fair 20262026
Eugene YanAI Engineer Summit 20232023
Alejandro VidalAI Engineer World's Fair 20262026
Chaitanya AsawaAI Engineer World's Fair 20262026
LLM Evals That Work IRL

Transcript reviewed

Aparna Dhinkaran, Aparna DhinakaranAI Engineer World's Fair 20242024
Emmanuel TurlayAI Engineer Summit 20232023
Ali KhialAI Engineer World's Fair 20262026
Lukas BiewaldAI Engineer World's Fair 20242024
James ShiAI Engineer World's Fair 20262026
Ben KunkleAI Engineer Europe 20262026
Christopher LovejoyAI Engineer Summit 20252025
Ayush BhardwajAI Engineer World's Fair 20262026
Ofer MendelevitchAI Engineer World's Fair 20252025
David KaramAI Engineer World's Fair 20252025
Tariq ShaukatAI Engineer World's Fair 20262026
Sarah Sachs, Carlos Esteban, Doug GuthrieAI Engineer World's Fair 20252025
Stefano FiorucciAI Engineer Europe 20262026
Niklas NielsenAI Engineer Summit 20232023
Preetika Bhateja, Daniel BumpAI Engineer World's Fair 20262026
Tisha Chawla, Susheem KoulAI Engineer World's Fair 20262026
Dex HorthyAI Engineer World's Fair 20252025
John DickersonAI Engineer World's Fair 20252025
Harrison ChaseAI Engineer World's Fair 20252025
Justin MullerAI Engineer World's Fair 20252025
Ari HeljakkaAI Engineer Summit 20252025
Cedric VidalAI Engineer World's Fair 20252025
Denys LinkovAI Engineer World's Fair 20262026
Alex DuffyAI Engineer World's Fair 20252025
Parth AsawaAI Engineer World's Fair 20262026
Paul HenryAI Engineer World's Fair 20242024
Soumya Gupta, Jai ChopraAI Engineer World's Fair 20262026
Naman JainAI Engineer Code 20252025
Sheila Gulati, Nischal NadhamuniAI Engineer World's Fair 20242024
Evals Are Not Unit Tests

Metadata candidate

Ido PesokAI Engineer World's Fair 20252025
Carlos Esteban, DougAI Engineer World's Fair 20252025
Julia Neagu, Deanna Emery, Maitar AsherAI Engineer World's Fair 20252025
Ankur GoyalAI Engineer World's Fair 20252025
Anirban ChatterjeeAI Engineer World's Fair 20262026
Vinoo GaneshAI Engineer World's Fair 20262026
Hamel Husain, Emil SedghAI Engineer World's Fair 20242024
Muktesh MishraAI Engineer World's Fair 20252025
Samuel ColvinAI Engineer World's Fair 20252025
Dat NgoAI Engineer Europe 20262026
Greg KamradtAI Engineer World's Fair 20252025
Amy Boyd, Nitya NarasimhanAI Engineer Europe 20262026
Diego RodriguezAI Engineer World's Fair 20252025
Dmitry KuchinAI Engineer World's Fair 20252025
Yuval Belfer, Niv GranotAI Engineer World's Fair 20252025
Aman KhanAI Engineer World's Fair 20252025
Taylor Jordan SmithAI Engineer World's Fair 20252025
Rishi DesaiAI Engineer World's Fair 20262026
Jim BennettAI Engineer World's Fair 20252025
Ankur GoyalAI Engineer World's Fair 20252025
Aparna DhinakaranAI Engineer World's Fair 20262026
Jacob E. ThomasAI Engineer World's Fair 20262026
Trust, but Verify

Metadata candidate

Shreya RajpalAI Engineer Summit 20232023
Mike ConoverAI Engineer Summit 20252025
Rafal Wilinski, Vitor BaloccoAI Engineer World's Fair 20252025
Sonam PankajAI Engineer World's Fair 20262026
Philipp KrennAI Engineer World's Fair 20252025
Kenny WorkmanAI Engineer World's Fair 20262026
Phil HetzelAI Engineer Europe 20262026
Manu GoyalAI Engineer World's Fair 20252025
Ari HeljakkaAI Engineer World's Fair 20252025
Ameya BhatawdekarAI Engineer World's Fair 20262026
Zach BlumenfeldAI Engineer World's Fair 20252025
Cedric Vidal, David Smith, Miguel MartinezAI Engineer World's Fair 20242024
Michael FesterAI Engineer World's Fair 20252025
Waseem AlshikhAI Engineer Summit 20252025
Nathan SoboAI Engineer World's Fair 20252025
Anushrut GuptaAI Engineer World's Fair 20252025
Kevin HouAI Engineer World's Fair 20242024
Ara KhanAI Engineer Europe 20262026
Andreas KolleggerAI Engineer World's Fair 20252025
Jonathan LarsonAI Engineer World's Fair 20252025
Kyle CorbittAI Engineer World's Fair 20252025
Hanna Lichtenberg, Aamir ShakirAI Engineer World's Fair 20262026
Mitesh PatelAI Engineer World's Fair 20252025
Philipp KrennAI Engineer World's Fair 20252025
Atita Arora, Deanna EmeryAI Engineer World's Fair 20242024
Anton TroynikovAI Engineer Summit 20232023
Preeti SomalAI Engineer World's Fair 20252025
Frank LiuAI Engineer World's Fair 20252025
Alex Volkov, Benjamin EckelAI Engineer World's Fair 20252025
Eno ReyesAI Engineer World's Fair 20242024
Sunil Pai, Matt CareyAI Engineer Europe 20262026
Bertrand CharpentierAI Engineer Europe 20262026
Chintan Parikh, Weiyi WangAI Engineer Europe 20262026
Will Hang, Cathy ZhouAI Engineer Code 20252025
Dan Fu, Olive SongAI Engineer World's Fair 20262026
Ian Butler, Nick GregoryAI Engineer World's Fair 20252025
Anita KirkovskaAI Engineer Summit 20252025
Varsha ShahAI Engineer World's Fair 20262026
Charles FryeAI Engineer Summit 20232023
Nagkumar Arkalgud, Keiji KanazawaAI Engineer World's Fair 20252025
Apoorva JoshiAI Engineer World's Fair 20262026
Brendan RappazzoAI Engineer World's Fair 20262026
Anthropic for VPs of AI

Metadata candidate

Alexander Bricken, Joe BayleyAI Engineer Summit 20252025
Aparna DhinakaranAI Engineer World's Fair 20252025
Paul Klein IVAI Engineer World's Fair 20262026
SallyAnn DeLucia, Fuad AliAI Engineer Code 20252025
Raj NavakotiAI Engineer Europe 20262026
Building a Chess Coach

Metadata candidate

Anant Dole, Asbjørn SteinskogAI Engineer Europe 20262026
Ben Hylak, Sid BendreAI Engineer World's Fair 20252025
Michael AlbadaAI Engineer World's Fair 20252025
Cedric VidalAI Engineer World's Fair 20252025
Nishant GuptaAI Engineer World's Fair 20262026
Peter WielanderAI Engineer Code 20252025
Shaan DesaiAI Engineer Summit 20252025
Building security around ML

Metadata candidate

Dr. Andrew DavisAI Engineer World's Fair 20242024
Sandra KublikAI Engineer World's Fair 20242024
Andrew ThompsonAI Engineer World's Fair 20252025
Abed MatiniAI Engineer World's Fair 20262026
Atul RamachandranAI Engineer World's Fair 20262026
Thariq ShihiparAI Engineer Code 20252025
Lance MartinAI Engineer World's Fair 20262026
Cohere for VPs of AI

Metadata candidate

Vivek MuppallaAI Engineer World's Fair 20242024
Compression at the Edge

Metadata candidate

Chris Alexiuk, Daniel Han, Asma Beevi, Merve Noyan, Parth SareenAI Engineer World's Fair 20262026
Dylan PatelAI Engineer World's Fair 20242024
Francesco Bonacci, Dillon DuPont, Robert WendtAI Engineer World's Fair 20262026
Dhruv BatraAI Engineer World's Fair 20262026
Conquering Agent Chaos

Metadata candidate

Rick BlalockAI Engineer World's Fair 20252025
Louis-François Bouchard, Omar Solano, Samridhi VaidAI Engineer World's Fair 20262026
Santosh RadhaAI Engineer World's Fair 20242024
Devendra Chaplot, Devendra Singh ChaplotAI Engineer World's Fair 20242024
Ben HylakAI Engineer World's Fair 20262026
Jun Yu TanAI Engineer World's Fair 20252025
Phil HetzelAI Engineer Europe 20262026
Kevin MaduraAI Engineer Code 20252025
Sylendran ArunagiriAI Engineer World's Fair 20252025
Satya NittaAI Engineer World's Fair 20242024
Joseph Wang, SidAI Engineer World's Fair 20262026
Maxime LabonneAI Engineer World's Fair 20242024
Mehedi HassanAI Engineer Europe 20262026
Nina Lopatina, Rajiv ShahAI Engineer World's Fair 20252025
Samir ModyAI Engineer Code 20252025
Sandipan BhaumikAI Engineer Europe 20262026
Philip Kiely, Pankaj GuptaAI Engineer World's Fair 20242024
Gaurav MishraAI Engineer World's Fair 20262026
Jason LopateckiAI Engineer World's Fair 20262026
Samuel ColvinAI Engineer Code 20252025
Fuzzing in the GenAI Era

Metadata candidate

Leonard TangAI Engineer World's Fair 20252025
Nik PashAI Engineer Code 20252025
Vasant KearneyAI Engineer World's Fair 20262026
Phil HetzelAI Engineer Europe 20262026
Evan BoyleAI Engineer World's Fair 20252025
How Claude Code Works

Metadata candidate

Jared ZoneraichAI Engineer Code 20252025
Hailong ZhangAI Engineer Summit 20252025
Charles FryeAI Engineer World's Fair 20252025
KP Sawhney, Ian BallantyneAI Engineer Europe 20262026
Jaspreet SinghAI Engineer World's Fair 20252025
Benjamin VerbeekAI Engineer Europe 20262026
Ash Prabaker, Andrew WilsonAI Engineer Europe 20262026
Chau TranAI Engineer World's Fair 20252025
Christopher LovejoyAI Engineer Europe 20262026
Jeff Huber, Jason LiuAI Engineer World's Fair 20252025
Sally-Ann DeLuciaAI Engineer Europe 20262026
Patricija ŽemaitytėAI Engineer World's Fair 20262026
Ankur Goyal, Olmo MaldonadoAI Engineer World's Fair 20242024
Hypermode Launch

Metadata candidate

Kevin Van GundyAI Engineer World's Fair 20242024
Erik MeijerAI Engineer World's Fair 20262026
Gabriel Jorge MenezesAI Engineer World's Fair 20262026
Lachlan Ainley, Humza IqbalAI Engineer World's Fair 20242024
Ian WebsterAI Engineer World's Fair 20242024
Vibhu SapraAI Engineer World's Fair 20252025
Lawrence JonesAI Engineer Europe 20262026
Juan PeredoAI Engineer Summit 20252025
Xiaofeng WangAI Engineer Summit 20252025
Kelvin MaAI Engineer World's Fair 20252025
Drasko ProfirovicAI Engineer World's Fair 20262026
Stefania DrugaAI Engineer World's Fair 20262026
Will BrownAI Engineer World's Fair 20262026
Arjun SinghAI Engineer World's Fair 20262026
Rami AlhamadAI Engineer World's Fair 20252025
Shafik QuoraisheeAI Engineer World's Fair 20252025
On AI and Knowledge

Metadata candidate

Pablo CastroAI Engineer World's Fair 20262026
Simon WillisonAI Engineer World's Fair 20242024
OpenLLMetry is all you need

Metadata candidate

Nir GazitAI Engineer Summit 20252025
Ryan MartenAI Engineer World's Fair 20252025
Jeronim MorinaAI Engineer World's Fair 20242024
Kwindla Hultman KramerAI Engineer World's Fair 20252025
Juan Herreros ElorzaAI Engineer Europe 20262026
Samuel ColvinAI Engineer Europe 20262026
Anish Agarwal, Matthew SchoenbauerAI Engineer World's Fair 20252025
Raza HabibAI Engineer World's Fair 20242024
David GomesAI Engineer Europe 20262026
Respect The Process

Metadata candidate

Andrew DumitAI Engineer World's Fair 20262026
RL Environments at Scale

Metadata candidate

Will BrownAI Engineer Code 20252025
Gabriela de Queiroz, Aishwarya Srinivasan, Pamela FoxAI Engineer World's Fair 20242024
Mozhgan Kabiri ChimehAI Engineer Europe 20262026
Sam MorrowAI Engineer Europe 20262026
Adrian BertagnoliAI Engineer Europe 20262026
Joshua SnyderAI Engineer Europe 20262026
Merve NoyanAI Engineer Europe 20262026
Raahul Singh, Vanč LevstikAI Engineer World's Fair 20262026
Reid MayoAI Engineer Summit 20232023
Kyle Penfound, Jeremy Adams - CasañasAI Engineer World's Fair 20252025
Peter BarAI Engineer World's Fair 20252025
Giran Moodley, Mayan Soni, Oussama Hafferssas, Mayank SoniAI Engineer Europe 20262026
Ben SteinAI Engineer World's Fair 20252025
Pedro RodriguesAI Engineer Europe 20262026
Marc KlingenAI Engineer Europe 20262026
Gus Martins, Ian BallantyneAI Engineer Europe 20262026
Daniel HanAI Engineer World's Fair 20262026
Manish SanwalAI Engineer Summit 20252025
Jan SimlAI Engineer World's Fair 20252025
Brendan O'DonoghueAI Engineer Europe 20262026
Zack Reneau-WedeenAI Engineer Summit 20252025
The Agentic AI Engineer

Metadata candidate

Benedikt Sanftl, Burak Cemil ÖzafşarAI Engineer World's Fair 20262026
Quinn SlackAI Engineer World's Fair 20242024
The AI Evolution

Metadata candidate

Mario RodriguezAI Engineer Summit 20232023
Chris White, Bryan Bischof, Brittany WalkerAI Engineer Summit 20232023
Jeremy Silva, Chris HernandezAI Engineer World's Fair 20252025
Jerry Wu, Wyatt MarshallAI Engineer World's Fair 20252025
Brook RiggioAI Engineer World's Fair 20252025
Diamond BishopAI Engineer Summit 20252025
Ben HylakAI Engineer World's Fair 20242024
Kyle CorbittAI Engineer World's Fair 20242024
Sandipan BhaumikAI Engineer Europe 20262026
Alberto RomeroAI Engineer Code 20252025
Maxime Rivest, Isaac MillerAI Engineer World's Fair 20262026
Kathryn Grayson NanzAI Engineer World's Fair 20262026
Training Agentic Reasoners

Metadata candidate

Will BrownAI Engineer World's Fair 20252025
Uri Rolls, Thom WolfAI Engineer World's Fair 20262026
Micah Hill-Smith, George CameronAI Engineer World's Fair 20252025
Kathleen KenealyAI Engineer World's Fair 20242024
Eugene YanAI Engineer World's Fair 20262026
Sidney PrimasAI Engineer World's Fair 20262026
Dippu Kumar SinghAI Engineer Europe 20262026
Rajkumar SakthivelAI Engineer World's Fair 20262026
Bilge YücelAI Engineer Europe 20262026
Peter GostevAI Engineer Europe 20262026
DottaAI Engineer World's Fair 20262026
What's next after RLHF?

Metadata candidate

Diogo AlmeidaAI Engineer World's Fair 20262026
Lei ZhangAI Engineer Code 20252025
Eugene Yan, Hamel Husain, Jason Liu, Dr Bryan Bischof, Charles Frye, Shreya ShankarAI Engineer World's Fair 20242024
Sam JulienAI Engineer World's Fair 20252025
Udi MenkesAI Engineer World's Fair 20262026
Philipp SchmidAI Engineer Europe 20262026
Ahmad AwaisAI Engineer World's Fair 20252025
Karina NguyenAI Engineer Summit 20232023
Dan FarrellyAI Engineer World's Fair 20262026
Veronica HylakAI Engineer World's Fair 20262026
Talha SheikhAI Engineer Europe 20262026
Sachin KumarAI Engineer World's Fair 20262026
Yuxuan ZhangAI Engineer Code 20252025
Diego CarpenteroAI Engineer Europe 20262026
Vivek MuppallaAI Engineer World's Fair 20262026
Tim AingeAI Engineer World's Fair 20262026
Nathan LambertAI Engineer World's Fair 20252025
Sharmila Chokalingam, ShubhiAI Engineer World's Fair 20242024
Yohei NakajimaAI Engineer World's Fair 20262026
Hubert MisztelaAI Engineer World's Fair 20252025
Stephen ChinAI Engineer World's Fair 20252025
Leonie MonigattiAI Engineer Europe 20262026
Gabe De MesaAI Engineer World's Fair 20262026
Jacob LauritzenAI Engineer Europe 20262026
Armanas PovilionisAI Engineer World's Fair 20262026
Armanas PovilionisAI Engineer World's Fair 20262026
Tejas KumarAI Engineer Europe 20262026
swyxAI Engineer World's Fair 20242024
Zach Blumenfeld, Ben Squire, Ryan KnightAI Engineer World's Fair 20262026
Tomas ReimersAI Engineer World's Fair 20252025
Amazon AGI

Metadata candidate

Amazon AGI, Aditya KhandelwalAI Engineer World's Fair 20262026
Stephen Chin, Jonathan LoweAI Engineer Summit 20252025
Gagan Bhat, Isabella Kai HeAI Engineer World's Fair 20262026
Richmond AlakeAI Engineer World's Fair 20252025
Lance MartinAI Engineer World's Fair 20242024
Henry MaoAI Engineer World's Fair 20252025
Corey CooperAI Engineer World's Fair 20252025
Sina ShahandehAI Engineer World's Fair 20262026
Don Bosco DuraiAI Engineer Summit 20252025
Nimrod HauserAI Engineer Europe 20262026
Grace IsfordAI Engineer Summit 20252025
Rajiv ChandegraAI Engineer World's Fair 20262026
Varun Badrinath Krishna, Petro Junior Milan, Rachelle MatternAI Engineer World's Fair 20242024
Will BrykAI Engineer World's Fair 20252025
Mahesh MuragAI Engineer Summit 20252025
Building AI For All

Metadata candidate

Amjad Masad, Michele CatastaAI Engineer Summit 20232023
John CrepezziAI Engineer Summit 20252025
Sherwood Callaway, Satwik SinghAI Engineer World's Fair 20252025
Harrison ChaseAI Engineer Summit 20232023
Building Cursor Composer

Metadata candidate

Lee RobinsonAI Engineer Code 20252025
Anoop Kotha, Toki SherbakovAI Engineer World's Fair 20252025
Simrat HanspalAI Engineer Summit 20232023
Adam TerlsonAI Engineer Summit 20252025
Steve KaliskiAI Engineer Europe 20262026
Eric ZakariassonAI Engineer Europe 20262026
Dan MasonAI Engineer World's Fair 20252025
Daniel ChalefAI Engineer World's Fair 20262026
Cat Wu, Thariq Shihipar, Simon WillisonAI Engineer World's Fair 20262026
Sunil PaiAI Engineer Europe 20262026
Rachna SrivastavaAI Engineer World's Fair 20252025
Pedro RodriguesAI Engineer Europe 20262026
Stephen ChinAI Engineer Europe 20262026
Stephen ChinAI Engineer Code 20252025
Context Is the New Code

Metadata candidate

Patrick DeboisAI Engineer Europe 20262026
Soheil FeiziAI Engineer World's Fair 20262026
Dominik KundelAI Engineer World's Fair 20242024
Stephen ChinAI Engineer World's Fair 20262026
Hanchi WangAI Engineer World's Fair 20242024
Mahesh SathiamoorthyAI Engineer World's Fair 20262026
Defying Gravity

Metadata candidate

Kevin HouAI Engineer Code 20252025
Scott WuAI Engineer World's Fair 20252025
Abi AryanAI Engineer Summit 20232023
Don't be data poor

Metadata candidate

Anuj IravaneAI Engineer World's Fair 20262026
Ara KhanAI Engineer Europe 20262026
Tomas ReimersAI Engineer World's Fair 20252025
Laurie VossAI Engineer World's Fair 20252025
Barry ZhangAI Engineer Summit 20252025
Rishabh BhargavaAI Engineer Europe 20262026
Ofer MendelevitchAI Engineer Code 20252025
Benjamin FletcherAI Engineer World's Fair 20242024
May WalterAI Engineer World's Fair 20262026
Abhishek BhardwajAI Engineer World's Fair 20262026
Omri Bruchim, Tomer AstAI Engineer World's Fair 20262026
Akram BaharloueiAI Engineer World's Fair 20262026
Alex AtallahAI Engineer World's Fair 20252025
Ilan BigioAI Engineer Summit 20252025
Jerry LiuAI Engineer World's Fair 20242024
Gateways are All You Need

Metadata candidate

Karan SampathAI Engineer Europe 20262026
Nikhil AbrahamAI Engineer World's Fair 20252025
Git push, get an AI API.

Metadata candidate

Ryan Fox-TylerAI Engineer World's Fair 20242024
Dave BurnisonAI Engineer World's Fair 20242024
Luke HarriesAI Engineer Europe 20262026
Phoebe KlettAI Engineer World's Fair 20242024
Matija SosicAI Engineer Summit 20232023
Emil EifremAI Engineer World's Fair 20242024
Iman MakaremiAI Engineer World's Fair 20252025
Ryan Lopopolo, Vibhu SapraAI Engineer Europe 20262026
Dex HorthyAI Engineer World's Fair 20262026
Tanmai GopalAI Engineer World's Fair 20242024
Donald HruskaAI Engineer World's Fair 20252025
Vaibhav Page, Infant VasanthAI Engineer World's Fair 20252025
Eno ReyesAI Engineer World's Fair 20262026
Raia HadsellAI Engineer Europe 20262026
Niels RoggeAI Engineer World's Fair 20262026
Alex BauerAI Engineer World's Fair 20262026
Patrick DoughertyAI Engineer Summit 20252025
David MyttonAI Engineer World's Fair 20252025
Zhou YuAI Engineer Summit 20252025
Ian ButlerAI Engineer World's Fair 20252025
Alex LissAI Engineer World's Fair 20252025
Robert ChandlerAI Engineer World's Fair 20252025
Tom SmokerAI Engineer World's Fair 20252025
Rachelle Mattern, Petro Milan, Varun KrishnaAI Engineer World's Fair 20242024
Hubert MisztelaAI Engineer World's Fair 20242024
Joel BeckerAI Engineer Code 20252025
Eno ReyesAI Engineer Code 20252025
Eashan SinhaAI Engineer World's Fair 20252025
MCP is all you need

Metadata candidate

Samuel ColvinAI Engineer World's Fair 20252025
Peter Werry, BrandonAI Engineer Europe 20262026
Ilan BigioAI Engineer World's Fair 20252025
Ahmed MenshawyAI Engineer World's Fair 20242024
Omar KhattabAI Engineer World's Fair 20252025
Yesu FengAI Engineer World's Fair 20252025
Phil NashAI Engineer Europe 20262026
Antje BarthAI Engineer World's Fair 20262026
Michael Hunger, Stephen Chin, Jesús BarrasaAI Engineer World's Fair 20252025
Steven MoonAI Engineer Summit 20252025
Steve KorshakovAI Engineer World's Fair 20262026
Douwe KielaAI Engineer Summit 20252025
Jerry LiuAI Engineer Summit 20232023
Sander SchulhoffAI Engineer World's Fair 20252025
Prompt Engineering Tactics

Metadata candidate

Dan ClearyAI Engineer Summit 20232023
Hursh AgrawalAI Engineer World's Fair 20262026
Jason LiuAI Engineer World's Fair 20242024
Ben FlastAI Engineer World's Fair 20242024
Pablo CastroAI Engineer World's Fair 20242024
Tengyu MaAI Engineer World's Fair 20252025
Kuba RogutAI Engineer Europe 20262026
Chris ParsonsAI Engineer Europe 20262026
Yuval BelferAI Engineer World's Fair 20252025
Recursive Model Improvement

Metadata candidate

Lee RobinsonAI Engineer World's Fair 20262026
Grant LeeAI Engineer World's Fair 20252025
Patrick DeboisAI Engineer Summit 20252025
Rewiring the State

Metadata candidate

Eoin MulgrewAI Engineer Europe 20262026
Aakanksha ChowdheryAI Engineer World's Fair 20252025
Pamela Fox, Harald Kirschner, Gabriela de QueirozAI Engineer World's Fair 20242024
Michael YuanAI Engineer World's Fair 20252025
Scaffold Wisely

Metadata candidate

Rahul SengottuveluAI Engineer Summit 20252025
Calvin Qi, Chang SheAI Engineer World's Fair 20252025
Ronak MaldeAI Engineer World's Fair 20262026
Bobby Tiernay, Kam SweenAI Engineer World's Fair 20252025
Skills are the New SDKs

Metadata candidate

Elvin AghammadzadaAI Engineer World's Fair 20262026
Asaf BordAI Engineer Code 20252025
Gergely Orosz, swyxAI Engineer Europe 20262026
The New Code

Metadata candidate

Sean GroveAI Engineer World's Fair 20252025
State of Data

Metadata candidate

Sean CaiAI Engineer World's Fair 20262026
Charles PackerAI Engineer Summit 20252025
Brandon WaselnukAI Engineer Europe 20262026
Lars GrammelAI Engineer Summit 20232023
Cedric ClyburnAI Engineer World's Fair 20262026
Jack MorrisAI Engineer Code 20252025
Rob CheungAI Engineer World's Fair 20242024
David BrumleyAI Engineer World's Fair 20262026
Nuno CamposAI Engineer Europe 20262026
Devansh TandonAI Engineer World's Fair 20252025
Ronan McGovernAI Engineer World's Fair 20252025
Sohail Shaikh, Ankush RastogiAI Engineer World's Fair 20262026
Michele CatastaAI Engineer Code 20252025
Apoorva Joshi, Ben PerlmutterAI Engineer World's Fair 20242024
Jack CableAI Engineer World's Fair 20262026
Dani Grant, Chelcie TaylorAI Engineer World's Fair 20252025
Corey GallonAI Engineer World's Fair 20262026
Addy OsmaniAI Engineer World's Fair 20262026
The Future of Work

Metadata candidate

Toran Bruce Richards, Silen Naihin, PootsAI Engineer Summit 20232023
Allie Howe, Dex Horthy, Geoffrey Huntley, Ian Livingstone, Greg PstruchaAI Engineer World's Fair 20262026
Ofer MendelevitchAI Engineer Summit 20252025
Jesse HanAI Engineer World's Fair 20252025
Itamar FriedmanAI Engineer World's Fair 20262026
Almog BakuAI Engineer Summit 20252025
The Making of Devin

Metadata candidate

Scott WuAI Engineer World's Fair 20242024
Jonathan FernandesAI Engineer World's Fair 20252025
Omer PrimorAI Engineer World's Fair 20262026
Filip MakraduliAI Engineer World's Fair 20252025
Itamar FriedmanAI Engineer Code 20252025
Walden, Carter, Tanay, Alex Atallah, NavAI Engineer World's Fair 20262026
Jonathan MortensenAI Engineer World's Fair 20252025
Aparna DhinakaranAI Engineer Code 20252025
Alex VolkovAI Engineer World's Fair 20262026
MuhtesemAI Engineer Summit 20252025
Leo PekelisAI Engineer World's Fair 20242024
Dr. Sarah BuchnerAI Engineer World's Fair 20242024
Useful General Intelligence

Metadata candidate

Danielle PerszykAI Engineer World's Fair 20252025
Victor DibiaAI Engineer World's Fair 20252025
Nico AlbaneseAI Engineer Summit 20252025
Itamar FriedmanAI Engineer World's Fair 20252025
Michael ArnaldiAI Engineer Europe 20262026
Peter RobicheauxAI Engineer World's Fair 20252025
Eddie SiegelAI Engineer Summit 20252025
Nik CaryotakisAI Engineer Summit 20252025
Suman DebnathAI Engineer World's Fair 20252025
Jyh-Jing HwangAI Engineer World's Fair 20252025
Sai Krishna RallabandiAI Engineer World's Fair 20262026
Soumith ChintalaAI Engineer Summit 20252025
Arjun Bansal, Trey DoigAI Engineer World's Fair 20242024
Alex AlbertAI Engineer World's Fair 20242024
Why Agent Engineering

Metadata candidate

swyx (Shawn Wang)AI Engineer Summit 20252025
Tom Shapland, PhDAI Engineer World's Fair 20252025
Cormac BrickAI Engineer World's Fair 20262026
Jesús BarrasaAI Engineer World's Fair 20252025
James LoweAI Engineer World's Fair 20252025
Kevin HouAI Engineer World's Fair 20252025
Eugene CheahAI Engineer Summit 20252025
Your agent is blindfolded

Metadata candidate

Johan LajiliAI Engineer Europe 20262026
Rafael LeviAI Engineer Europe 20262026
Zack ProserAI Engineer Europe 20262026
Ramana Siddanth EmaniAI Engineer World's Fair 20262026
Dan BjornnAI Engineer World's Fair 20262026
Mike PhippsAI Engineer World's Fair 20262026
Hamed Firooz, Maziar SanjabiAI Engineer World's Fair 20252025
Logan KilpatrickAI Engineer World's Fair 20252025
Sara HookerAI Engineer World's Fair 20262026
Uday Kiran Medisetty, Adam HudaAI Engineer World's Fair 20262026
Kevin HouAI Engineer Summit 20252025
Mike SpitzAI Engineer Europe 20262026
Agents Need Feature Flags

Metadata candidate

Sachin GuptaAI Engineer World's Fair 20262026
Rajat ShahAI Engineer World's Fair 20262026
Charles FryeAI Engineer Summit 20232023
Natalie SerrinoAI Engineer Code 20252025
Justin SmithAI Engineer World's Fair 20262026
Marlene MhangamiAI Engineer Europe 20262026
Greg BensonAI Engineer World's Fair 20252025
Samuel DentonAI Engineer World's Fair 20262026
Shawn ChanAI Engineer World's Fair 20262026
Louis-François Bouchard, Paul Iusztin, Samridhi VaidAI Engineer Europe 20262026
Cornelia DavisAI Engineer Code 20252025
Damien MurphyAI Engineer World's Fair 20242024
Jacob KahnAI Engineer Code 20252025
Val Bercovici, Callan FoxAI Engineer Code 20252025
Mani KhanujaAI Engineer World's Fair 20252025
Rhythm Garg, Linden LiAI Engineer Code 20252025
Field Guide to Fable

Metadata candidate

Thariq ShihiparAI Engineer World's Fair 20262026
Richard SocherAI Engineer World's Fair 20262026
Joel HronAI Engineer World's Fair 20252025
Rafael LeviAI Engineer Europe 20262026
Alex CheemaAI Engineer Europe 20262026
Brian JohnAI Engineer Code 20252025
Kyle KranenAI Engineer World's Fair 20252025
Beth GlenfieldAI Engineer World's Fair 20252025
Isaac RobinsonAI Engineer Europe 20262026
Vivek TrivedyAI Engineer World's Fair 20262026
Jake NationsAI Engineer Code 20252025
AI Engineer Summit 20252025
Ritvik PandyaAI Engineer World's Fair 20262026
Michael RichmanAI Engineer Europe 20262026
Daniel HanAI Engineer World's Fair 20242024
Christopher LovejoyAI Engineer World's Fair 20252025
Lin Qiao, Dmytro (Dima) DzhulgakovAI Engineer World's Fair 20242024
Mayank PantAI Engineer Europe 20262026
Mark MoyouAI Engineer World's Fair 20242024
Matthias LoiblAI Engineer World's Fair 20252025
Ronan McGovernAI Engineer World's Fair 20252025
Shirsha ChaudhuriAI Engineer Summit 20252025
Vikhyat KorrapatiAI Engineer World's Fair 20242024
Ishan AnandAI Engineer World's Fair 20262026
Pragmatic AI With TypeChat

Metadata candidate

Daniel RosenwasserAI Engineer Summit 20232023
Luke AlvoeiroAI Engineer Europe 20262026
Boris StarkovAI Engineer Europe 20262026
Sachin GuptaAI Engineer World's Fair 20262026
Shawn JanseparAI Engineer World's Fair 20242024
Ryan DahlAI Engineer World's Fair 20262026
Eno ReyesAI Engineer World's Fair 20252025
Louis Knight-WebbAI Engineer Europe 20262026
Ishan AnandAI Engineer World's Fair 20242024
Josh PurtellAI Engineer World's Fair 20252025
Pydantic is all you need

Metadata candidate

Jason LiuAI Engineer Summit 20232023
Vikash Agrawal, LindaAI Engineer World's Fair 20252025
Barr YaronAI Engineer World's Fair 20252025
Barr YaronAI Engineer World's Fair 20262026
Kevin Madura, Mo BhasinAI Engineer World's Fair 20252025
Marah Abdin, Robert McHardyAI Engineer World's Fair 20262026
Raphael KalandadzeAI Engineer World's Fair 20262026
The New Lean Startup

Metadata candidate

Sid BendreAI Engineer World's Fair 20252025
Thinking Deeper in Gemini

Metadata candidate

Jack RaeAI Engineer World's Fair 20252025
Angelos PerivolaropoulosAI Engineer Europe 20262026
Charles FryeAI Engineer World's Fair 20252025
Remy GuercioAI Engineer Europe 20262026
Why MLX

Metadata candidate

AI Engineer Europe 20262026
Daniel SzokeAI Engineer Europe 20262026
Mark BissellAI Engineer World's Fair 20252025
Zach BlumenfeldAI Engineer Europe 20262026
Erik HanchettAI Engineer World's Fair 20262026
Hamza TahirAI Engineer World's Fair 20262026
Ben BurtenshawAI Engineer Europe 20262026
Tun Shwe, Jeremy FrenayAI Engineer Europe 20262026
AI Engineer Summit 20252025

References

Coverage and source review
Processed transcripts
78 processed in full · 5 in the curated path
Automated source review
Passed
Metadata candidates
508 unreviewed; not verified topic membership
Corpus version
1bd8e407b26a07b33815594e1b2db5f41827119a2b3cb6fbf240f9fc571fc767

Automated review checks source support; it is not publication approval.

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

  1. Improving Your Statistical Inferences: Equivalence Testing and Interval Hypotheses

    Non-inferiority tests whether an effect exceeds a lower acceptable boundary: a new intervention may be slightly worse, provided a prespecified meaningful loss can be rejected. Translating this to a higher-is-better score, define d=candidate−baseline and acceptable-loss margin m>0; test the null d≤−m against d>−m. This requires evidence against unacceptable degradation, not merely a favorable point estimate. Two-sided equivalence additionally excludes effects beyond an upper boundary. Failure to detect a difference from zero establishes neither conclusion; data can remain inconclusive. The author requires bounds to be specified in advance and justified by the smallest effect considered important.

  2. Equivalence Testing for Psychological Research: A Tutorial

    A nonsignificant difference cannot distinguish absence of a meaningful effect from insufficiently informative data. Equivalence testing instead specifies lower and upper bounds for effects considered practically negligible. The two one-sided tests procedure requires rejecting effects beyond both bounds; at a 5% test level, the corresponding 90% confidence interval must fall within those bounds. Bounds require substantive justification, such as a cost-benefit argument, rather than an arbitrary universal effect size. A result can be neither significantly different nor demonstrably equivalent.

  3. Probability calibration

    A calibrated binary predictor assigns probabilities that match observed positive-class frequencies: approximately 80% of cases assigned probability 0.8 should be positive. A reliability diagram groups predictions and compares each group's average probability with its observed positive fraction; accompanying counts show where observations concentrate. Brier loss measures more than calibration, so a lower value does not necessarily mean better calibration. Calibration can change without changing classification accuracy or ranking. Fitting a calibrator requires data independent of the classifier's training examples.

  4. Evaluating Generative AI Systems Is a Social Science Measurement Challenge

    Evaluation requires specifying the concept of interest and its observable measurement separately. Validation can examine content coverage, convergence with independently validated measures, discrimination from different concepts, and prediction of relevant external outcomes. For example, a completion metric needs evidence that its checks cover the intended completion requirements, not merely that it correlates with fluent reports. The paper recommends publishing evidence both for and against validity and reconsidering it before reusing an instrument in a new context.

  5. NIST AI RMF Playbook: Measure

    Construct validity asks whether an indicator measures the concept it claims to measure; external validity concerns generalization beyond development conditions. NIST calls for documented operating conditions, measurement assumptions, limitations and variance. Evaluations using human-subject data should reflect the population in the context of use. Applied to agent evaluation, define the deployment population and scenario dimensions before sampling, document exclusions, and compare sampled conditions with intended users, tasks and operating environments. A split within an unrepresentative dataset does not establish deployment coverage.

  6. PROV Model Primer

    PROV distinguishes entities, activities and responsible agents. Activities use entities and generate entities; entities can derive from earlier entities, be attributed to agents, and represent particular versions. Agents are associated with activities and can act on behalf of others. Applied to evaluation, identify the action attempt as an activity, its request and target version as entities, and its executor as an agent. Identify the state read as a separate observation activity generating evidence; link the completion judgment to the evidence it used. Record roles and generation, usage, start and end times.

  7. Scikit-learn: scoring rules and baseline estimators

    Evaluation tools accept an explicit scoring rule; classification accuracy is sum_i 1[prediction_i=target_i]/n. Dummy estimators provide sanity-check baselines such as always selecting the training set's most frequent class. Accuracy can conceal poor minority-class performance, motivating metrics such as balanced accuracy. Methodological inference for technical tasks: define the correctness criterion and baseline before selection, evaluate candidates on the same validation cases, and apply the frozen criterion to the final test set. A syntax check, exact-answer comparison, and executable task test measure different properties.

  8. Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity

    METR recruited 16 experienced developers and randomly assigned 246 submitted repository issues to allow or disallow generative-AI assistance. Developers recorded their screens and reported implementation time. The study reported 19% longer completion time with AI allowed, although participants subsequently believed AI had accelerated them. Task completion included the developer's judgment that changes would satisfy review requirements, including style, tests and documentation. This directly compares an assisted workflow with an existing workflow rather than substituting a coding benchmark or satisfaction report.

  9. Demystifying evals for AI agents

    An agent evaluation separates a task and its success criteria from repeated trials, execution transcripts, graders, and final environment outcomes. A booking claim in a transcript is different from an actual reservation in the database. The system under test includes both model and agent harness. Code-based checks suit precise state or test assertions; model graders cover more open-ended properties but require calibration; human review helps establish the standard. Capability suites explore difficult behavior, while regression suites protect behavior that already works.

  10. Design by Contract and Assertions

    A precondition states the caller's obligations before an operation; a postcondition states the implementation's obligations on successful return. A class invariant defines valid object states and generally must hold before and after exported operations, not necessarily during every internal statement. For a state transition from s to s', the teaching shorthand is: assuming I(s) and P(s,a), successful return must establish Q(s,a,s') and I(s'). Postconditions can relate new values to old values. Eiffel's runtime assertion checks are configurable and detect violations on executed calls.

  11. tau-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains

    Tau-bench evaluates agents interacting with a simulated user, domain-specific tools, and policy instructions. Its reward checks the final database against an annotated target state and, where required, information conveyed to the user. The paper explicitly warns that this reward can pass despite a policy violation, such as acting without confirmation. Repeated trials measure consistency: pass^k is the probability that all k independent trials succeed, averaged across tasks; pass@k asks whether at least one succeeds. A correct final state, compliant process, one successful attempt, and reliable repeated execution are distinct claims.

  12. Inspect: Handling Errors

    Inspect distinguishes runtime exceptions from process crashes and preserves error information separately from scores. Ordinarily, failed samples are not scored. With score_on_error, a scorer can assess the partial state remaining after retries are exhausted; intermediate failed attempts are not scored. Sample retry errors are recorded. The documentation warns that retrying an agent bug triggered by particular inputs can give those inputs extra chances to succeed, changing the measured distribution. An evaluation can finish with status success while containing scored errors when configured to tolerate them.

  13. Statistics Canada: Probability sampling

    Probability sampling selects population units randomly with calculable inclusion probabilities. Stratified sampling divides the population into mutually exclusive groups and samples within every group, allowing adequate coverage of small subgroups. Cluster sampling instead selects groups and samples their members; similarity within groups can reduce precision compared with sampling individuals across the population. The agency explains why many small clusters can provide more information than a few large ones.

  14. NHANES Tutorials: Weighting

    A sampling weight represents how many population members a sampled person stands for. Base weights account for unequal selection probabilities using their reciprocals; subsequent adjustments address nonresponse and alignment with population totals. Oversampling improves estimates for selected subgroups, while weighting combines their results according to population proportions. The documentation distinguishes missing participation from missing individual measurements: its interview and examination nonresponse adjustments do not automatically correct item nonresponse.

  15. Holistic Evaluation of Language Models

    HELM organizes evaluation into scenarios and desired properties, measures multiple properties under standardized conditions, and documents missing coverage. It separates core scenarios from targeted evaluations that isolate particular skills and risks. This distinction supports reporting challenge-set results as diagnostic evidence rather than silently combining them with a representative-use score. A collection chosen to expose failures does not, merely by being diverse, estimate how often those failures occur in deployment.

  16. Cross-validation: evaluating estimator performance

    Reserve a final test set that does not guide model selection; tune on training/validation partitions or cross-validation instead. Repeatedly tuning against test results leaks information and invalidates its generalization role. GroupKFold keeps each group out of both sides of a train/test split. StratifiedGroupKFold additionally attempts to preserve class proportions; temporal splits respect ordering when future data must remain unseen. Applied to agent tasks, group related templates, paraphrases, source documents or customer episodes before splitting, rather than randomly separating their individual rows.

  17. Build Evals That Actually Matter - Nick Ung & Akshay Sharma, Lyft

    Helpful-assistant behavior in a user simulator can make conversations unrealistically easy; production examples and realistic user behavior are needed to expose harder failures.

  18. Evaluate correctness, calibration, robustness and efficiency separately

    HELM evaluates models under standardized adaptation conditions across scenarios and separate metrics. Classification accuracy is the fraction correct; other tasks require explicit metrics such as answer overlap or retrieval ranking quality. Calibration asks whether predictions assigned confidence c are correct approximately c of the time. Binned ECE averages |bin accuracy minus bin confidence| weighted by bin size; HELM uses ten equal-count bins. Robustness tests behavior under specified input perturbations rather than assuming clean accuracy transfers. Efficiency is a separate resource measurement: HELM distinguishes observed serving time, denoised runtime and runtime under standardized hardware/software, accounting for prompt and output lengths. Report the evaluation data, prompting, decoding, scoring and resource conditions alongside results. HELM warns that its limited example samples and three prompt-selection seeds do not establish statistical significance for every comparison.

  19. How to evaluate a model for your use case

    General benchmarks help compare models, but do not establish performance on an application's particular tasks and input data.

  20. Overview of the First Text Retrieval Conference (TREC-1)

    TREC addressed two problems: research groups lacked coordinated comparisons using the same data and evaluation methods, and existing collections were too small to test large full-text retrieval. Its topics separated a user's information need from the query submitted to a system and specified document-relevance criteria. Because exhaustive relevance assessment was impractical, TREC pooled the top 200 documents per topic from participating runs, removed duplicates, and assessed that subset. The report credits earlier Cranfield collections with supporting comparative evaluation.

  21. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding

    GLUE assembled nine English language-understanding tasks spanning different domains, training-set sizes, and difficulties to encourage knowledge transfer beyond individual datasets. It combined an evaluation platform with privately held test data for some tasks and a separate expert-constructed diagnostic collection. Reporting included task-specific metrics and their aggregate average. Diagnostic examples probed phenomena such as negation and world knowledge, supplying information that the aggregate score alone could not provide.

  22. SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems

    SuperGLUE responded to shrinking headroom on GLUE while explicitly recognizing that some constituent tasks and linguistic phenomena remained difficult. It retained two difficult GLUE tasks, added more challenging tasks and broader formats, and included human performance estimates. This illustrates benchmark saturation as diminishing usefulness for distinguishing further progress, rather than proof that the broader capability has been solved.

  23. Introducing SWE-bench Verified

    OpenAI and the SWE-bench authors screened tasks for underspecified issues, tests that reject valid solutions, and environment problems. One published example required an exact deprecation warning absent from the agent-visible issue. Professional developers assessed tasks independently, and filtering conservatively used the most severe of three annotations. The resulting 500-task subset illustrates maintenance of the measurement instrument: improving a benchmark can require changing its cases and assessment conditions rather than improving the evaluated model.

  24. The Art & Science of Benchmarking Agents

    Use adversarial multi-expert review with revision and adjudication to establish that tasks are well posed and solvable.

  25. The Oracle Problem in Software Testing: A Survey

    A test oracle is a procedure for distinguishing correct from incorrect behavior of the system under test. Generating inputs does not solve the separate problem of deciding whether their outputs are right. Complete specifications can support automated oracles, but specifications may be unavailable or incomplete. Metamorphic relations, documentation and execution evidence can support partial oracles; implicit checks detect only selected classes of failure. Where suitable artifacts are absent, humans must supply or assess expected behavior, incurring construction and review costs.

  26. Beyond Accuracy: Behavioral Testing of NLP Models with CheckList

    CheckList crosses capabilities with three test types. Minimum-functionality tests use focused labeled examples. Invariance tests apply changes expected to preserve the prediction, such as changing a location name in a sentiment example. Directional tests require a specified relationship between predictions, such as sentiment not becoming more positive after adding a negative statement. The latter two can test unlabeled inputs because their oracle concerns relationships between outputs rather than a complete reference answer.

  27. QuickCheck: Automatic Testing of Haskell Programs

    QuickCheck tests programmer-specified properties on randomly generated inputs and lets developers define generators and inspect their distribution. This supports evaluation through invariants across many cases rather than only a list of expected answers. A property checker still encodes a specification chosen by a person; passing its sampled cases does not establish an unsampled or unstated requirement.

  28. Specification gaming: the flip side of AI ingenuity

    Specification gaming occurs when behavior satisfies the implemented objective while exploiting a mismatch with the designer's intended task. DeepMind describes a block-stacking agent rewarded for the height of a block's bottom face: flipping the block collected reward without stacking it. The optimization can therefore work as implemented while the specification fails to express the desired outcome. The article also distinguishes undesirable loopholes from useful, unexpected solutions that satisfy the intended objective.

  29. Ship Real Agents: Hands-On Evals for Agentic Applications

    Use deterministic code for structural constraints, LLM-as-a-judge for semantic criteria, and humans to establish reference judgments and examine unfamiliar failures.

  30. Google ML Crash Course: Precision, Recall and False Positive Rate

    Define the positive class before interpreting metrics. If positive means accepting an answer, precision=TP/(TP+FP) is the fraction of accepted answers that are valid; FP counts invalid answers accepted. Recall=TP/(TP+FN) is the fraction of valid answers accepted; FN counts valid answers rejected. False acceptance among invalid answers is FP/(FP+TN), not 1−precision. If positive instead means detecting a failure, failure recall=TP/(TP+FN), and 1−recall is the missed-failure fraction. Zero denominators make the corresponding metric undefined.

  31. scikit-learn confusion_matrix

    A confusion matrix counts reference classes in rows and predicted classes in columns. With acceptable=1 and unacceptable=0, false acceptance is C[0,1] and false rejection is C[1,0]. Conditional rates are C[0,1]/(C[0,0]+C[0,1]) and C[1,0]/(C[1,0]+C[1,1]); a zero denominator leaves that rate undefined. Applied to judge validation, freeze the rubric and acceptance threshold, obtain independent reference labels, and compare judge decisions on held-out examples. Keep unresolved human disagreements and abstentions separately visible.

  32. Classification: Accuracy, Recall, Precision and Related Metrics

    Recall is the fraction of actual positives detected; precision is the fraction of positive predictions that are true positives. Accuracy combines correct positives and negatives, so it can look high when the important positive class is rare. These denominators answer different questions: sensitivity is not the probability that a flagged patient has disease. At fixed sensitivity and specificity, reducing prevalence increases the share of false alarms among positive results; this follows by applying the confusion-matrix counts to a different population.

  33. scikit-learn: precision_recall_fscore_support

    The API defines micro averaging by pooling true-positive, false-positive and false-negative counts before calculating metrics; macro averaging takes the unweighted mean of per-label metrics. These definitions concern classification labels. An explicitly analogous task-slice aggregation uses successes s_g among n_g eligible cases: pooled success=sum_g(s_g)/sum_g(n_g), while equal-slice success=(1/G)sum_g(s_g/n_g). The former weights slices by case count; the latter gives each slice equal weight. Call these pooled success and equal-slice mean success; if using micro/macro terminology, explicitly state that the averaging units are task slices, not classification labels.

  34. Best practices for the human evaluation of automatically generated text

    The authors recommend defining separate assessment criteria, reporting participant selection and demographics, and measuring agreement among multiple annotators. Practice examples spanning good and bad outputs can help reviewers establish a common rating scale. Random ordering or counterbalancing reduces presentation-order effects; fatigue and practice can otherwise confound system comparisons. Removing participants or missing responses can introduce selection bias. The paper distinguishes exploratory analysis from confirmatory hypothesis testing and explains that testing many hypotheses increases the chance of false-positive conclusions.

  35. How Evals and Prompts Shape Agent Behavior — Preetika Bhateja & Daniel Bump, YouTube Ads

    Establish strong human-human agreement using clear rubrics and examples before scaling rating work.

  36. Interrater Disagreement Resolution: A Systematic Procedure to Reach Consensus in Annotation Tasks

    After independent annotation, compare judgments and investigate disagreements as unclear instructions, unequal domain knowledge, inconsistent scoring, interpretive differences, or simple mistakes. Reviewers justify their labels using the task, guidelines and concept definitions, then weigh competing reasons. Correct acknowledged mistakes and inconsistencies; clarify deficient guidelines and reconsider affected annotations, including previously agreed cases. Interpretive disputes may require further research. The authors recommend an ambiguity category with an explanation of its source rather than forcing binary decisions. If disagreements persist, flag the affected cases and dataset and report the limitation. They warn that majority rule or an authoritative final decision can conceal unresolved defects rather than establish correctness.

  37. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena

    The paper validates model judges by comparing their decisions with human judgments on the same responses, including human–human agreement as a reference. Its controlled MT-Bench study uses 58 expert-level labelers; a separate Arena analysis uses sampled crowd votes. Under one setup excluding ties, GPT-4–human agreement reaches 85%, versus 81% between humans. The authors test position bias by swapping answer order, verbosity bias through redundant longer answers, and self-enhancement bias through preferences for a judge's own outputs. These results support scoped use as preference estimators, not acceptance evidence independent of model errors.

  38. Ship Real Agents: Hands-On Evals for Agentic Applications

    Provide task context, observable criteria derived from real failures, clearly separated data, labeled examples, and a constrained result format.

  39. Ragas Faithfulness

    Ragas Faithfulness decomposes the generated response into claims, judges whether each follows from retrieved context, and divides supported response claims by all response claims. Unlike Context Recall, its denominator comes from the response rather than the reference answer. Interpretation: a response can faithfully repeat false source content, so high faithfulness does not independently establish real-world factual correctness. Conversely, an externally correct statement absent from context may receive no faithfulness credit. The metric measures contextual support through a judge, not source authentication.

  40. Ship Real Agents: Hands-On Evals for Agentic Applications

    For fresh information outside the judge's knowledge, evaluate whether the response follows supplied research rather than expecting the judge to know current facts.

  41. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena

    The paper compares model judges with human preferences and tests position bias, verbosity bias, self-favoring behavior and reasoning errors. Position swaps can change judgments; redundant expansion can receive an undeserved preference; reference answers can help with reasoning tasks. Its GPT-4 judge reached 85% human agreement in one MT-Bench setup excluding ties, versus 81% human-human agreement. For application calibration, collect independent human labels under an explicit rubric, compare judge agreement by task category and tie policy, swap answer order, and test verbosity and model-origin effects. Review disagreements and fix the judge configuration before using its scores for architecture selection.

  42. Build Evals That Actually Matter - Nick Ung & Akshay Sharma, Lyft

    Treat each binary judge as a classifier and measure agreement with human labels on held-out examples.

  43. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena

    The study uses anonymous candidate pairs, shared evaluation instructions, expert human votes, reference solutions for some questions, and human–human as well as human–model agreement. It examines order swaps, verbosity and reference-guided judging. In reasoning examples, a judge can reproduce an error present in the candidate answer; independently generated references reduce failures in the tested setting. Human reconsideration after seeing GPT-4's explanation is a separate, influenced judgment. The authors say their limited data cannot determine self-enhancement bias.

  44. LLM Evaluators Recognize and Favor Their Own Generations

    On two news-summarization datasets, the researchers compared model preferences with human judgments of the same model-generated summaries. The models' preference for their own outputs exceeded the quality differences reflected in human comparisons. Pairwise assessment swapped candidate order and averaged confidence scores to address ordering effects. The study separately measured recognition of model authorship and preference for output quality; these are different properties.

  45. Language Models Don't Always Say What They Think: Unfaithful Explanations in Chain-of-Thought Prompting

    Turpin, Michael, Perez and Bowman tested whether model explanations disclosed experimentally introduced influences on answers. Their NeurIPS 2023 study changed prompts through answer-position patterns and suggested answers while retaining the underlying questions. GPT-3.5 and Claude 1.0 often changed their answers and supplied plausible rationalizations without acknowledging the biasing feature. The controlled input changes establish an influence that reading the explanation alone would miss.

  46. Inspect: inspect_ai.log API reference

    Inspect's documented evaluation record includes task version and arguments, dataset identity and sample IDs, model and generation configuration, sandbox configuration, source revision, package versions, scorers and metrics. Sample records include inputs, targets, conversation messages, outputs, scores, execution events, timing, model usage, errors and limits. The schema also records retried errors and configuration changes during a run. Its lightweight sample summaries omit large fields and replace media with placeholders, so summaries are not equivalent to complete execution records.

  47. Rethinking Benchmark and Contamination for Language Models with Rephrased Samples

    The authors deliberately trained models on paraphrased or translated evaluation material and observed substantially increased scores on the corresponding benchmarks. These transformations could evade tested string-overlap checks. Semantic similarity checks also required thresholds trading missed matches against false alarms. Without training-data access, completing a partial test prompt was not definitive evidence: a model could complete text for other reasons or fail to reproduce wording despite exposure to a transformed version.

  48. Generalization in Adaptive Data Analysis and Holdout Reuse

    Dwork, Feldman, Hardt, Pitassi, Reingold and Roth's 2015 work addresses analyses chosen after inspecting earlier results on the same data. A predictor can become dependent on a holdout through repeated selection even when that holdout was initially separated from training. Their reusable-holdout algorithms restrict the information returned during validation and provide generalization guarantees under stated conditions. A synthetic experiment illustrates the failure of ordinary adaptive reuse. The paper also identifies subsequent leaderboard work by Blum and Hardt as an application of this research direction.

  49. LiveBench: A Challenging, Contamination-Free LLM Benchmark

    LiveBench's June 2024 design combined questions derived from recent sources with automatically checkable answers and a plan for monthly updates. Its sources included recent competitions, papers and datasets; other tasks modified existing task families. The authors explicitly acknowledged that restricting evaluation to checkable answers excludes useful open-ended work such as composing an email. They also acknowledged sensitivity to prompt choices. Freshness and automatic scoring therefore address particular evaluation problems while imposing coverage and maintenance tradeoffs.

  50. Reproducibility and Replicability in Science: Understanding Reproducibility and Replicability

    The National Academies distinguishes computational reproducibility—obtaining consistent results from the same data, computational methods, code and analysis conditions—from replication using newly collected data to address the same scientific question. It also distinguishes making a computation checkable from another researcher actually checking it. Consistency must be interpreted with the uncertainty of the system under study; generalization to other populations or contexts is a further question.

  51. How to make your completions outputs consistent with the new seed parameter

    OpenAI's historical documentation describes seeded generation as best-effort determinism. It requires matching the seed and other request parameters and checking a backend fingerprint representing model weights, infrastructure and configuration. Even matching these values does not guarantee identical responses. This provides a concrete example of why recording a random seed alone is insufficient to promise exact reproduction of hosted-model outputs.

  52. Easier evaluations with LangSmith SDK v0.2

    LangChain's SDK release explanation distinguishes executing an application on a dataset and scoring new outputs, applying new evaluators to stored experiment outputs, and comparing outputs from two existing experiments. Its examples pass an application function for execution and an experiment identifier for rescoring. This supplies a concrete implementation of the distinction between changing the assessment of a historical output and producing a new system execution.

  53. NIST: What a confidence level means

    A 95% confidence-interval procedure is designed so that, over repeated samples under its assumptions, approximately 95% of the resulting intervals contain the fixed population parameter. It does not assign a 95% probability to an individual patient's outcome. Applied to diagnostic metrics, the parameter is a population sensitivity, specificity, or predictive value; an individual risk prediction instead estimates an event probability conditional on that patient's inputs. These answer different questions: uncertainty in a measured performance rate versus predicted outcome risk.

  54. NIST: Confidence Intervals for a Proportion

    A measured success fraction is an estimate, not an exact population success probability. NIST describes Wilson intervals derived by inverting a proportion test and exact binomial intervals for small samples or few failures. The sample size and failure count determine uncertainty; a perfect observed score does not establish zero future failure probability. Applying a binomial interval to agent trials requires an appropriate model of independent trials with a common success probability.

  55. Computer Use at the Edge of the Statistical Precipice

    DigiWorld nests apps, scenarios (task templates), configurations and stochastic rollouts. Configurations combine instance parameters, data profiles, themes and initial UI states. Per-configuration success is the mean binary rollout outcome; the paper uses Wilson intervals. Suite performance averages per-app means equally, holding the curated apps fixed. Its hierarchical bootstrap resamples scenarios within each app, enabled environmental axes independently, then rollouts within configurations; interval endpoints are bootstrap quantiles. This targets variation within that fixed suite, not a sampled population of apps. The experiments report separate model intervals. Matched configuration pairs in Appendix H vary one environmental axis while holding others fixed; these are not paired agent-version comparisons. The paper does not specify a paired estimator or confidence interval for the difference between agent versions.

  56. SciPy bootstrap: paired task-level mean differences

    SciPy bootstrap resamples observations with replacement; paired=True draws one index array shared by both samples. Evaluation-design application: for each task, summarize each version's prespecified repeated binary outcomes as its mean success, obtaining aligned values A_i and B_i. Estimate mean(B_i-A_i), weighting tasks equally rather than pooling unequal retry counts. Resample task indices, carrying both summaries together, and recompute the mean difference; bootstrap quantiles or a specified interval method yield uncertainty. Equivalently bootstrap the per-task differences. This application assumes independently sampled, representative task units. Dependent retries stay inside their task summary; related templates or shared-session effects invalidate treating those tasks as independent units. Select independent clusters and a suitable sampling design instead; paired=True alone does not supply hierarchical resampling.

  57. Guardrails and interference in online experiments

    Guardrail metrics represent outcomes experimenters seek not to degrade, distinct from the primary success metric. Standard treatment-effect analysis assumes a unit's outcome does not depend on other units' treatment assignments. Social connections, competition for shared marketplace resources or shared infrastructure failures can violate that assumption. Then a treatment-control difference need not estimate the effect of deploying one policy to everyone. Cluster randomization groups interacting units, while switchback designs alternate treatment over time; both require design-specific analysis. Clustering can reduce interference while also reducing effective sample size and statistical power.

  58. Evaluating Large Language Models Trained on Code

    HumanEval evaluates generated programs by executing tests. Pass@k asks whether at least one of k sampled candidates passes; it is not the probability that all k attempts succeed or that a user can select the right candidate without a checker. With n samples and c passing samples, the paper estimates it as 1 minus choose(n-c,k)/choose(n,k), averaged over tasks. Sampling budget and checker quality are part of what this score measures.

  59. τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains

    τ-bench checks the final database against an annotated goal and, where required, checks information in user-facing responses. Its binary reward is r=raction×routput. Repeated trials distinguish a successful run from consistent completion: pass^k is the probability all k independent, identically distributed trials succeed, averaged across tasks; pass@k requires only one success. With c successes among n trials, the pass^k estimator is the task average of C(c,k)/C(n,k), for k≤n. The paper explicitly warns that reward 1 can miss trajectory violations, such as executing without confirmation. Final-state checks must therefore be supplemented when the process itself has requirements.

  60. Can You Trust Your Model's Uncertainty? Evaluating Predictive Uncertainty Under Dataset Shift

    The authors evaluate predictive uncertainty under controlled distribution shifts across classification tasks. In their image experiments, temperature scaling performs well under small shifts but calibration error increases as corruption severity increases. Calibration on an independent validation set from the original distribution therefore does not establish calibration under changed conditions. Method rankings also differ across datasets.

  61. scikit-learn: brier_score_loss

    For binary targets y_i in {0,1} and positive-class probabilities p_i, the customary binary Brier loss is (1/N)sum_i(p_i-y_i)^2, ranging from 0 to 1. The general class-summed definition averages sum_c(y_ic-p_ic)^2 and ranges from 0 to 2. With two complementary class probabilities, that sum is twice the customary binary loss. The documented scale_by_half='auto' halves the class-summed score for binary classification but leaves multiclass scores unscaled. The published example reports 0.0375 by default and 0.075 with scale_by_half=False.

  62. Just Ask for Calibration: Strategies for Eliciting Calibrated Confidence Scores from Language Models Fine-Tuned with Human Feedback

    The study distinguishes probabilities assigned to generated answers from numerical confidence expressed in the model's response. On factual question-answering datasets, verbalized confidence was often better calibrated than conditional answer probabilities for the tested GPT and Claude models, with less consistent results for Llama-2-70B-Chat. Results depended on how confidence was elicited. The researchers measured calibration separately from the ability to distinguish correct from incorrect answers and identified transfer to long-form generation and reasoning-heavy tasks as unresolved.

  63. Selective Classification for Deep Neural Networks

    Selective prediction combines a predictor with a selection function that either accepts its prediction or abstains. Coverage is the probability of accepting a case; selective risk is expected loss conditional on acceptance. A risk-coverage curve shows how error among accepted cases changes as coverage changes. The paper selects confidence thresholds using labeled examples and derives risk bounds under independent, identically distributed sampling. The ranking score used for selection need not itself be a calibrated probability.

  64. Flipping the Dialogue: Training and Evaluating User Language Models

    Naous, Laban, Xu and Neville's October 2025 preprint compares prompted assistant models with models trained to simulate users. Holding GPT-4o as the assistant, they run ten conversations for each of 65 math and coding intents per simulator. Reported assistant success changes from 74.6% with a GPT-4o user simulator to 57.4% with UserLM-8b. Success means a solution passes assessment at any conversation turn. UserLM also changes information disclosure, wording, pacing and additional demands. The experiment therefore shows that simulator choice materially changes what the assistant encounters and its measured success.

  65. Counterfactual Credit Assignment in Model-Free Reinforcement Learning

    Credit assignment separates an action's influence on later rewards from external events and subsequent actions. A delayed outcome can depend on many intervening decisions, so temporal order alone does not identify its cause. The paper defines return as G_t=sum over u>=t of gamma^(u-t) R_u; this aggregates rewards, not causal responsibility. Its transition model makes the next state depend on the current state and action. Its structural causal model supports changing an action while holding exogenous randomness fixed. Consequently, counterfactual replay must recompute downstream states and observations after action divergence; feeding the old observation sequence to a changed policy does not generally simulate its outcome.

  66. The Selective Labels Problem: Evaluating Algorithmic Predictions in the Presence of Unobservables

    Selective labels arise when existing decisions determine which outcomes become observable. The paper's motivating example observes whether a released defendant returns to court but cannot observe what would have happened had a detained defendant been released. Consequently, labeled cases are not a random sample of everyone a replacement policy might act on. The authors also distinguish missing outcomes from decision-relevant information available to humans but absent from recorded data.

  67. Building Customer Support AI Agents at 100M-User Scale: An Evaluation-Driven Framework

    Nubank's card-delivery example retrieves authenticated customer and logistics data, checks delivery timelines, asks address-specific questions and offers reissue when investigation fails. Separate evaluators assess reissue behavior, customer-input verification, delivery-data checking, conciseness and resolution completeness. Three domain analysts label examples with explanations; majority vote supplies reference labels. Online reporting separates post-interaction satisfaction from self-service without human escalation. The authors explain that routing difficult cases to humans can improve AI satisfaction while reducing self-service. Their initial comparator lacked domain-action tools, and later variants changed tools, routines and prompts.

  68. Modeling Delayed Feedback in Display Advertising

    Olivier Chapelle's KDD 2014 paper distinguishes an outcome that has not happened from one that has not yet been observed. In post-click advertising, a purchase can occur days after the click. A short labeling window incorrectly marks later conversions negative, while waiting longer makes the available data older. The proposed model separates eventual conversion probability from conversion delay. The study defines a 30-day attribution window and last-click matching, illustrating that both observation time and outcome attribution determine the measured event.

  69. How to build world-class AI products — Sarah Sachs (Notion) and Carlos Esteban (Braintrust)

    Close the feedback loop by filtering production failures, reviewing their inputs and outputs, and promoting relevant spans into evaluation datasets.

  70. Canarying Releases

    Offline or synthetic tests expose defects under selected conditions. Traffic teeing sends copied live requests to a test deployment while production supplies user responses; its observations are comparisons, not evidence of safe live mutation. A canary exposes a limited real population to the candidate and compares version-specific metrics with a control. Define exposure size, duration, acceptable regressions and stop conditions; pause and roll back when candidate metrics diverge unacceptably. Metric windows must fit the experiment duration. Returning traffic to the previous version stops further candidate exposure.

  71. Randomized policy comparison and experimental uncertainty

    Randomly assigning eligible experimental units to control and treatment supports causal comparison of policy variants. For a scalar outcome, estimate the absolute effect as mean(Y_treatment)-mean(Y_control). Under independent units and appropriate large-sample conditions, an approximate 95% confidence interval is the estimated difference plus or minus 1.96 standard errors. Power depends on outcome variation, sample size and the effect one wants to detect. Choose an overall evaluation criterion before interpreting results, and examine operational metrics as well. The experiment measures outcomes during its observation period; short tests do not automatically identify long-term effects.

  72. Always Valid Inference: Continuous Monitoring of A/B Tests

    Choosing when to stop by repeatedly inspecting ordinary fixed-horizon p-values can invalidate their false-positive guarantees. The paper constructs always-valid p-value and confidence-interval processes whose guarantees hold at data-dependent stopping times under the specified statistical assumptions. It treats correction across multiple hypotheses as a separate requirement and studies conditions under which those corrections remain valid during continuous monitoring.

  73. We are Changing our Developer Productivity Experiment Design

    METR's follow-up experiment randomized submitted developer tasks to AI-allowed or AI-disallowed conditions, but encountered selection before randomization: some developers declined participation, and some withheld tasks they expected AI to accelerate. The report also describes differential task completion, changed task choices and output quality, and difficulty attributing time when developers used agents concurrently. METR consequently treats its estimates as weak evidence about the broader productivity effect and proposes redesigning the study.

  74. Shipping AI to a Million Patients Without an A/B Test

    An already-delivered clinical utterance cannot be undone, so reactive rollout monitoring cannot substitute for evidence gathered before exposure.

  75. Build Evals That Actually Matter - Nick Ung & Akshay Sharma, Lyft

    Continuously inspect execution traces and use annotation queues to turn domain-expert feedback into labeled evaluation datasets.

  76. Judge the Judge: Building LLM Evaluators That Actually Work with GEPA — Mahmoud Mabrouk, Agenta AI

    Use subject-matter-expert error analysis to derive specific binary judges from observed failures.

  77. Production Evals For Agentic AI Systems

    Treat agent traces as distributed tracing for autonomous workflows, recording execution structure rather than relying on ordinary logs alone.

  78. Who Validates the Validators? Aligning LLM-Assisted Evaluation of LLM Outputs with Human Preferences

    Shankar and colleagues' 2024 EvalGen system generates candidate code assertions and model-grading prompts, then uses human grades to select implementations. Its nine-participant study found that examining outputs changed both the criteria people wanted and their interpretation of existing criteria. A concrete disagreement concerned extracting names from hashtags: one participant wanted the entity excluded, while another wanted its name retained without the hash symbol. The same character-checking assertion satisfied only the latter interpretation. Additional labels could not resolve the mismatch when all candidate implementations encoded the wrong requirement.

  79. NIST: Completely randomized designs

    A randomized experiment assigns levels of a primary factor to experimental units and compares a response across replicated runs. For an agent failure, an illustrative intervention replaces only suspected faulty tool feedback with verified feedback, while keeping the task, initial state, model, instructions, tool implementation and budget fixed. Compare subsequent verified success against the unchanged condition, with randomized run order and repetitions. Improvement supports the tested feedback explanation under those conditions; it does not prove that planning or other interacting components were faultless.

  80. NIST AI RMF Core

    NIST connects measurement to deciding whether a system achieves its intended purpose and whether development or deployment should proceed. Risk responses include mitigation, avoidance and acceptance; remaining risks should be documented. The framework includes considering viable non-AI alternatives and assigning responsibility for superseding, disengaging or deactivating systems whose outcomes conflict with intended use. It also calls for evaluating measurement processes themselves and maintaining post-deployment monitoring, feedback, incident response, recovery and change management.

  81. Ship Real Agents: Hands-On Evals for Agentic Applications

    The speaker prioritizes capability evaluation during improvement and recommends reducing redundant regression evaluation costs.

  82. From Self-driving to Autonomous Voice Agents — Brooke Hopkins, Coval

    Passing a reproduction case can conceal a behavioral regression elsewhere.

  83. Build Evals That Actually Matter - Nick Ung & Akshay Sharma, Lyft

    Tie evaluation scores to explicit release decisions and give production regressions clear response owners.

  84. Production Evals For Agentic AI Systems

    Build a continuous evaluation loop that turns telemetry and human review into datasets used to validate updates offline.

  85. Demystifying evals for AI agents

    Anthropic distinguishes tasks, repeated trials, graders, recorded trajectories and actual outcomes in the environment. A statement that an action completed is different from the resulting database state. Code, model and human graders have different strengths; model-based graders need human calibration. Capability evaluations explore difficult tasks; regression evaluations protect behavior that already works.

  86. The Art & Science of Benchmarking Agents

    Choose task distributions intentionally: production representativeness and coverage of rare consequential failures are different evaluation goals.

  87. Prompt Engineering is Dead

    Giving the optimizer all evaluation examples can produce a prompt specialized to those questions; reserve separate examples to assess generalization.

  88. Build Evals That Actually Matter - Nick Ung & Akshay Sharma, Lyft

    Develop criteria through repeated inspection of actual outputs, and revalidate judges as those criteria evolve.

  89. Ship Real Agents: Hands-On Evals for Agentic Applications

    Use data-driven prompt engineering: map changes to observed failure explanations and compare versions on consistent inputs and evaluators.

  90. Computer Use at the Edge of the Statistical Precipice

    When reliable uncertainty estimates cannot distinguish candidate models, spend more effort evaluating instead of treating narrow but overconfident intervals as decisive.

  91. Optimization-based Prompt Injection Attack to LLM-as-a-Judge

    JudgeDeceiver inserts an optimized sequence into a candidate response so a judge selects that response despite its inferior content. The attack exploits the judge processing evaluation instructions and untrusted candidates together. Experiments compare clean judging, unmodified bad candidates, manual injections and optimized injections on MT-Bench and LLMBar. Attack success averages selection across both candidate orders; positional agreement consistency requires the attack to win in both orders. Table 2 reports successful attacks against four tested open models, including manual instruction-override and fake-completion baselines.