Recursive Flint

Recursive Flint is an open-weights mixture-of-experts (MoE) coding model developed by Recursive, released on October 21, 2026, under an Apache 2.0 license. Engineered specifically for autonomous agent workflows, Flint contains 39.8 billion total parameters while routing just 2.5 billion active parameters per token. This sparse design bridges the gap between massive context-aware reasoning and high inference throughput, making it a standout local AI model with 39.8B parameters in 2026.

Trained with Recursive's automated research platform (the Eureka Machine) with a data cutoff of June 1, 2026, Flint is tuned for end-to-end software engineering tasks. It excels at parsing multi-file codebases, executing multi-turn tool calls, writing unit tests, and resolving real-world bug tickets. In agentic evaluations, Flint achieves 54.9% on Terminal-Bench 2.1, 89.7% on SWE-bench Pro v2, and 74.2% on SWE-bench Verified. It rivals dense models in the 25B to 40B range while running up to five times faster on local hardware.

Practitioners looking to run Recursive Flint locally can bypass closed cloud APIs entirely. The model ships with official SGLang serving scripts and day-0 vLLM support, enabling full private deployments for development environments, continuous integration systems, and local terminal agents.

Flint employs a decoder-only MoE architecture designed to solve the compute bottleneck of long-context local code generation. While the model occupies the memory footprint of a ~40B model, its computational cost per token matches that of a lightweight 2.5B parameter network.

Key architectural specifications include:

• Parameter Distribution: 39.8B total parameters, with roughly 2.5B active parameters per token including the output head (the active transformer body alone contains approximately 2.2B parameters).
• Layer Configuration: 49 total layers, structured as 2 initial dense layers followed by 47 MoE layers.
• Routing Mechanism: 256 routed experts per MoE layer, with 6 experts dynamically routed per token, paired with an always-active shared expert.
• Attention Topology: A hybrid attention layout featuring 35 sliding-window attention layers and 14 full-attention layers. The sliding-window layers use a window span of 513 tokens (the current token plus 512 preceding tokens).
• Normalization and Positional Encodings: Per-head QK RMSNorm with learned per-head attention sinks. Rotary Position Embeddings (RoPE) are applied strictly within the sliding-window layers, while full-attention layers omit positional encodings entirely.
• Context Length: A documented context configuration of 262,144 tokens (262K), accommodating both input prompt and generated output.
• Attention Heads & Vocabulary: 32 query heads, 4 key/value heads (Grouped-Query Attention), head dimension of 128, and a vocabulary size of 150,144 tokens.

This hybrid sliding-window design radically reduces KV-cache memory inflation across deep context sessions. By limiting full attention to 14 layers, the Recursive Flint MoE efficiency allows workstations to process extended tool histories and repository context without exhausting GPU memory during multi-turn agent loops.

Recursive Flint is purpose-built for agentic code manipulation, terminal execution, and multi-step reasoning. Rather than functioning as a basic auto-complete engine, it operates as an interactive pair programmer capable of autonomous task execution:

• Autonomous Bug Fixing and Code Refactoring: With an 89.7% score on SWE-bench Pro v2, Flint can ingest a multi-file issue description, locate the affected code paths, draft a patch, and write regression tests to verify the fix.
• Terminal and Environment Interaction: Scored on Terminal-Bench 2.1 using Terminus 2, the model navigates Linux shell environments, compiles code, inspects stack traces, and iterates on build errors autonomously.
• Multi-Turn Tool and Function Calling: Flint integrates natively with tool parsers (including GLM-style calling conventions), supporting multi-turn agent workflows where the model queries file trees, reads documentation, and calls external linters before generating final solutions.
• Deep Codebase Context Ingestion: The 262,144-token window allows developers to feed entire repositories, architectural design documents, or large API schemas into prompt memory.

For complex reasoning tasks, Recursive recommends running Flint with a temperature of 1.0, top-p of 0.95, top-k of 20, and allocating an output generation budget of at least 32,768 tokens to allow ample space for internal reasoning traces.

Deploying Flint locally requires distinguishing between weight storage capacity and compute requirements. Because Flint activates only ~2.5B parameters per token, generation is remarkably fast once the 39.8B parameters are resident in memory.

• BF16 (Unquantized, ~80 GB weights): Requires at least 96 GB to 140 GB of VRAM to comfortably fit model weights and maintain an active KV cache for deep context.
• NVFP4 / Q4_K_M (~22 GB to 26 GB weights): Requires 32 GB to 48 GB of total memory to support standard agent sessions (32K to 64K context). A 24 GB card can host Q4 weights for shorter contexts, but requires aggressive KV-cache management.
• Q8_0 (~42 GB to 46 GB weights): Requires 48 GB to 64 GB of VRAM.

• Best GPU for Recursive Flint (Unquantized BF16): A single NVIDIA H200 (141 GB SXM) or NVIDIA B300 (192 GB) GPU comfortably runs an unquantized replica at full scale using the official SGLang kit (serve_h200.sh or serve_b300.sh). Multi-GPU setups such as 4x NVIDIA RTX 4090 (96 GB total) or 2x RTX 6000 Ada (96 GB total) can also host the BF16 checkpoint via tensor parallelism.
• Enthusiast Workstations and Consumer Hardware: When asking how to run a 39.8B model on consumer GPUs, quantization is essential. A dual RTX 3090/4090 rig (48 GB VRAM combined) provides the ideal environment for running NVFP4 or Q4_K_M quantizations with sufficient headroom for large context windows. On a single 24 GB GPU, such as an RTX 4090, users must restrict context limits or offload a small fraction of layers to system RAM.
• Apple Silicon Systems: Apple unified memory architectures excel with Flint. A Mac Studio or MacBook Pro equipped with an M4 Pro or M4 Max (64 GB or 128 GB unified memory) runs quantized GGUF variants with ease, bypassing discrete GPU memory barriers.

The best quantization for Recursive Flint depends on your architecture:

• NVIDIA Hardware: The native NVFP4 checkpoint provides quantization-aware fidelity with minimal accuracy drop. In vLLM and SGLang, a single GB200 delivers roughly 500 tokens per second even at 100K context. On workstation hardware like a 64 GB NVIDIA RTX Spark, short-context throughput exceeds 150 tokens per second.
• Apple Silicon and CPU Offload: GGUF variants quantized to Q4_K_M maintain benchmark accuracy on coding tasks while avoiding FP16 memory bloat. On an Apple M4 Pro MacBook Pro, Recursive Flint tokens per second exceed 125 tokens/s at short contexts.

For quick local testing, developers can load GGUF checkpoints through Ollama or llama.cpp:

1ollama run flint:latest

For high-throughput production serving with full tool-calling support, vLLM provides day-0 container support:

1docker run --gpus all --ipc=host -p 8000:8000 \
2  -v ~/.cache/huggingface:/root/.cache/huggingface \
3  vllm/vllm-openai:flint \
4  RecursiveSI/flint-nvfp4-gguf \
5  --hf-config-path RecursiveSI/flint \
6  --tokenizer RecursiveSI/flint \
7  --enable-auto-tool-choice \
8  --tool-call-parser glm47 \
9  --reasoning-parser glm47

Understanding Recursive Flint hardware requirements and performance relative to other local coding engines helps clarify when to choose it over dense alternatives:

Qwen2.5-Coder-32B is a dense model where every token activates all 32 billion parameters.

• Memory: Both models require comparable VRAM for weight storage (roughly 20 GB to 24 GB at 4-bit precision).
• Speed: Flint is significantly faster. Because Flint activates only 2.5B parameters per forward pass, its decode throughput is 3x to 5x higher than Qwen2.5-Coder-32B on equivalent hardware.
• Context Handling: Flint's hybrid sliding-window attention keeps the KV-cache smaller across deep prompts than Qwen's standard full-attention architecture.
• When to choose Flint: When running local multi-step coding agents where rapid response cycles and tool iteration speed are critical.

Mistral's Codestral 22B is an established dense option for local development:

• Hardware Footprint: Codestral 22B requires less raw storage and VRAM (~14 GB at Q4) than Flint's 39.8B parameter shell, fitting comfortably on lower-tier 16 GB GPUs.
• Agentic Capabilities: Flint holds a decisive advantage on reasoning and autonomous tasks, outperforming Codestral on SWE-bench and terminal navigation benchmarks.
• When to choose Codestral: When constrained strictly to a single 16 GB VRAM GPU where a 40B MoE cannot load.
• When to choose Flint: Whenever a 24 GB GPU, dual-GPU rig, or 64 GB Apple Silicon system is available, delivering superior reasoning and faster per-token generation.