The invoice arrives and no one can say which customer spent the money. Cost attribution isn't a report you run later — it's a schema decision you make at request time, and for agents the gateway total lies about where the spend went.
Public leaderboards answer 'which model is smartest,' not 'will it fix my bugs' — the only test that predicts your outcome is a private eval built from your own repo.
Approximate nearest-neighbor search is a tax you pay to survive scale you may not have. Below a few hundred thousand vectors, exact brute-force is faster, perfectly accurate, and has no index to rot.
A June 2026 paper clocks three popular memory frameworks on the same benchmark: 118K, 632K, and 3.26M tokens per query. The 500x spread isn't noise — it's a design choice most teams never realize they're making.
The benchmarks that grade an agent's memory just moved the finish line from 9,000 tokens to 10 million — and the new one proves a million-token context window doesn't buy you long-term memory.
An LLM judge flips up to a third of its verdicts when you swap the answer order, and scores its own writing 10–25% higher. Three biases corrupt your evals — and only one has a cheap fix.
You can't A/B test an agent the way you A/B test a button. The unit of variance is a trajectory, not a click — so the gate has to be offline, and "shadow mode" means something different than it does for a model.
Mem0 says 92.5% on LoCoMo. Mastra says 95% on LongMemEval. Zep corrected its own 84% to 58%. They can't all be right — and the baseline that beats them all is the one no vendor charts.
The MTEB leaderboard is a prior, not an oracle. The model that wins your RAG system is the one you measure on a few hundred of your own labeled queries — here is how to build that eval.
A deep research agent hands you a long, confident, well-structured report. Grading it means measuring two different things at once — how good it reads, and whether a single sentence is actually supported.
Write the eval before the prompt. The test suite you build first is the only thing that lets you change models next month without praying — and in 2026, you will change models.
Static benchmarks freeze the world while an agent thinks. Meta's GAIA2 lets time run — and the smartest model, GPT-5, turns out to be the one that misses deadlines.
An agent leaderboard that ranks only on accuracy is secretly ranking on willingness to spend. Add the cost axis and the board's #1 is often not even on the frontier.
Most agent benchmarks hand the whole task to the model. τ-bench keeps the user in the loop, and τ²-bench gives the user their own hands — which is where frontier agents quietly fall apart.
A new benchmark drops the same models from ~73% to ~25% — not by making the bugs harder, but by taking away the one thing SWE-bench always handed over: a map to the change.
Gartner says purpose-built agent software more than doubles to $206.5B this year. The same firm says 40%+ of agentic projects get canceled. Both numbers are true, and they're the same story.
The benchmarks for web-browsing agents split along a fault line the coding benchmarks never had — and the trick that makes one of them work quietly hides which half of your agent is actually good.
SWE-bench hands an agent a broken test and a healthy repo. Terminal-Bench hands it a live machine and lets it break things. That's why a top SWE-bench score tells you almost nothing about the second number.
The number on the spec sheet is a memory allocation, not a comprehension score. A needle test passing at 1M tokens tells you the model can find a string — not that it can use the context. Here's the benchmark that measures the difference.
Every provider now sells the same ~90% discount on repeated context. The number on the brochure is not where the bills actually diverge — three quieter terms are.
The number at the top of the MTEB leaderboard has quietly stopped meaning what you think it means. Here is which board to read, and why the newest one hides half its test set on purpose.
Decode is memory-bandwidth bound, so a GPU's TFLOPs barely predict serving capacity. What caps concurrency is the KV cache. Here's the actual arithmetic, with a worked example.
Every pricing model for an AI agent is really a decision about who absorbs the inference bill — and the floor under any outcome price is the cost of producing that outcome.
Bigger context windows don't fix forgetting. The benchmarks that actually test agent memory — LoCoMo and LongMemEval — and what their question categories reveal about where it breaks.
A single throughput figure is uninterpretable without the load that produced it and the prompt shape you fed in. The honest output of an LLM benchmark is a curve, and the number that matters is goodput — the most traffic you can serve while still meeting your latency SLO.
pass@k asks whether an agent can ever solve a task. pass^k asks whether it solves it every single time. For long-horizon agents those are different questions — and the gap is where production failures live.
A model that solves a task 61% of the time can be reliable only 25% of the time. The gap between those two numbers is where production agents go to die.
Learned sparse retrieval promises dense-quality matching without giving up the inverted index. The catch isn't relevance — it's the query-time bill, and there's a mode that erases it.
Flat top-k retrieval returns the chunks most similar to your query. For "what is this document about?" that's exactly the wrong thing. RAPTOR retrieves at the right altitude instead.
Three benchmarks, three verification methods, three very different definitions of 'success' — so a single computer-use percentage tells you almost nothing without the asterisks.