Recursive Flint

Recursive Flint

A 39.8B mixture-of-experts language model for coding agents that investigates codebases, fixes bugs, adds features and writes tests. For developers who run their own agents on a GPU server.

Made by RecursiveSI on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Recursive Flint is a language model from Recursive for coding agents. It has 39.8 billion parameters in total, but only about 2.5 billion are active for each token. It takes and returns text, reasons step by step and can call tools over several turns. The repository holds the BF16 checkpoint, the tokenizer, the chat template and an SGLang serving kit.

Who it suits: It suits engineering teams and tool builders who want to host a coding model themselves and wire it into their own agents.

Industry | Who uses it | How they use it | Example
Software teams | Engineers | Run a coding agent on their own GPUs | Ask it to track down a failing test in a repository
Developer tools | Tool builders | Back an agent through an OpenAI-compatible API | Serve the model with SGLang and call it from the openai client
AI research | Researchers | Study a mixture-of-experts coding model | Run it on the agent benchmarks the project reports

People without access to a B300 or H200 GPU can skip the BF16 checkpoint and look at the quantized variants, which the project prepares separately.

Where to use it:

• A server with one B300 or H200 GPU per replica, using the SGLang kit in the sglang folder
• Docker, to build and run the serving image
• Any client that speaks the OpenAI-compatible API, tool calls included
• Coding agents that call the model for code work

Use case | Who | What they get back
Investigating a codebase | Developers | The model's findings about how a repository works
Fixing bugs | Engineering teams | Proposed code changes for a reported problem
Features and tests | Developers | New code for a feature, plus tests written for it

How to set it up: You need these first:

• Python and pip
• Docker
• One B300 or H200 GPU per replica
• About 80 GB of disk for the BF16 checkpoint

1. Install the Hugging Face hub tool and the openai package.
2. Download the model into a flint folder and move into it.
3. Build the SGLang Docker image from the sglang folder.
4. Start the container with the serve script for your GPU, serve_b300.sh or serve_h200.sh.
5. Wait until the health check answers.

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

How to use it: When the server is up, send chat requests to its OpenAI-compatible endpoint with the model name flint. Use the checkpoint's chat template and keep the returned reasoning_content in the conversation history. The prompt and the output share one context window.

Tool | What it does
sglang/example_client.py | Example client that shows reasoning and a tool call
sglang/serve_b300.sh | Starts the server on a B300 GPU
sglang/serve_h200.sh | Starts the server on an H200 GPU
sglang/README.md | Documents what you need, the options of the serve scripts, running on several GPUs and the API

Example: You send the model a request such as "Find why my date parser test fails and fix it." It can reason about the code, call tools over several turns, and return a fix. For hard problems, allow at least 32768 output tokens, reasoning included.

For newcomers and experts: Flint is a large coding model that you host yourself, not a chat website. A first small thing to try is the example client in the sglang folder once the server reports healthy.

Under the hood, each mixture-of-experts layer has 256 routed experts, picks 6 per token and adds one shared expert. Of its 49 layers, 2 are dense and 47 are mixture-of-experts layers. Sliding-window attention covers 513 tokens in 35 layers, and 14 layers use full attention. The documented context is 262,144 tokens, and the vocabulary has 150,144 tokens. Only about 2.5B parameters work per token, but all the weights still have to fit in memory.

Download the BF16 checkpoint
Build and start the SGLang container
Wait for the health check to pass
Send OpenAI-compatible chat requests

Good to know: These are the project's own release scores. Evaluation setups differ between sources, and the Terminal-Bench score counts solutions found through web retrieval as unsuccessful.

Title: Release evaluation scores
Terminal-Bench 2.1: 54.9%
SWE-bench Pro v2: 89.7%
SWE-bench Verified: 74.2%

• Transformers: modeling code for the transformers library is not included yet, so the SGLang kit is the way to run it
• Sampling: the suggested values are 1.0 for temperature, 0.95 for top-p and 20 for top-k, which the server fills in when a request omits them
• Other versions: 100 quantized and 17 fine-tuned versions made by other people are listed
• License: Apache 2.0
• Cost to run: none named, but it needs one B300 or H200 GPU per replica
• Data it reaches: the prompts you send it, and the example publishes the server port on the local machine only

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 39.8B
• Weights: about 79.6 GB in BF16; about 19.9 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 51,087
• Likes: 1,391
• License: apache-2.0
• Quantized versions: 101
• Fine-tunes: 17
• Tags: transformers, safetensors, flint, text-generation, conversational

Links

• Model: https://huggingface.co/RecursiveSI/flint
• Files: https://huggingface.co/RecursiveSI/flint/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download RecursiveSI/flint

Then follow the usage in its model card. Nothing in this kit runs by itself.