Flint-40B-A2.5B

Recursive

Parameters

39.8B total / 2.5B active

MoE: total / active

Architecture

Decoder-only mixture-of-experts Transformer (hybrid sliding-window + full attention)

Released

21.10.2026

License

Apache License 2.0

Open Weights Commercial Use Multimodal BF16 Flint

Input Modalities

text

Output Modalities

text

Context (native)

262,144 tokens

Context (extended)

262,144 tokens

Openness Index Score 100.0/100

About

Recursive Flint

Overview

Flint is Recursive's open-weight mixture-of-experts (MoE) language model built for coding agents — models that investigate codebases, fix bugs, implement features, and write tests. It is developed by Recursive Superintelligence, Inc. ("Recursive") and was released on October 21, 2026 under the Apache 2.0 license. Flint has 39.8 billion total parameters with approximately 2.5 billion active per token (rounded model-size designation "40B-A2.5B"); per the card's convention the active count includes the output head and excludes the full input embedding matrix, leaving an active body of roughly 2.2B parameters. The HF repo provides the BF16 checkpoint (~80 GB download), model configuration, tokenizer, chat template, and an SGLang serving kit; Transformers modeling code is not included yet. Quantized variants (including NVFP4 for NVIDIA and runtimes for Apple Silicon) are prepared separately, and the model tree already lists 89 quantizations, 14 finetunes, and 1 adapter.

Architecture

Flint is a decoder-only mixture-of-experts Transformer (config class FlintForCausalLM, model_type: flint). Its 49 layers alternate between 2 dense layers followed by 47 MoE layers (mlp_only_layers [0,1], decoder_sparse_step 1). Each MoE layer routes among 256 routed experts, selecting 6 experts per token, plus an always-active shared expert (norm_topk_prob: true, sigmoid-based score function, moe_intermediate_size 512, shared-expert intermediate size 1024; dense layers use intermediate size 6144 with SiLU activation; hidden size 2048).

Attention is hybrid: 35 sliding-window layers and 14 full-attention layers. The sliding window is 513 tokens (current token plus 512 preceding tokens). The model uses 32 query heads and 4 key/value heads (grouped-query attention) with head dimension 128. Every attention layer applies per-head QK RMSNorm and learned per-head attention sinks (softmax_type: "learnable"). Position encoding is RoPE on sliding-window layers while the full-attention layers use no positional encoding (RoPE-free/NoPE on those layers, θ = 10000). The native context configuration is 262,144 tokens, with prompt and generated output sharing the context window. Vocabulary size is 150,144 tokens; embeddings are untied; dtype is BF16.

Capabilities and usage

Flint supports text input and output, reasoning, and multi-turn tool use (OpenAI-compatible tool calls); the chat template requires preserving returned reasoning_content in conversation history. Recommended generation settings: temperature 1.0, top-p 0.95, top-k 20, and an output budget of at least 32,768 tokens for hard problems, including reasoning. Deployment runs on one B300 or one H200 GPU per replica via the bundled SGLang kit (Docker-based serving with health checks and an example client). Flint is conversational, agentic, and local-friendly: Recursive also ships a local engine (recursive-oss/rec) plus documentation at docs.recursive.com.

Evaluation

In Recursive's release evaluations Flint scores 54.9% on Terminal-Bench 2.1, 89.7% on SWE-bench Pro v2, and 74.2% on SWE-bench Verified. Agentic scores use temperature 1.0, top-p 0.95, top-k 20; Terminal-Bench runs with Terminus 2, SWE-bench with mini-swe-agent, and agentic scores report average pass@1 over at least five attempts. Scores marked "†" are measured by Recursive; comparison scores are developer-reported. Flint's Terminal-Bench score counts solutions obtained through web retrieval as unsuccessful, an adjustment developer-reported comparison scores may not apply. A benchmark chart also compares the BF16 and NVFP4 checkpoints against local models running on similar hardware.

Training

Flint was trained from scratch through four stages: pretraining, mid-training, supervised fine-tuning (SFT), and reinforcement learning (RL). Training data includes text and code, instruction following, and agentic tasks; the SFT stage included safety-oriented examples. The stated knowledge cutoff is June 2026. Hyperparameters are not documented on the card.

License, limitations and reporting

The weights are released under Apache 2.0 (commercial use and open-source use permitted; hosted API terms and data practices are separate). The card documents limits worth noting: even with safety-oriented SFT examples the model can still produce incorrect or harmful content, faulty code, or inappropriate tool calls; long reasoning can exhaust the output budget; the 262,144-token context is a capacity limit rather than a guarantee of uniform accuracy across sequence lengths; and results vary with checkpoint precision and inference runtime. Contact channels: support@recursive.com, safety@recursive.com (safety/misuse), and security@recursive.com (vulnerabilities), with the checkpoint revision and runtime details included in reports.

Languages

The card does not document specific supported languages; card, docs, and reporting channels are in English, so the language list is left unset rather than guessed.

Training Data Trained from scratch through pretraining, mid-training, supervised fine-tuning, and reinforcement learning; data includes text and code, instruction following, and agentic tasks. Stated knowledge cutoff: June 2026.

Benchmark Scores

Benchmark Score Date
SWE-bench Verified
coding_agent
74.20%
—
Terminal-Bench 2.1 (Terminus-2)
coding_agent
54.90%
—
SWE-bench Pro
coding_agent
89.70%
—

Hardware Requirements

Estimated VRAM per quantization at 4,096 tokens context — MoE: all experts must fit in VRAM, only 2.5B are active per token

Quantization Weights KV Cache Total VRAM
FP16 — 16-bit 79.6 GB 0.4 GB 84.0 GB
INT8 — 8-bit 39.8 GB 0.2 GB 42.0 GB
INT4 — 4-bit 19.9 GB 0.1 GB 21.0 GB
FP4 — 4-bit 19.9 GB 0.1 GB 21.0 GB

Consumer GPUs that fit this model with a single card (INT4):

Architecture

Decoder Block ×49 input Embedding vocab 150K · d 2048 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×2 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×3 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 Sliding Window Attn Hybrid 32:4 · dₕ 128 · win 513 ×2 Full Attention Hybrid 32:4 · dₕ 128 · win 513 ×1 MoE FFN 256 experts · top-6 · dᴻ 512 Final Norm LM Head vocab 150K output
Attention
Hybrid Attention (32:4)
MoE
256 experts · top-6 per token
Layers
49
Hidden size
2048
Context
262K tokens
RoPE θ
10K
Parameters
39800M
Active params
2500M

Source: Hugging Face config.json · FlintForCausalLM · exact layer pattern · model repo

Type: decoder-only MoE transformer
Attention: gqa (32 query / 4 KV heads) hybrid: 35 sliding-window layers + 14 full-attention layers; per-head QK RMSNorm with learned per-head attention sinks (softmax_type learnable)
Decoder: sparse MoE
MoE: yes (256 experts)
Routing: sigmoid top-6 routing over 256 routed experts + 1 always-active shared expert (norm_topk_prob)
Layers 49
Context length 262K
Attention heads 32
KV heads 4
Head dim 128
Hidden size 2048
Vocabulary 150K
FFN dim 6144
Vision No
RoPE θ 10000
Sliding window 513
Layer Pattern full_attn, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, swa, full_attn, swa, swa, full_attn
Moe {'enabled': True, 'experts_total': 256, 'experts_active': 6, 'shared_experts': None, 'intermediate_size': 512, 'first_k_dense': None, 'layer_freq': 1, 'scoring_func': None, 'route_top_k': 6, 'num_moe_layers': 47, 'num_dense_layers': 2, 'shared_expert_count': 1, 'shared_expert_intermediate_size': 1024, 'router_score_function': 'sigmoid', 'norm_topk_prob': True, 'router_aux_loss_coef': 0.0005, 'mlp_only_layers': [0, 1], 'decoder_sparse_step': 1, 'traceability': "Raw keys above (enabled..route_top_k) are config_normalized.moe verbatim. Added keys are direct from config_raw or the card: num_moe_layers 47 = num_hidden_layers 49 - len(mlp_only_layers [0,1]) 2, matching card '49: 2 dense layers followed by 47 MoE layers' (config_normalized.layers.moe=0 understates because the normalizer ignores mlp_only_layers); shared_expert_count 1 and shared_expert_intermediate_size 1024 from config_raw.shared_expert_intermediate_size + card 'plus an always-active shared expert' (raw normalized shared_experts is null because the normalizer does not parse that key family); router_score_function 'sigmoid', norm_topk_prob true, router_aux_loss_coef 0.0005, mlp_only_layers [0,1], decoder_sparse_step 1 all verbatim from config_raw; shared-expert wording refined with card."}
Tied embeddings No

Training Pipeline

  1. 1
    pretraining

    Pretraining

    Flint was trained from scratch, and pretraining is the first stage named in the card's four-stage recipe. Per the card, training includes text and code as data. The card does not specify pretraining corpora, token counts, or objectives for this stage beyond text and code.

  2. 2
    cpt

    Mid-training

    The card names mid-training as the second stage of the from-scratch recipe but describes no separate data, method, or objectives for it, beyond the overall statement that training includes text and code, instruction following, and agentic tasks. 'Mid-training' is not an allowed stage type, so it is mapped to 'cpt' (continued pretraining) as the closest permitted value per the stage taxonomy. No hyperparameters, data composition, or duration are documented for this stage.

  3. 3
    sft

    Supervised fine-tuning

    Supervised fine-tuning is the third stage in the card's recipe. The card's overall training statement covers instruction following and agentic tasks, and the Limitations section adds that “Flint's supervised fine-tuning included safety-oriented examples.” No hyperparameters or further dataset details are given.

  4. 4
    rl

    Reinforcement learning

    Reinforcement learning is the final stage named in the card. The card says only “reinforcement learning” and never mentions RLHF, human feedback, or a reward model, so it is classed as generic 'rl' rather than 'rlhf' as the closer match (agentic/tool-use training data is described globally, not attributed to this stage). No hyperparameters, reward signal, or training details are documented.

Related Models

Comments (0)

No comments yet

Be the first to share your thoughts!