Cursor Hit 50% of PRs by Fixing Environments, Not the Model

Classify the failure before you change the model

An agent run fails exactly three ways: the environment never came up, the test output was unreadable, or the logic was wrong. Only the third is a model problem. Most teams never separate the three, conclude the model is not good enough, and go shopping. The misattribution is the expensive part. Two of the three categories are fixed by work already in the muscle memory of any platform team.

Agent-legible has a spec, not a vibe. One command that provisions and verifies. Machine-readable test output in JSON, not scrollback. Seeded deterministic fixtures instead of shared staging state. Mocked external dependencies, so a run does not die on someone else's rate limit. Snapshot and restore, so a failed run does not poison the next. Every one of those helps human developers too, which puts a floor under the investment.

Decomposition shows up in three independent traces

Google's Chrome vulnerability pipeline is not one model doing one thing. Automated triage runs first, then a fixing agent drafts patches, then a critic agent reviews them, then test-writing agents verify across every supported platform. The last gate is machine-checked, which is the part that matters. Devshot reports the same direction from a different angle: decomposing an automated task into guided steps succeeded 100% of the time versus 50% one-shot, with higher-quality output. AgentRadio, per AINews, moved SWE-Atlas QnA from 32.3% to 62.1% using four agents over asynchronous messaging, beating a stronger single-model baseline. Three unrelated systems, one finding: the bottleneck is orchestration, not model capability.

The costs are specific and they arrive early. Async message ordering is non-deterministic. Debugging fan-out without trace-level observability is misery. Tracing goes in before the second agent does.

Where agents are measurably unsafe

The review queue is the next queue

GitHub shipped Stacked Pull Requests in public preview. The detail worth reading is that existing reviews, status checks and merge requirements keep working, which means the integration problem third-party stacked-diff tools kept re-implementing is now native. Good engineering. The announcement skips two failure modes. CI fan-out: required checks on a five-PR stack cost five times the build minutes of one large PR. Mid-stack rebase cascades: a reviewer's change at layer two invalidates everything above it. Cap stack depth at three or four. Put the highest-risk change at the bottom so it fails early.

One correlation risk nobody in the available coverage named. If the same model family generates the code, reviews the diff and writes the tests, that is a second opinion from the same brain. Shared priors, shared blind spots. Decorrelating costs a config change.

If your coding agents are not merging code, the bug is probably in your build harness, not your model choice.

The physical bottleneck moved from silicon to power

Rented compute is inflating, and chip supply is not the mechanism. a16z read the import and orders data: power-conversion imports are down roughly 23% in units while prices are up about 25% versus January 2025, HVAC is the fastest-growing data center machinery order category, and the backlog ratio for computer and electronic products sits just under six months. Vertiv booked $3.27B of revenue and still missed its own guidance by about $76M, blaming multi-phased project execution as deployments scale in size and complexity. That is tail latency with concrete poured into it. Aggregate capacity arrives; per-project schedules widen as builds get bigger.

The second-order finding matters more for procurement. A100 spot pricing is stable and older editions are getting more expensive. There is no obsolescence dividend. Prior-generation accelerators are a live, bid sourcing pool, which makes a wide CUDA compatibility floor and a validated quantized-model path on A100-class hardware a first-class deployment tier rather than an emergency fallback.

Why the token cuts do not reconcile

OpenAI credited serving gains to speculative decoding: +15% token generation and -20% GPU serving cost. Do that arithmetic. It does not fund an 80% price cut. Per AI Breakfast's analysis, the residual is distillation into a smaller checkpoint plus deliberate margin sacrifice against Chinese providers. Read those prices as a competitive weapon, not a structural floor, and keep the cost model behind an abstraction you own.

DeepSeek's V4-Flash 0731 makes the same point from the other side: Artificial Analysis index 50 against GPT-5.6 Luna's 51, roughly 60% lower cost per task, $0.14/$0.28 per million tokens, MIT weights the same day, Responses API compatible and "fully adapted for Codex." An A/B is a router config change, not a migration. Pin the dated string 0731, not flash, so a post-training refresh cannot silently regress you.

The discount lands on the input prefix

Cached input is $0.0028 per million — exactly 2% of the $0.14 input rate. Here is what actually happens in an agent loop: every turn replays a growing tool-call transcript, so cached input dominates volume. TLDR's arithmetic on a representative 10-turn session lands at roughly 200K input tokens against 5K output. Most of the spend is the agent re-reading its own conversation. Past turn five, prefix-cache hit rate and context compaction outrank model choice.

So prompt engineering is a caching problem. Hoist timestamps, request IDs and per-user state out of the prefix. Freeze tool-definition ordering. Keep context append-only, and stabilize retrieved-chunk ordering. One dynamic token near position zero of a system prompt is a ~50x input-cost multiplier. The optimization is provider-agnostic; it pays on every vendor you route to.

Where memory pressure lands

Record memory-industry profits and hyperscalers now graded on free cash flow point the same direction: memory does not get cheaper. In an inference stack that pressure lands almost entirely on the KV cache. Measure gigabytes per concurrent session, enable paged attention and prefix caching, cut oversized default context windows, and evaluate KV quantization before buying more accelerator hours. Watch the long-context interaction. Weights are one budget, KV cache is another, and running near a million tokens moves a box from 2x80GB to 4x80GB.

Efficiency work deferred as premature optimization is now the only capacity available at a price you were planning for.