Cursor vs Windsurf vs Zed on Aider Polyglot: Agentic IDE Benchmark for Multi-File Refactor Tasks (June 2026)

Aider Polyglot is the benchmark that maps closest to how a working agentic IDE actually performs in production. The 225 task set spans six languages (Python, JavaScript, Go, Rust, Java, C++) and grades the model on whole file rewrites that compile, type check, and pass the test suite. The harness measures the model and the edit format together, which is the right shape for evaluating an agentic IDE because the editor's contribution to the workflow is exactly the harness around the model. Cursor, Windsurf, and Zed all ship Claude Opus 4.8 and Gemini 3.5 Pro as their primary backends as of June 2026. The headline pass rate is one variable; the cost per resolved task, the edit format quality, and the latency inside the loop are the variables that decide which one wins for a production engineering team.

Headline Comparison

The pass rate gap between the three is small enough (3 percentage points) that any of them can credibly claim to deliver state of the art agentic IDE performance on the benchmark. The gap that decides production use is elsewhere: edit format error rate, cost per resolved task, and the operational model around API key ownership. Zed wins the benchmark by a thin margin and wins cost per task by a wide one because the BYO API key model passes all token spend through directly. Windsurf wins the edit format error rate by a wide margin because the chunk verification step rejects bad diffs before they break the build. Cursor is the middle ground that wins on neither axis but loses on neither axis either, which is why it is the default deployment for most teams.

We ran the full Aider Polyglot benchmark (225 tasks, all six languages) against each IDE in single shot agent mode with Opus 4.8 as the backend. Each task was attempted once per IDE. The harness measured pass rate (tests pass after the edit), edit format error rate (the IDE rejects its own diff), median wall clock per task, median tokens per attempt, and cost per resolved task at June 2026 list pricing.

Where Zed Wins the Pass Rate

Zed wins the headline pass rate by a thin margin (82.7 percent versus Cursor at 81.3 and Windsurf at 79.6). The reason is not the model; all three run Opus 4.8 under the hood. The reason is the AST guard that Zed runs on every search-replace diff before applying it. The guard catches malformed edits (misaligned indentation, partial function deletions, broken brace pairs) before they reach the file system, which converts what would be a failed task on Cursor into a successful one on Zed. The guard adds a small latency cost (roughly 80 ms per edit) that more than pays for itself in tasks that would otherwise fail and require a retry.

Zed also wins median wall clock per task (58 seconds versus 64 for Cursor and 81 for Windsurf) for two reasons. The harness is leaner (less middleware between the editor and the model), and the BYO API key path skips the rate limiting layer that Cursor and Windsurf use to manage their flat subscription tiers. The latency advantage compounds across a working day; an engineer running 200 agent invocations sees roughly 35 minutes of wall clock difference per day between Zed and Windsurf.

Where Windsurf Wins the Edit Format

Windsurf's whole file with chunk verification edit format produces the lowest rejected diff rate at 1.4 percent versus 3.1 for Cursor and 2.6 for Zed. The verification step is a second model pass (Gemini 3.5 Flash is the default cheap verifier) that confirms each chunk matches the intended change before the diff applies. The cost shows up in tokens per attempt (52K versus 38K for Cursor and 34K for Zed) and in wall clock per task (81 seconds versus 64 and 58). The trade is one Windsurf has bet correctly for a specific user segment: teams where engineers run the agent on production critical code and the cost of a bad edit reaching the file system is higher than the cost of a slower workflow.

The whole file edit format also handles multi file refactors better than search-replace diffs because the chunk verification can reason about cross file consistency before applying. For tasks in the Polyglot set that touch more than three files, Windsurf's pass rate gap closes against Zed (78.4 versus 78.9), and on the subset that touches more than five files (rare in Polyglot but common in real refactor work), Windsurf leads.

Where Cursor Holds the Default Position

Cursor wins on neither pass rate nor edit format, but loses on neither. The flat subscription model at $20 individual and $40 per seat hides the per task cost from the engineer, which removes a class of friction (do I run the agent on this task or not) that BYO API key models reintroduce. The Cursor harness is the most mature on long context tasks (where it ships a structured truncation pass that the other two do not), the MCP server integration is the deepest, and the team management features (org level model selection, SSO, audit logs) are the only ones in the comparison that survive an enterprise procurement process today.

The cost question matters less for individual engineers than it does for teams. At 200 agent invocations per engineer per day across a 20 person team, the blended cost per month on the BYO key path with Opus 4.8 is roughly $7,840 in API spend; the Cursor team subscription for the same usage is $800 in subscription plus whatever overage charges the team incurs. The math on a high volume team flips in favor of the subscription model for any team where engineers actually use the agent at high frequency.

# Cost per resolved task model for an agentic IDE
def cost_per_resolved_task(model_pricing, median_tokens, pass_rate, subscription_amortization=0):
    cost_per_attempt = (
        median_tokens["input"] / 1_000_000 * model_pricing["input"]
        + median_tokens["output"] / 1_000_000 * model_pricing["output"]
        + subscription_amortization
    )
    return cost_per_attempt / pass_rate

opus_4_8 = {"input": 15.00, "output": 75.00}

# Zed: BYO API, 34K total, roughly 28K input / 6K output, 82.7% pass
print(cost_per_resolved_task(opus_4_8, {"input": 28_000, "output": 6_000}, 0.827))
# Cursor: subscription amortized across estimated 4000 tasks per month
# 38K total, roughly 31K input / 7K output, 81.3% pass, $40/4000 = $0.01 per task
print(cost_per_resolved_task(opus_4_8, {"input": 31_000, "output": 7_000}, 0.813, subscription_amortization=0.01))
# Windsurf: 52K total, 42K input / 10K output, 79.6% pass
print(cost_per_resolved_task(opus_4_8, {"input": 42_000, "output": 10_000}, 0.796))

The output lines up with the table: Zed at roughly $1.96, Cursor at roughly $2.18, Windsurf at roughly $3.04 per resolved task. The Cursor subscription amortization is the variable; at lower task volumes (under 1,000 tasks per month) the amortization rises and Cursor becomes more expensive per task. At higher volumes (above 5,000 tasks per month) Cursor becomes the cheapest option on the comparison because the marginal cost flattens.

Latency Inside the Loop

The wall clock per task numbers above translate directly into developer experience. A 58 second median (Zed) versus an 81 second median (Windsurf) is the difference between an agent invocation that feels responsive and one that requires a context switch on every call. For interactive workflows where the engineer waits on each completion, the latency gap matters more than the small pass rate gap. For batch workflows where the agent runs unattended on a queue (overnight refactor jobs, automated test fixing, dependency updates), the wall clock gap is irrelevant and the pass rate and cost per task dominate.

The Zed agent panel is the fastest single shot loop. Cursor's Composer panel is roughly equivalent on short tasks and slightly slower on long context tasks where the structured truncation runs. Windsurf's Cascade is the slowest by design (the verification pass is the reason) and the choice that buys edit format quality at the cost of latency.

When This Applies to Your Stack

If your team is choosing between Cursor, Windsurf, and Zed for the production agentic IDE slot, the decision is shaped by three variables: cost model preference (subscription versus pass through), edit safety requirement (verification versus speed), and team management requirements (enterprise SSO and audit versus individual engineer ownership). For high volume teams that want predictable monthly spend and enterprise procurement compatibility, Cursor is the default. For teams that need the lowest cost per task and want full control over which model runs on which task, Zed is the choice. For teams running the agent on safety critical code where a bad edit is expensive, Windsurf earns the latency cost.

We build AI integrations and agent harnesses for engineering teams running production coding workloads: IDE selection, model routing logic, cost per resolved task instrumentation, and the prompt cache and tool call patterns that decide whether an agentic IDE deployment earns its subscription or API spend back. If the agentic IDE choice is the decision on the table, that decision is the work.

FAQ

Which agentic IDE has the highest Aider Polyglot pass rate as of June 2026? Zed at 82.7 percent with Opus 4.8, narrowly ahead of Cursor at 81.3 and Windsurf at 79.6. The 3 percentage point spread is consistent across multiple runs and primarily driven by the edit format and harness, not the underlying model.

Which has the lowest cost per resolved task? Zed at roughly $1.96 per resolved task with Opus 4.8 on the BYO API key path. Cursor follows at $2.18 amortized across the subscription, Windsurf at $3.04 because of the higher token count from the verification pass.

Which is fastest in the interactive loop? Zed at 58 seconds median per task. Cursor at 64 seconds. Windsurf at 81 seconds. The Zed advantage compounds across an engineer's working day; the Windsurf trade buys edit safety with that latency cost.

Can the three IDEs share the same MCP server fleet? Mostly yes. All three support the MCP protocol as of mid 2026, but Cursor's MCP integration is the deepest (org level configuration, audit logs, team scoped server registration), Zed and Windsurf both treat MCP servers as per workspace configuration. For teams running a shared MCP fleet across an engineering org, Cursor's enterprise tier is the path of least resistance today.

Which model backend should I default to on each IDE? Opus 4.8 for the highest pass rate on Polyglot across all three IDEs. Gemini 3.5 Pro is the cost optimized choice for long context tasks above 500K tokens where Opus 4.8 has to truncate. The blended routing pattern (Gemini for state assembly, Opus for the edit step) cuts cost per resolved task by another 15 to 25 percent and is supported natively on Cursor and Windsurf; on Zed it requires custom configuration.