How to Run Recursive Flint Locally: a 39.8B Coding Model You Can Actually Fit on a Mac

Flint is Recursive's 39.8 billion parameter mixture-of-experts model for coding agents, with only about 2.5 billion parameters active per token. The full BF16 checkpoint wants a datacenter GPU, but Recursive's own rec engine runs it on an Apple Silicon Mac with 48 GB of unified memory, and community GGUF quantizations bring it to llama.cpp as well.

Written by Priya Raghunathan, local-AI hardware reviewer. I check parameter counts, licenses, hardware requirements and install commands against the primary source before recommending a setup path.

A new top-20 entrant on Hugging Face's trending list

Flint entered the top 20 of Hugging Face's overall trending list in October 2026. At time of writing it has 482 likes and 420 downloads on the RecursiveSI/flint model page, released October 21, 2026 under the Apache 2.0 license. Recursive's rec inference engine on GitHub has 115 stars. The most-liked Space linking to it is tardellirs/model-pulse (200 likes), a Hub-wide stats dashboard rather than a demo of the model itself.

Specs at a glance

What it actually does

Flint is built to investigate codebases, fix bugs, implement features and write tests, not to write general prose. It takes text in and gives text out, supports multi-turn tool calls in an OpenAI-compatible format, and exposes a separate reasoning stream that Recursive calls reasoning_content, which you're supposed to keep in the conversation history on later turns. The mixture-of-experts design is the reason a 39.8 billion parameter model is realistic to run at all outside a datacenter: at any given token, only about 2.5 billion of those parameters are doing the work, which is closer to the compute cost of a model a fifteenth the size.

Run it on a Mac with rec

Recursive publishes rec, a separate inference engine built specifically to run Flint on Apple Silicon. It's the realistic option for most people who want this model on their own hardware rather than rented cloud GPUs, and it's a single install script rather than a Python environment.

The installer puts the rec binary in ~/.local/bin and stores model data under ~/.local/share/rec. Once it's installed, rec pull downloads a 4-bit quantized Flint for Apple Silicon, and rec launch starts the model server and opens a coding harness in one step.

rec also opens an OpenAI-compatible endpoint at http://127.0.0.1:11500/v1 under the model name flint, so you can point any OpenAI-client-compatible tool at it directly. Run rec auth token to get the local API key the server expects.

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:11500/v1", api_key="local")
response = client.chat.completions.create(
    model="flint",
    messages=[{"role": "user", "content": "Write a Python function that merges overlapping intervals."}],
)
print(response.choices[0].message.content)

Recursive's own benchmarks put rec at 1.4 to 2.6 times the token throughput of llama.cpp running the same 4-bit Flint on an M4 Pro, across context lengths from 1,000 to 252,000 tokens with 1,024 output tokens. The tradeoff is that rec is built for a single session; if you want several agents hitting the model at once, llama.cpp or the datacenter route below fit that better.

Running the full checkpoint yourself

If you do have access to datacenter-class hardware, Recursive ships an SGLang serving kit alongside the raw checkpoint. This is the path for a B300 or H200 GPU, not a desktop.

Recommended sampling settings are temperature 1.0 with top-p 0.95 and top-k 20, and Recursive suggests budgeting at least 32,768 output tokens, including reasoning, for hard problems. The server applies those defaults automatically when a request omits them.

Community quantizations

Recursive's model card also lists quantized community builds for llama.cpp, LM Studio, Jan and Ollama, alongside the rec-specific Apple Silicon build. If you already run one of those tools and want Flint without installing rec, check the quantizations listed on the RecursiveSI/flint model page for a build sized to your GPU or unified memory.

Benchmarks

Recursive's release evaluations use temperature 1.0, top-p 0.95 and top-k 20, with Terminal-Bench run through Terminus 2 and SWE-bench run through mini-swe-agent. Agentic scores are an average pass rate over at least five attempts.

Recursive counts any Terminal-Bench solution obtained through web retrieval as a failure, which is a stricter rule than some developer-reported scores from other labs apply, so a direct percentage-to-percentage comparison against another model's self-reported Terminal-Bench number can be misleading.

Known limitations

Flint's supervised fine-tuning included safety-oriented examples, but Recursive is explicit that it can still produce incorrect or harmful content, faulty code, or bad tool calls, and that structured tool-call formatting does not by itself stop the model from choosing an unsafe or wrong action. Test generated code and review consequential changes before applying them, and keep your own permission boundaries around anything the model can execute. Long reasoning traces can eat into the output budget before an answer finishes, and Recursive notes the 262,144 token context is a capacity limit, not a promise of even accuracy across the whole range. The stated knowledge cutoff is June 2026.

FAQ

What is Recursive Flint?

A 39.8 billion parameter mixture-of-experts language model from Recursive, built for coding agents: investigating codebases, fixing bugs, implementing features and writing tests. About 2.5 billion parameters are active per token.

Can I run Flint on a laptop?

Yes, with the right machine. Recursive's rec engine runs a 4-bit quantized Flint on an Apple Silicon Mac with an M4 Pro chip or better and at least 48 GB of unified memory. The raw BF16 checkpoint on Hugging Face is built for a datacenter GPU like a B300 or H200, not a laptop.

Is Flint free to use commercially?

The model weights are released under the Apache 2.0 license, which allows commercial use. Recursive notes that hosted API terms and data practices, if you use their own API instead of self-hosting, are separate from the weight license.

How big is the download?

The full BF16 checkpoint is about 80 GB. The 4-bit quantized build that rec downloads for Apple Silicon is much smaller, and community GGUF quantizations for llama.cpp come in a range of sizes depending on the quant level chosen.

Where to go from here

• Browse other open coding and agentic models: the local AI model directory lets you compare specs side by side.
• New to running quantized models on llama.cpp? the how-to guide index has setup guides for other local models that cover the same workflow.