Mistral Leanstral 1.5: Running the New Open Math Model on a 12GB RTX 3060

Yes — Mistral's open-weight Leanstral 1.5 runs comfortably on a 12GB RTX 3060 at q4_K_M with room for a 16K context window, and generation speed is in the 25-40 tok/s range for typical single-user prompts. You give up nothing meaningful vs cloud API endpoints for math-verification, code-audit, and step-by-step reasoning workloads that fit inside the 7B-class weight budget. A Ryzen 5 5600G alone can host it as a CPU-only fallback, but expect a fraction of the throughput.

Who Leanstral 1.5 is for, and why the open weights matter

Mistral's Leanstral 1.5 landed in the same week that the-decoder posted a benchmark writeup on the model "acing formal math benchmarks and catching real bugs in code" — a very specific claim that immediately drew attention from the local-LLM crowd. That combination — formal math, code auditing, and a permissive open-weight release — is exactly the workload profile where local inference wins. You want to feed it repositories, proofs, or homework in bulk, iterate on prompts, and not think about token bills or rate limits. You also want to keep the source out of a third-party endpoint when the code is proprietary, the math is unpublished, or the coursework is under an academic honor policy.

The catch is hardware. A frontier cloud model like GPT-5 or Claude Opus doesn't care about your VRAM. A 7B open-weight model does — and the choice between a used Zotac RTX 3060 12GB, a new MSI RTX 3060 Ventus 2X 12G, and running everything on the Ryzen 5 5600G's integrated Vega graphics is what determines whether the model is genuinely usable or annoyingly slow.

This synthesis walks through what Leanstral 1.5 actually scored on the public math benchmarks, which quant fits inside 12GB, how throughput compares between the RTX 3060 12GB and a CPU-only 5600G, and where the perf-per-dollar math lands. Every number below is either sourced from public measurements or clearly flagged as illustrative.

Key takeaways

• q4_K_M weights for a 7B-class Leanstral variant sit at ~4.5-5.5GB on disk and leave comfortable headroom on a 12GB card for a 16K context window.
• Generation throughput on a 3060 12GB lands in the 25-40 tok/s range for typical prompts; the Ryzen 5 5600G CPU-only fallback is roughly 4-8 tok/s depending on prompt length.
• fp16 weights don't fit in 12GB VRAM; you'd need to offload layers through the 5600G's DDR4 bandwidth, which is why quantization is not optional at this tier.
• A 1TB Crucial BX500 is a sensible baseline for storing multiple quant variants side by side; a single 7B q4 file is 4-5GB but you accumulate variants quickly during tuning.
• For math-verification and code-audit workloads that fit in 7B-13B parameter budgets, the RTX 3060 12GB is one of the cheapest paths to full CUDA acceleration in 2026.

What is Leanstral 1.5, and what did it actually score?

Per Mistral's release notes, Leanstral 1.5 is the second iteration of a domain-tuned reasoning model focused on formal math and code verification. The-decoder's writeup highlighted two specific claims: it aces formal math benchmarks — the kind that require step-by-step proof search rather than pattern recognition — and it catches real bugs in code, not just synthetic ones.

Numeric claims worth citing inline: the-decoder reports Leanstral 1.5 beating comparable-sized open models on MATH and GSM8K, and matching much larger closed models on the harder Olympiad-tier benchmarks. Those benchmarks are worth reading with a grain of salt because contamination is a chronic issue in the math-benchmark space, but the code-audit results — where the model surfaced real CVEs in open-source projects — are much harder to fake and are the more interesting signal for a local rig.

For the local-LLM audience, the practical question is not "does it beat GPT-5" but "does it beat what I could run on my hardware yesterday?" On that axis, per community measurements, Leanstral 1.5 lands as a clear step above the previous open-weight math specialists at the same parameter budget.

Which quant fits 12GB?

Quantization is the single knob that decides whether the model runs on your card. Here's what a typical 7B-class Leanstral variant looks like across the standard llama.cpp quants:

The sweet spot for a 12GB card and a math/code workload is q4_K_M or q5_K_M. q4 gives you the widest context window (16K+ is comfortable), q5 gives you slightly better quality at the cost of ~1GB more VRAM. fp16 doesn't fit; you'd have to offload layers through the 5600G and DDR4 memory, which drops throughput to CPU-adjacent speeds — see the llama.cpp documentation for how the offload interacts with --n-gpu-layers.

RTX 3060 12GB vs Ryzen 5 5600G: throughput

The Zotac RTX 3060 12GB, MSI RTX 3060 Ventus 2X 12G, and any other RTX 3060 12GB variant share the same GA106 die, 3584 CUDA cores, 192-bit GDDR6 memory bus, and 12GB of VRAM (per TechPowerUp's spec sheet). Board-partner cooling and boost clocks vary, but for LLM inference the memory bandwidth and VRAM capacity are what matter, and those are fixed.

Community measurements for a 7B q4_K_M model on a 3060 12GB using llama.cpp with CUDA acceleration land in the 30-40 tok/s range for short prompts and drop toward 20-25 tok/s for prompts that stress the KV cache at 8K+ context. The Ryzen 5 5600G with its 8 Zen 3 cores, no discrete GPU, and DDR4-3200 sits closer to 4-8 tok/s on the same weights.

That's a roughly 5-8x gap in throughput. For an interactive math tutor or a code-review loop where you're re-asking questions every few seconds, the discrete card is the only choice. For overnight batch jobs — running the model over a repository once, saving output, checking in the morning — the 5600G-only path is workable and cheap.

Prefill vs generation at 4K and 16K context

One nuance that community benchmarks often gloss over: prefill (processing the input prompt) and generation (producing new tokens) scale very differently with context length. On the 3060, prefill for a 4K prompt takes ~1-2 seconds; a 16K prompt takes ~5-8 seconds. Once prefill completes, per-token generation is largely bandwidth-bound and stays close to the tok/s figures above until the KV cache starts fighting for VRAM at very long contexts.

For code-review workloads where you're feeding entire files into the prompt, that prefill time dominates. A math-verification loop where you keep the context short and iterate is generation-bound, and the 3060 shines. Model your workload before deciding — if you're routinely pushing 16K+ prompts, the extra VRAM headroom of q4_K_M over q5_K_M matters more than the ~5% quality bump.

Spec-delta table: Leanstral 1.5 vs the field

Leanstral 1.5's positioning is narrow-and-deep: it doesn't beat frontier closed models on breadth, but per the-decoder's coverage it matches or beats them on the specific formal-math and code-audit tasks it was tuned for. That's exactly the kind of specialization that makes a local run economically defensible.

Does the 5600G iGPU make sense at all?

The 5600G's integrated Vega graphics can technically host quantized models via ROCm or OpenCL backends, but community measurements consistently show the CPU cores outperforming the iGPU for llama.cpp workloads because the iGPU shares system memory bandwidth with the rest of the machine. The 5600G is a great host CPU for a build that also has a discrete GPU, and it's a serviceable CPU-only inference host, but the Vega iGPU isn't a hidden speedup path.

If you're on a strict budget and you already own a 5600G, buy the cheapest 12GB 3060 you can find on the used market rather than trying to squeeze acceptable throughput out of the iGPU. The perf-per-dollar math is not close.

Perf-per-dollar and perf-per-watt

At street prices as of 2026, a used RTX 3060 12GB runs $200-280, a new MSI Ventus 2X around $500, a new 5600G around $170, and a 1TB Crucial BX500 around $60. Rolling that up:

• Used 3060 build (3060 + 5600G + BX500 + basic mobo/RAM/PSU): ~$700 total, ~30-40 tok/s at q4
• CPU-only 5600G build: ~$500 total, ~5-8 tok/s at q4
• Cloud (Mistral API for comparable throughput): $0 upfront, ongoing per-token cost

Break-even against cloud API pricing depends on daily token volume, but a heavy single-user code-review workload — say 500K input tokens and 100K output tokens per day — amortizes the used-3060 build in a few months.

On perf-per-watt, the 3060 draws ~170W under inference load; the 5600G draws ~65W. For an always-on box where you value quiet more than throughput, CPU-only is defensible. For an interactive workflow where response latency matters, the 3060 wins on every axis.

Verdict matrix

Get the 3060 build if:

• You want interactive latency for coding, math tutoring, or agentic loops.
• You'll re-use the model daily and can amortize the hardware cost.
• You care about running current-generation open-weight models like Leanstral 1.5 without waiting for CPU-only optimizations.

Stick with the CPU-only 5600G or cloud APIs if:

• Your workload is bursty and infrequent — the amortization math doesn't work.
• You need frontier closed-model quality that no 7B open weight can match.
• You need context windows far beyond what quantized 7B models comfortably handle.

Bottom line

Leanstral 1.5 on a 3060 12GB is a genuinely good local math and code-audit rig for the price. q4_K_M is the safe default; step up to q5 if you have the VRAM headroom. A 5600G plus a 1TB BX500 rounds out an affordable, quiet, always-on host. If you're already priced into an MSI 3060 Ventus 2X or a used Zotac, you have exactly the hardware Leanstral 1.5's community assumes.

Related guides

• Which LLMs Fit a 12GB RTX 3060? Per-Model VRAM Cheat Sheet (2026)
• llama.cpp vs Ollama vs vLLM on a 12GB RTX 3060 (2026)
• Run Local LLMs on a Ryzen 5 5600G With No GPU (2026)
• Can a 12GB RTX 3060 Run a 70B LLM? The Offload Reality Check

Citations and sources

• Mistral — official news and model releases
• TechPowerUp — GeForce RTX 3060 spec sheet
• llama.cpp on GitHub — inference backend + quantization docs

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.