Recursive Flint: 40B MoE coding-agent model released under Apache 2.0

What this is about

The company Recursive has released the model Flint (RecursiveSI/flint) on Hugging Face. It's a language model built specifically for coding agents: AI programs that independently explore code repositories, fix bugs, implement features and write tests. The weights are available for download under the Apache 2.0 license, which also allows commercial use. The model takes text as input and output, can "think" (reasoning) and call tools over multiple steps. The maker gives its knowledge cutoff as June 2026.

At the time of writing, the repository had about 420 downloads and 500 likes. The benchmark figures come from the maker and have not been independently verified.

Architecture: many experts, few active

Flint is a Mixture-of-Experts (MoE) model. The network consists of many specialized sub-networks ("experts"), and only a small share of them is used for each token. Flint has 39.8 billion parameters in total (roughly, the tunable values learned during training), but only about 2.5 billion are active per token. The maker counts the output head but not the input embeddings; the "body" alone comes to about 2.2 billion. The short name is "40B-A2.5B".

The key specs:

Most layers only look at a limited window of the last 512 tokens (sliding window). That saves memory, especially with long context. Only 14 layers look at the entire context. The sliding-window layers use RoPE (a method that tells the model where each word sits in the sequence), while the full-attention layers use no positional encoding at all. The model also applies normalization per attention head and learned "attention sinks".

Benchmarks

According to the Model Card, Flint scores as follows:

The evaluation used temperature 1.0, top-p 0.95 and top-k 20. Terminal-Bench ran with the Terminus 2 agent harness, SWE-bench with mini-swe-agent. The figure given is average pass@1 (the share of tasks solved on the first attempt) over at least five runs. On Terminal-Bench, Recursive counts solutions found via web search as failures. The comparison figures for other models mostly come from their developers and may not have been cleaned the same way. The chart compares the BF16 and NVFP4 checkpoints with local models of a similar hardware class.

Running it and settings

The repository contains the BF16 checkpoint, config, tokenizer, chat template and an SGLang serving kit (SGLang is software for running language models fast). According to the guide, Flint runs on one B300 or H200 GPU per replica. The download is about 80 GB. The model is launched via Docker and offers an OpenAI-compatible API, including for tool calls. Model code for the Transformers library is still missing. Quantized variants for NVIDIA and Apple Silicon are being prepared separately; a "Local engine" is linked on GitHub.

Recommended settings: temperature 1.0, top-p 0.95, top-k 20. For hard tasks, the output budget should be at least 32,768 tokens including reasoning. The reasoning_content that the model returns should be kept in the conversation history.

Training and limits

According to the maker, Flint was trained from scratch: pretraining, mid-training, supervised fine-tuning and reinforcement learning, using text, code, instruction following and agentic tasks. The card gives no details on data or compute.

The card itself points out limits: the model can produce false or harmful content, faulty code and inappropriate tool calls. Applications should set their own permission and execution boundaries. Long reasoning increases latency and can eat up the output budget. The 262k context length is a capacity limit, not a guarantee of consistent quality. Results depend on precision and runtime environment.

What you need to try it

The BF16 original is meant for data-center hardware: an NVIDIA B300 or H200, about 80 GB of disk space for the weights, Docker and an NVIDIA container environment. The original won't run on ordinary home GPUs. For consumer hardware, the announced quantized variants (NVIDIA, Apple Silicon) are the way to go, and the card says they'll come out separately. There's no GGUF format yet. You can still test the model on rented servers (cloud GPUs).

Our take

What's interesting about Flint is the ratio of total to active parameters. With only about 2.5B active parameters, inference should be fast and cheap, while the full model spreads its knowledge across 40B parameters. The Apache 2.0 license is very permissive. The benchmark numbers, especially 89.7% on SWE-bench Pro v2, are vendor claims from the maker's own agent setup. Without independent re-testing, they're hard to compare with other models, not least because the card itself notes inconsistent evaluations. Still open: the training data, when the quantized versions will arrive, and how well the model performs on smaller hardware. The license covers only the weights; terms for the hosted API are separate.