Recursive opens Flint, a 40B coding model with 2.5B active

On October 21, Recursive released open weights for Flint, its first model, on Hugging Face under Apache 2.0. Flint is a mixture of experts for coding agents. It has 39.8 billion parameters, but only about 2.5 billion of them work on any given token. Recursive is aiming it at developers who want agents that run offline, keep code on the machine and avoid API fees.

The Recursive model card on Hugging Face lists four jobs: investigating codebases, fixing bugs, implementing features and writing tests. The model takes text in and gives text out, reasons, and handles multi-turn tool use. In Recursive’s 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.

What runs on each token

The 2.5 billion figure counts the output head and leaves out the full input embedding matrix. The active body alone comes to about 2.2 billion, and “40B-A2.5B” is the rounded name. Flint has 49 layers: two dense ones first, then 47 mixture-of-experts layers. In each of those, a router picks 6 of 256 expert sub-networks for the token, and one shared expert runs every time.

Attention is split too. 35 layers use a sliding window of 513 tokens (the current token plus the 512 before it), and only these layers carry RoPE position encoding. The other 14 attend over the full context with no positional encoding. All layers use 32 query heads sharing 4 key/value heads with a head dimension of 128, per-head QK RMSNorm, and learned per-head attention sinks: slots where the model can put attention that no real token needs.

The card documents a context of 262,144 tokens, with the prompt and the generated output sharing it. Testing Catalog gives a different ceiling: up to 512k tokens, with Recursive recommending users stay within 256k. The vocabulary is 150,144 tokens and the stated knowledge cutoff is June 2026. Recursive trained the model from scratch in four stages: pretraining, mid-training, supervised fine-tuning and reinforcement learning. The data covered text and code, instruction following and agentic tasks.

Scores and their conditions

All three scores used temperature 1.0, top-p 0.95 and top-k 20. Terminal-Bench ran through the Terminus 2 harness, and both SWE-bench numbers through mini-swe-agent. Each agentic score is the average pass@1 over at least five attempts. In the comparison tables, Recursive marks the scores it measured itself, labels the rest as developer-reported, and warns that evaluation setups vary between sources.

One rule tilts the comparison against Flint. On Terminal-Bench, Recursive counts any solution the model got through web retrieval as a failure, and the card notes that developer-reported scores from other labs may not apply the same adjustment. That makes the 54.9% the stricter of the numbers in that table.

Testing Catalog reports further claims from Recursive. By the company’s account, Flint leads mixture-of-experts models under 50 billion total parameters on SWE-Bench Pro v2, Terminal-Bench 2.1 and SWE-Bench Verified, and it performs comparably to dense coding models of 25 to 40 billion parameters while running more than five times faster. Richard Socher, a Recursive co-founder, put the speed on X as “Up to 2x faster than comparable models,” with “125+ tokens/sec on a MacBook Pro, 150+ on RTX Spark.” Testing Catalog gives the conditions for those two speed figures: Recursive’s optimized engine, an M4 Pro MacBook Pro and a 64GB NVIDIA RTX Spark, at short contexts.

Built with the Eureka Machine

Testing Catalog reports that a small team of people and agents built Flint from scratch in under four months, with help from the company’s automated research system, the Eureka Machine. The system worked on architecture, data, optimizers, training recipes, infrastructure, quantization and inference performance. It proposed ideas, implemented them and tested the results. Its architecture search started from a 35-billion-parameter baseline with 3 billion active and ended at Flint’s 40 billion total with 2.5 billion active, so the final model is bigger overall and lighter per token.

Quantization (storing weights at lower precision) went through the same system. The Eureka Machine put the output layer at four bits and used offline distillation, training the quantized model against the 16-bit model as teacher. Testing Catalog says the resulting NVFP4 model came within 0.7 points of the 16-bit version across Recursive’s benchmarks, and needed nearly half as many training steps as its quantization-aware baseline. Recursive also wrote specialized kernels for low-bit projections, MoE operations, attention and prompt processing. One of them is a Metal megakernel that fuses the decode forward pass on M4 and M5 chips.

The money arrived before the model. The Decoder reported that the startup, then four months old, raised at least $500 million at a $4 billion pre-money valuation in a round led by GV, with Nvidia taking part. The founders include Socher, formerly chief scientist at Salesforce, and Tim Rocktäschel, an AI professor at University College London and previously a principal scientist at Google DeepMind. The team numbers about 20. The company’s stated goal is an AI system that keeps improving itself without human involvement, and at the time of that report the idea was still in the research phase.

Running it

The Hugging Face repository holds the BF16 checkpoint, the model configuration, the tokenizer, the chat template and an SGLang serving kit. The download is about 80 GB. At full precision each replica needs one B300 or H200 GPU, and the repository does not yet include Transformers modeling code. The card’s quick start:

• install the clients with pip install -U huggingface_hub openai and fetch the weights with hf download RecursiveSI/flint --local-dir flint;
• build the container with docker build -t flint-sglang sglang and start it with sglang/serve_b300.sh, or serve_h200.sh on an H200;
• poll localhost:30000/health_generate until the server answers, then point any OpenAI client at http://localhost:30000/v1 with the model name flint.

When a request leaves out the sampling settings, the server fills in the recommended ones (temperature 1.0, top-p 0.95, top-k 20). For hard problems Recursive recommends an output budget of at least 32,768 tokens, and reasoning counts against that budget. Tool calls use the OpenAI-compatible format. The card asks you to use the checkpoint’s own chat template and to keep the returned reasoning_content in the conversation history. The SGLang README in the repo covers multi-GPU deployments and the serve-script options.

Laptops and smaller cards need other builds. Recursive is preparing separate quantized variants for NVIDIA and Apple Silicon. Testing Catalog lists support for llama.cpp, Ollama, Unsloth, LM Studio, vLLM and SGLang, plus rec, Recursive’s own inference engine tuned for Flint on M4 Pro, M5 Pro and M5 Max machines. The card warns that results can vary with checkpoint precision and inference runtime, and asks users to evaluate the exact checkpoint and runtime they plan to deploy.

How much guidance does it need?

Testing Catalog reports that Recursive recommends splitting complex work into smaller subtasks and giving explicit instructions, because Flint may need more guidance than larger closed-source alternatives. The card adds that long reasoning can increase latency and use up the output budget before an answer is complete. It also says the context configuration is a capacity limit and does not guarantee the same accuracy at every sequence length or on every task.

Flint’s supervised fine-tuning included safety-oriented examples. Even so, the card says the model can produce faulty code or inappropriate tool calls, and that consequential changes should be reviewed before they are applied. Anyone wiring it into an agent should enforce their own permissions and execution boundaries, the card says, because “structured tool-call grammar does not prevent the model from choosing an unsafe or incorrect action.”