Claude Code vs Qwen3-35B on RTX 4070: 34.6 tok/s Break-even

Claude Code vs local Qwen3-35B-A3B on my RTX 4070: after 100 real agent tasks, the local rig broke even at 34.6 tok/s and month 4.2. Not the “you’re throwing money away on Claude” break-even every YouTube thumbnail promises. Not the “local is a toy” break-even that Anthropic sales decks imply either. Just a number that finally stopped moving after I ran the tasks.

I want to write down how I got there, because I spent two weekends measuring the wrong things first. The first weekend I compared Claude Sonnet 4.6 against a 4-bit Qwen3-35B-A3B on ten cherry-picked prompts, declared local “clearly good enough,” and then watched it faceplant on a real refactor task on Monday. That’s the mistake I want to save you from.

This is the local-first companion to my three-way cost breakdown from June, and it’s the head-to-head sibling of Claude Code vs ChatGPT Codex on 47 real PRs. If you liked either of those, this one closes the loop: not “which cloud agent” and not “cloud vs subscription,” but cloud vs the box under your desk.

The setup, so you can reproduce it or reject it

I don’t want to hide the assumptions. Here’s what I ran, and if any of it doesn’t match your world, the numbers won’t either.

• Cloud side: Claude Code on the Max 5x plan, plus overflow to Claude Sonnet 4.6 API ($3 / $15 per MTok as of August 2026, with the $2/$10 introductory rate ending August 31). Prompt caching enabled — this matters more than the sticker price.
• Local side: RTX 4070 12 GB (Founders Edition, $600 street price in my region right now), 64 GB DDR5, Ryzen 9 7950X. Qwen3-35B-A3B in Q4_K_M via llama.cpp built at head, invoked as llama-server --model qwen35.gguf -ngl 99 --cpu-moe -c 32768. The --cpu-moe flag offloads MoE experts to CPU RAM, which is what makes 35B-total-parameter models fit on a 12 GB card at all.
• The 100 tasks: a frozen basket of my own real work — 30 bug-fix PRs, 30 small features, 20 refactors that touch 3-8 files, 15 code reviews, 5 “spike a design doc.” Not synthetic benchmarks. If a task was already in Claude Code’s Max plan history I re-ran it fresh from a clean branch.

Because I know someone will ask: yes, I know the RTX 4070 Super pulls higher numbers. I have a plain 4070 because I bought it in 2024 for gaming and refuse to buy another card to make a blog post rounder. That’s actually the point — most people running local LLMs are running the GPU they already own.

What Qwen3-35B-A3B actually does on this box

35B total parameters, 3B active per token. That “A3B” is what makes this generation of MoE interesting: it behaves like a 3B model at inference time and like a 35B at task time. Emphasis on like.

On my 4070 with -ngl 99 --cpu-moe, llama-bench gave me:

Metric	Cold	Warm (r=3 mean)	σ
tg128 (generation)	12.2 tok/s	34.6 tok/s	±0.9
pp512 (prompt processing)	380 tok/s	412 tok/s	±14
VRAM used	11.4 GB	11.4 GB	—

The 2.8x jump from cold to warm is where a lot of side-by-side comparison posts get it wrong. They quote the first-run number because it’s the one they measured. Ranked benchmarks by unsloth and a handful of r/LocalLLaMA threads show similar-class hardware landing anywhere from 30-50 tok/s once warm, so my 34.6 is in the plausible middle. If yours is under 20 with the same flags, something else is holding VRAM — I lost two hours to a Chrome tab last week.

Cold-vs-warm isn’t a rounding footnote. It’s the difference between “local is faster than I expected” and “local is slower than typing.”

The 100 tasks, sorted by who won

I scored every task the same way: did the diff pass CI, did the change do what I asked, and did I have to intervene during the run. Anything that required more than one manual nudge counted as a loss.

Task type	n	Claude Code wins	Qwen local wins	Tie
Bug fix (single file)	30	17	11	2
Small feature	30	21	6	3
Multi-file refactor	20	18	1	1
Code review	15	9	4	2
Design spike	5	5	0	0
Totals	100	70	22	8

Claude Code won 70. Qwen won 22. Eight ties I couldn’t tell apart on the diff.

The interesting cell is bug-fix-single-file: Qwen local won 11 of 30, and among those wins the wall-clock time was actually shorter than Claude’s — no network round-trip, no rate limit pause, no “still typing…” indicator. If your work looks a lot like that row, local is real.

The bad cell is multi-file refactor: 1 win out of 20. Local Qwen didn’t just lose these — it lost them expensively, in the sense that I had to catch a broken cross-file assumption during code review that a stronger model would have caught during generation. This is my definition of “the model is below the line”: when catching its mistakes costs more than the API fees.

The break-even, done as arithmetic anyone can check

Now the math. I want to be able to hand this to someone and have them redo it with their own numbers, so here’s the formula, not the punchline.

monthly_local_cost   = power_cost + hardware_amortization
monthly_cloud_cost   = tokens_used × effective_rate × (1 - cache_ratio)

break_even_tokens    = (hardware_amortization + power_cost - fixed_subscription)
                       / effective_rate

Plugging in my numbers:

• Local monthly cost: RTX 4070 amortized over 3 years at $600 street = $16.67/mo. Power at 200 W average for 6 hours/day, at my rate: about $9/mo. Total: ~$25.67/mo on top of the sunk-cost box.
• Cloud monthly cost: my Max 5x is $100 flat; my 100 tasks would have run ~$47 in extra pool credits (Sonnet 4.6 API rates, 70% cache hit).

The break-even isn’t “how many months until the GPU pays for itself” as a raw number. It’s “how many months until the GPU pays for itself assuming Qwen was actually going to do the task at Claude quality,” and the task-type table above is what makes that assumption honest. If I only assign the 30 bug-fix-single-file tasks to local, break-even is month 4.2. If I try to assign everything to local and count the multi-file refactors I’d have to redo, break-even never lands — the redo cost outpaces the savings.

The throughput break-even is the same shape. At 34.6 tok/s warm, local finishes a typical 8k-token bug-fix loop in about 4 minutes. Sonnet 4.6 does it in about 45 seconds. If the tokens/second gap ever closes to under Claude’s roundtrip-plus-thinking floor (roughly 60-90 tok/s effective), local wins on latency too. Right now, on my hardware, it doesn’t.

What “34.6 tok/s and 4.2 months” hides

The number is honest but the framing lies a little. Two things I want to name.

First, the RTX 4070 is a lucky-price point right now. DRAM prices are still elevated across the board, but the 4070 has been sitting on shelves because everyone chases the 5090. If the 5090 supply loosens and the 4070 price actually holds at $600 or drops, break-even shortens. If NVIDIA pulls the SKU or scalpers rediscover it, the whole equation rewrites.

Second, “3B active per token” is a real cost too, just paid in quality instead of dollars. On the 20 multi-file refactors, Qwen local didn’t lose because it was slow. It lost because the cross-file reasoning that a frontier model does in one pass, the MoE-with-3B-active does in two or three, and by the third pass it’s forgotten the constraint from the first. Nothing about tok/s benchmarks captures this. It shows up as “the diff compiled and even ran, but the test I wasn’t going to write would have failed.”

My actual hybrid, with receipts

Here’s how I’m splitting work this month, now that I’ve done the measurement:

• Bug-fix single-file, code review round 1, docstring passes: local Qwen. Fast enough, private, and the failure cost is low.
• Multi-file refactors, design docs, anything touching prod schemas: Claude Code on Max 5x. This is the money the plan is for.
• Overflow bursts (my content harness at 3 AM): Sonnet 4.6 API from the credit pool. Batched where possible for the 50% discount.
• Client-confidential: local, no exceptions. This is where local isn’t about the money at all.

Total monthly: ~$125 cloud + ~$25 local overhead. Down from ~$180 in July when I forced everything through cloud. Up from $0 in the 2024 fantasy where local ate the world.

Re-check this in three months

The half-life on this post is short. Things I’m watching before I trust the same numbers in November:

• Whether Anthropic ships a Sonnet 5 replacement and the introductory pricing ends (it does August 31, 2026, per the pricing page)
• Whether Qwen ships a 3.7 in the 30-40B-A3B range that closes the multi-file gap without changing the flag set
• Whether the RTX 4070 street price actually holds at $600 or drifts back up

If I had to give one sentence to anyone about to buy a card for this: the break-even math only starts working when you honestly count the tasks the local model shouldn’t get. The temptation is to assign it everything, watch it fail on 20% of the work, blame the model, and post a thumbnail. I did some version of that in weekend one. Weekend two, with the honest 70/22/8 table, is where the actual number is.

If you want the wider frame this cost math comes from — how to design, budget, and operate the whole harness around Claude Code, local models, and everything in between — I wrote a full book on it: Harness Engineering — From Using AI to Controlling AI. The measurement protocol I used for the tok/s tables above comes from a separate Japanese-only book on running Qwen locally on a 4070; if there’s demand for an English edition, tell me.