The lab

Key features

• Mixture of experts: 3.8B of 25.2B parameters active per word
• Reads images as well as text
• Reasoning mode that can be switched on or off
• Apache 2.0 licence, so it can run fully on premises

Where a business would use it

• Pull fields out of invoices, forms and contracts into structured data. It got every field right on my 24-document test, at a median of 0.89 seconds a document, the fastest of the models I ran.
• First-line triage in a tiered AI set-up, with harder cases passed up. It is the first rung of my model ladder because it is quick and passed both of my coding checks.
• High-volume classification and summaries where data must stay inside the company. It runs locally at roughly 87 to 115 tokens a second, with no per-token cloud bill.

How it was trained

Google DeepMind built it as a mixture of experts: many small expert blocks, with only a few used for each word. I run a 4-bit build that was trained with that compression in mind, and I have not fine-tuned it.

Learning after deployment

No. Its weights never change once released.

Key features

• Dense 27B model under an Apache 2.0 licence
• Compressed to 3.5 bits per weight, yet the compression card reports no score loss on three benchmarks
• Optional draft model that speeds up decoding
• Four builds compared directly on the same tests

Where a business would use it

• Data extraction where the answer has to be right every time. It got all 120 fields right on my golden set in every build, at 11 to 18 seconds a document.
• Reasoning over long internal documents on one workstation. The compressed build keeps dense 27B quality in under 12 GB.
• Testing how far a model can be compressed before it loses accuracy. Four builds of one model let a team see the cost of each step on its own tasks.

How it was trained

Alibaba trained it as a dense model, where all 27B parameters work on every word. ISTA-DASLab, not me, compressed the smaller build afterwards. I ran four released builds side by side and compared them.

Key features

• Dense 29.6B model with a built-in vision encoder
• Distilled from a larger Meta model
• Best LiveCodeBench subset score of any local model I ran
• About 27 to 29 tokens a second

Where a business would use it

• Harder reasoning and multi-step planning that must stay on the company network. It had the highest coding pass count of any local model I ran, 22 of 30.
• Reviewing documents or screenshots where images and text are read together. Image input is built in.
• Overnight or batch analysis where quality matters more than speed. It got every extraction field right, at a median of 32.31 seconds a document.

How it was trained

Meta distilled it from a larger model of its own, Muse Spark, which is how a 30B model gets scores usually seen from bigger ones. I run it as released and have not trained it.

Key features

• 2.3B effective parameters, so it fits in a few GB of memory
• Extra per-layer embeddings get more out of few parameters
• Apache 2.0 licence
• Text only in my tests

Where a business would use it

• Always-on classification or routing of short messages on a laptop or edge device. It is small and fast and needs no network.
• A cheap pre-screen that decides whether a request needs a bigger model. It is quick enough to run on every request at almost no cost.
• Offline help for field staff with no connection. It is small enough for a standard work laptop.

How it was trained

Google DeepMind built it as a small dense model for devices. I run it as released and have not trained it. Against the 26B sibling it gave up 7 coding tasks of 30 in my run.

Key features

• Sparse mixture of experts: 6B active out of 125B
• Coder build prunes half of the experts and uses 1.89 bits per original parameter
• Full marks on my extraction test in both builds
• Removed from my serving set at the clean-up

Where a business would use it

• Large-model coding quality on a single workstation. The compressed Coder build passed 18 of my 30 coding tasks.
• Testing extreme compression before buying bigger hardware. It shows whether a frontier-size model survives heavy pruning on your own task.
• Document extraction with a quick turnaround. It got all 120 fields right at about 8 to 10 seconds a document.

How it was trained

Alibaba trained the sparse model. ISTA-DASLab made the Coder build by pruning half the experts and quantising the rest. I ran the released builds and did not change the weights.

Key features

• About 304B parameters under an MIT licence
• Strong agent and terminal results on its card
• About 27 tokens a second on local hardware
• Retired from my serving set

Where a business would use it

• Judging whether frontier-scale open weights can run privately. It showed what a model of this size does on one high-memory workstation, at heavy compression.
• Agentic terminal and automation tasks. The maker reports 82.7 on Terminal Bench 2.1.
• Policy or contract analysis that needs a long chain of reasoning. Large model, long context, and an MIT licence.

How it was trained

DeepSeek released it as a very large mixture of experts. I ran a compressed build as released. Speed and memory, not quality, were the limit.

Key features

• 30B total, 3B active parameters
• 92.56 tokens a second on the hard coding problem
• Only 3 of 24 extraction documents came back as usable data
• Retired at my October clean-up

Where a business would use it

• Fast chat-style assistants where strict output formats are not needed. Speed is its strength.
• Showing why format reliability has to be tested before deployment. It did well on coding and still failed structured extraction, so one benchmark is never enough.
• Science and knowledge question answering. The maker reports 81.94 on MMLU Pro.

How it was trained

NVIDIA built it for throughput. I ran a 4-bit build as released. In my tests the speed came at the cost of reliable structured output.

Key features

• 320B total, 18B active
• Extreme 1-bit-class compression
• About 26 tokens a second
• Hard coding problem returned no code block

Where a business would use it

• Capacity planning: will frontier-scale open weights fit on workstation hardware. One experiment shows the practical floor for memory and speed.
• Feasibility studies for on-premises large-model deployment. It shows that a 320B model can be loaded locally, with a quality trade-off.
• Compression research. It is a worst-case data point for how far quantisation can go.

How it was trained

Z.ai built it as a very large sparse model. I ran a community build compressed to about 1 bit per weight, as released, to find the limit.

Key features

• 0.5B parameters, 8-bit build
• All 25 layers on the graphics card
• Used to confirm probability output before larger jobs

Where a business would use it

• Infrastructure smoke tests before committing GPU time. It loads in seconds and exercises the whole stack.
• Very cheap text classification or formatting on commodity GPUs. It is tiny and fast.
• A prototype of an on-premises assistant for low-stakes tasks. It runs on a consumer graphics card.

How it was trained

Alibaba released it as a small instruction-tuned model. I used it only as a test fixture, chosen for its size and not its quality, and did not train it.

Key features

• Coding-focused mixture of experts: 80B total, 3B active
• About 86 to 94 tokens a second on local hardware
• My default local coding model
• Passed both of my coding problems in full

Where a business would use it

• First-draft bug fixes and small features in an internal codebase, reviewed by an engineer. It is my best local score on repository bug fixing, 24 of 63 SWE-bench tasks, at a speed that suits interactive work.
• Code review and unit-test generation on code that cannot leave the company. It runs on premises and passed all 15 hidden tests on my two coding problems.
• Migration and refactoring chores such as API upgrades and renames. It handles tool use and long files well for its size.

How it was trained

Alibaba built it as a mixture of experts specialised for coding and tool use. I run it as released.

Learning after deployment

No. The model itself does not learn.

Key features

• 24B dense model aimed at software-engineering agents
• Apache 2.0 licence
• Passed the hard coding problem 8 of 8, but only 3 of 7 on the easy one
• About 32 to 35 tokens a second on local hardware

Where a business would use it

• Agentic code exploration across a large repository. Mistral built it for tool-driven code navigation, so it is useful as a second opinion beside a stronger coder.
• The back end of an internal coding assistant on one workstation. A 24B dense model fits on a single high-memory workstation or large GPU.
• Fact-check style tasks where the model must push back on a wrong premise. In one earlier role test it was the only model that refused a false premise. That was a single test, not a benchmark.

How it was trained

Mistral trained it as a dense model for agentic coding, not as a general chat model. I run it as released.

Key features

• About 0.96B parameters
• Reads text, tables, formulas and charts from page images
• Median of 1.5 seconds a page on local hardware
• Runs fully on premises

Where a business would use it

• Digitising scanned invoices, forms and archives. It is small enough to run on every page without a cloud OCR bill.
• A pre-processing step before an extraction model. It turns page images into text so a language model can pull out fields.
• Regulated document handling where pages cannot leave the network. All inference stays local.

How it was trained

Baidu built it as a purpose-built document reader, not a general chat model, which is why it is far smaller than the others. I use it as released.

Key features

• Takes images and text together
• Two sizes: 30B with 3B active, and 4B dense
• Served locally, with no cloud calls
• Apache 2.0 licence

Where a business would use it

• Reading screenshots and screen state for process-automation agents. Image input lets an agent see the screen.
• Describing and tagging product or document images. It runs locally, so the images stay on the network.
• Answering questions about charts and diagrams. It is built for vision-language work.

How it was trained

Alibaba added a vision encoder to the Qwen3 language model. I use it as released and have not trained it.

Key features

• Reads images and picks from fixed options with probabilities
• The 8-bit build gives the same answer as full precision 99 times in 100
• Ran a batch of 11,688 images with no errors
• Apache 2.0 licence

Where a business would use it

• Sorting and tagging large image or document collections. My batch put 11,688 images into 13 categories with no errors, at 1.30 images a second.
• Visual quality control and inspection triage. Options with probabilities suit pass, fail and review thresholds.
• Moderation of user-uploaded images. Calibrated probabilities let a team set its own review thresholds.

How it was trained

It is a LoRA adapter on Qwen3.8-27B, trained on a distilled decision set and merged into GGUF builds by Atlas3D. I used the 8-bit build, which matches full precision 99 times in 100. The 4-bit build matched only about 93 times in 100, so I avoided it. I needed a patched readout in llama.cpp, and I did no training.

Key features

• Gemma 4 12B base with a merged fine-tune, Apache 2.0
• Also handles ordinary chat and image input
• Strong on my YouTube early-signal test
• 247 milliseconds median per answer

Where a business would use it

• Decision scoring where text and images both matter. It accepts image input, which most small decision models do not.
• Calibrated triage with an explicit confidence. It returns a probability for every option.
• A comparison baseline when choosing a decision model. Public JevBench figures let a team check it against their own data.

How it was trained

EldanRing fine-tuned Gemma 4 12B for typed decisions, chat and image input, and the GGUF files hold the merged result. I evaluated the 8-bit build only and did not train it.

Key features

• Typed questions: choice, score and true or false
• Large size is a merged LoRA on Gemma 4 31B, Apache 2.0
• Also tuned for Vietnamese
• Large and Medium measured on the same tests

Where a business would use it

• Multilingual intent and ticket triage. The card states English plus Vietnamese tuning, with other languages at lower accuracy.
• Calibrated scoring of text for review queues. It returns a probability for every option.
• Choosing a model size by accuracy and latency. I measured Large at 270 ms and Medium at 287 ms on the same tests.

How it was trained

It is Gemma 4 31B with a merged LoRA fine-tune and a letter-readout decision prompt, built for calibration. I evaluated both sizes and did not train either.

Key features

• No generated text
• Multi-task: classification, routing and scoring
• Newer v3 adds image input; I tested v2.1
• Apache 2.0 licence

Where a business would use it

• Routing and classification inside business software. It is called like a function and returns a probability.
• Content scoring from early signals. The 4B v2.1 model reached 0.9624 AUC on my YouTube early-signal test.
• Low-latency screening of high-volume text. I measured a median of 43.2 ms for the 2B and 86.4 ms for the 4B.

How it was trained

Both models are small Qwen3.5 base models trained for typed one-pass decisions. They are generalists, and they did not transfer to my Hacker News test. I evaluated them and did not train them.

Key features

• 2 to 16 options per question
• One pass, no generated tokens
• A single fitted temperature for calibration
• Apache 2.0 licence

Where a business would use it

• Multiple-choice decisions with evidence, such as case review and policy lookup. It is built for evidence plus options.
• Quick calibrated triage on commodity GPUs. The card reports about 28 ms median on a consumer card.
• Hard cases where a base decision model is unsure. Training weighted up the hard and uncertain questions.

How it was trained

It is a fine-tune of a base decision model on hard cases written and double-checked by Qwen3.8-27B, with wrong or uncertain questions weighted up. The training set comes from cases a weaker model got wrong. I evaluated it and did not train it.

Key features

• LoRA adapter on Qwen3.5-2B-Base
• Trained across about 30 public classification datasets
• Apache 2.0 licence
• Median of 42.3 ms on my test

Where a business would use it

• Intent, sentiment and topic classification for customer messages. Its training data covers these tasks.
• Spam and abuse screening. The card lists spam and hate-speech datasets in training.
• A cheap first pass at labelling text. It was quick in my test, at a median of 42.3 ms.

How it was trained

It is a LoRA adapter on a Qwen3.5 2B base across many small public tasks: breadth over depth. I evaluated it and did not train it.

Key features

• Never generates text, so there is nothing to parse
• Reads up to 8,192 tokens
• More than 100 languages
• Fastest model I compared: 16.1 ms median

Where a business would use it

• Multilingual ticket and email routing. The card says it covers more than 100 languages.
• Moderation and guardrail checks. One pass, no text to parse, and very low latency.
• Scoring and classification at very high volume. It had a median of 16.1 ms in my test.

How it was trained

It was trained with reinforcement learning against proper scoring rules, so it is rewarded for being well calibrated rather than only for matching labels. I evaluated it and did not train it.

Key features

• Finds the start and end times of a described moment
• Answers multiple-choice video questions
• My llama.cpp port matches the PyTorch original to 0.99991 on questions
• Good on visual events, poor at reading small on-screen text

Where a business would use it

• Searching training, meeting or call archives for the moment a topic appears. It returns a time range for a plain-English query.
• Quality checks on produced video: does the cut show what the script says. On a 43.7-second test video it located 11 of 12 moments and got 4 of 4 questions right.
• Automatic chaptering of long screen recordings. It found visual events well, though it missed cues that exist only as text.

How it was trained

Nanjing University fine-tuned Qwen3.5-4B to score time ranges and answers directly instead of describing the video. I converted it to GGUF, wrote my own llama.cpp scoring driver and checked it against the PyTorch original. I did not train it.

Key features

• Hosted, with no local weights
• Top tier of my cascade: local, then Codex, then Claude
• Cheaper tiers are used for sub-agents; the strongest only for final review
• Reasoning, coding and long-context work

Where a business would use it

• Final-stage review and decision support on code, policy or documents. It has the highest capability, placed at the end of a cheaper pipeline.
• Complex multi-step engineering and analysis. I use it for the hardest tasks in my tests.
• Orchestrating cheaper local models. It acts as controller and checker. A local model may fail work but never approves it.

How it was trained

Anthropic trains and runs it as a closed hosted service, with no model card published. I use it through a subscription and change nothing about it.

Learning after deployment

The model does not learn from my data.

Key features

• Hosted coding agent
• Second rung of my cascade, after the local models
• Used as an independent reviewer
• Solved 58 of the 150 SWE-bench Verified tasks after the local model failed them

Where a business would use it

• Code changes and review that go beyond what a local model can do. It sits between free local inference and the most expensive tier.
• An independent second opinion on model-written code. A different vendor catches different mistakes.
• Automated repository maintenance. It works as an agent with tools.

How it was trained

OpenAI trains and runs it as a closed hosted service. I use it as a service and change nothing about it.

Learning after deployment

The model does not learn from my data.

Key features

• 7M parameters in a single 2-layer network
• Refines a hidden answer in repeated loops
• Strong reported puzzle scores for its size (see accuracy)
• A puzzle solver, not a language model

Where a business would use it

• Embedded reasoning on very small devices. Seven million parameters fit almost anywhere.
• Puzzle and constraint-solving research, such as scheduling and Sudoku-like logic. The paper's results are on Sudoku, mazes and ARC puzzles.
• Understanding the cost floor of reasoning. It is a counterpoint to scale-first strategies.

How it was trained

The authors trained it from scratch on small puzzle sets, using recursive reasoning with supervision at each loop. That is very different from a large language model, which learns from huge text collections and writes its reasoning out. I have only read the paper and have not run it.

Key features

• 0.6B parameters, built on Qwen3-0.6B
• Decides game moves by scoring the options
• Mixed results across its own test games
• The smallest Jev-style model I know of

Where a business would use it

• Real-time control decisions on tiny hardware. It is very small and quick.
• Simulation and training environments. It is built for game-like state.
• Research on how small a decision model can be. The mixed results show where the limit is.

How it was trained

It is a fine-tune of Qwen3-0.6B for game decisions. I have only read the model card and have not run it.