Model reference · open weights

flint

LLMs RecursiveSI Text gen 2 builds Open weights 1k dl/mo

flint is an open-weight language model from RecursiveSI. flint-GGUF (GGUF) weighs 25.1 GB; the smallest configuration that runs it is 2× RTX 4060 Ti 16 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • Flint is a 39.8 billion parameter mixture-of-experts language model developed by RecursiveSI for coding agents.
  • It is designed to investigate codebases, fix bugs, implement features, and write tests, supporting text input and output along with multi-turn tool use.
  • The model features a context length of 262,144 tokens and is released under the Apache 2.0 license.

Summary of the RecursiveSI/flint model card, 2026-10-24. The estimate below is for another build of the family.

What it is

Released byRecursiveSI
Released2026-10-21
Parameters39.8B
VRAM25.1 GB for the weights

What it runs on

Memory and cards for flint-GGUF (GGUF)

25.1 GBweights, file size
651 MBruntime overhead, at least
262,144 tokenscontext max

How much memory each request adds isn't estimated yet for this architecture. The weights need at least the cards below, plus room for the context.

CardWeights alone
RTX 3060 12 GB … RTX 4090 24 GB
4 smaller cards
does not fit
RTX 5090 32 GBfits
L40S 48 GBfits
A100 80 GBfits
H100 80 GBfits
RTX PRO 6000 Blackwell 96 GBfits
DGX Spark (GB10) 128 GB unifiedfits
H200 141 GBfits
B200 180 GBfits
2× RTX 4060 Ti 16 GB
split by layers (llama.cpp)
tight
2× RTX 4090 24 GB
split by layers (llama.cpp)
fits
2× RTX 3090 24 GB
split by layers (llama.cpp)
fits

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
flint ↗ 39.8BBF16 79.6 GB2× L40S 48 GB
flint-GGUF (above) ↗
packaged by unsloth
10 builds: IQ1_M 11.4 GB … BF16 79.6 GB
GGUF 25.1 GB2× RTX 4060 Ti 16 GB

From the model card

What RecursiveSI says about flint

Read the model card

Flint is Recursive’s mixture-of-experts language model for coding agents, with 39.8 billion total parameters and approximately 2.5 billion active per token. It is designed to investigate codebases, fix bugs, implement features, and write tests.

Flint supports text input and output, reasoning, and multi-turn tool use. In our release evaluations, it scores 54.9% on Terminal-Bench 2.1, 89.7% on SWE-bench Pro v2, and 74.2% on SWE-bench Verified.

This repository contains the BF16 checkpoint, model configuration, tokenizer, chat template, and an SGLang serving kit. Quantized variants are prepared separately for NVIDIA and Apple Silicon runtimes.

Evaluation

Flint results use temperature 1.0, top-p 0.95, and top-k 20. Terminal-Bench uses Terminus 2; SWE-bench uses mini-swe-agent. Agentic scores report average pass@1 over at least five attempts. † marks scores measured by Recursive; other comparison scores are developer-reported.

Evaluation setups vary across sources. Flint’s Terminal-Bench score counts solutions obtained through web retrieval as unsuccessful; developer-reported scores may not apply the same adjustment.

Model specifications

PropertyFlint
DeveloperRecursive
ArchitectureDecoder-only mixture-of-experts Transformer
Total parameters39.8B
Active parameters per tokenApproximately 2.5B, including the output head¹
Layers49: 2 dense layers followed by 47 MoE layers
Attention35 sliding-window layers and 14 full-attention layers
Sliding window513 tokens: the current token and 512 preceding tokens
Attention heads32 query heads and 4 key/value heads; head dimension 128
Attention normalizationPer-head QK RMSNorm and learned per-head attention sinks
Position encodingRoPE on sliding-window layers; no positional encoding on full-attention layers
Experts per MoE layer256 routed experts, with 6 selected per token, plus an always-active shared expert
Documented context configuration262,144 tokens, including prompt and generated output
Vocabulary150,144 tokens
Input / outputText / text
Stated knowledge cutoffJune 2026

¹ The active-parameter convention includes the output head and excludes the full input embedding matrix. The active body alone is approximately 2.2B parameters. “40B-A2.5B” is the rounded model-size designation.

Getting started

Flint runs on one B300 or H200 GPU per replica with the SGLang kit in sglang/. Transformers modeling code is not included yet.

pip install -U huggingface_hub openai
hf download RecursiveSI/flint --local-dir flint && cd flint   # about 80 GB
docker build -t flint-sglang sglang
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 bash /model/sglang/serve_b300.sh   # H200: serve_h200.sh
until curl -sf localhost:30000/health_generate >/dev/null; do sleep 15; done      # progress: docker logs -f flint
python3 sglang/example_client.py --base-url http://localhost:30000/v1              # reasoning and a tool call
from openai import OpenAI

client = OpenAI(base_url="http://localhost:30000/v1", api_key="unused")
response = client.chat.completions.create(
    model="flint",
    messages=[{"role": "user", "content": "Write a Python function that merges overlapping intervals."}],
    max_tokens=32768,
)
print(response.choices[0].message.content)

sglang/README.md covers requirements, serve-script options, multi-GPU deployments, and API details.

Recommended generation settings

SettingValue
Temperature1.0
Top-p / top-k0.95 / 20
Output budget for hard problemsAt least 32768 tokens, including reasoning

The server applies these sampling settings when a request omits them. Flint supports OpenAI-compatible tool calls. Use the checkpoint’s chat template and preserve returned reasoning_content in conversation history. Prompt and output share the context window.

Training

Flint was trained from scratch through pretraining, mid-training, supervised fine-tuning, and reinforcement learning. Training includes text and code, instruction following, and agentic tasks.

Limitations and responsible use

Flint’s supervised fine-tuning included safety-oriented examples, but the model can still produce incorrect or harmful content, faulty code, or inappropriate tool calls. Test generated code and review consequential changes before applying them. Tool-using applications should enforce their own permissions and execution boundaries; structured tool-call grammar does not prevent the model from choosing an unsafe or incorrect action.

Long reasoning can increase latency and exhaust the output budget before an answer is complete. The context configuration is a capacity limit, not a guarantee of uniform accuracy across all sequence lengths or tasks. Results can vary with checkpoint precision and inference runtime; evaluate the specific checkpoint and runtime you intend to deploy.

License and reporting

Flint is released under the Apache 2.0 license. Hosted API terms and data practices are separate from the weight license.

For model and serving issues, contact support@recursive.com and include the checkpoint revision, runtime version, hardware, launch command, and a minimal reproduction. Report safety concerns or suspected misuse to safety@recursive.com, and security vulnerabilities to security@recursive.com.

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms