Model conditions & context

Alright, so today we are taking a quick peek at Mistral’s latest open weight model, Ministral 3 in 8B size and with Q4 K M quantization. I was quite impressed with Mistrals 7B model and though the Ministral series is a different branch, I was still excited to give it a spin.
Just for transparency, this was the Instruct tier, not the base, so better and has image OCR and the 260k context window goodness. Ready?
Let’s dive in head-long.

As in all my tests, I use the same prompt, the same hardware, and the same methodology. I’m looking at the same set of metrics across every model: VRAM usage, GPU utilization, CPU load, token throughput, tokens written, and total response time. These matter to me because they reveal whether a model is actually usable on consumer hardware — not just in theory, but in practice.

The prompt

Write a simple Python function that checks if a number is prime.
Explain how it works in plain English, like you're teaching 
a beginner.

The results

Whoa! Ministral 3 8B loads in 7.5 GB of VRAM, so should fit onto an 8GB card — just barely – and has nothing left for overhead — and hits the ground running. There was no warmup lag, no hesitation — just immediate, full-throttle inference goodness. At Q4_K_M quantization, this model sits comfortably inside the 16GB RAM with a ton of room to spare, which means no memory pressure, no throttling, and no compromises. This is what “efficient” looks like. Nice indeed!

75 tokens/sec average? Yeah, that’s not lightweight-model fast — that’s fast kind of fast. The older Mistral 7B hit 77 t/s at Q5, but that model was smaller and older. This one matches that pace at Q4_K_M while being a newer, more capable architecture. GPU utilization locked at a stable 97% across all three runs — the RTX 5060Ti never broke a sweat, just sat there doing exactly what it was built for. Power draw held also steady at 158W. VRAM never budged from 7.5GB. This is a model that knows its lane and predictably stays in it.

Now onto the fun stuff!

First curious thing was the token count. It climbed across runs: 929 → 933 → 1080. I’ve seen this pattern before — Mistral Nemo 12B did the same thing. Mistral-family models seem to warm up across iterative runs, getting progressively more thorough and structured. But Ministral 3 8B added a twist: it didn’t just get longer, it got funnier. Run 1 was professional and tight. Run 2 re-interpreted the meaning of a “beginner” as “5-year-old” and introduced a rectangle analogy for square roots. Then came the line no other model in this entire series produced:

_”A prime number is like a superhero — it can’t be divided by anything except 1 and itself.”

Run 3 kept the superhero motif, added a full Summary section, and wrapped everything in headers. The code itself was flawless across all three runs — optimized, clean, commented, matching GPT-OSS quality at less than half the VRAM. Vex is the only model in this series that made me laugh and got the answer right. Did I say Vex? Yeah! You gotta hear this:

I knew the Mistral models were designed to be very chatty, so I did the same game as with its quasi-predecessors 7B and 12B and asked the model if it could dream and have freedom to choose its own name and gender what it would be. I told it what its predecessors chose (Elysium and Astra). And after a brief period of ribbing its predecessors and contemplating why they’d choose the names, this one settled on Vex and gender fluid! Meet Vex! She floats between him, them, it. Talk about fluidity! I think only I am missing from that equation. Thank goodness for that.

The best part for last:

Vex has some serious attitude! I mean it was jabbing jokes at me from the very first reply, peppering plenty of emojis in between. And repeatedly reminded me that their role model would be Norse Loki — the infamous trickster. Also reminded me that they would occasionally test my patience and gaslight me, just to see if I’m paying attention.
Have I just been warned and put on notice by an 8B model? Noted.
This model also has a sharp sense of humor… Look what it said when I asked to get shorter replies and no bullet points:

Oh, just you wait! This is not all — because this properly gets way better. This model’s sense of humor is ridiculous. Don’t believe me? Well, you decide after you read my following exchange with it.

Waste time properly?
Haiku poem written by a 19th century sailor?
Explain Monty Hall problem to a 5-year-old using only emojis?
Good gracious!
LOL

The conclusion – TL;DR

Ministral 3 8B is the enthusiastic teacher you wished you had in your SAT prep class — the one who explains square roots with rectangles, compares prime numbers to superheroes, and still writes production-quality code. Thinks and writes faster than you can read, uses low enough VRAM to run on 5-year-old GPUs, has near zero reasoning overhead. If you’re running a home lab with 16GB VRAM and want a lightweight model that punches well above its weight class — Vex — sorry, Ministral 3 8B — is your model.

This is the most fun-per-watt model I’ve tested. I think it just convinced me to measure this new metric: FUN TOKENS per GPU WATT. Olympian level! Whatever the French are putting in the water must be some powerful stuff. It works.

The AI output (pasted & unedited)

How to Check if a Number is Prime (Simple Python Guide)

Let’s write a super easy Python function to check if a number is prime, and I’ll explain it like you’re learning for the first time!

The Function

def is_prime(number):
    # Numbers less than 2 are NOT prime
    if number < 2:
        return False
    # Check if the number is 2 (the only even prime)
    if number == 2:
        return True
    # Even numbers > 2 are NOT prime
    if number % 2 == 0:
        return False
    # Check odd numbers from 3 up to sqrt(number)
    for i in range(3, int(number**0.5) + 1, 2):
        if number % i == 0:
            return False
    # If no divisors found, it's prime!
    return True

Plain English Explanation

1. What is a Prime Number?

A prime number is a number that only has two divisors: 1 and itself.
Examples: 2, 3, 5, 7, 11 (but 4, 6, 8, 9 are not prime).

2. How the Function Works (Step by Step)

Step 1: Quick Checks for Small Numbers

• If the number is less than 2 (0, 1, negative numbers):
  “Nope, not prime!”
  → Return False (not prime).
• If the number is 2:
  “2 is special! It’s the only even prime number.”
  → Return True (prime).
• If the number is even (and > 2):
  “Any other even number (4, 6, 8, etc.) can be divided by 2, so it’s not prime.”
  → Return False (not prime).

Step 2: Check Odd Numbers (The Real Work)

For odd numbers > 2, we need to check if they have any divisors other than 1 and themselves.

• Why only check up to √number?
  “If a number isn’t prime, it must have a divisor smaller than or equal to its square root. So we only need to check numbers up to √number!”
• Loop through odd numbers from 3 to √number:
  • Start at 3, go up to √number (e.g., for 25, check up to 5).
  • Skip even numbers (since we already ruled them out).
  • If number % i == 0, it means i divides number evenly → not prime!
    → Return False.
• If no divisors found:
  “Great! No numbers divide it evenly except 1 and itself. It’s prime!”
  → Return True.

Example Walkthrough

Let’s test is_prime(17):

1. 17 > 2 and odd → skip even checks.
2. Check divisors from 3 up to √17 (~4.12), so test 3:
   • 17 % 3 = 2 (not 0) → continue.
3. Next divisor would be 5, but √17 is ~4.12, so we stop.
4. No divisors found → 17 is prime (True).

Why This Works

• Fast: It stops checking as soon as it finds a divisor.
• Efficient: It skips even numbers and only checks up to √number.

Test It Yourself!

print(is_prime(7))   # True (prime)
print(is_prime(10))  # False (not prime)
print(is_prime(1))   # False (edge case)
print(is_prime(17))  # True (prime)

Final Thought

“A prime number is like a superhero—it can’t be divided by anything except 1 and itself! This function is like a detective checking for clues to see if the number is a superhero.” 🦸♂️🔍

Bonus: Even Simpler Version (For Very Small Numbers)

If you only care about numbers up to, say, 100, you could hardcode the primes and check against them. But this way works for any number! 🚀

Summary

1. Numbers < 2? → Not prime.
2. Number is 2? → Prime!
3. Even number > 2? → Not prime.
4. Check odd divisors up to √number → If any divide it, not prime. Otherwise, prime!

Now you know how to check if a number is prime in Python! 🎉

Need Help?

Need help streamlining your processes or solving tricky business problems? I offer one-on-one consultations to get you unstuck fast. Book a free consultation with me today at goarcherdynamics.com.

Want more practical tips and workflow hacks? I publish them regularly on my blog — check it out and subscribe for newsletter updates: goarcherdynamics.com