Running a Local Coding Model on Your Laptop: Recursive Flint

A local coding model used to mean trading speed and quality for privacy. On October 21, Recursive, Richard Socher's company, released Flint, an open-weight model built for agentic coding on local hardware. It's under the Apache 2.0 license, and it runs through Ollama, LM Studio and llama.cpp.

I haven't run it yet. This post is the homework I do before downloading 23 GB of anything: what the model is, what it needs, the setup commands Recursive and the runtimes publish, and where a local model would sit next to the cloud models I already use.

Flint is a mixture-of-experts model. The model card lists 39.8 billion total parameters, which Recursive rounds to 40B, with about 2.5 billion active for each token. That active number is the whole trick. Only a small slice of the model does the work for each token, so it can generate fast on hardware that couldn't run a dense 40B model well.

It's text in and text out, with reasoning and multi-turn tool use. That means it can work in an agent loop: read files, run commands and edit code. The model card documents a 262,144-token context window shared between the prompt and the output. Recursive's blog says it supports up to 512K but recommends staying within 256K.

The benchmark numbers are Recursive's own. The model card reports 89.7% on SWE-bench Pro v2, 74.2% on SWE-bench Verified and 54.9% on Terminal-Bench 2.1, using the mini-swe-agent and Terminus 2 harnesses. For context, the SWE-bench Pro v2 paper shows top frontier agents resolving up to 99.4%. Flint isn't competing with those. It's competing with what fits on a desk.

This is the question that decides everything else, so here are the published numbers:

• LM Studio lists a 24 GB minimum system memory for its Flint build.
• Ollama's default flint tag and the flint:40b-a2b-qat-int4 build Recursive's docs use are both 23 GB downloads. A q4_1 build is 26 GB, and the full-precision MLX build is 80 GB.
• rec, Recursive's own Mac engine, needs an M4 Pro, M5 Pro or M5 Max with at least 48 GB of unified memory. It refuses to download the model on anything less.

The fine print matters. Recursive's troubleshooting page says the file size doesn't include the KV cache and working buffers. A 23 GB model fitting in 24 GB of RAM doesn't mean the full context will. On a 32 GB laptop with an editor, a browser and a dev server open, expect to run a shorter context.

The speed headline, more than 125 tokens per second on an M4 Pro MacBook Pro, is also Recursive's number. It's measured with its own optimized engine at short contexts. Ollama and LM Studio will have their own speeds, and nobody has published those yet.

Ollama. Recursive's guide uses this command:

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

It downloads on first run and opens a chat. Type /bye to leave. Ollama's library page also lists plain ollama run flint, but that tag points to a different build than the one Recursive's guide uses, so I'd stick with the documented one.

LM Studio. Install LM Studio, open it once, then use its CLI:

lms get recursivesi/flint
lms load --identifier flint
lms server start --port 1234

That gives you an OpenAI-compatible server at http://127.0.0.1:1234/v1 with the model ID flint.

Recursive's sampling settings are temperature 1.0, top-p 0.95 and top-k 20. For hard problems, give it an output budget of at least 32,768 tokens, because reasoning eats into the same budget.

Recursive documents a few paths. From your project folder, ollama launch vscode sets up VS Code's built-in chat. ollama launch opencode and ollama launch pi start terminal coding agents. Cline works through Ollama's provider settings. For anything else that speaks the OpenAI API, point it at http://127.0.0.1:11434/v1 for Ollama, or port 1234 for LM Studio.

Recursive doesn't document a setup for Cursor, so I'm not going to guess at one. My plan is to try it in VS Code and a terminal agent on a test repo first.

If you'd rather try it before downloading anything, Recursive says Flint is available free in OpenCode's free tier, with capacity and rate limits. That's not local, so your code leaves the machine.

My day-to-day setup is in my AI coding setup post: Cursor as the editor, Grok 4.7 for almost all of the work. I'm also lining up Gemini 4 Argon for a head-to-head on bigger tasks. A local model isn't replacing either one. It answers a different question: what can I do when the code shouldn't leave the machine, or when there's no internet?

Recursive is upfront about this. It says Flint may need more guidance than the large closed models, and it suggests splitting complex work into smaller subtasks with explicit instructions. That shapes how I'll test it:

• Small, well-defined tasks. Write the tests for one function, or explain what a legacy include file does.
• Code that's sensitive by nature. A config loader, or a script that touches credentials, where keeping the code on my machine is the point.
• The same task in the cloud model. I'll compare the diffs myself and note what it costs in time and corrections.

The benchmarks are vendor-reported. Recursive ran them on its own harness settings. Your repo is the real test.

Memory is the real limit. Download size isn't runtime size, and long contexts need a lot more.

A tool-using model still needs fences. The model card says it can make incorrect or unsafe tool calls. Run agents in a scratch repo with narrow permissions, the same rule I use for the cloud ones.

None of that is a reason to skip it. A free, open coding model that runs offline is worth an afternoon of testing.

Local or cloud, the agent types and I decide what ships. I wrote about that split in Cursor, Grok, and the other agents, and a local model doesn't change it. I'll write up what I find once I've actually run it.

If you want help setting up an AI-assisted workflow that keeps sensitive code in-house, get a free quote.

What is the best local coding model to run on a laptop?

It depends on your memory and your tasks. Recursive Flint is a new open-weight option built for local agentic coding. Its own benchmarks put it ahead of other mixture-of-experts models under 50B parameters, but test it on your own code before you switch.

How much RAM does Recursive Flint need?

LM Studio lists a 24 GB minimum, and Ollama's main builds are 23 GB downloads. Recursive's rec engine requires a Mac with an M4 Pro, M5 Pro or M5 Max and at least 48 GB of unified memory. Longer contexts need more memory on top of the model file.

Is Recursive Flint free?

Yes. The weights are on Hugging Face under the Apache 2.0 license, so you can run it locally with no API fees. Recursive also lists free access through OpenCode's free tier, with rate limits.

Can I use Flint with Ollama?

Yes. Recursive's guide uses ollama run flint:40b-a2b-qat-int4, which downloads the model on first run. Ollama's launchers can then connect it to VS Code, OpenCode and other coding tools.

• Recursive, "Introducing Flint"
• Hugging Face, RecursiveSI/flint model card
• Recursive Docs, "Ollama"
• Recursive Docs, "LM Studio"
• Recursive Docs, "rec"
• Recursive Docs, "VS Code"
• Recursive Docs, "Troubleshooting"
• Ollama, "flint" model library
• LM Studio, "Flint"
• arXiv, "SWE-Bench Pro V2: A Cleaner, Harder-to-Game Coding Benchmark"
• Richard Socher on X, Flint announcement (October 21, 2026)