Recursive has released Flint, an open-weight coding model built to run coding agents on a laptop or a single workstation GPU. If you want a local model that can read a repository, call tools, and make changes without sending your code to a remote API, this guide shows the three supported ways to run it today (Ollama, Recursive’s own rec engine on Apple Silicon, and llama-server on NVIDIA) and how to plug it into a coding harness. Every command below comes from Recursive’s documentation, the model card, or Ollama’s Flint page, checked on October 22, 2026.

Key facts (from the Flint model card and launch post):

• Architecture: decoder-only mixture-of-experts, 39.8B total parameters, about 2.5B active per token (256 routed experts, 6 selected per token, plus a shared expert).
• Context: documented configuration of 262,144 tokens. Recursive says Flint supports up to 512k but recommends staying within 256k.
• License: Apache 2.0.
• Publisher-reported scores: 54.9% Terminal-Bench 2.1, 89.7% SWE-bench Pro v2, 74.2% SWE-bench Verified. Recursive notes that evaluation setups vary across sources.
• Speed claim: more than 125 tokens/s on an M4 Pro MacBook Pro and more than 150 tokens/s on a 64GB NVIDIA RTX Spark at short contexts, using Recursive’s optimized engine.
• Stated knowledge cutoff: June 2026.

Step 0: Pick the right path for your hardware

Your machine	Recommended path	Download size
Any machine that runs Ollama	Ollama, flint:40b-a2b-qat-int4	23 GB
Apple Silicon M4 Pro, M5 Pro or M5 Max with 48 GB+ unified memory	rec (Recursive’s engine)	about 30 GB free disk needed
NVIDIA GPU with 48 GB+ memory (or Spark unified memory)	llama-server with the NVFP4 GGUF	22.9 GB
Datacenter GPU (one B300 or H200)	SGLang kit from the BF16 checkpoint	about 80 GB

One caution from Recursive’s troubleshooting page: the model file size does not include the KV cache and working buffers, so a 23 GB download fitting in memory does not mean the full 256K context will. Lower the context length if you run out of memory.

Option A: Run Flint with Ollama

Ollama’s library lists several Flint tags. Recursive’s Ollama guide uses the QAT INT4 build:

ollama run flint:40b-a2b-qat-int4

Ollama downloads the model on first run and opens a chat. Type /bye to leave. The other tags on the Ollama tags page include flint:latest (23 GB), flint:40b-a2b-q4_1 (26 GB), an MLX NVFP4 build, and an 80 GB flint:40b-a2b-mlx-bf16. Ollama added MLX support for Flint in v0.40.8, so update Ollama first if the model fails to load.

Connect a coding harness through Ollama

From your project directory, use Ollama’s launcher and pick flint:40b-a2b-qat-int4 when prompted:

ollama launch opencode   # OpenCode
ollama launch pi         # Pi
ollama launch codex      # Codex (install Codex first)
ollama launch vscode     # VS Code

Ollama’s model page also lists launchers that take the model name directly, including Claude Code:

ollama launch claude --model flint
ollama launch opencode --model flint

For any other OpenAI-compatible client (OpenHands, Cline, your own scripts), use base URL http://127.0.0.1:11434/v1, the placeholder key ollama, and confirm the exact model ID is listed:

curl --fail-with-body --silent --show-error http://127.0.0.1:11434/v1/models

Option B: Run Flint with rec on an Apple Silicon Mac

rec is Recursive’s own local inference engine. Recursive reports 1.4 to 2.6 times llama.cpp’s token throughput on an M4 Pro (48 GB) with 4-bit weights. It requires an M4 Pro, M5 Pro or M5 Max, at least 48 GB of unified memory, about 30 GB of free disk, and Node.js 22 for the harnesses. It refuses to download the model on unsupported hardware. NVIDIA RTX Spark support is listed as coming soon.

Install it and check your setup:

curl -fsSL https://raw.githubusercontent.com/recursive-oss/rec/main/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
rec doctor

Then launch a harness from your project directory. Recursive recommends Pi, saying informal reports suggest roughly 1.5x faster workflows than OpenCode:

rec launch pi        # recommended
rec launch opencode  # alternative

The first launch downloads the model and a matching harness version. The model server keeps running after you close the harness, so run rec stop when you’re done.

To use your own client instead, start the server with rec serve, wait for flint is ready, and send a request:

curl -fsS http://127.0.0.1:11500/v1/chat/completions \
  -H "Authorization: Bearer $(rec auth token)" \
  -H 'Content-Type: application/json' \
  -d '{"model":"flint","messages":[{"role":"user","content":"Say hello."}],"max_tokens":128}'

Other clients use base URL http://127.0.0.1:11500/v1, model flint, and the key printed by rec auth token. Useful extras: rec status, rec pull (download without serving), rec update, and rec uninstall.

Option C: Run Flint with llama.cpp on NVIDIA

The NVFP4 GGUF is a 22.9 GB file aimed at NVIDIA GPUs with llama.cpp built for CUDA. Recursive says it has been tested on B300, RTX PRO 6000 Blackwell, RTX Spark and DGX Spark, and recommends at least 48 GB of GPU memory. Build or install a llama.cpp release with Flint support and put llama-server on your PATH, then:

hf download RecursiveSI/flint-nvfp4-gguf flint-nvfp4.gguf pi-models.json opencode.json \
  --local-dir flint-nvfp4-gguf

llama-server -m flint-nvfp4-gguf/flint-nvfp4.gguf \
  --alias flint -ngl all -c 262144 -np 1 \
  -fa on -ctk f16 -ctv f16 --jinja \
  --temp 1 --top-p 0.95 --top-k 20 --min-p 0 \
  --host 127.0.0.1 --port 8080

Notes from the model card: this uses the full 262,144-token context, so reduce -c only if you need to cut KV memory. Leave --swa-full unset to keep compact sliding-window caching, and keep --jinja on so the bundled chat template is used.

The download includes ready-made client configs. With llama-server running, open a second terminal in the folder that contains flint-nvfp4-gguf:

# OpenCode
OPENCODE_CONFIG="$PWD/flint-nvfp4-gguf/opencode.json" opencode --standalone

# Pi
mkdir -p .pi-flint
cp flint-nvfp4-gguf/pi-models.json .pi-flint/models.json
PI_CODING_AGENT_DIR="$PWD/.pi-flint" pi --provider flint-local --model flint

These configs assume 262,144 context tokens and a 65,536-token generation budget. If you change -c, change the client’s context limit to match. On Apple Silicon, Recursive points llama.cpp users to the INT4 GGUF instead. If llama-server won’t answer, our guide to fixing llama-server connection refused, 503 and 404 errors covers the usual causes.

Step 4: Use the recommended generation settings

From the model card:

Setting	Value
Temperature	1.0
Top-p / top-k	0.95 / 20
Output budget for hard problems	at least 32,768 tokens, including reasoning

Two details matter for agent use. Flint reasons before answering, and prompt and output share one context window, so a small max_tokens can cut it off mid-thought. And when you replay a conversation, keep the returned reasoning_content in the history; the chat template expects it.

Step 5: Give it a first task

Recursive’s getting-started page suggests starting with a small repository you know: ask Flint to explain one function, add a focused test, then fix the behavior that test exposes, checking the diff and test output after each step. The launch post adds that Flint “may need more guidance than the larger closed-source coding models you’re used to,” so break bigger jobs into smaller subtasks with explicit instructions. If you’re comparing local coding models, our Qwen 3.6 local coding guide and Kimi K2.7 Code local setup use similar harness setups.

Troubleshooting

These fixes come from Recursive’s troubleshooting page:

• rec won’t download the model. Check that you have an M4/M5 Pro or Max with at least 48 GB of unified memory, enough free disk, and a connection, then run rec doctor.
• “Unknown architecture” or model metadata errors. Your runtime build doesn’t support Flint yet. Use a release with Flint support, verify the checksum, and keep split GGUF parts together.
• Out of memory. Lower the context length and parallel requests (-c and -np in llama.cpp) and close memory-heavy apps.
• Unexpectedly slow. Check the startup logs for Metal or CUDA initialization and real GPU offload, and look for CPU offload or swapping.
• The answer stops early. If finish_reason is length, the output budget ran out, possibly during reasoning. Raise max_tokens, trim history, or split the task.
• Tool calls show up as plain text. The tokenizer, chat template and parser must match. In llama.cpp, make sure --jinja is set.
• The agent loops or drifts. Try a shorter task in a fresh session and keep tool output concise.

FAQ

Is Flint really free to use commercially? The weights are released under Apache 2.0. Recursive notes that hosted API terms are separate from the weight license.

Is there a hosted Flint API? Recursive’s FAQ says the Flint API is available to select partners by request. Its docs also mention a hosted Flint-40B on OpenCode’s free tier, subject to capacity and rate limits.

Which Ollama tag should I use? Recursive’s own guide uses flint:40b-a2b-qat-int4. flint:latest is the same 23 GB size; check the tags page for MLX and BF16 builds.

Can I run the full BF16 model? Yes, but the model card’s SGLang kit targets one B300 or H200 per replica, and the checkpoint is about 80 GB. Transformers modeling code isn’t included yet.

Are the benchmark numbers independent? No. They are Recursive’s own release evaluations, run at temperature 1.0, top-p 0.95, top-k 20. Test it on your own repository before switching your daily workflow.

For more local model guides, see the 7minai homepage.