The appeal of a capable local model is simple: you can work on a private repository, research notes, or office documents without sending every prompt to a hosted API. The difficult part is choosing a model that fits both the job and the machine. Three recent releases make that choice more interesting: InternScience Sage-A1.5, Recursive Flint, and Nanbeige4.3-33B.
They occupy roughly the same downloadable workstation model conversation, but they are not interchangeable. Sage is a vision-capable mixture-of-experts (MoE) model aimed at scientific investigation and agents. Flint is a text-only MoE model optimized for coding agents and local speed. Nanbeige is a dense text model aimed at coding and professional work. All three publish weights under Apache-2.0. The license gives broad rights to use and modify the released weights; it does not mean their entire training data and process are available.
The practical answer: try Flint first for a fast local coding agent, Sage for image-and-text research workflows, and Nanbeige for a dense general agent with a 512K advertised context. Then test the exact quantization, runtime, and task on your own machine. We did not run a common benchmark or a local inference test for this article.
The specification comparison
The figures below come from the three publishers’ Sage, Flint, and Nanbeige model cards. “Active parameters” count the part of an MoE model used for a token; the full set of weights must still be stored or accessed during inference.
| Property | Sage-A1.5 | Recursive Flint | Nanbeige4.3-33B |
|---|---|---|---|
| Developer | InternScience / Shanghai AI Lab | Recursive Superintelligence | Nanbeige LLM Lab |
| Architecture | MoE, Qwen3.5 MoE family | MoE, custom Flint architecture | Dense transformer |
| Total parameters | About 35–36B | 39.8B | About 33.1B |
| Active parameters/token | Not stated on card; eight of 256 experts routed/token | About 2.5B including output head | All 33.1B |
| Input | Text and images | Text | Text |
| Main target | Scientific research and agents | Local coding agents | Coding and professional agents |
| Documented context | 262,144 tokens native | 262,144 tokens configured | 524,288 tokens |
| Longer-context claim | 512K via YaRN scaling | Up to 512K in launch post; publisher recommends at most 256K | 512K is the stated limit |
| License | Apache-2.0 | Apache-2.0 | Apache-2.0 |
| Official BF16 weights, approximate | 70+ GB class | About 80 GB download | About 66 GB by parameter count |
The Sage family name and file metadata vary between rounded 35B and 36B descriptions. Its configuration lists 256 experts and eight routed per token, but its card does not give a directly comparable active-parameter figure. Flint’s card explicitly counts its output head in the 2.5B active figure and says its active body is about 2.2B. Nanbeige’s dense architecture puts essentially every model weight on the compute path for each token. These differences affect compute, but weight memory follows total parameters, not active parameters.
Context limits need the same caution. A model that accepts a 256K or 512K prompt may need much more memory for its KV cache and may perform worse or become very slow near that limit. Flint’s model card specifies 262,144 total prompt-plus-output tokens, while its launch post says up to 512K and recommends staying within 256K. Treat 256K as the documented planning point until the chosen local engine and exact task demonstrate otherwise.
Why Sage-A1.5 is the research pick
Sage-A1.5 combines image input with tool-oriented reasoning and scientific evaluation. That matters when a task contains figures, charts, scanned pages, lab notes, or visual documents alongside code and text. Its technical report describes a model built on the Qwen3.5 MoE family and Agents-A1 work, with training and orchestration aimed at long-horizon scientific workflows.
Its benefit is breadth. A research assistant can inspect a document image, search, reason through a scientific question, and use tools in one workflow. The card reports 91.5 on OmniDocBench, 48.3 on FrontierScience-Research, 65.2 on MLE-Lite, and 61.2 on SWE-bench Pro. It also reports 81.7 on BrowseComp without agentic orchestration and 82.8 with it. That last pair is a reminder that the system around the model can move a score.
The tradeoff is deployment complexity. Sage uses a vision stack as well as MoE language weights. An official Q4_K_M GGUF lists roughly 21.7 GB of language-model weights and a separate vision projector of about 0.9 GB. A text-only test does not prove the image path works. Check your engine’s support for the exact Qwen3.5 MoE format, image projector, chat template, and tool calls. The card documents SGLang and vLLM routes for the original checkpoint.
Why Flint is the coding pick
Recursive Flint targets the repetitive loop of a coding agent: read a repository, edit files, run commands, inspect failures, and try again. Its 39.8B total parameters create a substantial weight file, but only about 2.5B are active per token by Recursive’s accounting. It uses 256 routed experts per MoE layer, selects six, and keeps a shared expert active. The architecture also combines sliding-window and full attention.
Recursive reports 54.9% on Terminal-Bench 2.1, 89.7% on SWE-bench Pro v2, and 74.2% on SWE-bench Verified. Its launch post reports more than 125 output tokens/s on an M4 Pro MacBook Pro and more than 150 tokens/s on an NVIDIA RTX Spark at short context with Recursive’s optimized engine. These are publisher measurements, not speeds we reproduced. Long prompts, tool calls, other engines, and different quantizations can change throughput sharply.
The benefit for a laptop owner is the prospect of useful coding-agent performance without a large remote GPU. The limitation is that the original BF16 checkpoint is about 80 GB and its card currently supplies a specific SGLang kit for one H200 or B300 GPU; it says Transformers modeling code is not included yet. For a smaller local system, use a supported quantized conversion and confirm that the chosen engine implements Flint correctly. The ggml-org GGUF conversion lists a Q4_K_M file around 23.4 GB. A file that fits disk is not a guarantee that the full agent workload fits memory.
Why Nanbeige is the dense alternative
Nanbeige4.3-33B takes a different route: approximately 33.1B dense parameters, text in and text out, and a stated 524,288-token context. Its publisher positions it as a flagship teacher model for a later 3B distillation line. Today, the 33B release is aimed at coding, tool use, and professional “cowork” tasks.
The dense design is easy to understand operationally: there is no expert routing to support, and a broad range of runtimes already understand the model’s Llama-family base. But all weights are involved in every token, so the same size class can demand more compute than a small-active-parameter MoE. The official card gives Transformers, SGLang, and vLLM examples. It recommends preserve_thinking=true for multistep tool use and XML tool calls for its best tool-calling performance. Those settings are part of a fair deployment test; a generic chat template can understate its ability.
Nanbeige reports 80.9 on Terminal-Bench 2.1, 60.3 on SWE-bench Pro, 65.5 on DeepSWE, 54.2 on Automation Bench, 44.8 on JobBench, and 84.8 on GDPval. Its own table runs several comparison models with the same stated harness and inference parameters, which is more useful than juxtaposing unrelated launch charts. It still remains a publisher evaluation. The community Q4_K_M GGUF is roughly 20.8 GB; the original BF16 weights are approximately 66 GB before runtime overhead.
Benchmark evidence without a false leaderboard
The table records what each publisher reports for its own model. A dash means that publisher did not report that result here. Columns are not a controlled head-to-head test. Even when a benchmark name matches, dataset revision, harness, sampling, timeouts, internet access, tool budget, and scoring can differ. Flint explicitly uses SWE-bench Pro v2; do not rank its 89.7 against the other two Pro figures as if they were the same test.
| Reported benchmark | Sage-A1.5 | Flint | Nanbeige4.3-33B |
|---|---|---|---|
| Terminal-Bench 2.1 | — | 54.9% | 80.9% |
| SWE-bench Pro | 61.2% | — | 60.3% |
| SWE-bench Pro v2 | — | 89.7% | — |
| SWE-bench Verified | — | 74.2% | — |
| DeepSWE | — | — | 65.5% |
| MLE-Lite | 65.2 | — | — |
| FrontierScience-Research | 48.3 | — | — |
| OmniDocBench | 91.5 | — | — |
| Automation Bench | — | — | 54.2% |
| JobBench | — | — | 44.8% |
| GDPval | — | — | 84.8% |
Sources and method notes: Sage’s evaluation table, Flint’s evaluation and launch methodology, and Nanbeige’s evaluation table. Sage says its SWE-bench series uses mini-SWE-agent offline at a 200K context. Flint says its agent scores average at least five attempts, with Terminal-Bench through Terminus 2 and SWE-bench through mini-swe-agent. Nanbeige says its comparison table uses common hyperparameters and harnesses within that release, but its benchmark footnotes still identify different agents and judges across tasks. None of these launch results is a measured result from Dataxad.
What “reasonable local hardware” really means
The tempting number is the Q4 weight file. It is a download size, not a complete RAM or VRAM requirement. Add the operating system, inference engine, KV cache, prompt processing, tool process, and any image projector. Long context or multiple users can make the gap substantial. Quantization also changes answer quality; benchmark scores for BF16 weights do not automatically carry to Q4 files.
| Model and artifact | Approx. weight files | First machine class to investigate | Main caveat |
|---|---|---|---|
| Sage official Q4_K_M GGUF | 21.7 GB + 0.9 GB projector | 32 GB unified memory or more | Vision and new MoE runtime support |
| Flint ggml-org Q4_K_M GGUF | 23.4 GB | 32 GB unified memory or more | Confirm Flint engine support and agent speed |
| Nanbeige community Q4_K_M GGUF | 20.8 GB | 32 GB unified memory or more | Dense compute and long-context cache |
| Sage original BF16 | 70+ GB class | Multi-GPU or high-memory host | Vision stack adds overhead |
| Flint original BF16 | About 80 GB | H200/B300 route documented by publisher | Specific SGLang serving kit |
| Nanbeige original BF16 | About 66 GB | Multi-GPU or high-memory host | Runtime overhead beyond weights |
“32 GB or more” is a short-context starting point to investigate, not a tested minimum or a buying recommendation. A 24 GB card has little headroom beyond these Q4 weight files; whether a model runs entirely in VRAM depends on the engine, cache, and context length. CPU offload can sometimes make an experiment possible at a speed cost. A 32 GB unified-memory machine may load a Q4 model and still run out of headroom with a long prompt. For regular work, 48–64 GB gives more room to choose context length and keep the rest of the computer responsive. Before buying hardware, download one exact artifact, run your real prompt length, and measure load success, first-token delay, output speed, and peak memory. Our local AI capacity planner can help shortlist a machine, but it does not replace that test.
How to choose in practice
| Your workload | First model to test | Why | Check before adopting |
|---|---|---|---|
| Private repository coding agent | Flint | Built and evaluated for coding loops; small active MoE path | Agent harness, quantized quality, engine speed |
| Research with figures or scanned pages | Sage-A1.5 | Image input and science-oriented tool workflows | Vision projector, document accuracy, source verification |
| Text-only office and coding work | Nanbeige4.3-33B | Broad agent evaluations and 512K stated context | Dense throughput, tool template, memory at real context |
| Very long documents | Nanbeige, then Sage | Larger stated limit on Nanbeige; Sage offers scaled context | Retrieval quality and memory near the limit |
| Limited 24 GB VRAM | None as a guaranteed single-GPU fit at Q4 | Listed Q4 weights are about 21–23 GB before cache | Lower quantization or offload tradeoffs |
The selection should follow the complete task, not the parameter label. A coding model that generates tokens quickly but repeatedly calls the wrong tool may finish later. A science model that reads an image but invents a citation is unsafe for research. A 512K context window is only valuable if the model finds and uses the right evidence inside it. Test the end-to-end workflow and keep an independent check for important outputs.
Where the Qwen 4 27B rumors fit
Qwen 4 27B is generating interest because Qwen3.8-27B already made a strong case for local 27B inference. As of October 26, 2026, however, we could not find an official Qwen 4 27B weight release or model card from Qwen. A llama.cpp discussion refers to early kernel work, while a community preparation repository explicitly says it has no Qwen 4 weights. Neither is a release announcement or evidence of final specifications.
There is therefore no responsible Qwen 4 score, memory figure, or hardware requirement to add to the tables. If you need a local model now, the three published checkpoints are testable options. If Qwen releases a 27B successor, compare its official checkpoint and a reproducible local run with the same tasks, harness, quantization, and machine. The rumor can guide what to watch; it cannot choose today’s deployment for you.
The takeaway
These launches show three credible ways to make a workstation model useful: Sage’s multimodal scientific workflow, Flint’s sparse and speed-focused coding path, and Nanbeige’s dense general-agent approach. Their Q4 downloads are within reach of some 32–64 GB local systems, but none has a universal “runs on a laptop” guarantee. Start with the task, choose one exact artifact, and measure it. The best local model is the one that completes your work reliably within your machine’s memory and time budget.