The B200's headline 5-6x throughput jump is two different upgrades wearing one number — bigger HBM and FP4 compute — and which one matters depends entirely on whether your workload is memory-bound or compute-bound.
An LLM judge scores the final answer. For a multi-step agent, that signal is sparse, late, and easy to fool — a broken trajectory can still land on a right answer, and you'd never know.
Both spend N times the inference to make a model smarter. The difference is how they choose the winner — and that choice decides which tasks each one can help.
Search teams optimize NDCG. RAG teams copy them — and measure the wrong thing. For a pipeline that hands the whole top-k to a generator, recall is the floor and rank position is a second-order correction.
Offline evals ask whether the agent matched a known answer. Online evals can't — there is no answer. Treating them as one pipeline with one metric is the mistake that lets agents pass every test and still fail in production.
Token logprobs are right there in the API, cheap and ignored — and after RLHF they're systematically overconfident. The signal that actually tracks whether the answer is right costs you N times the inference.
The scoring framework is the commodity. The hard, valuable, un-buyable work is looking at your own outputs and distilling real failures into labeled cases — your eval set is a precipitate of error analysis, not a download.
Amazon's agent platform sells you everything except the agent. Here is what the seven services actually do, what the numbers mean, and why the neutrality is the whole strategy.
The open-weight embedding race stopped being one race. It split into two that don't compete — and the most interesting model isn't a single vector at all.
Grading every reasoning step sounds strictly better than grading only the final answer. The models that actually pushed reasoning forward threw the step-grader away and rewarded the one thing they could verify by rule.
"Dynamo vs vLLM" is a category error. One is an orchestrator across pools of GPUs; the other is the engine inside a single replica. Sort that out and the real choice gets clear.
Merging averages the weights of separately fine-tuned models into one — no GPUs, no gradients, just arithmetic. The methods aren't a quality ladder; they're escalating answers to a single problem: interference.
Every attention variant since 2019 has been one argument about the same scarce resource — the key-value cache — and the newest answer changes the terms of the deal.
Pure Mamba never beat the Transformer outright — but a wave of hybrids that keep ~8% of layers as attention now cut long-context memory 70%+ and triple decode throughput.
The three numbers everyone quotes measure three different bottlenecks — and per-user speed and system throughput move in opposite directions, so a vendor's headline tok/s can mean whatever flatters it.
Distillation is the only model-compression method that moves a capability across a size class. The decade-long arc: the supervision signal went from "match the teacher's answer" to "let the student practice and have the teacher grade it."
Almost every hallucination detector measures one thing — whether the answer is grounded in the context it was given. That is not the same as whether the answer is true.
GRPO scores a whole response, then corrects the policy one token at a time — and on long outputs and MoE models that mismatch quietly destroys training. GSPO's fix is almost embarrassingly simple: optimize at the same unit you reward at.
GEPA optimizes prompts by reading the agent's own failure traces in plain language instead of chasing a scalar score — and reports beating an RL baseline with up to 35x fewer rollouts.
There is rarely one correct path through a task, so grading an agent against a golden trajectory fails. Grade invariants over the path, and the final state, instead.
You can distill a sentence transformer into a token lookup table that needs no forward pass at inference — up to 500x faster on CPU, ~50x smaller, and it keeps more quality than the speedup suggests it should.
A Matryoshka-trained embedding lets you chop off the tail of every vector and still search well — and a two-pass trick gets you the storage savings and the accuracy at the same time.
GRPO didn't win on optimization theory. It won by removing a policy-sized value network from the training loop — and the memory it saved is what put RL post-training within reach of a single node.
Agents don't run on chatbot leaderboards. The model that wins your tool loop is decided by function-calling reliability, agentic benchmarks, and an "agent tax" the headline price hides.
Both bolt a quality check onto RAG, but they fix different failures at different points — and the choice comes down to one question: do you control the model's weights?
Every major provider sells inference at roughly half price if you can wait up to 24 hours. The discount isn't the point — the contract is, and it tells you which agent work was never realtime to begin with.
You quantized the weights to 4-bit and thought memory was solved. At long context the KV cache dwarfs the weights — and it needs a different kind of quantization to shrink safely.
The three formats aren't competing for the same job — one buys you faster math, one buys you smaller weights, and one is the fallback for hardware that can't do the first. Know which bottleneck you're paying down.