Recursive Flint: Run It in Claude Code, OpenCode and Cline

Use Recursive Flint through Ollama on a compatible Mac to try local coding in Claude Code, OpenCode or Cline. If your computer cannot fit the model, try OpenCode’s temporary hosted offer with non-sensitive code first. Start with a bounded task and a clear test, keeping your existing cloud model available for work that repeatedly stalls.

The availability and configuration details below are current as of 2026-10-23.

What does Recursive Flint change?

Flint combines a large pool of weights with relatively little computation per generated token. Its official model card specifies 39.8B total parameters, approximately 2.5B active per token, text input/output, and Apache 2.0 weights. A mixture-of-experts model activates selected experts for each token; the inactive weights still contribute to its storage and memory requirements.

Flint supplies reasoning and tool requests. Your coding client executes file reads, edits and terminal commands, then returns their results. Evaluate the model, inference runtime and coding client together.

Recursive reports more than 125 tokens/s on an M4 Pro MacBook Pro and more than 150 tokens/s on a 64GB RTX Spark, using its optimized engine at short contexts. These are vendor-reported generation rates, not measured times to a correct patch in Ollama or Cline.

Use the context limit your runtime actually configures. The model card documents 262,144 tokens shared by input and output; the announcement mentions up to 512K but recommends staying within 256K. Neither number guarantees that your laptop can allocate the full window.

How much memory does Flint need?

Budget for weights, context cache, compute buffers and your other applications. A roughly 23GB download does not establish that Flint will run comfortably on a 24GB computer.

Deployment	Published hardware and storage requirements	Practical implication
Recursive’s optimized rec engine	M4 Pro, M5 Pro or M5 Max; at least 48GB unified memory; about 30GB free disk	This is the documented Mac requirement for rec, not a universal Ollama minimum.
Ollama flint package	Current default download: 23GB; Flint support in v0.40.8 is macOS-only	Leave memory beyond the package size and verify the allocated context.
NVIDIA NVFP4 GGUF with compatible llama.cpp/CUDA	22.9GB model file; Recursive recommends at least 48GB GPU memory, or unified memory on Spark	RTX Spark and DGX Spark are tested targets. The 64GB launch demonstration is not a published minimum.
BF16 SGLang serving bundle	Validated on B300 or H200 with at least 141GB VRAM per replica; about 80GB weights plus 50GB container image	This is a separate server deployment, beyond ordinary laptop hardware.

These figures come from the rec requirements, Ollama model listing, official NVIDIA quantization card and SGLang deployment guide.

The macOS restriction belongs to Ollama v0.40.8’s Flint implementation, which defers other GPU support to a subsequent release. NVIDIA-compatible weights already exist for other runtimes; their availability does not establish Windows/Linux support for the same Ollama command.

Run Flint locally with Ollama

Install or update Ollama, keep its service running, and confirm a plain model response before connecting a coding client. Ollama’s Mac installation guide requires macOS Sonoma 14 or newer.

Run in Bash:

ollama --version
ollama run flint

The second command downloads the model if needed and opens a chat. Ask it to explain a short function, then exit that chat.

For coding clients, allocate at least 64K context through the Ollama app’s settings. Both Claude Code and OpenCode integration guidance call for that size. More context consumes more memory; if it cannot fit, use the hosted route or different hardware.

While a request is running, inspect the server from another terminal:

ollama ps

Check that Flint appears, inspect CONTEXT, and look at PROCESSOR for GPU offloading. The context documentation explains these fields. An advertised maximum and the currently allocated context can differ.

If no client can connect, first open the Ollama app and repeat ollama run flint. If Flint is missing from a client’s list, run ollama pull flint and refresh that list.

Connect one coding tool and verify an edit

Choose the client you already use and open an empty trial directory or a disposable repository branch. These are alternative connections to the same local model.

Claude Code

Use Ollama’s launcher with an installed Claude Code client:

ollama launch claude --model flint

The command is published on Flint’s Ollama page. The launcher directs Claude Code to Ollama’s Anthropic-compatible endpoint; you do not enter a vendor API key for local Ollama inference.

Run /status inside Claude Code to inspect the selected model and connection. Verify that the endpoint is local, normally http://localhost:11434, and correlate a request with ollama ps. Asking the model to identify itself is not a routing check.

If Claude Code still uses an old endpoint, inspect ANTHROPIC_BASE_URL and related authentication/model overrides in ~/.claude/settings.json, project settings and your shell configuration. Claude settings can override inherited shell values. Organization-managed restrictions still apply.

OpenCode

Launch the local model from your project directory:

ollama launch opencode --model flint

Ollama publishes this exact command. In OpenCode’s /models picker, confirm that the active provider is Ollama and the model is Flint. The hosted Flint 40B Free entry is a different connection.

If OpenCode is not installed, use its current installation instructions. The launcher route avoids maintaining a provider JSON example across OpenCode’s configuration versions.

Cline

Select Cline’s native Ollama provider:

1. Open Cline Settings and choose Ollama.
2. Set Base URL to http://localhost:11434.
3. Select flint, or the downloaded tag shown as flint:latest.
4. Enable Use Compact Prompt under Settings → Features.

This follows Cline’s local-model instructions. The native Ollama provider uses the address above without /v1. Select Act mode when you want Cline to edit files and execute the test below.

Check an actual edit and test run

Use this small task to check the complete tool loop:

Create slugify.py with a slugify(text) function. Lowercase ASCII letters, replace each run of non-alphanumeric characters with one hyphen, and remove leading and trailing hyphens.

Create test_slugify.py using unittest. Check that "Hello, World!" becomes "hello-world", "  A__B  " becomes "a-b", and an empty string stays empty.

Run python3 -m unittest -v. Show the changed files and the actual test result. Use only the Python standard library.

Have Python 3 available and approve the relevant file and terminal actions. Success means the files exist and the tool log shows a completed test command with exit status 0. Inspect the implementation and tests; a prose claim that they passed is insufficient.

This is a suggested integration check, not a benchmark result. If plain chat works but editing or command execution fails, check client permissions, context allocation and provider selection before judging model quality.

Try hosted Flint without downloading the model

Use OpenCode’s free hosted entry to evaluate a non-sensitive task before committing local memory or hardware. With OpenCode installed, run opencode in Bash, enter /models, and select Flint 40B Free.

The exact selector is opencode/flint-40b-free. OpenCode’s model catalog lists it as free for a limited time; its homepage says included free models can be used without creating an account. Recursive describes hosted access as subject to capacity and rate limits.

The hosted offer does not have local inference’s data boundary. OpenCode states that Flint’s collected data may be used to improve the model and is retained for 30 days. Use a project you are allowed to send to that service.

If the free entry is unavailable, check the current catalog rather than assuming permanent free access. For confidential code, choose a suitable local deployment or a separately approved provider.

Serve Flint through an OpenAI-compatible GPU endpoint

Use Recursive’s supplied SGLang bundle when you need a server API and have a supported datacenter GPU. The BF16 recipe requires Linux, Docker, NVIDIA Container Toolkit and a compatible driver; an 80GB GPU does not meet its single-replica requirements.

The serving README supplies a Flint plugin and patched kernels for SGLang 0.5.16. A stock install alone is insufficient. These Bash commands resolve one repository revision and keep its weights and serving files together:

python3 -m venv .venv-flint
source .venv-flint/bin/activate
python3 -m pip install -U huggingface_hub openai

FLINT_REV=$(python3 -c 'from huggingface_hub import HfApi; print(HfApi().model_info("RecursiveSI/flint").sha)')
hf download RecursiveSI/flint --revision "$FLINT_REV" --local-dir "flint-$FLINT_REV"
cd "flint-$FLINT_REV"
hf cache verify RecursiveSI/flint --revision "$FLINT_REV" --local-dir .
docker build -t "flint-sglang:${FLINT_REV:0:12}" sglang

After download, verification and build succeed, launch on H200:

docker run -d --name flint --gpus '"device=0"' --ipc=host \
  -p 127.0.0.1:30000:30000 \
  -v "$PWD:/model" -e MODEL=/model \
  "flint-sglang:${FLINT_REV:0:12}" \
  bash /model/sglang/serve_h200.sh

For B300, use serve_b300.sh instead. Follow the deployment guide’s driver requirements: normally R580 or newer for CUDA 13; its H200 setup also documents compatibility with driver 570.133.20 through the image’s compatibility libraries.

Startup is asynchronous. Inspect docker logs -f flint and wait for readiness; then, in another terminal, check:

curl --fail --silent --show-error http://127.0.0.1:30000/health_generate

A successful health response means you can send a request:

curl --fail --silent --show-error \
  http://127.0.0.1:30000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "flint",
    "messages": [
      {"role": "user", "content": "Write a Python function that merges overlapping intervals."}
    ],
    "max_tokens": 32768
  }'

Read the answer in choices[0].message.content. The server-side model ID is flint, and the client base URL is http://127.0.0.1:30000/v1. This recipe has no API authentication and publishes only on loopback; add authenticated access before exposing it to other machines.

Keep the supplied chat template and parsers. The recommended sampling settings are temperature 1.0, top_p 0.95 and top_k 20. Preserve returned reasoning_content in subsequent assistant messages. If finish_reason is length, reasoning may have consumed the output budget before the final answer or tool call.

For a tool round-trip, run the bundle’s python3 sglang/example_client.py --base-url http://127.0.0.1:30000/v1 from its directory. If startup never becomes healthy, inspect the container logs for driver, memory or bundle-loading failures before debugging the client.

What do the coding benchmarks actually establish?

Treat the published scores as reasons to try Flint on your work, with the evaluation settings attached. They do not establish a universal replacement for either Qwen or a larger cloud model.

Benchmark	Recursive’s Flint release result	Relevant published comparison
Terminal-Bench 2.1	54.9%	Dense Qwen3.8-27B: 73.0% in Qwen’s evaluation
SWE-bench Verified	74.2%	Qwen3.6-35B-A3B: 73.4% in Qwen’s evaluation
SWE-bench Pro v2	89.7%	Do not substitute older, unversioned Pro scores into this comparison.

The figures are published in the Flint, Qwen3.8-27B and Qwen3.6-35B-A3B model cards.

Recursive uses Terminus 2 for Terminal-Bench and mini-swe-agent for the SWE benchmarks. Its Terminal-Bench run permits internet access but counts solutions obtained through retrieval as unsuccessful. Qwen’s published comparison does not establish that it applied the same adjustment; Qwen3.6 also uses its own SWE agent scaffold.

There is a further limit on interpreting Pro v2. Scale’s locked protocol specifies a 50-minute task budget and regrading patches in pristine environments. Recursive’s general evaluation note allows agentic timeouts up to five hours without establishing its benchmark-specific alignment with that protocol. Report 89.7% as Recursive’s release result, not as an independently certified locked-protocol result.

If Qwen3.6 already completes your tasks reliably, a 0.8-point published Verified difference is not enough reason to migrate. Test Flint when local responsiveness is your bottleneck; keep it only if the same task reaches a correct, reviewed result with acceptable latency and retries.

Which tasks should stay local, and how do you switch back?

Start Flint with a contained bug fix, a small utility, focused tests or a code explanation. For changes spanning many subsystems, ambiguous failures or repeated unsuccessful repairs, try your established larger model with the relevant files, failing command and short progress summary.

This workflow recommendation follows Recursive’s advice to split complex tasks and give explicit instructions. Measure time to passing tests and review effort. Local inference avoids provider token charges, but hardware, electricity and repeated attempts still have costs.

To return from the Ollama-launched Claude Code session, exit it and reopen Claude Code using your original cloud configuration. For an already configured Anthropic Sonnet setup, run in Bash:

claude --model sonnet

Check /status before sending code. Model selection does not itself reset the endpoint: this command assumes you have not persisted local endpoint, authentication or model overrides. If you did, restore those trial changes to their previous values and restart, preserving your existing cloud credentials.

In OpenCode, use /models to select an already connected cloud provider/model; use /connect first if needed. In Cline, restore the original provider and model in Settings, checking both Plan and Act configurations if they differ.

A local model only keeps inference local. Web tools, MCP servers and other client integrations can still contact outside services; review those separately when code must remain on your machine.