27× to 45× more efficient than Claude and GPT: how a fleet of 23 fine-tuned AI experts crushes the market
Published on 11 May 2026
Table des matières
reading time: 22 minutes
When you use an LLM for daily software development, you always end up hitting the same wall: the model doesn’t know your codebase. It doesn’t know that you use such ahttps://fr.wikipedia.org/wiki/Graphe_orient%C3%A9_acyclique[DAG]pattern, such a Gradle convention, or such epistemic stratification in yourhttps://fr.wikipedia.org/wiki/AsciiDoc[.adoc]files. So you inject context, you repeat, you correct, you iterate. And time — and money — slip away.
I therefore asked the question bluntly: how much would a team of models fine-tuned on my workspace cost, capable of spitting out code in my style without needing to be explained every time? And above all: how does this approach compare to classic proprietary solutions — Claude, GPT, Gemini, Grok?
The answer surprised me. Much less than I imagined. And the cost/efficiency ratio against the industry giants is indecent. Here is the full detail.
The problem: why fine-tuning instead of RAG?
RAG is good. My knowledge graph and my epistemic compartmentalization work. But RAG has a fundamental flaw: with every request, you must re-inject the relevant context. Your prompt grows, your latency explodes, and the model never internalizes your patterns — it reads them every time as an external document.
Fine-tuning, on the other hand, is muscle memory. The model knows that you write`build.gradle.kts`with tasks recorded via`tasks.register`, that your`AGENTS.adoc`follow a standardized syntax, that your workspace is structured in boroughs. It doesn’t need to be reminded.
|
Fine-tuning is not a replacement for RAG. It is a complementary layer. RAG remains relevant for data that changes often (logs, tickets, recent commits). Fine-tuning is for long-term structural and stylistic knowledge. |
The idea: a fleet of experts, not a single model
A single model fine-tuned on my entire workspace is already good. But it’s suboptimal. My workspace covers very different domains:
-
Gradle plugins (Kotlin, convention plugins, composite builds)
-
DAG Engine (Kotlin, scheduling, execution)
-
LLM Agents (Python, LangChain4j, RAG)
-
Architectural documentation (AsciiDoc, governance)
-
Infra/DevOps (Docker, GitHub Actions, CI/CD)
A single model should be good everywhere, excellent nowhere. The solution? Afleet of specialized models, with an orchestrator that routes each request to the right expert.
Total fleet:1 orchestrator + 22 experts = 23 models. And the monthly inference cost?€17/monthon an annual Ollama Pro subscription — expandable by stacking accounts if quotas are exceeded, as demonstrated in my multi-account Docker method. We start at €17, then add €20 per tier based on actual need. No waste.
Codebase under the microscope: 7,900 files, 144,000 lines
Before estimating training costs, we need to know what to train. I audited my workspace by rigorously excluding everything ignored by Git:
----
build/ out/ node_modules/ runtimes/ .gradle/ dist/
target/ venv/ __pycache__/ .cache/ .tox/
----
Here is the result for tracked files only:
[cols="2,2"]
|===
|Metric |Value
|Tracked source files |**7,896** |Lines of code (LOC) |**143,805** |Git repositories |**26** |Main languages |Kotlin (1,903), AsciiDoc (2,765), Python (5,029)
|===
[IMPORTANT]
====
These 5,000+ Python files include`runtimes/`from notebooks and utility scripts. The application core (Gradle plugins, DAG engine, agents) is primarily in Kotlin and AsciiDoc.
====
From this mass, I estimate I can generate a synthetic dataset of**~170 million tokens**via an instructor LLM (distillation of the codebase into instruction/response pairs).
=== Dataset detail by expert type
[source,text]
----
Dataset maître (généraliste V4-Flash) : 50M tokens
Expert Gradle/Build : 15M tokens
Expert Kotlin/DAG : 15M tokens
Expert AsciiDoc/Gouvernance: 15M tokens
Expert Agent/LLM/Python : 15M tokens
Expert Infra/CI-CD : 15M tokens
Micro-experts Qwen/Gemma : ~5M tokens chacun
----
== Choosing the models: 100% MoE, zero dense
This is where the architecture becomes truly efficient.
A *dense* model activates all its weights for every token. An *MoE* (Mixture of Experts) model only activates a fraction of its parameters. The inference cost — and fine-tuning cost — is proportional to the**activated**parameters, not the**stored**parameters.
Let's look at what the market offers in MoE today on Ollama Cloud:
[cols="3,2,2,1,3"]
|===
|Model |Total params |Activated |Activation |Ollama Cloud
|DeepSeek V4-Pro |1.6T |49B |3.1% |✅ native |DeepSeek V4-Flash |292B |13B |4.5% |✅ native |Gemma 4 26B-A4B |26B |3.8B |14.6% |✅ native |Qwen3.6-35B-A3B |35B |3B |8.6% |❌ (not yet integrated) |Qwen3.5-35B-A3B |35B |3B |8.6% |✅ native
|❌ Qwen3.5-27B |27B |27B |100% dense |eliminated |❌ Qwen3.5-4B/9B |4B/9B |4B/9B |100% dense |eliminated |❌ Gemma 4 31B |31B |31B |100% dense |eliminated
|🧪 Gemma 4 E2B/E4B |5B/8B |5B/8B |100% dense |validation pipeline
|===
[CAUTION]
====
The activation ratio is the discriminating criterion. A Gemma 4 26B-A4B only activates 3.8B of its 26B parameters — that's 7× less than a dense 27B, for comparable coding agent performance (77.1% vs 80% on LiveCodeBench v6).
====
=== Why I'm abandoning dense models
The exception: Gemma 4 E2B and E4B. These two models, under Apache 2.0, are perfect for testing and validating a training pipeline at a lower cost. A 2-3h run on an E2B costs less than $5 — if the dataset or hyperparameters are faulty, we know it for a few dollars. Once the pipeline is dialed in, they can even be used for ultra-micro tasks (trivial reformatting, binary classification). But for the main fleet experts, I'm sticking with MoE. Here's why:
.But not only: Gemma 4 E2B/E4B, experts in fine anonymization
[NOTE]
====
Google designed these small models to be competitive in native tool calling — they know how to call functions, manipulate regex, and search for patterns. Once fine-tuned on anonymization examples (emails, tokens, UUIDs, file paths), they become ultra-fast**dataset anonymizers**. We feed them a block of raw text, they call`sed`/`regex`via a tool call and return the cleaned block. The inference cost is negligible: 5B activated, it fits on a single entry-level GPU. These models are not business experts — they are**specialized workers**in the dataset production chain.
====
* Its training VRAM (even in QLoRA) is proportional to the**27B total**
* Its training time is proportional to the**27B activated**
Let's compare with a Qwen3.6-35B-A3B (MoE):
[cols="3,2,2,2"]
|===
| |Qwen3.5-27B (dense) |Qwen3.6-35B-A3B (MoE) |Ratio
|VRAM QLoRA |~55 GB |~35 GB |1.6× |GPU-hours (8M tok) |~12h |~4h |**3×** |Cost per fine-tune |~$24 |~$8 |**3×** |SWE-bench Verified |75.0% |73.4% |comparable
|===
MoE costs 3× less to train for agent-coding performance within 5%. Across 22 experts, the gap amounts to thousands of euros.
== Training estimation: 811 H100-hours
I broke down the training cost model by model, in 4-bit QLoRA, with the datasets described above.
=== Lightweight MoE micro-experts (3-3.8B activated)
These models require 1 H100 (80 GB) per run. Model VRAM in Q4 is around 13-18 GB, leaving plenty of room for LoRA optimizer states and activations.
[cols="4,2,3,2"]
|===
|Model |Nb of runs |GPU-h/run |Total GPU-h
|Gemma 4 26B-A4B-FT |6 |3.5 h |**21 h** |Qwen3.6-35B-A3B-FT |5 |4.0 h |**20 h** |Qwen3.5-35B-A3B-FT |5 |4.0 h |**20 h** |*Micro subtotal* | | |*61 h*
|===
=== V4-Flash Executives (13B activated / 292B stored)
DeepSeek V4-Flash is a special case. Even though only 13B are activated per token, the full model in Q4 weighs ~142 GB — all experts must be in VRAM during training. Thus,**3× H100**per run is needed to be comfortable.
[cols="4,2,3,3,2"]
|===
|Model |Dataset |GPUs |Hours |Total GPU-h
|V4-Flash Generalist-Base |50M tok |3× H100 |50 h |**150 h** |V4-Flash expert ×5 |15M tok |3× H100 |40 h |**600 h** |*Executive subtotal* | | | |*750 h*
|===
[cols="3,2,1"]
|===
|**TOTAL** | |**811 H100-h**
|===
[NOTE]
====
For comparison, a full fine-tune of V4-Flash (without QLoRA, all weights) would cost ~4,000 H100-h just for the 6 models. QLoRA divides the cost by 5. It is the only way to make the project economically viable at this scale.
====
=== GPU Rates: who rents what in May 2026
I benchmarked the main H100 providers. The list price, for 811 hours.
[cols="3,2,2,2"]
|===
|Provider |$/H100·h |Total 811h |Reliability
|**Vast.ai spot** |$1.60 |**$1,298** |★★☆ interruptible |**Crusoe Cloud** |$2.00 |**$1,622** |★★★★ reliable datacenter |FluidStack |$1.98 |$1 606 |★★★ |TensorDock |$1.80 |$1 460 |★★☆ |RunPod |$2.29 |$1 857 |★★★ good compromise |CoreWeave |$2.25 |$1 825 |★★★★ corporate |Lambda Labs |$2.49 |$2 019 |★★★★ premium
|===
[TIP]
====
Vast.ai spot is the cheapest but your runs can be interrupted at any time. For training, that's risky. Crusoe at $2.00/h is the best reliability/price ratio. The $324 surcharge vs Vast is worth the peace of mind.
====
=== Wall-clock: how long to train everything?
With a single 3× H100 node, the 31 runs (1 generalist + 30 experts) take about**12 days**sequentially. If you rent 2 nodes in parallel, it drops to**6 days**.
In practice, micro-experts can run on separate nodes (1 H100 each) while the V4-Flashes occupy the 3× H100 node. With smart planning:Nœud A (3× H100) : V4-Flash généraliste → V4-Flash experts ×5 (11 jours) Nœud B (1× H100) : Gemma 4 26B ×6 → Qwen 36 ×5 → Qwen 35 ×5 (6 jours)
7 days of rental, all done.
Inference: 23 models on Ollama Cloud from €17/month
This is the most elegant part of the architecture.
Ollama Cloud allows uploading private models (Pro plan feature). My 22 fine-tuned models are pushed as`.gguf`to my Ollama space, marked as private, and accessible via the standard API.
Start at €17/month, scale if needed
The Ollama Pro plan (€17/month annually) allows 3 concurrent cloud models. In this architecture, I never need more than 2-3 experts simultaneously:
-
The classification phase (V4-Pro) occupies 1 slot, for a few seconds
-
The targeted expert occupies 1 slot, for the time it takes to generate its response
-
The 3rd slot remains in reserve for parallel tasks
If usage increases, I add additional Pro accounts via the Docker method described in my article on stacking subscriptions. No €100/month Max plan — I only add what I actually need.
The only limiting factor is the monthlyGPU-time quotaof Ollama (50× the free plan for Pro). For my usage of a few hundred requests per day, this is more than enough.
|
The marginal cost of a call to V4-Pro (49B activated) vs Gemma 4 26B-A4B (3.8B activated) is thesame for me: zero. It’s the Ollama flat rate that absorbs the compute difference. My only indicator is latency. |
Routing in practice
----
Volume de requêtes estimé : ~500/jour
├─ 50% → Gemma 4 26B-A4B-FT (micro, 3.8B actifs)
│ Formatage AsciiDoc, scripts simples, conventions nommage
│
├─ 25% → V4-Flash-FT (exécutif, 13B actifs)
│ Plugins Gradle, refactoring Kotlin, génération DAG
│
├─ 15% → Qwen 35B MoE-FT (micro, 3B actifs)
│ Tâches intermédiaires, review de code, documentation
│
└─ 10% → V4-Pro (orkestrateur, 49B actifs)
Décisions architecturales, refactoring transverse,
problèmes vraiment nouveaux
----
The bulk of the traffic goes through the small ones. The big model only intervenes as a last resort.
== The painful comparison: Claude, GPT, Gemini, Grok vs my fleet
This is where the gap becomes dizzying. Let's look at what the same volume of work (500 requests/day, ~300 input tokens + 2,000 output tokens on average) would cost with the market's proprietary solutions in May 2026.
=== Anthropic — Claude (May 2026 rates)
Anthropic recently *lowered* its prices. The pressure from open-weight solutions like DeepSeek and Qwen is being felt.
[cols="3,2,2,2,2"]
|===
|Model |Input $/MTok |Output $/MTok |Cost/day |**Cost/month**
|Opus 4.7 (most intelligent) |$5 |$25 |$25.75 |**$772** |Sonnet 4.6 (balanced) |$3 |$15 |$15.45 |**$463** |Haiku 4.5 (fastest) |$1 |$5 |$5.15 |**$154**
|===
[CAUTION]
====
These rates are *after* Anthropic's latest price drop (May 2026). Before that, Opus was at $15/$75 per MTok. The fear of open-weight is real.
====
Even the cheapest Claude model — Haiku 4.5 at**€154/month**— costs 9× more than my €17 Ollama Pro subscription. And Haiku doesn't know my codebase, doesn't generate in my style, and requires systematic prompt engineering.
The most intelligent — Opus 4.7 — blows the budget at**€772/month**for a modest volume of 500 requests per day. That is**45× more expensive**than my solution.
=== OpenAI — GPT (May 2026 rates)
[cols="3,2,2,2,2"]
|===
|Model |Input $/MTok |Output $/MTok |Cost/day |**Cost/month**
|GPT 5.5 (most intelligent) |$5 |$30 |$30.90 |**$927** |GPT 5.4 (standard) |$2.50 |$15 |$15.45 |**$463** |GPT 5.4 Mini |$0.75 |$4.50 |$4.64 |**$139**
|===
Even OpenAI's "economical" model — GPT 5.4 Mini at €139/month — costs 8× my subscription, for a model that knows *nothing* of my conventions and requires heavy prompt engineering.
GPT 5.5, their flagship:**€927/month**. For *zero-shot* on my codebase. With 2-3 iterations per task due to unmastered style, the real monthly cost easily doubles.
=== Google — Gemini (May 2026 rates)
[cols="3,2,2,2,2"]
|===
|Model |Input $/MTok |Output $/MTok |Cost/day |**Cost/month**
|Gemini 3.1 Pro (High) |$3.50 |$17.50 |$18.00 |**$540** |Gemini 3.1 Pro |$2 |$10 |$10.30 |**$309** |Gemini 3 Flash |$0.30 |$1.50 |$1.54 |**$46**
|===
Gemini 3 Flash at €46/month is competitive in pure price — but without fine-tuning, it generates "generic" code. Not *Cheroliv* code.
=== Grok — xAI (May 2026 rates)
[cols="3,2,2,2,2"]
|===
|Model |Input $/MTok |Output $/MTok |Cost/day |**Cost/month**
|Grok 4 |$4 |$16 |$16.48 |**$494** |Grok 4 Mini |$0.80 |$3.20 |$3.30 |**$99**
|===
=== Microsoft — Azure OpenAI (May 2026 rates)
Azure applies the same prices as the direct OpenAI API, but additionally charges for infrastructure and network. A 10-20% surcharge for the managed service should be expected.
[cols="3,2,2,2,2"]
|===
|Model |Input $/MTok |Output $/MTok |Cost/day |**Cost/month**
|GPT 5.4 (Azure, Global) |$2.50 |$15 |$15.45 |**$463** |GPT 5.4 + infrastructure |15% surcharge |15% surcharge |$17.77 |**$533**
|===
[NOTE]
====
The rates above concern the API, not "chat" subscriptions (Claude Pro at $20/month, ChatGPT Plus at $20/month). We are comparing *developer* usage here, where you chain hundreds of requests per day via API to generate, refactor, and document. Consumer subscriptions have quotas that are hit long before 500 requests/day.
====
=== The final comparative table
[cols="3,2,2,2,2,2"]
|===
|Solution |Codebase Knowledge |Integrated Style |Cost/month |Iterations |**Effective Cost**
|**My fleet (Ollama Pro)** |✅ Fine-tuned |✅ In the weights |**€17** |0-1 |**€17** |Claude Opus 4.7 |❌ Zero-shot |❌ Prompt required |$772 |2-3 |$1 500-2 300 |Claude Haiku 4.5 |❌ Zero-shot |❌ Prompt required |$154 |3-4 |$460-615 |GPT 5.5 |❌ Zero-shot |❌ Prompt required |$927 |2-3 |$1 854-2 781 |GPT 5.4 |❌ Zero-shot |❌ Prompt required |$463 |2-3 |$925-1 390 |GPT 5.4 Mini |❌ Zero-shot |❌ Prompt required |$139 |3-5 |$417-695 |Gemini 3.1 Pro High |❌ Zero-shot |❌ Prompt required |$540 |2-3 |$1 080-1 620 |Grok 4 |❌ Zero-shot |❌ Prompt required |$494 |2-3 |$988-1 482 |**Azure GPT 5.4** |❌ Zero-shot |❌ Prompt required |$533 |2-3 |$1 066-1 600
|===
[plantuml, cost-comparison, svg]
----
@startuml
skinparam backgroundColor #FAFAFA
title Rapport coût/efficacité — ma flotte vs le marché (mai 2026)
rectangle "17€/mois" as OURS #4ECDC4
rectangle "Opus 4.7\n772€" as OPUS #FF6B6B
rectangle "Sonnet 4.6\n463€" as SONNET #FF8B94
rectangle "GPT 5.5\n927€" as GPT #FFD93D
rectangle "Gemini 3.1 Pro\n540€" as GEMINI #6C5CE7
rectangle "Grok 4\n494€" as GROK #A8E6CF
rectangle "Haiku 4.5\n154€" as HAIKU #DFE6E9
rectangle "GPT 5.4 Mini\n139€" as MINI #B2BEC3
note bottom of OURS
Avec fine-tune intégré.
Zéro prompt engineering.
90%+ first-shot correct.
end note
@enduml
----
€17/month for 23 fine-tuned AI experts. The flagship Claude Opus 4.7 costs**45× more**for inferior quality on *my* codebase. GPT 5.5 costs**54× more**. Even the cheapest model on the market (Gemini Flash at €46) costs**2.7× more**without knowledge of my workspace.
The verdict is final: fine-tuning on MoE architectures in 2026 is not just "cheaper." It is an efficiency factor of**27× to 54×**on the cost/quality ratio compared to proprietary solutions. Anthropic, OpenAI, Google — they all know it, and that's why they are lowering their prices in panic.
== Efficiency factor: 5-8× vs using V4-Pro alone
Let's compare the two extremes.
=== Scenario A: V4-Pro alone for everything
[cols="3,2"]
|===
|Metric |Value
|Codebase Knowledge |0 (zero-shot) |Naming Convention |40-60% first-shot correct |Prompt Engineering Required |Yes, systematic |Iterations per task |2-3 |Inference Cost |$100/month (Ollama Max) |Average Latency |~20 tok/s + network
|===
=== Scenario B: Orchestrated MoE Fleet
[cols="3,2"]
|===
|Metric |Value
|Codebase Knowledge |Integrated (fine-tune) |Naming Convention |90-95% first-shot correct |Prompt Engineering |No (style is in the weights) |Iterations per task |0-1 |Inference Cost |$60/month (3× Ollama Pro) |Average Latency |~50 tok/s (light models)
|===
[cols="4,2,2,2"]
|===
|Dimension |V4-Pro alone |MoE Fleet |Factor
|Monthly cloud cost |$100 |**$60** |1.7× |Context to inject |High (prompt) |**Zero** |∞ |Average iterations |2-3 |**0-1** |2-3× |Perceived latency |20 tok/s |50 tok/s |**2.5×** |First-shot correct |50% |90%+ |**1.8×**
|===
**Overall efficiency factor: 5-8×**— in perceived developer productivity.
[NOTE]
====
The factor is not measured in tokens or dollars. It is measured in "how much time I spend explaining to the model what it should already know." With fine-tuned models, this time tends toward zero.
====
== The complete budget: a one-shot investment, a ridiculous flat rate
[cols="3,2"]
|===
|Item |Amount
|Training GPU (811 H100-h, Crusoe $2/h) |**$1,622** |Synthetic dataset generation (LLM API) |**$400** |Inference (Ollama Pro annual, $17/month) |**$204** |**Total first year** |**$2,226** |**Monthly equivalent** |**$186** |**Estimated cost per request** |< $0.01
|===
[plantuml, budget-breakdown, svg]
----
@startuml
skinparam backgroundColor #FAFAFA
rectangle "Budget Année 1 : $2 226" as Total #E8E8E8 {
rectangle "Training GPU\n$1 622 (73%)" as Train #FF6B6B
rectangle "Dataset\ndistillation\n$400 (18%)" as Data #FFE66D
rectangle "Ollama Pro\n$204 (9%)" as Cloud #4ECDC4
}
note bottom of Total
$186/mois équivalent année 1.
Dès l'an 2 : $17/mois.
Amorti par ~$235 de CA
mensuel avec marge 95%.
end note
@enduml
----
$186/month the first year,**$17/month**starting year 2. The price of a premium Netflix subscription, for a team of 23 AI experts available 24/7, writing code *in my style* without me needing to explain my conventions.
=== Profitability calculation
With edster.cloud and its margin of ~95%, the break-even point is at**~$2,340 in additional revenue**over the year. In practice:
* 1 software steering mission → $3,000-5,000 → investment covered + profit
* 1 corporate training → $5,000-10,000 → comfortable
* Implicit upsell: "my AI team masters my software forge" → commercial differentiator
From year 2, training is no longer paid (unless the dataset is updated). The annual cost drops to**$204**($17/month). The cost/value ratio is that of a unicorn: almost zero.
== Limits of the exercise
This remains a *rough estimate*. Several variables can shift the budget:
[cols="2,3"]
|===
|Variable |Impact
|Synthetic dataset generation |If the distillation API fails (hallucinations, poorly formed pairs), human time is needed for curation. Hidden cost. |Ollama GPU-time Quotas |If usage exceeds Pro plan quotas, an upgrade or switch to dedicated GPU will be necessary. |Effective quality of fine-tunes |A failed fine-tune → must be redone. The real risk is hyperparameters, not GPU rental. |Rapid model evolution |Qwen3.6/Gemma 4 were released < 1 month ago. In 6 months, the next generation will be better AND cheaper to fine-tune.
|===
[WARNING]
====
Do not launch 811 hours of training without first testing the pipeline on *a single* micro-model. A 3-4h run on a Qwen 35B-A3B costs $8. If the dataset is garbage, you'll know for $8, not for $1,622.
====
== Conclusion: fine-tuning has become an accessible luxury
A year ago, fine-tuning a 292B parameter model (even in QLoRA) was a research project. Today, in May 2026, it's a feasible project for an independent developer:
* **811 H100-hours**of training — $1,622 at Crusoe
* **23 specialized models**loaded on Ollama Cloud —**$17/month**
* **0 servers, 0 local GPUs, 0 infra maintenance**
Democratization came from three convergent factors:
1. **MoE architectures**— which allow efficient fine-tuning of models where only a fraction of weights are activated
2. **Ollama Cloud flat plans**— which transform a variable cost (per-token) into a fixed cost (subscription)
3. **High-quality open-weight models**— DeepSeek V4, Qwen3.6, Gemma 4 are under MIT/Apache 2.0 licenses
"Civilization advances by extending the number of important operations which we can perform without thinking about them."
Fine-tuning is exactly that: an operation you delegate to the machine so you no longer have to think about it. And in 2026, it costs less than a salaried junior developer.
---
_Article published on {jbake-date}_
== Fine-tuned models of the fleet
[cols="2,2,2,2,3"]
|===
|Activated size |Number |Base model |Domain |Dataset
|13B |1 |DeepSeek-V4-Flash-Base |General workspace |50M tokens |13B |5 |DeepSeek-V4-Flash |Gradle, Kotlin, DAG, Doc, Infra |15M tokens |3.8B |6 |Gemma 4 26B-A4B |Micro-tasks, formatting, scripts |5M tokens |3B |5 |Qwen3.6-35B-A3B |Refactoring, review, intermediate doc |5M tokens |3B |5 |Qwen3.5-35B-A3B |Legacy tasks, compatibility |5M tokens
|===
== Resources
=== Open-weight models on HuggingFace
* https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash-Base[DeepSeek V4-Flash-Base — 292B params, MIT license]
* https://huggingface.co/Qwen/Qwen3.6-35B-A3B[Qwen3.6-35B-A3B — 35B/3B activated, Apache 2.0 license]
* https://huggingface.co/Qwen/Qwen3.5-35B-A3B[Qwen3.5-35B-A3B — 35B/3B activated, Apache 2.0 license]
* https://huggingface.co/google/gemma-4-26B-A4B-it[Gemma 4 26B-A4B — 26B/3.8B activated, Apache 2.0 license]
=== Pricing sources (May 2026)
* https://ollama.com/pricing[Ollama Cloud rates — Pro plan $17/month annual]
* https://www.anthropic.com/pricing[Anthropic rates — Claude API (Opus 4.7 $5/$25, Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5)]
* https://openai.com/api/pricing/[OpenAI rates — GPT API (GPT 5.5 $5/$30, GPT 5.4 $2.50/$15)]
* https://deepinfra.com/pricing[DeepInfra rates — GPU instances H100 $1.79/h, B200 $2.79/h]
* Vast.ai, Crusoe Cloud, FluidStack, TensorDock, RunPod, CoreWeave, Lambda Labs — manual price checks, dated May 2026
=== Official announcements
* https://qwen.ai/blog?id=qwen3.6-35b-a3b[Official Qwen3.6-35B-A3B announcement — Qwen blog]— agentic coding, Apache 2.0, 262K context