Archer Dynamics

Conditions & Context

After doing a review of its little 8B brother a couple days ago, today we are looking at Cogito V1 14B model and I’m curious how it would fare in my very simple test. Unlike the 8B, which was based on Meta’s Llama model, this 14B variant is forked off open source Qwen 2.5. But, as with the prior iteration, this one too was put under IDA hybrid training regimen (inference + self-awareness), which changes the game. Even if it is nearly a year old. FYI – I know that Deep Cogito have released V2 in the 70B weight and I’m eagerly waiting when the small sub-20B models drop.
So, let’s see what our current model from this Massachusetts-based company is about. Let’s dive in.

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 number is prime.
Explain how it works in plain English, like teaching a beginner.

The Results

Cogito V1 14B Qwen loaded onto my 5060Ti at 9.7GB — very comfortable headroom for longer context window. There was no RAM spill, 97% GPU utilization locked in from the first token and stayed there. The throughput of 45 tokens a second is not blazing fast, but still very quick and for daily use it has plenty of speed. This is a reasoning-first model and the metrics show that priority. Consistency across three runs is to me almost suspicious — 45.00, 44.36, 43.79 — less than 3% variance total. I think that’s a model that knows exactly what it’s doing and does it the same way every time — even if its total token output varied significantly, it was methodical about it.

Three runs, three correct implementations, zero hallucinations, zero formatting garbage that I’ve learned to loathe. The code is clean throughout — proper edge case handling, square root optimization where it belongs, inline comments that explain intent rather than regurgitate the syntax back at you. Variable names are deliberately readable: number and divisor instead of the terse n and i you’d see in the 8B variant — cool! That’s a “small” choice that signals to me “big” awareness of the audience — a beginner. Token output stabilized at ~490 after Run 1, where the model was the shortest, likely finding its natural depth and fine-tuned it during the two subsequent iterations.

If you’ve read my Cogito 8B article from a couple days ago, you already know what’s coming, don’t you? Yes! Same playbook: run 2 stepped back to beginner-friendly brute force — checking all divisors up to n-1 instead of the square root — and did it on its own, without being asked, without explaining why, but with the implicit knowing that a beginner seeing this prompt a second time might need the simpler version first. Run 3 returned to the efficient square root solution again with a better explanation than Run 1. And it added a candy analogy! For me, that landed as the cleanest of the three. Same three-act arc as the 8B: first efficient, then simple-with-awareness, and finally efficient-but-better.

The Conclusion – TL;DR

Cogito V1 14B Qwen is the 8B’s bigger sibling — same IDA instincts, more weights’ horsepower behind them. At 45 tokens a second and sub 10GB VRAM usage this is a perfect model for a 16 gig GPU. The three-run shows yet again that this model adapts its explanation to context rather than repeating itself. That is useful.
In my own situation, I will use the 8B for my 3060Ti 8GB student lab, and the 14B will earn its place on my 5060Ti box. Deep Cogito’s V2 is already out at 70B — when the sub-20B V2 drops, this one will have some explaining to do. Until then, it’s become part of my daily toolkit. It may not be the freshest model, and is becoming long in the tooth (a year old as of this writing), but that hybrid IDA training did some magic behind the scenes. Let’s face it – even the newest amazing models can become trash, if their training is off kilter. This one? Is like an old Civic with a Hemi V8 and a blower on top. New lease on life.

P.S.:
I like Deep Cogito's name word play on Renee Descartes' famous Latin quote: 
Cogito ergo sum. 
I think, therefore I am.

The Output (unedited)

Here’s a simple function to check if a number is prime:

def is_prime(number):
    # Numbers less than 2 are not prime
    if number < 2:
        return False
    
    # Check for divisors from 2 up to the square root of the number
    for i in range(2, int(number ** 0.5) + 1):
        if number % i == 0:  # If there's no remainder, it's not prime
            return False
            
    return True
# Let's test it with some examples:
print(is_prime(7))   # Output: True
print(is_prime(8))   # Output: False

Let me explain this like we’re talking to a beginner:

Imagine you have a number, and you want to know if it’s “prime” (which means it can only be divided evenly by 1 and itself).

Here’s how our function works:

1. First, we check if the number is less than 2. If it is (like 0 or 1), we immediately say “not prime” because these numbers aren’t considered prime.
2. Then, we try dividing our number by all smaller numbers to see if any divide evenly:
   • For example, with 7:
     • Try dividing by 2? No remainder?
     • Try dividing by 3? No remainder?
     • If none of them work, then it’s prime!
3. But wait! There’s a clever trick we can use to make this faster:
   • We don’t actually need to check ALL numbers up to our original number
   • We only need to check up to the square root of our number!
   • This works because if a larger factor exists, there must be a smaller one too.
4. If any division gives us no remainder (meaning it’s divisible), then we know right away that our number isn’t prime.
5. If none of these divisions give us a zero remainder, then our original number is definitely prime!

This function will tell you:

• Is 7 prime? Yes! (because nothing divides into it evenly)
• Is 8 prime? No! (because it’s divisible by 2)

Think of it like this: if you can’t find any “partners” that would share your candies equally without breaking them, then the number is prime!

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