Run Recursive Flint Locally on Windows 11, Mac and Kali Linux: The 40B Coding Model That Uses 2.5B per Token, the RAM You Really Need, Ollama, LM Studio and llama.cpp Setup

To run Recursive Flint locally, install Ollama v0.40.8 or newer and run ollama run flint:40b-a2b-qat-int4. That pulls a 23 GB 4-bit build of the new open coding model (Apache 2.0, released October 21, 2026). It also works in LM Studio (lms get recursivesi/flint), Unsloth, and llama.cpp from build b11801 onward. Flint is a 39.8-billion-parameter mixture-of-experts model that uses only about 2.5 billion parameters per token, which is why it runs fast on a home machine, with a 262K-token context. Recursive reports 74.2 percent on SWE-bench Verified. Before you download, know three things. First, the 23 GB download is not the memory you need. Unsloth puts the 4-bit version at about 26 GB of RAM plus VRAM, and Recursive's own Mac guides ask for 48 GB of unified memory, so on a 16 to 32 GB machine you want the 3-bit (18.5 GB) or 2-bit (11 to 14 GB) files. Second, Flint's thinking cannot be switched off. Every answer starts with reasoning, so give it a big output budget (Recursive suggests at least 32,768 tokens for hard problems) or it stops mid-thought. Third, a llama.cpp build from before October 21 rejects the file with "unknown model architecture: 'flint'". This guide covers Windows 11, Mac and Kali Linux setup, which file fits your hardware, the settings that matter, connecting coding agents, and every error you are likely to see.

Ethan writes the small Python scripts that run Jake's shop: stock counts, the repair queue, the nightly backup. He wanted a coding assistant but did not want the customer database pasted into anybody's cloud. "Can it run on the shop PC?" Jake asked. "The download fits," Ethan said, reading the model page. "The question is whether the memory does." That question, and the rest of Ethan's checklist, is what this page answers.

New to running AI on your own computer? A local model is a file you download and run with a free app such as Ollama or LM Studio. After the download, nothing leaves your machine: no account, no per-token bill, and it works offline. The limits are your computer's memory and speed. Our run AI locally series covers the basics, and our comparison of Ollama, LM Studio, Jan and Unsloth helps you pick an app. Flint is a coding model, built to read a repository, fix bugs and write tests through a coding agent, rather than to chat about the weather.

What is Recursive Flint?

Flint is the first model from Recursive, a lab building automated AI research systems. Its team says Flint was built from scratch in under four months, with their "Eureka Machine" proposing and testing ideas across data, training and inference. What matters for you is the shape of the model:

The mixture-of-experts design is the key to running it at home. All 39.8 billion parameters must sit in memory, which sets how much RAM you need. But each generated token only touches about 2.5 billion of them, which sets how fast it runs. That is why Flint can generate quickly on a laptop-class chip while a dense 27-billion-parameter model, which reads every parameter for every token, crawls. Recursive reports more than 125 tokens per second on an M4 Pro MacBook Pro and more than 150 tokens per second on a 64 GB NVIDIA RTX Spark at short contexts, using its own optimized engine. Your speed will depend on your hardware, your app and your context length.

Hardware: how much RAM and VRAM Flint needs, and which file to pick

Two numbers matter: the size of the file, and the memory it needs while running, which adds the KV cache (the model's working memory for your conversation and code), runtime buffers and your operating system on top. These are the totals for each precision (system RAM plus GPU VRAM, or Mac unified memory):

Those figures assume modest contexts. Coding agents push context up fast, because they read files, keep tool results and remember the whole session, and the KV cache grows with every token. Flint's sliding-window layers keep that growth smaller than in a model with full attention everywhere, but a 100K-token agent session still needs real headroom. A simple rule: pick the largest file that leaves at least 6 to 8 GB free after loading, and lower the context length before you lower the quantization.

Recursive's own tools set a higher bar on Macs. Its rec engine and its llama.cpp Mac guide both require an M4 Pro, M5 Pro or M5 Max with at least 48 GB of unified memory. That is a supported-configuration line, not a hard limit for every app. The 3-bit file fits 24 GB setups at short contexts, but the 48 GB line tells you where Flint is expected to run well. "So the shop PC can run it, just not the biggest version," Jake said. "And not with the whole repository loaded at once," Ethan said. "That's fine. I only need one script at a time."

Why mixture of experts changes the hardware math

In a normal (dense) model, every weight is used for every token, so the whole model must sit in fast memory, ideally GPU VRAM, or it crawls. Flint is different. About 95 percent of its weights live in the 256 experts of each MoE layer, and each token only uses 6 of them plus one shared expert. The rest of the model, the attention layers, the shared expert and the embeddings, is small and used on every token.

That split lets you place the parts where they fit best. llama.cpp has two flags for exactly this, both present in current builds:

• --cpu-moe keeps all expert weights in system RAM and puts everything else on the GPU. A card with modest VRAM then holds the always-used parts, and the big expert tables sit in cheaper system memory.
• --n-cpu-moe N keeps the experts of only the first N layers in RAM. Raise N until the model fits your VRAM, and lower it to put more on the GPU for speed.

Because only a few experts are read per token, keeping experts in RAM costs far less speed than offloading a dense model would. You still need enough total memory for the whole file. Recent llama.cpp builds also turn on --fit by default, which adjusts any settings you leave unset (GPU layers and context) to fit your devices, keeping 1,024 MiB spare on each and never cutting the context below 4,096 tokens. Ollama makes the same kind of split automatically, and ollama ps shows the result.

Context length vs memory: what a long agent session costs

The KV cache is the memory a model uses to remember your conversation, and for coding agents it can be large. Flint's design keeps it unusually small. In 35 of its 49 layers, attention only looks back 513 tokens, so those layers keep a tiny fixed cache (about 37 MB in total). Only the 14 full-attention layers store every token. Working from the published architecture (4 key/value heads of 128 dimensions in each of those 14 layers), the cache costs about 28 KB per token at 16-bit precision:

These are estimates for the cache alone. Runtimes add compute buffers on top, and a runtime that does not optimize sliding-window layers uses more. llama.cpp's --swa-full option, off by default, would give those layers a full-size cache too. The practical lessons are simple. A 32K-token agent session costs under 1 GB of extra memory, so it is cheap. The full 262K window adds about 7.5 GB, so it is possible on a 48 GB machine but not on a 32 GB one with the 4-bit file. And llama.cpp's -ctk q8_0 -ctv q8_0 options store the cache at 8 bits, which halves it.

One llama.cpp default deserves a warning. If you start llama-server without --ctx-size, the help text says the default is 0, which means "loaded from model", so it aims for Flint's full window. The --fit option then trims it to what fits your memory. That protects you from a crash, but it can leave you with a smaller or larger context than you expected, so set --ctx-size explicitly once you know what your agent needs.

NVIDIA and AMD GPU sizing: 8, 12, 16 and 24 GB cards

Matching the memory table above to common graphics cards gives these starting points. Each assumes at least 32 GB of system RAM for the parts that do not fit on the card:

• 24 GB (RTX 3090, 4090, 5090-class): the 3-bit UD-Q3_K_XL (18.5 GB) fits entirely on the card with room for a mid-sized context. The 4-bit files (23 to 25 GB) need a few expert layers in RAM, so use a small --n-cpu-moe value, or let Ollama split it.
• 16 GB: the 2-bit files (11 to 14 GB) fit on the card. For better quality, run 3-bit or 4-bit with the experts in system RAM (--cpu-moe or a larger --n-cpu-moe), which keeps the frequently used parts on the GPU.
• 8 to 12 GB: keep all experts in RAM with --cpu-moe, and the card holds attention, the shared expert and the KV cache. You need the full memory total from the table in system RAM.
• No GPU: Flint still runs on the CPU from system RAM, and its small active size makes CPU-only use more practical than with a dense model of similar quality. Expect it to be noticeably slower than with a GPU.

AMD cards work through llama.cpp's ROCm 10.0 and Vulkan builds, and Intel GPUs through SYCL or Vulkan. Ollama picks a backend for you. NVIDIA's FP4 format (the gguf-nvfp4 Ollama tag and the flint-nvfp4 GGUF) is built for recent NVIDIA hardware. On other cards, use the regular 4-bit files.

Run Flint on Windows 11 with Ollama

1. Install or update Ollama. Download the Windows installer from ollama.com, or run irm https://ollama.com/install.ps1 | iex in PowerShell. You need v0.40.8 or newer, the release that added Flint. Check with ollama --version, and see our Ollama update guide if you are on an older version.
2. Pull and run Flint. Open a terminal and run ollama run flint:40b-a2b-qat-int4, the 23 GB tag Recursive's documentation uses. Plain ollama run flint also works and pulls the default 40b-a2b tag, which is also 23 GB. The first run downloads the model, and later runs start from disk.
3. Try a coding prompt. Ask "Write a Python function that merges overlapping intervals, with tests." You will see the reasoning stream first, then the answer. Type /bye to leave the chat.
4. Check where it runs. Run ollama ps in another terminal. It shows how much of the model is on the GPU and how much on the CPU. If it says 100% CPU on a machine with an NVIDIA card, see our Ollama GPU fix.
5. If loading fails for memory, Ollama reports that the model requires more system memory than is available. Close other apps, or use a smaller GGUF (below). Our memory error guide walks through the options.

Ollama's Flint tags on October 22, 2026: latest, 40b and 40b-a2b (all the same 23 GB build), 40b-a2b-qat-int4 (23 GB), 40b-a2b-gguf-nvfp4 (23 GB, NVIDIA's FP4 format), 40b-a2b-q4_1 (26 GB) and 40b-a2b-mlx-bf16 (80 GB, full precision for Macs). All list a 256K context window. Ollama does not use the whole window by default, so raise its context setting if an agent needs more and you have the memory.

Running a smaller file in Ollama. Ollama can pull a GGUF straight from Hugging Face, which is how you get the 3-bit or 2-bit versions: ollama run hf.co/unsloth/flint-GGUF:UD-Q3_K_XL. Use the exact quantization name from the file list (UD-Q3_K_XL, UD-IQ2_XXS and so on).

Run Flint on a Mac

On a Mac you have three good options, depending on your chip and memory:

• rec, Recursive's engine (M4 Pro, M5 Pro or M5 Max with 48 GB or more, about 30 GB free disk). Install it with curl -fsSL https://raw.githubusercontent.com/recursive-oss/rec/main/install.sh | bash, which puts rec in ~/.local/bin. Then run rec launch pi (the coding agent Recursive recommends) or rec launch opencode. The first run downloads the model and the agent, and Node.js 22 is needed for pi. rec serve starts only the OpenAI-compatible server (it prints flint is ready. when loaded), and rec stop stops it. Recursive measures rec at 1.4 to 2.6 times llama.cpp's token throughput on an M4 Pro. It is built for one session at a time, so use another runtime for several agents at once.
• Ollama, with the same commands as Windows. The 40b-a2b-mlx-bf16 tag (80 GB) suits Macs with very large memory. Otherwise use the 23 GB tags.
• LM Studio or Unsloth, with a smaller GGUF on 24 to 36 GB Macs. Unsloth suggests UD-Q4_K_XL even on a 48 GB Mac for headroom, and the 3-bit file for less memory.

On Macs with 16 GB, the 2-bit files technically load, but with your apps, the OS and any real amount of code in context, there is little room left. A smaller dense or MoE model will usually be the better experience on those machines.

Run Flint on Kali Linux (and Ubuntu or Debian)

1. Install Ollama with curl -fsSL https://ollama.com/install.sh | sh. The script sets Ollama up as a background service, so it keeps running after you close the terminal.
2. Confirm the version is 0.40.8 or newer with ollama --version. Re-run the install script to upgrade.
3. Run Flint with ollama run flint:40b-a2b-qat-int4, or a smaller Hugging Face GGUF as shown above.
4. For an NVIDIA GPU, check nvidia-smi first. If the driver is missing, Ollama silently falls back to CPU, which works with a MoE model like Flint but is much slower.
5. Serve it to other tools. The Ollama service listens on http://127.0.0.1:11434. Its OpenAI-compatible endpoint is http://127.0.0.1:11434/v1 with any placeholder key (Recursive's docs use ollama), and the model ID is the tag you pulled.

If you prefer llama.cpp on Linux, download a prebuilt release from the llama.cpp GitHub page. Build b11801 or newer includes Flint, and there are separate packages for CPU, CUDA 12.8 and 13.4, Vulkan, ROCm 10.0 and SYCL. Or build from source with -DGGML_CUDA=ON as shown in the next section. Everything here works the same on Ubuntu and Debian.

Run Flint with llama.cpp (any OS)

llama.cpp gives you the most control over offloading, context and server options. Flint support was added in pull request #30928, merged on October 21, 2026. The first build that includes it is b11801, and prebuilt packages exist for Windows (CPU, CUDA 12.4 and 13.4, Vulkan, ROCm, SYCL), macOS (Apple Silicon and Intel) and Linux. The shortest path, from the ggml-org model page:

llama serve -hf ggml-org/Flint-GGUF

Or download a specific file and start the server yourself, which is Recursive's documented setup:

pip install -U huggingface_hub
hf download unsloth/flint-GGUF flint-UD-Q4_K_XL.gguf --local-dir models/flint

./llama-server \
  --model models/flint/flint-UD-Q4_K_XL.gguf \
  --alias flint-local \
  --ctx-size 32768 \
  --n-gpu-layers 99 \
  --temp 1.0 --top-p 0.95 --top-k 20 \
  --host 127.0.0.1 --port 8080

Then point any OpenAI-compatible client at http://127.0.0.1:8080/v1 with model flint-local and any placeholder key. Check that it is up with curl http://127.0.0.1:8080/v1/models. Three tips from the guides:

• --n-gpu-layers 99 asks for full GPU offload. Read the startup log to see what actually landed on the GPU. Lower it, or set 0 for CPU only, if VRAM runs out, and keep enough system RAM for the layers left on the CPU.
• Lower --ctx-size first if memory runs out. Do not set it to the model's 262K maximum unless you have tested that your machine holds it.
• Keep the model's own chat template (Unsloth's commands add --jinja) and do not add custom stop strings during your first test, because they can cut off reasoning or tool calls.

Unsloth's BF16 GGUF comes in three parts. Download all three into one folder and point llama.cpp at the first one. The ggml-org BF16 file is a single 79.63 GB download.

Run Flint in LM Studio or Unsloth

LM Studio. In the desktop app, open Settings, then Local Models, then Explore, search for recursivesi/flint, and pick a variant that fits your memory. From the terminal, the lms command that comes with LM Studio does the same:

lms get recursivesi/flint        # choose a variant when prompted
lms load --identifier flint      # stable name for clients
lms chat flint                   # chat in the terminal
lms server start --port 1234     # OpenAI-compatible API at http://127.0.0.1:1234/v1

If LM Studio reports that it cannot load the model, update its runtime first, because older runtimes do not know the Flint architecture. Our LM Studio "failed to load model" guide covers the other causes.

Unsloth. Install Unsloth with curl -fsSL https://unsloth.ai/install.sh | sh (macOS, Linux, WSL) or irm https://unsloth.ai/install.ps1 | iex (Windows PowerShell). Search for unsloth/flint-GGUF in Model hub and download UD-Q4_K_XL or smaller. To serve it, run unsloth run --model unsloth/flint-GGUF:UD-Q4_K_XL --alias flint --temp 1.0 --top-p 0.95 --top-k 20 --host 127.0.0.1 --port 8001. To open a coding agent with it, run unsloth start claude --model unsloth/flint-GGUF:UD-Q4_K_XL (or opencode). Unsloth's API needs a key you create under Settings, then API.

The settings that matter: sampling, thinking and output budget

Recursive recommends temperature 1.0, top-p 0.95 and top-k 20 as starting values, and every benchmark it published used them. These are higher-variety settings than many people use for code, so do not "fix" them down to 0.2 before you have tried them. Re-check them if you change quantization.

Thinking is always on. Flint reasons before every answer, and there is no switch to disable it. Recursive's docs say not to send a reasoning-effort setting, a disable-thinking flag or a thinking budget unless your server documents support for it. This has three practical effects:

• Give it room. Recursive suggests an output budget of at least 32,768 tokens for hard problems, counting reasoning. With a small max_tokens, the reply ends with finish_reason: "length" before the answer appears.
• Expect a pause on short questions. Even "rename this variable" gets some reasoning first. For tiny edits, a non-reasoning model can feel snappier.
• Keep the reasoning in the conversation. In multi-turn agent use, preserve the returned reasoning_content and tool-call messages in the history, as the model card asks. Clients that strip them can confuse the next turn.

Top-k is not a standard OpenAI field. Servers like llama.cpp take it at startup (--top-k 20). From the Python OpenAI SDK, you can send it with extra_body={"top_k": 20} where the server accepts it. "It thinks out loud," Jake said, watching the reasoning scroll past. "Better than me," Ethan said. "I think out loud and still get it wrong."

Connect Flint to a coding agent

Flint was built for agents, tools that read and edit your files and run commands, not just chat. The quickest routes:

• Ollama launchers (run from your project folder after pulling Flint): ollama launch opencode, ollama launch pi, ollama launch codex, ollama launch vscode, and ollama launch claude --model flint for Claude Code against the local model. Select the Flint tag when asked. You need a recent Ollama that includes the launcher.
• rec on Macs: rec launch pi or rec launch opencode sets up the agent and the model together.
• Unsloth: unsloth start opencode, unsloth start pi --persist, or unsloth start claude.
• Cline, OpenHands and others: add an OpenAI-compatible provider with the base URL of your server (http://127.0.0.1:11434/v1 for Ollama, :8080/v1 for llama.cpp, :1234/v1 for LM Studio), the exact model ID, and a placeholder key.

Our OpenCode guide covers that agent in depth. Before you trust any agent setup, run one complete tool cycle: ask it to read a file, change one line and run a test. A desktop chat that works does not prove tool calls work, because the tool-call format depends on the chat template and the server's parser. Recursive's own advice for local coding is to break big jobs into smaller subtasks with explicit instructions, because Flint may need more guidance than the large cloud coding models.

Your first coding task with Flint and OpenCode, step by step

1. Pull the model and make sure it answers. Run ollama run flint:40b-a2b-qat-int4, send a short prompt, wait for the answer, then type /bye.
2. Open your project folder in a terminal. Commit or back up first, because an agent edits files. A clean git state means you can always see and undo what it changed.
3. Start the agent with ollama launch opencode and select the Flint tag when it asks. OpenCode runs in your terminal with Flint as its model.
4. Give it one small, specific task. For example: "Read inventory.py. The function count_stock fails when a row has an empty quantity. Fix it and add a test in tests/test_inventory.py." Name the files, the symptom and the definition of done.
5. Watch the tool calls. Flint reasons, reads the files, proposes an edit and asks to run commands. Keep the agent's approval prompts on, so nothing runs without your OK.
6. Review the diff with git diff. Read every line, as you would review a colleague's change.
7. Run the tests yourself before you commit. If they fail, paste the failure back into the agent and ask for a fix, which is where a coding agent earns its keep.

Start a new session for each separate task. A fresh session keeps the context short, which keeps memory use and response time down, and it stops old details from confusing the new job. "One script, one session," Ethan said. "Same rule as with interns."

Can Claude Code, Codex or VS Code use Flint? Local models in coding tools

Yes. Searches like "can Claude Code use local models" and "Codex with local models" have the same answer: point the tool at a local, OpenAI-compatible server, and Flint becomes its model. The launchers do the wiring for you:

• Claude Code: ollama launch claude --model flint, or unsloth start claude --model unsloth/flint-GGUF:UD-Q4_K_XL from Unsloth.
• Codex: ollama launch codex, after installing Codex itself, or unsloth start codex --persist, which needs Unsloth's GGUF/llama-server backend.
• VS Code: ollama launch vscode or unsloth start vscode. Cline in VS Code takes Ollama as a provider directly.
• OpenCode and Pi: ollama launch opencode, ollama launch pi, or rec launch pi on a supported Mac, which is Recursive's recommended pairing.

Running Flint this way is free in the sense that matters for a small shop: the model and Ollama cost nothing to run locally, and there is no per-token bill. The coding tool keeps its own license and account terms, so check those separately. Expect a different feel from a big cloud model. Flint is fast, but it plans less on its own, so give it narrow tasks, name the files, and say what "done" means. When a task is too big for it, that usually shows up as a long loop of tool calls without progress. At that point, split the task rather than letting it run.

What local saves you. A coding-agent session that sends about 2 million input tokens (most of them cached) and gets 50,000 tokens back costs roughly $1 on a cloud model priced at $2 / $10 per million tokens, and about $5 to $6 on a $10 / $50 frontier model. Ten sessions a day is roughly $10 to $60 a day. On Flint the same sessions cost electricity. The trade is quality on hard tasks and the hardware you already own, so many developers use a local model for routine work and keep a cloud model for the tough problems.

Ollama itself is free for local models and works offline once a model is downloaded. If ollama launch is not recognized, your Ollama is too old for the launcher. Update it, then retry.

Flint benchmarks vs Qwen, Gemma and Muse (publisher-reported)

These are Recursive's release numbers, with scores marked by Recursive as measured internally (†) where the original chart did. Treat them as a starting point, not a verdict on your codebase:

Read the table honestly. Among MoE models of its size, Flint leads clearly, beating Qwen 3.6 by 10 points on Terminal-Bench 2.1. Among dense models, Qwen 3.8 scores higher on most of these tests. The trade is speed: a dense 27-billion-parameter model reads every weight for every token, while Flint reads about 2.5 billion, so on the same machine Flint answers several times faster. Recursive says more than five times faster than dense models of similar coding scores. The NVFP4 quantized checkpoint lost very little, which is good news for anyone running the 4-bit files. If you already run Qwen3.8 27B and are happy with the speed, Flint is a speed upgrade more than a quality upgrade. If Qwen 3.8 is too slow on your machine, Flint is the strongest option at this speed.

Is there a Flint API? Price and access

Not a public one. Recursive's FAQ says the Flint API is available to select partners, with an access request form, and partner access runs through Nebius. There is no public per-token price as of October 22, 2026. For everyone else, Flint is a local model. That is the point of it, and with Apache 2.0 weights there is no license fee or usage cap for commercial use. Hosted API terms, when they come, will be separate from the weight license. If you need Flint on a server, Recursive ships an SGLang serving kit with the full model, which needs one B300 or H200 GPU per copy and an 80 GB download. Ready-made Transformers modeling code was not included at launch.

Common Flint errors and fixes

• "llama_model_load: error loading model: unknown model architecture: 'flint'" means your llama.cpp build is older than b11801 (or an app bundles an older llama.cpp). Download a current release, or rebuild from the latest source. Build b11800 still prints this message for a Flint file. Builds from b11801, the first one after the change was merged, recognize the architecture.
• Ollama cannot pull or load flint. Update to v0.40.8 or newer, which added Flint. On Windows, quit the tray app and reinstall. On Linux, re-run the install script.
• "Unsupported architecture" in LM Studio or Unsloth. Update the app and its inference runtime, which often update separately, then retry.
• Out of memory, or a crash while loading. Lower the context length first, then move down one quantization step (4-bit to 3-bit). On NVIDIA, partial CPU offload can make it load, but it will run slower.
• Answers stop mid-sentence, with finish_reason: length. The output budget ran out during reasoning. Raise max_tokens, to 32,768 for hard problems.
• Tool calls fail or come back as plain text. The chat template or tool parser does not match. Use the template bundled with the model, avoid custom stop strings, and update your server.
• Very slow responses. Check ollama ps or the llama.cpp log for CPU fallback, close memory-hungry apps, and shorten the context. A long agent session slows every runtime down.

Keeping Flint, and the apps around it, up to date

A model released this week will get fixes, and so will the apps that run it. A few habits keep you current without surprises:

• Ollama: ollama pull flint:40b-a2b-qat-int4 fetches any updated version of the tag, downloading only what changed. Update Ollama itself from time to time too.
• Hugging Face files: re-run hf download for the file you use. Keep a note of the model revision (the commit shown on the repository page), because results can change between revisions.
• llama.cpp, LM Studio and Unsloth: runtime updates often bring Flint speedups and fixes, especially for tool calling in the first weeks.
• When you report a problem, Recursive asks for the checkpoint revision, runtime version, hardware, launch command and a minimal example. Keeping that list in a text file next to your setup saves time later.

Offline and private: what stays on your machine

Once Flint is downloaded, inference runs entirely on your computer. Ollama, llama.cpp, LM Studio and Unsloth serve it on 127.0.0.1, which only your own machine can reach. Two cautions keep it that way. First, do not expose those ports (11434, 8080, 1234, 8001) to your network or the internet unless you add authentication, because anyone who can reach them can use your model. Second, a coding agent is a separate program with its own settings. Some agents can browse the web, install packages or send usage data, depending on how you configure them. Check the agent's settings if "nothing leaves this machine" is your reason for running locally. For Jake's shop, that check took five minutes, and it was the most important five minutes of the setup.

Flint vs other local coding models: which to run on your machine

• 16 GB RAM, no big GPU: Flint only in 2-bit form, with little room for context. A smaller model will usually feel better. See our Qwen3.8 Flash Next guide for a lighter option.
• 32 GB RAM, or a 24 GB GPU: Flint's 3-bit or 4-bit files are a strong fit. This is where its MoE speed shines, because a dense model of similar quality would be much slower.
• 48 GB+ Mac (M4 Pro, M5 Pro or Max): the supported sweet spot. Use rec for the fastest experience, or Ollama for convenience.
• 64 GB+ workstation: Q8_0 or Q6 for the best local quality, with room for long agent sessions.
• When quality matters more than speed: a dense model like Qwen 3.8 still edges Flint on several benchmarks. Our Muse Glimmer guide covers another dense alternative.

If you searched for the best local coding model for 8 GB, 12 GB, 16 GB or 24 GB of VRAM, the answer for 2026 depends on system RAM as much as on the card. Flint's experts can live in RAM, so a 12 GB card with 32 GB of RAM runs the 4-bit file. A dense model of similar quality needs nearly all of its weights in VRAM to be fast. On a 24 GB card, Flint's 3-bit build fits entirely on the GPU, which makes it one of the quickest strong coding models you can run on a single consumer card. On 8 GB cards, keep the experts in RAM and expect CPU-bound speeds.

Ethan's shop PC has 32 GB of RAM and a 24 GB graphics card, right in the middle of that list. He started with the 4-bit Ollama tag at a 32K context, kept Recursive's sampling settings, and pointed OpenCode at it for one script at a time. The customer database never left the room.

Flint troubleshooting, by symptom

ollama run flint downloads but will not start

Ollama is older than v0.40.8, or there is not enough free memory. Update Ollama, close other apps, or try a 3-bit GGUF.

llama.cpp says unknown model architecture flint

Your build predates b11801. Download a newer release or rebuild from the latest source.

Flint writes a lot of reasoning and then stops

max_tokens is too small. Flint always reasons first, so allow up to 32,768 output tokens for hard tasks.

The coding agent chats fine but never edits files

Tool calls are not being parsed. Keep the bundled chat template, remove custom stop strings, and update the server or app.

It was fast at first and slowed down later

The context grew during the session. Start a fresh session per task, or lower the context length.

My GPU is idle while Flint runs

The runtime fell back to CPU. Check the GPU driver, then ollama ps or the llama.cpp log for the offload split.

ollama launch says the command does not exist

Your Ollama predates the launcher. Update Ollama, then run ollama launch opencode or ollama launch claude --model flint again.

The model loads in LM Studio but answers are garbled

The runtime or chat template is out of date for Flint. Update LM Studio's runtime and reload the model with its bundled template.

Recursive Flint: frequently asked questions

A week later, Ethan's stock-count script had tests for the first time. Flint had written most of them, and he had read every one. Jake asked whether the new assistant ever got things wrong. "All the time," Ethan said. "So do I. The difference is that it never gets tired of fixing them, and it never sees anything outside this room."

Revision note. Written October 22, 2026, the day after Flint's release, with the model files, app versions and setup commands of that date. "Measure twice, cut once," the carpenter's proverb says, and with a 23 GB model the measuring is your memory.