Tiel-Coder 35B Delivers 125 Tokens/s on RTX 4070 Ti SUPER: Agent Config

⚡ The Gist in 5 Seconds

• Tiel-Coder-35B-A3B-MTP in the Q2_K_XL quant delivers 125 tokens per second on an RTX 4070 Ti SUPER with 16 GB of memory.
• The speedup is built from three parts: MoE (+200–450%), MTP (+20%), and Sharp Template (inference 59% shorter).
• Context is 65,535 tokens, so tasks are split up via plan.md and the lightweight Pi agent instead of Codex or Claude Code.

🔍 What Happened

An author under the handle igumnov posted a write-up on Habr on how to turn an RTX 4070 Ti SUPER with 16 GB of GDDR6X into a host for a full-fledged coding agent. The card costs around $900, and according to GaugeDB surveys, 16 GB models account for 27.21% of the desktop GPU market. The speed benchmark is set right away: a dense model like Qwen 3.8 27B delivers 10–20 tokens per second on this hardware, while an agent needs 100–150 for comfortable work. The full case study with launch parameters is on Habr.

The mechanics rest on three layers. The MoE architecture of Tiel-Coder-35B-A3B only computes part of the parameters for each token, hence the +200–450% boost to generation. MTP (Multi-Token Prediction) predicts several tokens ahead — another +20%. Sharp Template, a trimmed-down Jinja chat template with a system prompt, makes the model reason less "on the side": inference is 59% shorter, and the agent's work is roughly twice as fast. The author keeps two files — Tiel-Coder-35B-A3B-MTP-UD-Q2_K_XL.gguf and an abliterated version, Cyber-Tiel-Coder-35B-A3B-MTP-UD-Q2_K_XL.gguf, which, according to him, doesn't refuse to write exploits.

The agent is Pi: it needs about 1.5K tokens of system prompt versus 10–14K for Codex and Claude Code. In ~/.pi/agent/models.json, the lmstudio provider is configured with baseUrl: http://YOUR_LOCAL_IP:1234/v1, contextWindow: 65536, and maxTokens: 32768. The workflow goes like this: /new, then plan.md with a plan of changes, /new again, and implementation according to the plan. Larger tasks are split by SKILL subtask4llm-pi — no more than 10 subtasks, each in a separate agent instance.

🧠 Our Take

There's nothing new in the individual components: MoE and MTP are well known, and so are GGUF quants. Our assessment — the value here is in the assembly, and in the fact that someone has finally published numbers for the most common class of cards. 16 GB is a compromise niche where you used to have to choose between model intelligence and response speed.

What this changes in practice: a local agent stops being a toy for owners of 24–48 GB cards. But the bottleneck has shifted — 65,535 tokens is not enough for agentic coding work, and the author's entire workflow with plan.md and subtasks is a workaround for that limitation, not a solution. We believe that over the next year the debates won't be about tokens per second, but about how to retain context.

The winners are owners of 16 GB cards and teams that can't send their code to the cloud. The losers, in our assessment, are cloud agents on small routine edits — there, the local loop is already comparable. A separate note on the abliterated version: it's not a feature, it's a risk, and I wouldn't put it in a production repository.

⚠️ What We Don't Know

The main thing is missing from the article — code quality. No pass@1, no SWE-bench, no comparison with the same Qwen in Q4. The speed was measured by one person on one card, and the methodology (number of runs, prompt length) isn't disclosed in the summary. Q2_K_XL is a very coarse quant, and the author doesn't show what it costs in quality. The 27.21% figure comes from a GaugeDB survey, not sales data — don't take it as a market figure.