Recursive Flintlocal LLMAI coding agentsOllamallama.cppApple Siliconindie developers

Can a Laptop Coding Model Replace Your Cloud Agent? Recursive Flint for Indie Devs

Muhammad Tayyab

October 22, 2026·17 min read

A laptop screen showing colourful code in a dark editor, a nod to running a coding model on your own machine. Photo by Mohammad Rahmani on Unsplash.

Recursive's Flint is an Apache 2.0 coding model with 40B total and about 2.5B active parameters, built to run agentic coding locally. Here's what it really needs (48 GB of memory), how to set it up with Ollama, llama.cpp or rec, where it beats paid APIs, where it still needs hand-holding, and a simple way to decide.

Most indie developers who use a coding agent pay for it twice: once in subscription or API fees, and again in the small worry about sending a client's codebase to someone else's servers. Local models have always promised a way out, but in practice they've been too slow, too forgetful or too clumsy with tools to run a real agent loop.

On October 21, 2026, Recursive released Flint, an open-weight coding model built specifically for agentic coding on local hardware. It's free to download under Apache 2.0, and early hands-on reviews from WIRED were unusually positive. That makes it worth a serious look, and worth being honest about the catch: you need at least 48 GB of memory, and it still needs more guidance than the big paid agents.

Here's what's confirmed, what runs on which machine, how to set it up, and how to decide whether it should replace, or just sit beside, your cloud agent.

What Recursive actually released

From Recursive's launch post and the Hugging Face model card:

A mixture-of-experts (MoE) model with 39.8B total parameters and about 2.5B active per token. "40B-A2.5B" is the rounded name. The 2.5B figure includes the output head; the active body alone is about 2.2B. Only a small slice of the model runs for each token, which is why it's fast on a laptop.
Built for coding agents: investigating codebases, fixing bugs, implementing features and writing tests, with reasoning (always on) and multi-turn, OpenAI-compatible tool calls.
Apache 2.0 weights on Hugging Face. Recursive notes that its hosted API terms are separate from the weight license.
A 262,144-token documented context. The launch post says Flint "supports context windows of up to 512k tokens" but recommends staying within 256k. Locally, your memory decides how much of that you can actually use.
Knowledge cutoff of June 2026.
Built largely with automated research. Recursive says its "Eureka Machine" system helped with nearly every part of the stack and that a small team built Flint from scratch in under four months. That's the company's description; TechCrunch and WIRED report it as Recursive's claim.

The benchmark numbers (vendor-reported)

Recursive reports 74.2% on SWE-bench Verified, 89.7% on SWE-bench Pro v2 and 54.9% on Terminal-Bench 2.1. Ollama's model page also labels these as publisher-reported. A few details matter when you compare:

SWE-bench runs used mini-swe-agent with no internet access, averaging pass@1 over at least five attempts, at temperature 1.0.
Recursive says Flint leads MoE models under 50B total parameters on these agentic benchmarks and rivals dense 25–40B models. TechCrunch notes that on Recursive's own six-test average, one model, Qwen3.8 27B, still scored higher.
The headline scores are for the full-precision model. Recursive says its NVFP4 version scores within 0.7 points of 16-bit; I couldn't find separately published scores for the Mac INT4 build.

Treat these as a strong reason to try it, not proof it will handle your codebase.

The speed claim

Recursive says Flint generates more than 125 tokens per second on an M4 Pro MacBook Pro and more than 150 on a 64 GB NVIDIA RTX Spark, at short contexts, using its own optimized inference engine (rec). TechCrunch reported about 131 tokens per second on the M4 Pro, against 58–69 for similar models on the same machine. Those are Recursive's measurements with rec; expect different numbers with other runtimes, longer contexts, or a busy machine.

What runs on which machine

Recursive doesn't publish a RAM table by Mac model. It publishes one floor, and it's firm.

Macs

Supported for rec (Recursive's fast Mac engine): M4 Pro, M5 Pro or M5 Max, with at least 48 GB of unified memory, plus about 30 GB of free disk. rec checks your chip and memory and won't download the model if you don't meet this.
llama.cpp on Mac: Recursive's guide targets M4/M5 Pro or Max with at least 48 GB. The Q4_1 GGUF card says any Apple Silicon Mac with at least 48 GB.
Under 48 GB (16, 24, 32 or 36 GB Macs): not a configuration Recursive supports. The 4-bit files alone are 22.6–26 GB, and the KV cache, your editor, a simulator and the OS all need room on top. I wouldn't plan an agent workflow around it.
Older chips (M1–M3) with 48 GB or more: not covered by rec. The GGUF route only lists the 48 GB requirement, so it may work through llama.cpp or Ollama, but there are no official speed numbers.

PCs and NVIDIA GPUs

llama.cpp with CUDA on Linux or WSL2. Recursive recommends at least 48 GB of GPU memory (or unified memory on Spark machines) and lists tests on B300, RTX PRO 6000 Blackwell, RTX Spark and DGX Spark.
Typical 24–32 GB gaming GPUs aren't in the tested list. Recursive's docs say partial CPU offload may let a model load but can substantially change performance.
rec on NVIDIA RTX Spark is "coming soon."

The available builds (quantizations)

MLX INT4, about 22.6 GB, for rec on Apple Silicon.
Q4_1 GGUF, 26.0 GB, for llama.cpp with Metal on Macs.
NVFP4 GGUF, 22.9 GB, for llama.cpp with CUDA on NVIDIA.
BF16, about 80 GB, for SGLang on a single B300 or H200 data-centre GPU. Not a laptop option.
Ollama packages Flint as several tags of 23–26 GB. Recursive's docs use flint:40b-a2b-qat-int4.

Setting it up

All commands below are taken from Recursive's, Ollama's and Hugging Face's own instructions as of October 22, 2026. Check the current docs before you run them, because this is a two-day-old release.

Option 1: Ollama (easiest on any supported machine)

Install Ollama, then pull and chat with Flint:

# Example: run Flint in Ollama (tag from Recursive's docs)
ollama run flint:40b-a2b-qat-int4
# type /bye to leave the chat

Ollama's launcher can then wire Flint into a coding harness. Run it from your project directory and pick the Flint model when asked:

# Example: connect Flint to a coding harness through Ollama
ollama launch opencode   # or: ollama launch pi
ollama launch codex      # needs Codex installed first
ollama launch vscode     # VS Code's built-in chat

Ollama's own Flint page also lists ollama launch claude --model flint for Claude Code. Ollama recommends at least 64K context for OpenCode, so raise Ollama's context setting if your memory allows it.

Option 2: rec (fastest on supported Macs)

rec is Recursive's own Apache 2.0 engine for M4 Pro and M5 Pro/Max Macs. It downloads the model, starts a local server and configures the harness for you:

# Example: install rec and launch Flint with the Pi harness (supported Macs only)
curl -fsSL https://raw.githubusercontent.com/recursive-oss/rec/main/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
rec doctor          # checks your chip and memory
rec launch pi       # or: rec launch opencode
rec stop            # when you're done

As always with a curl | bash installer, read the script first if you're cautious. Recursive recommends Pi as the lighter harness and cites informal reports of roughly 1.5× faster workflows than OpenCode.

Option 3: llama.cpp (most control)

Flint support was merged into llama.cpp on October 21, 2026 (pull request #30928), and the first release build that includes it is b11803. Older builds won't recognise the model. On a Mac with 48 GB or more, the Hugging Face card for the Q4_1 GGUF gives this recipe:

# Example: download the Mac GGUF and serve it with llama.cpp (Metal)
hf download RecursiveSI/flint-int4-gguf flint-int4-q4_1.gguf pi-models.json opencode.json \
  --local-dir flint-int4-gguf

llama-server -m flint-int4-gguf/flint-int4-q4_1.gguf \
  --alias flint -ngl all -c 262144 -np 1 --cache-ram 0 \
  -b 256 -ub 128 -t 8 -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

That uses the full 262K context. If you run out of memory, lower -c first and set your harness to the same limit. On NVIDIA, the RecursiveSI/flint-nvfp4-gguf card has the CUDA equivalent. Keep --jinja on, because Flint's chat template matters for tool calls.

LM Studio is also supported (lms get recursivesi/flint), if you prefer a desktop app.

Wiring it into your editor or agent

Every route ends with an OpenAI-compatible endpoint on localhost, which most coding tools can use:

Ollama: http://127.0.0.1:11434/v1, model flint:40b-a2b-qat-int4.
rec: http://127.0.0.1:11500/v1, model flint, with the key from rec auth token. Treat that token as a secret.
llama.cpp: http://127.0.0.1:8080/v1, with the model name set by --alias.

For Cline in VS Code, Recursive's guide uses the Ollama provider, base URL http://localhost:11434 (without /v1), model flint:40b-a2b-qat-int4, the Use Compact Prompt setting turned on, and at least 32,768 tokens of context in both Ollama and Cline. Before trusting any setup, check that it can complete a full tool cycle: read a file, edit it and run a command. A chat reply alone doesn't prove the agent loop works.

Example first task (adapted from Recursive's docs):
Read this project and explain how to run its tests. Do not change files yet.

Where local beats a paid cloud agent

Privacy and client work. With a local runtime, your code and prompts stay on your machine. That's a real advantage for NDA work, unreleased products and regulated clients. Do check your harness's own telemetry settings, and note that hosted "free" Flint routes are a different matter: OpenCode's free tier is cloud-hosted, and at least one router says its free variant may log prompts.
Offline work. Planes, trains and bad hotel Wi-Fi stop mattering once the model is downloaded.
No per-token bills. After the hardware, a long agent session that reads a whole repository costs you electricity, not tokens. That's especially useful for exploratory work, repetitive refactors and test-writing loops that burn through tokens on paid APIs.
No rate limits or outages from a provider. Your model is always available, and its behaviour won't change under you unless you update it.
You can adapt it. Apache 2.0 means you can fine-tune or ship it inside your own tools.

Where it still needs hand-holding

Recursive is upfront about this: Flint "may need more guidance than the larger closed-source coding models you're used to," and it recommends breaking complex tasks into smaller subtasks with explicit instructions. In practice, plan for:

Smaller, well-scoped tasks. "Add a test for this function and fix what it exposes" will go better than "build the billing system."
Memory pressure. A 48 GB machine running Flint, Xcode, a simulator and Docker at once is tight. Long contexts grow the KV cache, so you'll trade context length for headroom.
Configuration that has to match. Tool calls depend on a matched chat template, parser and runtime version. Recursive's troubleshooting page lists tool calls appearing as plain text and agents repeating actions as known symptoms.
Running out of output budget. Reasoning is always on. If a reply stops early with finish_reason: length, raise the output budget or start a fresh, shorter task.
One job at a time. rec handles one generation at a time, and overlapping requests can get an HTTP 429. Parallel sub-agents are a cloud strength for now.
Reviewing everything. The model card warns about faulty code and inappropriate tool calls. Keep approvals on for commands, run tests, and read diffs, exactly as you would with a cloud agent.

A simple decision framework

Try Flint as your daily local model if:

You already have a supported Mac (M4 Pro, M5 Pro or M5 Max) or an NVIDIA setup with 48 GB or more.
A lot of your work is privacy-sensitive, offline, or token-heavy and repetitive.
You're comfortable splitting work into small steps and reviewing diffs.

Keep a cloud agent as your main tool if:

Your machine has less than 48 GB of memory. Buying new hardware for this alone rarely makes sense until you've tried Flint through a hosted route.
You rely on long, autonomous, multi-file tasks or several agents running in parallel.
You need the strongest possible results on unfamiliar or messy codebases.

For most indie devs, the honest answer is both: use Flint locally for private code, routine edits, tests and offline sessions, and save the paid cloud agent for the hard, sprawling tasks where it clearly earns its fees. Give it a week on a real project before cancelling anything.

Corrections and caveats

"40B" is rounded. The model card says 39.8B total and about 2.5B active, including the output head (about 2.2B without it).
The 125+ tokens per second figure is Recursive's measurement with its own rec engine, on an M4 Pro MacBook Pro, at short contexts. It doesn't describe Ollama or llama.cpp, or long agent sessions.
There's no official per-Mac RAM table. The only published requirement is at least 48 GB of memory; rec also requires an M4 Pro, M5 Pro or M5 Max.
Context length: the launch post says up to 512K, while the model card and Ollama list 262K (256K). Plan around 256K at most, and less on a 48 GB machine.
Benchmarks are vendor-reported and measured on the full-precision model with a specific harness. They're not independent results.
llama.cpp support is brand new. Use build b11803 or later.
Direct API access is limited to select partners. For hosted access today, Recursive points to OpenCode's free tier (subject to capacity and rate limits) and other providers.

Quick checklist

Check your memory: 48 GB or more, and for rec, an M4 Pro, M5 Pro or M5 Max.
Free about 30 GB of disk space.
Start with ollama run flint:40b-a2b-qat-int4, or rec launch pi on a supported Mac.
Connect your harness and verify a full read, edit and run cycle.
Lower the context length before anything else if you run out of memory.
Give it small, explicit tasks, keep approvals on and review every diff.
Keep your cloud agent for long, sprawling tasks until Flint proves itself on your code.

If you're working out how local and cloud coding agents fit into your own workflow and want a second opinion, get in touch.

About the author: Muhammad Tayyab is a full stack and mobile developer based in Lahore. He builds DripScore, an AI outfit rating app live on the App Store, under dawnapps.co. Find him on GitHub, LinkedIn, and X, or say hello at /#contact.

Sources

Back to all posts

Thanks for reading 🙏