Archer Dynamics

Conditions & Context

Today we have a doozy. A relatively tiny model with a really big heart. I just recently tested Nvidia’s Nemotron Mini, which is a puny 4B model and it performed alright. I’ve read up on their Nemotron 3 Nano, which is slightly heavier – sitting right above 5 GB in weight, but what is striking about it is that is is an MoE hybrid. It is still a 4B model, but….MoE magic allows it to be in fact a 30B beast disguised in a 4B cloak.

I picked a very simple prompt which contains a mixture of code generation and some reasoning logic, and writing prowess. What I’m looking for is a number of metrics of interest to me: how much VRAM the model uses, utilization of GPU, wattage and temperature of GPU, CPU utilization, token throughput, total number of tokens written, total time to response. All these are important to me as not only do they match the best model for my hardware, but also provide the best quality of UX for me as an end user. I focus on overall quality of the answer, but most importantly on the reasoning and explanation to someone who is a novice in the field. My goal here is to show whether the model is usable and good enough to help someone who is seeking assistance in learning how to code or write code.

The Prompt

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

The Results

Well, this was unexpected! This model arrived with a résumé that looked almost too good to be true — hybrid MoE (Mixture of Experts) architecture, 262k context window, thinking capability, tool use, all in a 4B package. Whoa!
The output quality stopped me cold. This model didn’t write a working prime checker I expected from a 4 or 5B model. Hell no. It puts some 14B models to shame. It handles the even number edge case explicitly, skips even divisors in the loop for efficiency, includes a proper docstring, type hints, and though unprompted, also included worked examples at the very bottom. Every explanation step is mathematically correct. No factual errors. As I’ve said justa. few sentences earlier, this is not a 4B model output. This is what a well-trained 14B sounds like on a good day.

At 124 t/s it’s slower than nemotron-mini’s 153 t/s — which makes sense given it’s carrying nearly 5GB of model weights vs mini’s 3.1GB. But the throughput gap is narrow and the quality gap of their output is enormous. The thinking capability is visibly active — each run showed a brief reasoning trace before responding, and that internal deliberation shows in the output structure. The algorithm it produced is genuinely more efficient than the standard square-root implementation most models reach for: by handling even numbers upfront and stepping by 2 through odd divisors only, it halves the number of iterations in the main loop, gaining efficiency. A beginner reading this explanation would actually learn something correct and useful not only about math, but Python too. That’s rare at any model size.

Bonus – and you’ve gotta hear this!

Under the hood, Nemotron-3-Nano has very interesting specs you wouldn’t expect at this size. The context window is staggering 262,144 tokens — yeah, you’ve read it right. That’s not a typo! 260k? I still giggle while writing this.
Most 14B models I’ve tested don’t come close to that and the Ministrals have held that trophy with 120k context window size up to this point. It also also ships with ‘thinking’ which can be turned off, and ‘tool-use’ capabilities baked in, meaning it can reason through problems step-by-step and handle function calling. Now, that last bit really piqued my interest. More on that below in TL;DR. NVIDIA claim they’ve built this as an agentic model, not just a chat assistant, and the specs back that up. At 4.9GB with a 262k context and tool support, this is a serious small model — not a toy by any stretch.

Let m reiterate: this is a 30B model packaged in a 5 GB size, because thanks to it’s Mixture of Experts architecture, only 3.5B of its weights are active at any given moment. So, yeah. For all intents and purposes, this is a 30B model the size of a 5B model! And it shows! How did NVIDIA do this? According to Ollama, they’ve put in 23 Mamba-2 and MoE layers, along with 6 Attention layers. Each MoE layer includes 128 experts plus 1 shared expert, with 6 experts activated per token.

How does a guy understand that last geeky mumbo-jumbo bit by translating it into plain English? Well, it’s like taking a supercharged V8 from Dodge Hellcat, shoving it into a Yugo with 355/45 Pirelli P-Zeros, then flooring it, and holding onto your dear life. That about sums it up. 

Now, back to the context window, “thinking” and tool-calling. I will have to give this model a serious second look, because I can already see some very interesting business use cases – I’m talking document summarization with RAG and possibly doing API calls or database queries. And a 260k context window? Wow. You could use this for example to do long legal document summarization, extract text of contracts or procedures, write specific exhibit values into a database, verify specific values against an API. Hmmmm. This changes things. And you would not need a monster PC do do this either. I mean this could be done on a consumer-grade hardware, like mine. And wickedly fast.

Say all you want about NVIDIA — they’ve received a lot of flak lately for their highly questionable business practices — and rightfully so, but they’ve built something genuinely impressive here, and at this size and price point — free and open — there is no excuse not to try it. 

Speaking of open: there is open and then there is OPEN. Not only did they release the open weights, they’ve also published their training data and recipes too! That it unheard of. These large tech companies usually guard their training data and recipes like an invaluable heirloom. Open weights mean nothing when you don’t know what data they’ve been trained on and the strategy (recipe). And NVIDIA delivered. On all three counts.

The Conclusion – TL;DR

Nemotron-3-Nano is the most surprising model I have ever tested. On paper it’s a 4B – something I’d not even scoff at and deliberately have not done any testing of these tiny models, because they… just aren’t that great. That changed today.

In practice this model thinks, it reasons, it writes correct and efficient code, and it explains it like a patient teacher – reminds me a lot of Qwen Coder and Ministral 14B. It uses mere 4.9GB of VRAM, runs at 124 t/s, and finishes a thorough response in under 7 seconds. So this will run on your RTX 5060 or whatever 8GB GPU you happen to have in your PC. There is no excuse now! Your old gaming rig is calling for a new lease on life. The MoE architecture means 30 billion parameters are sitting in reserve while only less than 4 billion do the work — and you feel all 30 in the output quality. If you have 6GB of VRAM and nothing else to run, this model will make you question why you ever needed anything larger.

The Output (unedited)

Thought for 1 seconds 

We need to provide a simple Python function to check if a number is prime, and explain in plain English for beginners. Should be straightforward. Provide code:

def is_prime(n):
if n <= 1: return False
if n ==2: return True
if n%2 ==0: return False for i in range(3, int(n**0.5)+1, 2): if n%i ==0: return False
return True

Explain: prime is >1 and only divisible by 1 and itself. The function checks conditions.

Let’s produce answer.

Python code

def is_prime(n: int) -> bool:
    """
    Returns True if n is a prime number, False otherwise.
    """
    # 1️⃣ A prime must be greater than 1
    if n <= 1:
        return False
    # 2️⃣ 2 is the only even prime
    if n == 2:
        return True
    # 3️⃣ Any other even number is NOT prime
    if n % 2 == 0:
        return False
    # 4️⃣ For odd numbers we only need to test divisors up to √n
    #    (if a larger factor existed, its pair would be smaller than √n)
    limit = int(n ** 0.5) + 1
    for i in range(3, limit, 2):   # test only odd numbers
        if n % i == 0:           # found a divisor → not prime
            return False
    # No divisor found → prime
    return True

How the function works (plain‑English explanation)

1. First we look at the easy “no‑peace” cases
   *A prime number must be larger than 1.**
   If n is 0, 1, or negative, the function says “not prime” right away. *The only even prime is 2.**
   If the number is exactly 2, it is prime – we return True. *Any other even number can’t be prime.**
   If n is even and not 2, the function returns False because it’s divisible by 2.
2. Now we handle odd numbers bigger than 2
   The most important idea: If a number has a factor larger than its square‑root, the matching “partner” factor must be smaller than the square‑root.
   So we only need to test possible divisors up to √n. We skip even divisors because we already ruled out even numbers as candidates.
   The loop starts at 3 and goes up to int(√n) + 1, stepping by 2 each time (so it only checks odd numbers: 3, 5, 7, …).If any of those odd numbers divides n evenly (n % i == 0), then n is not prime.
   The function returns False immediately.
3. If we finish the loop without finding a divisor
   The only thing left is that n could only be split into 1 and itself – that’s the definition of a prime.
   Therefore we return True.

Example usage

print(is_prime(2))   # True
print(is_prime(3))   # True
print(is_prime(4))   # False
print(is_prime(17))  # True
print(is_prime(20))  # False

The function is simple, easy to read, and runs quickly because it only checks numbers up to the square‑root of the input.

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