Georgia State University — J. Mack Robinson College of Business PATH — Pathways for AI Training & Hiring CIS 4394 Agentic AI  ·  Fall 2026  ·  Dr. Xinyu Fu
02 · Metrics & benchmarks

One symbol apart. Opposite stories.

pass@k and pass^k look almost identical on a slide and mean nearly opposite things. One is the most generous number you can quote about an agent; the other is the number your customer actually lives in. Learning to tell them apart is the single most useful thing on this site.

The definitions

Read the symbol carefully

pass@k — a generosity metric

“At least ONE of k samples passes.”

Introduced for evaluating code generation on HumanEval (Chen et al., 2021). You let the model generate k candidate solutions for one problem and count the problem as solved if any single one of them passes the unit tests. It answers: if I can sample k times and cheaply check which one is right, how often is a correct answer somewhere in the batch?

pass@k = P(at least one of k passes) = 1 - (1 - p)^k // rises toward 1 as k grows

Rises with k. Bigger k always looks better. That is legitimate when a cheap, reliable verifier exists — unit tests, a compiler, a checksum — because the verifier is what lets you pick the winner out of the batch.

Chen et al., 2021 — Evaluating LLMs Trained on Code (arXiv:2107.03374) ↗

pass^k — a consistency metric

“ALL k independent trials succeed.”

Introduced by τ-bench (Yao et al., 2024) precisely because pass@k was flattering agents that could not be relied on. Run the same task k independent times; it counts only if every single run succeeds. It answers: can I hand this to a customer who will use it k times?

pass^k = P(all k trials succeed) = p^k // collapses toward 0 as k grows

Falls with k — fast. There is no verifier to rescue you: in production nobody generates eight refunds and picks the good one. The customer gets the run they get.

Yao et al., 2024 — τ-bench (arXiv:2406.12045) ↗

Both formulas above assume independent trials each succeeding with probability p — the clean textbook case. Real runs are not perfectly independent (a badly worded test case fails every time; a flaky API fails in bursts), so treat these as the model that makes the shape obvious, and measure your own agent to get the real numbers. In practice you estimate pass@1 (= p) by running many trials and counting how many passed, then compute the rest.
Interactive · the whole week in one widget

Move the dials. Watch the two curves separate.

Set the per-run success rate p and the number of trials k. The blue curve is pass@k (at least one succeeds). The red curve is pass^k (all of them succeed). Same agent. Same p. Opposite conclusions.

50%75%99%
1510
pass@1  (one attempt)90.0%
pass@k  (at least one of k)99.9%+
pass^k  (all k succeed)43.0%

The manager's version. An agent that succeeds 90% of the time sounds like a good hire. But a customer who uses it eight times has only a 43% chance of a week without a failure — so most of your customers meet the failure, not the average.
The arithmetic, laid out

Reliability is exponentially expensive

Three agents you might describe with the same word — “reliable” — and what happens to each when a real user runs it more than once. Every cell is pk, rounded.

pass@1 (one run)pass^2pass^3pass^5pass^8What it means in a sentence
70%49%34%17%6%Fails more often than it works by the third use. This is a prototype, not a product.
90%81%73%59%43%The number everyone celebrates. Most repeat users still hit a failure.
99%98%97%95%92%Survives repeated use — and going from 90% to 99% is usually far more than 9% more work.
Why the last nine costs the most

Moving 70% → 90% is usually prompt work, a better tool, one retry. Moving 90% → 99% means finding the long tail: the malformed inputs, the empty tool results, the rate limits, the adversarial cases. Each of those is a separate engineering project, and each buys a fraction of a point. Budget accordingly — and notice that the same money spent on narrowing the task often buys more reliability than the same money spent on the agent.

The honest way to quote a number

“Our agent is 90% accurate” is not a lie, but it is not a deployment statement either. The deployable version names the metric, the k, the dataset, and the date: “On our 40-case eval set, pass@1 = 0.90 and pass^3 = 0.73, measured 10/14. The 27% of cases that fail at least once in three runs are listed here.” That sentence is the deliverable of your capstone eval harness.

The reliability gap. The distance between pass@1 and pass^k is the demo-versus-production gap, expressed as a number. Demos are sold on pass@1 (or worse, on one run). Managers ship on pass^k. Naming the gap out loud — “90% single-run, 43% across eight” — is how you keep the conversation honest without pretending the agent is bad.
Interactive · click a benchmark

Benchmark literacy

Public benchmarks are the closest thing the field has to shared evidence — and the most misquoted numbers in any AI vendor deck. Three you will meet constantly, what each actually stresses, and how the score gets used misleadingly.

Side by side

The scorecard

BenchmarkDomainWhat it stressesMetric usually quotedWatch out for
SWE-bench
Jimenez et al., 2023
Real GitHub issues, Python reposNavigating an unfamiliar codebase, long edits, making the repo's own tests pass% of issues resolved, single attemptContamination (public issues and fixes); which subset was used; harness differences
τ-bench
Yao et al., 2024
Retail and airline customer tasksTool use with a simulated user, while following a written domain policypass^k — and pass@1 alongside itDomain policies are specific; simulated users are not real ones; airline is harder than retail
WebArena
Zhou et al., 2023
812 tasks on self-hosted website clonesLong-horizon, realistic web work across multiple sitesTask success rateClones are not the live web; the headline numbers are from launch and are dated
Misquote 1 · contamination

If the benchmark's problems and their solutions have been public on the internet for years, some of them may sit in the model's training data. A high score can then reflect recall rather than capability — and it will not transfer to your private codebase or your internal tickets.

Misquote 2 · harness differences

The same model scores differently depending on the scaffolding around it: which tools it gets, how many steps it is allowed, how many attempts, whether a retry counts. Two “SWE-bench scores” are only comparable if the harnesses were. Ask what the scaffold was.

Misquote 3 · which subset

“SWE-bench” names a family: the full 2,294-issue set, the human-validated Verified 500-issue subset, and smaller subsets. A number quoted without its subset is unreadable — and the flattering subset is the one that ends up on the slide.

Reading a benchmark critically — the five questions
The stance to hold: a benchmark is evidence, never a guarantee. It narrows the field of candidate models and designs. The decision to deploy is made on your data, with your cases, at your k.
The evaluator problem

LLM-as-judge: useful, biased, and easy to trust too much

Most of what an agent produces has no exact right answer, so you need a grader for open-ended output. The obvious move is to have a strong model grade it against a rubric or a reference (Zheng et al., 2023). It scales beautifully. It is also a fallible evaluator, and the failure mode is that it looks rigorous.

Pick the evaluator per check, not per project

KindGood forCost
Rule / exact matchAnything checkable: IDs, numbers, required fields, forbidden actions, schema validity, tests passingNearly free, perfectly consistent
LLM-as-judgeOpen-ended quality: clarity, tone, helpfulness, faithfulness to a sourceCheap per item, but biased and needs validating
Human reviewHigh-stakes and ambiguous edges: legal risk, safety, anything you will be asked to defendExpensive, slow, and the ground truth everything else is calibrated against

Worked example — one document-QA agent, four checks: the cited document ID → rule (it either matches or it does not). The extracted dollar amount → rule. Whether the answer reads clearly and stays faithful to the source → LLM-judge. Anything flagged as a legal-risk edge case → human. Do not reach for a judge where a rule is exact and free.

LLM as a Judge (IBM Technology, 6m08s)

The concept, the rubric, and the pitfalls in six minutes. Watch it, then read the four biases below and see how many the video names.

The four biases you must be able to name

Position bias

When comparing two answers, judges can favor the one in a particular position rather than the better one. Documented in Zheng et al., 2023. Your ranking can flip when you swap A and B.

Verbosity / length bias

Longer, more elaborate answers tend to score higher, whether or not they are more correct. This is the bias students game accidentally: pad the response and the rubric rewards it.

Self-preference

A judge can prefer text in its own style or from its own model family. If the judge and the agent are the same model, you are partly grading a family resemblance.

Sycophancy

Agreeable, flattering, confident-sounding output scores well. Confidently wrong answers are exactly the ones a judge is worst at catching — and exactly the ones that hurt in production.

Why this is worse than having no eval: a biased judge produces a number, a chart, and a sense of rigor. Teams then make deployment decisions on it and stop looking. An unmeasured system at least keeps people suspicious.

Mitigations — validate the evaluator like you validate the agent

  1. Swap positions and average. Run every pairwise comparison in both orders. If the verdict flips, the judge is reading position, not quality — record that as a disagreement rather than a score.
  2. Write an explicit rubric with anchors, and give a reference answer. “Rate helpfulness 1–5” invites vibes. “2 = answers the question but omits the policy citation” is checkable, and it is what makes two runs of the judge agree with each other.
  3. Prefer pairwise comparison over absolute scores when you can. “Which of these two is better?” is a far more stable judgment than “score this 1–10,” for models and humans alike.
  4. Calibrate against humans — non-negotiable. Hand-label a sample (say 50 items), run the judge on the same sample, and report the agreement rate. If the judge agrees with your humans 60% of the time, its scores are decoration. Recheck the agreement whenever the rubric, the judge model, or the task changes.
  5. Use rules wherever a rule exists. Every check you can express deterministically is one fewer place for bias to enter, and it is cheaper besides.

Zheng et al., 2023 — Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (arXiv:2306.05685) ↗

Discussion
Discussion questionA vendor's deck says: “Our coding agent achieves 78% on SWE-bench — near-human performance.” You have four minutes with them. What do you ask, and what would change your mind either way?
Four questions, in order of how much they move the number:
1. Which subset, and which harness? Full set, Verified, or Lite — and what scaffolding did the agent get: how many steps, which tools, how many attempts, did retries count? Two numbers are only comparable if these match.
2. pass@1 or pass@k? If the agent generated many patches and a test suite picked the winner, that is a pass@k number and it is legitimate only because SWE-bench has a free verifier — my repository at 2 a.m. does not. Ask for the pass^k, or at least the variance across repeated runs.
3. Contamination? These issues and their accepted fixes have been public for years. Ask what they have measured on issues created after the model's training cutoff, or on a private repo.
4. What does it do on my tickets? The only question that decides anything. Propose a pilot on 30 of our own issues, scored by our own tests, run three times each, reporting pass@1 and pass^3.

What would change my mind: a strong result on our own private cases at pass^3, with traces I can inspect. What would not: a bigger benchmark number. And note the rhetorical move to reject explicitly — “near-human performance” compares a benchmark score against a human baseline measured on that same benchmark, which says nothing about human performance on our work.
Concept check

Three questions before you move on

← Previous01 · Why demos lie