Reka Flash 3 Guide: A 21B Apache Reasoning Model, Revisited

Reka Flash 3 is old by the standards of this field. Reka released it in March 2025, and its successor, Flash 3.1, followed four months later. Yet it is still listed on OpenRouter and still downloadable from Hugging Face. The reason is a combination that remains uncommon: a 21B model, trained from scratch, under a genuinely permissive licence, with a simple mechanism for capping how long it thinks.

This guide is about whether that combination is enough to justify using it now, and for which jobs.

What Reka Flash 3 is

Reka's announcement and model card describe a 21B general-purpose reasoning model, pretrained from scratch on public and synthetic data. It was then instruction-tuned and finished with reinforcement learning using REINFORCE Leave-One-Out (RLOO), with both model-based and rule-based rewards. Reka was explicit that the aim was general capability, not a maths or coding specialist.

It is text-only. Reka positioned it for low-latency, cost-sensitive and on-device applications, and as a base for building domain-specific reasoning models through fine-tuning. Reka also used it internally to power its Nexus agent platform.

The released version has a 32K context window, according to Reka's announcement. OpenRouter lists a larger figure in its catalogue; go with the vendor's number when planning prompts.

The licence is the reason it lasted

The weights are on Hugging Face under Apache 2.0. That means you can fine-tune, redistribute, embed and sell products built on it without a revenue threshold, a user cap or a separate agreement.

Not every open-weight release is that permissive, including some newer ones. Reka's own 2026 model, Reka Edge, ships under a Business Source License with a $1 million revenue threshold for free commercial use; the Reka Edge guide covers that model and its terms. If you need a reasoning model you can ship inside a product without a bespoke licence review, Flash 3 qualifies. Open weights vs open source explains why the licence often matters more than the benchmark.

Budget forcing: capping the thinking

Flash 3 reasons before it answers, inside <reasoning> and </reasoning> tags. Reka's announcement describes a simple control: if you force the closing tag after a set number of reasoning steps, the model stops thinking and writes its answer. Reka reports that the answers remain reasonable when cut short, and that quality improves with more thinking time.

This matters because reasoning length is the main driver of latency and output cost on any thinking model. Being able to set a hard ceiling per request, rather than hoping the model stops on its own, makes behaviour predictable. A practical pattern is a low budget for interactive requests and a higher one for offline jobs. Reasoning models explained covers why thinking longer helps some tasks and not others.

The chat format is unusual and worth knowing if you self-host. Turns are written as human: and assistant:, separated by <sep>, and generation should stop on <sep> or <|endoftext|>. In multi-turn chats, Reka recommends dropping the reasoning from earlier assistant turns to save tokens for the model to think; check that your serving stack's chat template actually does this.

human: Explain the bug in this function. <sep> assistant:

Memory and hardware

Reka gives the footprint as 39GB at fp16, falling to 11GB with 4-bit quantisation. At 11GB it fits on a single consumer GPU with room for a reasonable KV cache, which is the whole point of a model this size. Reka compared that with QwQ-32B at 64GB in bf16, while noting QwQ-32B scored much better on AIME 2024.

The model uses a Llama-compatible format and the cl100k_base tokenizer, so it runs in the standard open-model stack: Transformers, vLLM and the usual quantised runtimes.

Where it falls short

Reka was candid about the weaknesses, and they are real:

• Knowledge. Reka reports an MMLU-Pro score of 65.0 and recommends pairing the model with web search for knowledge-heavy tasks. Do not use it as a fact store.
• Language. It is built primarily for English. It often reasons in English even when prompted in another language, which can degrade the answer.
• Alignment. Reka says it has not had extensive alignment or persona training, so expect less polished refusals and tone than a chat-tuned commercial model.
• Context. 32K is small by 2026 standards. Long documents need retrieval rather than stuffing.

Flash 3 or Flash 3.1

Reka Flash 3.1, announced in July 2025, is the same 21B size with an upgraded reinforcement-learning stack. Reka reports a 10-point gain on LiveCodeBench v5 over Flash 3 and positions it as stronger at coding and as a better base for agentic fine-tuning. Reka also released a 3.5-bit quantised build of 3.1 alongside it.

If you are starting fresh and want this model family, evaluate 3.1 first. Flash 3 remains the sensible choice when you need a model that is already served on a public router, when your pipeline is already built around it, or when you want the exact model behind earlier published comparisons.

Should you use it in 2026?

On the hosted side, OpenRouter lists Flash 3 at $0.10 per million input tokens and $0.20 per million output at the time of writing. That is cheap, but so are many newer small models, and a model released in 2026 has had more than a year of newer training data and techniques behind it.

The decision rule is mostly about licence and ownership:

• Use it when you need an Apache 2.0 reasoning model you can fine-tune and ship on one GPU, and your tasks are English, bounded and not knowledge-heavy.
• Skip it when you only need an API, when you need long context or multilingual reasoning, or when a newer model passes more of your tasks at similar cost.

Either way, test it on twenty real tasks against a current small model before deciding. Age alone is not a reason to rule it out, and familiarity is not a reason to keep it.