Recursive released Flint on October 21, 2026, and the coding model is worth revisiting several days after launch for a practical reason: developers can try it through a free OpenRouter endpoint before deciding whether to run it locally. OpenRouter lists a 262,144-token context window, tool calling and JSON output support for the hosted version. Its model identifier is recursive/flint-v1.0:free. (OpenRouter model listing)
Flint is an open-weight mixture-of-experts, or MoE, model with 40 billion total parameters and about 2.5 billion active parameters per token. Recursive built it for coding agents that investigate repositories, fix bugs, implement features and write tests. The company says its automated research system, Eureka Machine, contributed to the model’s architecture, training and inference optimization. (Recursive’s introduction)
The useful distinction is between getting access and choosing a deployment. OpenRouter offers a low-friction way to evaluate an agent integration. Downloadable weights provide a separate route toward local execution and control over where code is processed. Those routes have different costs, privacy properties and hardware requirements.
What You Can Use Today
OpenRouter’s Flint listing provides the key hosted specifications:
| Detail | Flint v1.0 on OpenRouter |
|---|---|
| Model identifier | recursive/flint-v1.0:free |
| Architecture | Open-weight mixture-of-experts |
| Total parameters | Approximately 40 billion |
| Active parameters | Approximately 2.5 billion per token |
| Context window | 262,144 tokens |
| Prompt and completion token pricing | Free, subject to rate limits |
| Tool calling | Supported |
| JSON output | Supported through response_format, without JSON-schema enforcement |
| Listed release date | October 21, 2026 |
Developers with an existing OpenRouter-compatible application can select that model identifier. OpenRouter describes its API as OpenAI-compatible, so applications already built around that interface have a familiar integration path. That compatibility covers the request interface; an agent still needs to handle Flint’s responses, tool requests and errors correctly.
OpenRouter also announced the model’s availability on October 21 and described it as free to use at launch:
“Free” here has a specific meaning: OpenRouter lists zero charges for prompt and completion tokens on this endpoint. Requests remain rate-limited, and availability can change. The opened listing does not provide a fixed quota that can safely be treated as a permanent allowance.
The listing also shows one hosting provider and says Flint is not currently available through EU in-region routing. That last restriction concerns OpenRouter’s regional routing option; it should not be read as a blanket statement that European users cannot access the model. (OpenRouter model listing)
I’d treat the free endpoint as an integration and evaluation route first. Coding agents can make many requests during one task, especially when they alternate between reading files, editing code and running tests. A zero token price is useful, but a workflow that repeatedly hits a rate limit still needs retry handling and a sensible way to stop.
What 2.5B Active Parameters Means for Local Use
Flint’s parameter counts describe two different parts of the deployment problem.
The 40B total figure describes the model’s overall parameter set. The 2.5B active figure describes how much of that set participates in processing a token. In an MoE architecture, routing selects a subset of experts instead of activating the entire model for every token. Recursive says it searched different expert configurations and widths to find a balance between coding performance and local inference speed. (Recursive’s architecture explanation)
That makes the active-parameter figure relevant to computation, but it is a poor shortcut for estimating the memory needed to run Flint. A deployment still needs access to the broader model weights.
A simple calculation illustrates the difference:
- Assume, hypothetically, that all 40 billion parameters were stored at exactly four bits each.
- Four bits is half a byte, giving 20 billion bytes, or about 20 GB, of raw parameter data.
- That calculation excludes quantization metadata, runtime allocations, context-related memory and other overhead.
This is an illustrative storage calculation, not a measured Flint download size or minimum RAM requirement. Recursive describes its own quantization work, including a final NVFP4 model, but the opened sources do not provide a complete hardware-sizing guide for every available weight format.
The practical implication is straightforward: do not choose hardware as though Flint were a conventional 2.5B-parameter model. Check the actual weight package, supported runtime and memory requirements before downloading it.
OpenRouter’s page includes a Model weights link for people taking the local route. The open-weight label should also be kept separate from licensing assumptions: the evidence here does not establish the precise commercial-use or redistribution terms, so those need checking with the distributed weights. (OpenRouter model listing)
The Hosted Context Limit and the Model’s Larger Ceiling
Flint has two context figures in the published material:
- OpenRouter exposes 262,144 tokens, displayed as 262K.
- Recursive says Flint supports up to 512K tokens, while recommending that users stay within 256K for the best results on coding and other tasks.
These describe different things: the hosted endpoint’s listed limit and the model developer’s broader capability statement. A client using the free OpenRouter endpoint should follow its 262,144-token limit, not assume it can submit a 512K-token request. (OpenRouter; Recursive)
A long context window is particularly relevant to coding agents because their working material extends beyond the user’s initial prompt. Repository excerpts, instructions, previous edits, tool results and test logs can all accumulate during a task. The agent also needs room for its response.
The useful benefit is the ability to keep more relevant material together. It is not a guarantee that filling the entire window with a repository will produce a better answer.
My preference would be to start with the files, interfaces and test failures directly connected to a task, then expand the context when the agent identifies a dependency. That approach follows Recursive’s own guidance to split complex work into smaller subtasks and give explicit instructions. It also makes failures easier to diagnose: there is less unrelated material to inspect when an agent changes the wrong file.
Recursive puts that guidance plainly:
“For complex tasks, break the work into smaller subtasks and provide explicit instructions.”
The company also acknowledges that Flint may need more guidance than larger closed-source coding models. That is useful deployment advice, especially for teams considering an autonomous workflow. (Recursive’s usage guidance)
Tool Calling Enables an Agent Loop, Not Automatic Execution
Flint’s tool support matters because coding agents need to interact with a workspace. A typical loop lets the model request a file read, inspect the returned contents, propose an edit and then request a test run.
The surrounding application executes those actions. Tool-calling support means the model can produce requests that an agent framework interprets. It does not give the hosted model direct access to your filesystem or terminal.
For a builder, the integration therefore has several distinct responsibilities:
- Describe the available tools and their arguments.
- Validate each requested operation.
- Apply permissions before reading files, writing changes or running commands.
- Return tool results in a form the model can use.
- Handle failed commands, repeated requests and API limits.
OpenRouter confirms that Flint accepts tools for function calling. It also supports JSON output through response_format, but explicitly lists no JSON-schema enforcement. (OpenRouter’s supported features)
That distinction is easy to miss. Valid JSON can still contain the wrong keys, unexpected types or an action your application never intended to allow.
For example, an illustrative request body for an already configured OpenRouter client could look like this:
{
"model": "recursive/flint-v1.0:free",
"messages": [
{
"role": "user",
"content": "Return a JSON object with keys summary and tests for this change: reject an empty filename before opening a file."
}
],
"response_format": {
"type": "json_object"
}
}
Frequently Asked Questions
4 questions
1Is Flint free on OpenRouter?
OpenRouter currently lists zero prompt and completion token charges for recursive/flint-v1.0:free. The endpoint is rate-limited, and its availability can change.
