Ornith 9B Tested: Can a 16GB Mac Mini Handle Local AI Coding?

A New Player in Open-Source AI Coding Models: Deep Reinforce Ornith 1.0

The open-source AI coding model space has a new entrant. San Francisco-based Deep Reinforce has released Ornith 1.0, an open-source model family purpose-built for agentic coding.

What is agentic coding? Traditional AI coding assistants (like early Copilot) focus on "completion" — passively responding to user input. Agentic coding models, by contrast, actively plan tasks, invoke tools (file I/O, terminal commands, code execution), and self-correct based on execution feedback, forming a "think → act → observe" loop. This demands stronger long-range consistency, tool-call accuracy, and error recovery — not just raw code generation quality. Representative frameworks include Claude Code, Cursor Agent, and Devin. Pi Agent, used in this article, belongs to the same category.

This article is based on hands-on testing by a Bilibili creator running on a 16GB M4 Mac Mini. We take a deep dive into the smallest model in the family — the 9B dense model — and ask whether it can realistically handle everyday coding tasks in a local environment.

Ornith 1.0: A Model Family Designed for Agentic Coding

Ornith 1.0 is not a single model but a full family spanning four sizes:

• 9B dense model (the subject of this test)
• 31B dense model (not yet available for download)
• 35B MoE model
• 397B MoE model

The 9B, 35B, and 397B are all open-weight models, available for direct download and local deployment.

Dense vs. MoE models: In a dense model, every parameter participates in every forward pass — parameter count equals compute. MoE (Mixture of Experts) models partition parameters into multiple "expert" networks and activate only a few per forward pass. This explains why the 397B MoE can still run on consumer hardware — its actual active parameter count during inference may be comparable to a much smaller dense model, making compute demands far lower than the raw parameter count might suggest. Other notable MoE architectures include Mixtral and DeepSeek-V3.

On the technical foundation side, Ornith 1.0 is built on Gemma 4 and Qwen 3.5. Gemma 4 is widely regarded as one of the strongest models for agentic task completion, while the Qwen series is a standout in the local AI coding space. Starting from both, the model theoretically combines strengths in task execution and code generation.

How to Read the Benchmark Numbers

The official release includes evaluation results across several benchmarks: Terminal Bench 2.1, SWE Bench Verified/Pro, and CLAW Eval. Looking at the charts, the 9B model (shown in orange) appears to trail the larger 31B and 35B models by a surprisingly narrow margin.

But there's a critical insight worth highlighting: these benchmarks measure fundamentally different capabilities.

• SWE Bench (proposed by Princeton in 2023, sampled from real GitHub issues) tests whether a model can read an unfamiliar codebase, locate bugs, and generate patches that pass tests — it's the gold standard for measuring "fix existing code" ability.
• Terminal Bench tests whether a model can operate within a harness, execute tool calls, and complete tasks in a terminal.
• Critically, neither tests the ability to build a complete application from scratch.

This is a significant mismatch between benchmark coverage and real developer needs. For most developers, "help me build a complete project from zero" is the most realistic use case. That's why the most valuable evaluation is always running your own workloads on your own hardware.

Hardware & Setup: Deploying on a 16GB Mac Mini

The test device is a 16GB M4 Mac Mini. In terms of memory allocation, roughly 4GB is reserved for the OS and background apps, leaving about 12GB for the model.

The runtime environment is LM Studio, a free desktop application. When searching for Ornith 9B, two formats are available — MLX and GGUF:

• MLX: Apple's machine learning framework designed specifically for Apple Silicon. It leverages the unified memory architecture of M-series chips (where CPU and GPU share the same memory pool), eliminating data-transfer bottlenecks common in traditional GPU inference. MLX files are smaller and faster on Apple Silicon, especially during the prefill phase.
• GGUF: The universal quantized format led by the llama.cpp project. It offers better cross-platform compatibility across Windows, Linux, and macOS — and is what was used in this test.

Once loaded, the model weights occupy 6.2GB, with a maximum context length of up to 260K tokens. Setting context to approximately 185K tokens puts memory usage around 12GB — impressive for a local small model.

Pro tip: For even longer context, enable Flash Attention and quantize the KV cache to Q8.

Flash Attention & KV Cache Quantization: Flash Attention (introduced by Tri Dao et al. in 2022) uses a tiling technique to perform attention matrix computation in fast on-chip SRAM rather than high-bandwidth memory, delivering significant speedups for long contexts. KV Cache is a standard Transformer inference optimization — caching previously computed Key/Value matrices to avoid redundant per-token recalculation, at the cost of growing memory usage over context length. Quantizing the KV cache to Q8 (8-bit) can cut memory consumption by roughly 50% with minimal accuracy loss, making a full 260K token context window feasible on a 16GB device.

With memory usage sitting at around 10.29GB, the full context window is accessible. Activity Monitor ultimately showed usage just over 15GB — pushing right up against the 16GB ceiling. For simple requests, the GGUF version runs at approximately 16 tokens/sec.

Real-World Test: 9B vs. 35B — Building a Tower Defense Game from Scratch

To put the "optimized for agentic coding" claim to the test, the evaluation used a realistic task: with Pi Agent as the harness and VS Code as the editor, a simple prompt was given — build a tower defense game in a single HTML file.

The reason for choosing Pi Agent over Claude Code is straightforward: small models on small hardware take too long with Claude Code. The first request alone can take three or four minutes. Pi Agent responds faster and is more practical in this context.

For a baseline comparison, the LM Link feature was used to call Ornith 35B (4-bit MLX) from another Mac Studio running the same task. The speed difference was immediate:

• 9B (16GB Mac Mini): ~16 tokens/sec
• 35B (Mac Studio): ~100 tokens/sec — nearly 5× faster

Results: The Accuracy Gap Is Unmistakable

The 35B model produced roughly 750 lines of code, yielding a basically playable game: archers fire at enemies, there's a gold economy system, and it runs smoothly. Its capabilities are clearly visible.

The 9B model was disappointing. It generated nearly 900 lines of code, but the game barely functioned — units didn't shoot, and the logic was broken. Worse, when using the 9B model to debug itself, it fell into a repetitive loop, making things progressively worse with each iteration.

The solution was a compromise: take the working code from the 35B run, feed it to the 9B model, and after four or five rounds of iteration, scrape together a version that was technically playable — but far less polished than the 35B original.

Core Finding: The Accuracy Ceiling of Small Models

This isn't a problem unique to Ornith. Other open-source small models like Qwen exhibit the same behavior:

9B-class models lack sufficient accuracy — they create functions without declaring them, write empty function bodies, and sometimes produce broken tool calls that prevent the agent from understanding the model's intent.

This has deep architectural roots. Building a complete application requires the model to simultaneously maintain global consistency of data structures, precise alignment between function signatures and call sites, and cross-module state management logic — all across thousands of generated tokens. Research consistently shows that a model's ability to handle long-range dependencies scales non-linearly with parameter count. The jump from 9B to 35B parameters delivers far more than a proportional increase in "effective working memory."

This is an industry-wide observation: Qwen2.5-Coder-7B, DeepSeek-Coder-7B, and other models at the same scale exhibit similar "fragmentation" problems in comparable tasks — misspelled identifiers, functions defined but never called, code structures that can't hold together internally. These small flaws accumulate until "maintaining the integrity of a complete application within a single task" becomes practically impossible at the 9B parameter level.

For developers looking to run local coding models on a 16GB Mac Mini, two practical recommendations:

1. Calibrate your expectations — don't count on a 9B model to build a complete application in one shot.
2. Break tasks into smaller units — decompose requirements into smaller, more clearly defined chunks before handing them to the model.

The 35B model demonstrates that the Ornith architecture itself is capable of producing quality code — the issue is purely the precision loss that comes with 9B parameters. For developers who prioritize local privacy and low-cost inference, the Ornith family is worth watching. But choosing the right model size based on your actual hardware matters far more than trusting benchmark numbers at face value.