Tiel Coder 35B-A3B is a community-made model, and it is important to say that clearly from the first line because it changes how you should read everything else on this page. It is not a new release from a company. It is an MIT-licensed GGUF quantization of Ornith AI's Ornith-1.5-35B-A3B, built by a Hugging Face contributor who goes by peculiar-ragdoll. The base model is open. The quantization and the template tweaks are the contributor's work. There is no independent benchmarking lab, no official documentation, and no published reproduction of any of the numbers below.
That does not make it worthless. The contributor has written a model card that is unusually detailed and honest about what changed and what did not. What follows is a careful summary of exactly what that card claims, flagged with what is verified against the base model and what should be treated as an unconfirmed first-party assertion. If you decide to run this model, treat the card as the primary source, not any article written about it.
The Architecture
Tiel Coder 35B-A3B is a mixture of experts model. The Hugging Face metadata lists its architecture as qwen35moe. It carries 35 billion total parameters, with roughly 3 billion active per token, which is what makes both the speed and the memory profile possible. The card explains it plainly: a 256-expert mixture routes about 8 experts per token.
The efficiency story is the real reason this kind of community quantization exists. The card reports less than 5 GB of RAM for a 262k token context at 16-bit KV precision. For agentic coding, where a model spends many turns holding a large repository in memory, that kind of headroom is what separates a model that can run on a workstation from one that needs dedicated hardware. The contributor states this is a property of the underlying Ornith-1.5 architecture, not something they invented.
The model is also multimodal, inheriting Ornith-1.5's vision tower, the base model from Ornith AI. Point it at a screenshot of a failing test, a stack trace, or a design mock, and a projector interprets it. The card is careful to separate authorship here: the projector is Ornith's own code, shipped at its original BF16 precision on every tier and passed through unmodified. The contributor changed the chat template, not the weights. That honesty about what is theirs versus what is inherited is worth paying attention to, because it tells you exactly where to place your trust.
There is one architectural detail worth flagging honestly. The original quantization tiers did not carry a multi-token prediction head because it was untrained at the time of baking. The contributor measured this rather than assuming it: every matrix in the block sat at a standard deviation of 0.020 with kurtosis of 3.00, which is indistinguishable from a fresh random initialization. That meant roughly 2.4 percent of every file was doing no work. They later re-uploaded a single trained shard, measured kurtosis of 25.1 against a 98-sigma outlier, and shipped it in a separate repository. That is a lot of care for what is, after all, a community contribution.
What Gap It Attempts to Fill
The local model space in 2026 has two persistent problems: capability that demands expensive hardware, and hardware-friendly models that feel like toys. Tiel Coder attempts the gap between them, and the attempt is honest about its tradeoffs.
The trade is deliberate. A model that activates only 3 billion of its 35 billion parameters per token pays for inference efficiency, not peak intelligence. You get speed and context headroom. You give up raw knowledge and hard reasoning, where the card says the model sits well below both the dense 27 billion parameter models and its own parent, Ornith-1.5. The card's own summary line captures it: it is the fast coder of the family, and it is cheerfully bad at trivia.
What the Card Claims About Benchmarks
Here is the part where I have to be careful on your behalf. Every number in this section comes from the contributor's own card. It has been independently verified by nobody, and the contributor measures against a small set of problems that may not represent your actual work. Treat these as first-party claims, not settled facts.
The headline claim is that on SWE-bench-Live, a set of 25 agentic coding problems, the 4-bit quantization fixes 12. The card states this matches Opus 4.6 (medium) and beats both Ornith-1.5 itself and stock Qwen3.6-35B-A3B. Its median time per attempt is reported as 8.6 minutes.
For context, here is how the card compares Tiel Coder to its direct peers. Note the measurement caveat: Tiel's numbers come from the quantizer's own evaluation, while the Qwen and Gemma figures come from their manufacturers' official cards, so they are not measured on identical harnesses.
| Model | SWE-bench Verified | SWE-bench-Live (25) | MMLU-Pro | Source |
|---|---|---|---|---|
| Qwen3.6-35B-A3B | 73.4 | Not reported | 85.2 | Qwen official |
| Tiel Coder 35B-A3B (4-bit) | Not reported | 12 of 25 (claimed) | 73.7 (claimed) | Contributor card |
| Ornith 1.5-35B-A3B (base) | Not reported | 8 of 25 | 78.0 | Contributor card |
| Gemma 4-31B | 52.0 | Not reported | 85.2 | Gemma official |
The table is more useful for what it reveals than for the raw numbers. Qwen3.6 leads on knowledge and agentic coding in the manufacturer's own benchmark. Gemma 4-31B scores equivalently on knowledge but trails hard on agentic work. Tiel Coder lands between them, closer to Ornith's parent, with a speed and memory profile the others cannot match.
The single most instructive figure is the MMLU-Pro gap, and the card is honest about why it exists. Tiel scores 73.7 at 4-bit against Nail's 84.0, and the card attributes almost all of that to inheritance rather than any design choice. Ornith-1.5 itself scores 78.0, while stock Qwen3.6-35B-A3B scores 85.3. A control quant reproduces Ornith's exact score, which means the quantization is not the cause. Tiel's sharper template buys shorter answers at the cost of about four knowledge points. That is a disclosed, deliberate trade, not a hidden flaw.
Recent Local Model Improvements
Tiel Coder sits inside a wave of changes that have made local coding models genuinely useful over the past year or so, and the card reflects several of them.
The first is the maturation of the mixture of experts format for consumer hardware. Models in the 35 billion total parameter range with a few billion active now deliver much of the capability of far larger dense models, at a fraction of the inference cost.
Quantization has become far more sophisticated. The card describes an importance matrix generated over 3,000 chunks of 512 tokens, drawn from a coding-heavy calibration corpus that is roughly three quarters Python and one quarter JavaScript. The interleaving is deliberate: the corpus leans coding while the combined slice keeps mathematics, tool-calling, and non-English text represented so those paths are not quantized carelessly. This is a marked departure from the naive per-tensor quantizations of a year ago, where entire expert categories could be silently destroyed.
The return of properly trained multi-token prediction heads is another meaningful improvement, and the card's treatment of it, measuring whether the head actually trained before shipping it, is a good example of the care this kind of community work can reach.
Harnesses It Pairs Well With
Because it is a GGUF quantization, Tiel Coder is designed to run through llama.cpp. The card recommends typical agentic sampling settings and notes that the contributor ran with more conservative settings for agentic coding. Any runtime that consumes GGUF models will work, which includes Ollama and most local inference front-ends.
For agentic coding specifically, it pairs best with harnesses that give it long context and file-edit tools. The card recommends at least q8_0 KV precision and a context between 131k and 262k tokens, which is a useful signal about how to configure the model rather than just download it. If your runtime does multi-token speculative decoding, the separate MTP repository is worth the roughly 903 MB it costs. If it does not, take the standard quantization and keep that space.
What the Card Admits It Is Not Good At
The honesty of the limitations section is one of the card's strengths, and it is worth reproducing faithfully.
The clearest limitation is knowledge. At 73.7 on MMLU-Pro, it is a coding model, not a generalist, and the gap to dense 27 billion parameter models is real and inherited. The card also warns against a common mistake: choosing the smallest quant simply to fit your VRAM. The 2-bit version costs 12.3 GB but gives up real ability and struggles with agentic coding. The recommended sweet spot is the 4-bit tier around 22 GB, snug on 24 GB of VRAM and comfortable on 32 GB.
There is a subtler limitation baked into the design. The card reports that relative to its base, Tiel answers better than it clarifies: it is up on answer quality but down on asking clarifying questions. If you would rather have a model that interrogates a vague request before acting, the base Ornith model does that better. That is a personality difference, not just a score difference, and it is exactly the kind of thing you will only learn by reading the card carefully.
Who Built It
It is worth singling out peculiar-ragdoll, the contributor who published this model, because the quality of the work is visible in every detail. The card does not just state numbers; it explains the methodology behind them. It describes how the importance matrix was calibrated, why the calibration corpus was weighted the way it was, and exactly which layers were changed and which were left identical to the upstream weights. It reports measured statistics rather than claims. It separates the contributor's own template work from Ornith's vision projector, and it discloses what it does not know.
That level of care is uncommon for a community contribution, and it is the main reason this quantization is worth reading about at all. If you run any local coding model, worth reading about the same care is a reasonable standard.
Should You Use It?
If your workflow is editing a codebase locally, Tiel Coder may well be one of the better options in its price bracket, which is essentially free beyond hardware. But the honest answer is that nobody has independently confirmed whether it earns that reputation. The card makes a credible argument, and the methodology is sound, but the numbers remain first-party claims until someone reproduces them.
If your workflow is answering exam questions or reasoning through hard general problems, this is the wrong tool regardless of verification. Pick a dense model or a knowledge-focused one for that.
For a broader sense of what is worth running locally, the Best Open-Source LLMs Right Now comparison walks through the other serious contenders in this space.
Primary source:
- Tiel Coder 35B-A3B model card on Hugging Face by peculiar-ragdoll