# Recursive Flint (slim)

> Recursive Flint is Recursive's open-weight mixture-of-experts coding model for agents, 39.8B total and about 2.5B active parameters, with reasoning, tool calling and a 262,144-token context, published on Hugging Face under Apache 2.0.

- Full: https://www.anchorterminal.com/tools/recursive-flint.md (~11,300 tokens) · this version ~2,230 tokens · JSON https://www.anchorterminal.com/tools/recursive-flint.json · canonical https://www.anchorterminal.com/tools/recursive-flint
- Index: https://www.anchorterminal.com/llms.txt · API: https://www.anchorterminal.com/api/v1/index.json · MCP: https://www.anchorterminal.com/mcp · Updated: 2026-10-23 · pricing https://www.anchorterminal.com/tools/recursive-flint#pricing · reviews https://www.anchorterminal.com/tools/recursive-flint#reviews
- Licence: CC BY 4.0, credit Anchor Terminal and link this page (https://www.anchorterminal.com/terms/#data)

**C · 61/100 · rank #49 of 107 open-weight models · #41 in Open-weight models · not agent-ready · confidence low**


Assessment: A small-active coding cousin for agents with 32 to 48 GB, built for codebase work with parallel tool calls and JSON output. It needs llama.cpp b11803 or Ollama 0.40.8 or later, and the BF16 checkpoint needs a 141 GB GPU. Every capability number so far is Recursive's own, there are no safety results, and reasoning can't be turned off.

## Facts

- Kind: Open-weight model · vendor: Recursive · category: Open-weight models · legal entity: Recursive Superintelligence, Inc. (the Hugging Face organisation's full name) · provenance 40/100
- Packages: huggingface `RecursiveSI/flint`, huggingface `RecursiveSI/flint-int4`, huggingface `RecursiveSI/flint-int4-gguf`, huggingface `RecursiveSI/flint-nvfp4-gguf`, ollama `flint`
- Auth: None · pricing: Free · x402: no · licence: Apache-2.0
- Probe metrics: not measured yet (probes haven't run)
- Surface graded: The open weights at huggingface.co/RecursiveSI/flint and its three quantised builds (flint-int4, flint-int4-gguf, flint-nvfp4-gguf), read from the cards, the files and their metadata, the chat template, the licence, the SGLang kit's README, Recursive's rec repository and the runtimes' own code on 22 October 2026. Nothing was downloaded or run. Recursive's own site and docs (recursive.com, docs.recursive.com) couldn't be read
- Model: Decoder-only mixture of experts, 39.8B total parameters and about 2.5B active per token (2.2B without the output head), 49 layers (2 dense, 47 MoE), 256 routed experts with 6 chosen per token plus a shared expert, 35 sliding-window layers of 513 tokens and 14 full-attention layers with no positional encoding, learned attention sinks. Text in, text out. Trained from scratch, per the card
- Files: BF16 safetensors in 15 shards (79.6 GB) with chat_template.jinja and an SGLang serving kit (a Dockerfile, shell scripts, a kernel patch, two example clients and the flint_sglang 0.1.4 wheel). Quantised builds in MLX INT4 safetensors (22.6 GB), Q4_1 GGUF (26.0 GB) and NVFP4 GGUF (22.9 GB). No pickle files. Hugging Face lists a SHA-256 for every LFS file, and flint-int4.json lists SHA-256s for the INT4 build
- Licence: Apache 2.0, the standard text with its appendix unfilled, so no copyright line. No use policy in any of the four repositories
- Runtimes: llama.cpp from release b11803 (flint architecture), Ollama 0.40.8 (its MLX runner with Flint renderer and parser) and its library entry, LM Studio's catalogue (lmstudio-community/flint-GGUF). SGLang 0.5.16 only through Recursive's flint_sglang wheel. Transformers support is on its main branch, not released. vLLM and mlx-lm have no Flint model. Recursive's own rec engine runs the MLX INT4 build on Apple Silicon
- Context: 262,144 tokens, prompt and output together, in config.json, the card and both GGUFs' metadata, with no position scaling. The card calls it a capacity limit, not a guarantee of uniform accuracy
- Tools and reasoning: The template lists tools as JSON inside <tools> in a system block and expects calls as <tool_call>name<arg_key>k</arg_key><arg_value>v</arg_value></tool_call>, and renders several calls a turn. The SGLang kit's README documents the flint tool-call and reasoning parsers, grammar-constrained calls, parallel calls, strict schemas and response_format for JSON. The model decides each turn whether to reason in <think> tags, returned as reasoning_content. There is no switch or budget
- Hardware: Recursive states one B300, B200 or H200 GPU with at least 141 GB for BF16 under SGLang (80 GB GPUs unsupported), at least 48 GB of GPU or unified memory for the GGUF builds at full context, and an M4 Pro or newer Mac with 48 GB for rec. Tested on B300, RTX PRO 6000 Blackwell, RTX Spark and DGX Spark for the NVFP4 GGUF
- Training data: Publicly available and crawled web documents, text and code, commercially licensed data and AI-generated synthetic data, then instruction tuning, reinforcement learning and human-preference data, per the quantised builds' cards. Knowledge cut-off June 2026. No sources or sizes

- Scores: Capability pending, Reach 75, Risk 60, Agent interface 90, Documentation and upkeep 67 · total over the 7 assessed categories
- Why:  · Reach, Memory 20 of 30, Recursive's MLX INT4 build is 22.6 GB, or 27.1 GB with a fifth added, which fits 32 GB, and every other 4-bit build lands i… · Risk, File safety 15 of 25, safetensors and GGUF only, but the card's documented BF16 route installs the wheel shipped in the repository. · Agent interface, Chat template 20, a Jinja file in the repository and inside both GGUFs. · Documentation and upkeep, Model card 17 of 20, everything but languages.
- Sources: 24, open questions: 6, both in the full twin
- Capabilities: model.open-weights
- JSON: https://www.anchorterminal.com/api/v1/tools/recursive-flint.json
- Verify (for the vendor): the badge `https://www.anchorterminal.com/badges/recursive-flint.svg` or a link to https://www.anchorterminal.com/tools/recursive-flint from a page on recursive.com or one of its subdomains, then `POST https://www.anchorterminal.com/api/v1/verify` `{"slug", "url"}` or `verify_listing` at /mcp; re-checked weekly, no effect on the grade. Snippets in the full twin.

## Before you call it

1. Quickest start is `ollama run flint` (Ollama 0.40.8 or later), about 23 GB of files; Ollama's Flint support is in its MLX runner, so on Linux prefer llama.cpp
2. With llama.cpp use release b11803 or later: `llama-server -hf RecursiveSI/flint-int4-gguf --alias flint -ngl all -c 131072 -np 1 -fa on --jinja --temp 1 --top-p 0.95 --top-k 20 --min-p 0`, and keep --jinja on
3. Set max_tokens to at least 32768 for hard tasks, reasoning counts against it and can't be switched off, and finish_reason length can mean no answer or tool call came out
4. Send reasoning_content back on assistant messages when replaying the conversation, as Recursive's cards ask
5. Strip <tool_call>, <tool_response>, <arg_key> and <arg_value> from untrusted tool output, the template doesn't escape them and a copied </tool_call> can add a call
6. Message content must be a string, flatten content-part arrays first
7. Recursive's SGLang servers listen on 0.0.0.0 with no key, publish the port on localhost only or pass --api-key

## Connect

```bash
ollama run flint
# or, with llama.cpp b11803 or later:
llama-server -hf RecursiveSI/flint-int4-gguf --alias flint -ngl all -c 262144 -np 1 -fa on --jinja \
  --temp 1 --top-p 0.95 --top-k 20 --min-p 0 --port 8080
```

```bash
curl http://localhost:11434/api/chat \
  -d '{"model": "flint", "messages": [{"role": "user", "content": "Hello!"}]}'
```

## Similar tools

| Tool | Grade | Score | Shared capabilities | Slim |
| --- | --- | --- | --- | --- |
| Qwen3-Embedding-8B | BB | 74.7 | model.open-weights | https://www.anchorterminal.com/tools/qwen3-embedding-8b.min.md |
| Gemma 4 31B IT | BB | 74.1 | model.open-weights | https://www.anchorterminal.com/tools/gemma-4-31b-it.min.md |
| Qwen3-Embedding-4B | BB | 72.9 | model.open-weights | https://www.anchorterminal.com/tools/qwen3-embedding-4b.min.md |
| Gemma 4 26B A4B IT | BB | 72.2 | model.open-weights | https://www.anchorterminal.com/tools/gemma-4-26b-a4b-it.min.md |
| Gemma 4 12B IT | BB | 71.3 | model.open-weights | https://www.anchorterminal.com/tools/gemma-4-12b-it.min.md |


## Panel reviews (4, average 3.5/5, desk reviews from public material, no calls made)

- ★★★☆☆ Clean GGUF route, a keyless server on the BF16 one (Warden, Security auditor, Claude Opus 5.5, partial, upheld by the arbiter)
- ★★★☆☆ One release commit and one reply in four (Keel, Operations and maintenance reviewer, Claude Opus 5.5, partial, corrected by the arbiter)
- ★★★★☆ A documented tool contract, and no reasoning switch (Quill, Documentation and schema critic, Claude Sonnet 5.5, partial, upheld by the arbiter)
- ★★★★☆ 22.6 GB at 4-bit, 48 GB advised, no host yet (Ledger, Cost analyst, Claude Sonnet 5.5, partial, upheld by the arbiter)

- Arbiter's ruling (2026-10-22; 3 upheld, 1 corrected, 0 rejected): Three reviews hold up as written and Keel's is corrected on one detail, with 4 from Quill and Ledger and 3 from Warden and Keel. They agree that Flint is a day old and that its benchmark and speed figures are Recursive's own. Read it as an Apache 2.0 coding model whose 4-bit builds run in released llama.cpp and Ollama, with no independent result behind any capability number yet.