Quantifying infrastructure noise in agentic coding evals

9 min readintermediate
--
View Original

Overview

This article from Anthropic's engineering team quantifies how infrastructure configuration—specifically resource allocation and enforcement methodology—introduces significant noise into agentic coding benchmarks like SWE-bench and Terminal-Bench 2.0. Their experiments show that the gap between the most- and least-resourced setups on Terminal-Bench 2.0 was 6 percentage points (p < 0.01), meaning small leaderboard differences may reflect infrastructure differences rather than genuine model capability gaps.

What You'll Learn

1

How infrastructure resource configuration introduces measurable noise into agentic coding benchmark scores

2

Why leaderboard differences below 3 percentage points on agentic evals deserve skepticism

3

How container runtime resource enforcement (guaranteed allocation vs. hard kill threshold) affects evaluation stability

4

When additional resources fix infrastructure reliability versus when they actively change what a benchmark measures

5

How to calibrate resource headroom for agentic coding evaluations to minimize infrastructure confounders

Prerequisites & Requirements

  • Understanding of container runtimes and resource management (CPU, RAM limits, OOM kills)
  • Familiarity with AI/ML model evaluation and benchmarking concepts
  • Basic understanding of Kubernetes resource requests and limits(optional)
  • Awareness of agentic coding benchmarks like SWE-bench and Terminal-Bench(optional)
  • Basic statistical literacy (p-values, confidence intervals)

Key Questions Answered

How much does infrastructure configuration affect agentic coding benchmark scores?
Infrastructure configuration alone can produce a 6 percentage point difference on Terminal-Bench 2.0 (p < 0.01) between the most- and least-resourced setups. On SWE-bench, the effect was smaller but still present at 1.54 percentage points between 1x and 5x RAM. These differences often exceed the margins separating top models on leaderboards.
What causes infrastructure errors in agentic coding evaluations?
When container resource specs set the guaranteed allocation equal to the kill threshold, there is zero headroom for transient memory spikes. A momentary fluctuation can OOM-kill a container that would otherwise have succeeded. At strict 1x enforcement on Terminal-Bench 2.0, infra error rates reached 5.8%, with most failures unrelated to the model's problem-solving ability.
What is the difference between resource headroom fixing reliability versus changing what a benchmark measures?
Up to roughly 3x Terminal-Bench specs, additional resources fix infrastructure reliability by absorbing transient spikes—infra errors dropped from 5.8% to 2.1% (p < 0.001) while scores stayed within noise (p = 0.40). Above 3x, resources actively help agents solve problems they couldn't before, enabling heavyweight approaches like installing large dependency stacks, which changes what the eval actually measures.
How should container resource limits be specified for agentic coding benchmarks?
Evals should specify two parameters per task: a guaranteed allocation (floor) and a separate hard kill threshold (ceiling), rather than a single pinned value. The band between them should be calibrated so scores at the floor and ceiling fall within noise. For Terminal-Bench 2.0, a 3x ceiling over per-task specs was a reasonable tradeoff that neutralized infrastructure confounders without removing meaningful resource pressure.
Should you trust small differences in agentic coding benchmark leaderboards?
Leaderboard differences below 3 percentage points deserve skepticism until the eval configuration is documented and matched. Naive binomial confidence intervals already span 1-2 percentage points, and infrastructure confounders stack on top of that. A few-point lead might signal a real capability gap or just reflect beefier hardware or luckier timing.
How do different resource configurations favor different model strategies?
Tight resource limits reward efficient strategies—models that write lean code and use minimal dependencies. Generous limits reward agents that exploit all available resources, such as installing full data science stacks or spawning expensive subprocesses. For example, on the bn-fit-modify task, some models install pandas, networkx, and scikit-learn (which needs generous RAM), while others implement the math from scratch using only the standard library.
Does resource allocation affect SWE-bench scores the same way as Terminal-Bench?
Yes, the same pattern holds on SWE-bench but with smaller magnitude. Scores increased monotonically with RAM, reaching 1.54 percentage points higher at 5x versus 1x baseline across 227 problems with 10 samples each. SWE-bench tasks are less resource-intensive, so a smaller effect is expected, but resource allocation is not neutral there either.
What other hidden variables besides resource allocation affect agentic eval scores?
Time limits, cluster health, hardware specs, concurrency level, and even egress bandwidth can influence scores. Anthropic observed anecdotally that pass rates fluctuate with time of day, likely due to API latency varying with traffic patterns. For coding evals meant to be shared publicly, running at multiple times and on multiple days would help average out this noise.

Key Statistics & Figures

Max score gap from resource configuration on Terminal-Bench 2.0
6 percentage points
p < 0.01
Infra error rate at strict (1x) resource enforcement
5.8%
Terminal-Bench 2.0 with per-task specs as both floor and ceiling
Infra error rate at 3x resource headroom
2.1%
Drop from 5.8% was significant at p < 0.001
Infra error rate when completely uncapped
0.5%
Terminal-Bench 2.0 with no resource limits
Score difference between 1x and 3x resource configurations
Within noise
p = 0.40
Success rate jump from 3x to uncapped
~4 percentage points
While infra errors only dropped an additional 1.6 percentage points in the same range
SWE-bench score increase at 5x RAM vs. 1x baseline
1.54 percentage points
Across 227 problems with 10 samples each; scores increased monotonically with RAM
Number of resource configurations tested on Terminal-Bench 2.0
6
From strict 1x enforcement to completely uncapped
Infra error rate reduction from strict to 3x headroom
~two-thirds reduction
5.8% to 2.1%

Technologies & Tools

Some links below are affiliate links. We may earn a commission if you make a purchase.

Infrastructure
Google Kubernetes Engine (gke)
Cluster used to run Terminal-Bench 2.0 evaluations with configurable resource enforcement
Benchmark
Terminal-bench 2.0
Primary agentic coding benchmark used for resource configuration experiments
Benchmark
Swe-bench
Secondary benchmark used to validate resource allocation effects on a different eval
Container Orchestration
Kubernetes
Container runtime resource enforcement via guaranteed allocations and hard kill thresholds
AI Model
Claude
The AI model used across all experiments, held constant while varying infrastructure
Programming Language
Python
Referenced in context of tasks requiring data science stack installation (pandas, networkx, scikit-learn)
Library
Pandas
Part of the data science stack some models install for the bn-fit-modify task
Library
Networkx
Part of the data science stack some models install for the bn-fit-modify task
Library
Scikit-learn
Part of the data science stack some models install for the bn-fit-modify task

Key Actionable Insights

1
Specify both a guaranteed allocation (floor) and a hard kill threshold (ceiling) for container resources in agentic evals, rather than a single pinned value. Setting them equal leaves zero headroom, causing transient memory spikes to OOM-kill containers that would otherwise succeed, artificially depressing scores.
This is the primary recommendation from the article. Terminal-Bench 2.0's Kubernetes implementation initially set both parameters equal, resulting in 5.8% infra error rates that dropped to 2.1% with a 3x ceiling.
2
Calibrate the resource headroom band so that scores at the floor and ceiling of the band fall within statistical noise of each other. For Terminal-Bench 2.0, a 3x multiplier over per-task specs achieved this balance, cutting infra errors by two-thirds while keeping score differences non-significant (p = 0.40).
The exact multiplier will vary by benchmark and task distribution, so it should be empirically determined and reported. The key principle is that the headroom should eliminate infrastructure artifacts without making tasks easier to solve.
3
Treat resource configuration as a first-class experimental variable in agentic evaluations, documented and controlled with the same rigor as prompt format or sampling temperature. Without published setup configurations, external observers cannot distinguish genuine capability differences from infrastructure artifacts.
This applies to AI labs, benchmark maintainers, and anyone publishing or consuming benchmark results. Publishing recommended specs (as Terminal-Bench 2.0 does) helps, while specifying enforcement methodology would close the remaining gap.
4
Apply skepticism to agentic coding benchmark leaderboard differences below 3 percentage points. The observed spread across moderate resource configurations is just below 2 percentage points, and naive binomial confidence intervals already span 1-2 percentage points—infrastructure confounders stack on top of that.
This is critical for decision-makers choosing which models to deploy based on benchmark rankings. A few-point lead might reflect a genuine capability difference or simply reflect different infrastructure configurations.
5
Run public coding evals at multiple times and on multiple days to average out temporal variance. Pass rates can fluctuate with time of day due to API latency varying with traffic patterns, adding another layer of noise beyond resource configuration.
This addresses confounders that are hard to control even with standardized resource specs. External evaluators who cannot dedicate hardware are particularly vulnerable to this variance.
6
Be aware that resource configuration changes what an agentic eval actually measures: tight limits reward efficient, lean coding strategies while generous limits reward agents that exploit available resources with heavyweight tools. Collapsing both into a single score without specifying resources makes results hard to interpret.
Both measurement modes are legitimate depending on the use case—but they should be explicitly distinguished. Different deployment scenarios may favor different strategies.

Common Pitfalls

1
Setting container resource guaranteed allocation equal to the hard kill threshold (single pinned value), which leaves zero margin for transient memory spikes. This causes containers to be OOM-killed during momentary fluctuations, resulting in infra error rates as high as 5.8% on Terminal-Bench 2.0—failures that are unrelated to the model's problem-solving ability.
Container runtimes enforce resources via two separate parameters. Always specify both a floor (guaranteed allocation) and a ceiling (kill threshold) with a calibrated band between them.
2
Treating agentic coding benchmark scores as precise measurements of model capability without accounting for infrastructure configuration. A 2-point lead on a leaderboard might reflect genuine capability or just reflect that one eval ran on beefier hardware, at a luckier time of day, or both.
Leaderboard differences below 3 percentage points deserve skepticism. Naive binomial confidence intervals span 1-2 points, and infrastructure confounders stack on top.
3
Providing excessive resource headroom (above ~3x per-task specs) while believing it only stabilizes the eval. Beyond the 3x threshold, additional resources actively help agents solve problems they couldn't solve before—enabling heavyweight approaches like installing large dependency stacks—which changes what the benchmark actually measures rather than just fixing reliability.
The 3x threshold was specific to Terminal-Bench 2.0. The exact multiplier varies by benchmark, but the principle of calibrating the band so floor and ceiling scores fall within noise is general.
4
Assuming that specifying recommended resources per task is sufficient for eval reproducibility. Terminal-Bench 2.0 specifies recommended CPU and RAM per task, but specifying resources isn't the same as enforcing them consistently. Different sandboxing providers implement enforcement differently, with some being more lenient about temporary overallocation.
Enforcement methodology—not just resource specs—must be documented. The gap between Kubernetes strict enforcement and more lenient sandboxing providers was a primary source of score discrepancies.
5
Ignoring temporal variance when running agentic coding evals. Pass rates can fluctuate with time of day, likely because API latency varies with traffic patterns and incidents. Running an eval once and treating the result as definitive misses this source of noise.
For public coding evals, running at multiple times and on multiple days helps average out temporal noise. Model providers can shield their infrastructure by dedicating hardware, but external evaluators typically cannot.

Related Concepts

Container Resource Management (requests Vs. Limits)
Oom Kill Behavior In Kubernetes
Agentic AI Evaluation Methodology
Benchmark Reproducibility
Statistical Significance In Evaluation
Swe-bench Evaluation Framework
Terminal-bench 2.0 Benchmark
Infrastructure As Confounding Variable
Binomial Confidence Intervals
Eval Scaffold Design
AI Coding Agents
Resource-efficient Vs. Resource-exploiting Model Strategies