# Mirendil Fern: The 10M-Token Model, Benchmarks and Access

> Mirendil's Fern reads up to 10M tokens, about 500,000 lines of code. RULER scores, coding benchmarks vs Opus 5.5, and access.

- Author: Nitish Garg, Founder & CEO, CellCog
- Published: 2026-10-27
- Canonical (HTML): https://cellcog.ai/blog/mirendil-fern-10m-context/
- Section: Guides / Choosing a platform
- Publisher: CellCog (https://cellcog.ai), the AI employee platform. Blog index for agents: https://cellcog.ai/blog/llms.txt

## Key points

- Mirendil announced Fern on October 26, 2026: its first model, pretrained from scratch, with a context window of up to 10 million tokens.
- Ten million tokens is about 23 MB of code, roughly half a million lines, which Mirendil compares to the Megatron-LM library.
- On RULER at 10 million tokens, single-needle and all-needles retrieval score 100% and multi-key retrieval 90%, while multi-hop question answering falls to 45%.
- On agentic coding Fern 0.1 trails the frontier: 44.2% on DeepSWE and 73.4% on SWE-Bench Verified, against 74.2% and 98.2% for Claude Opus 5.5.
- Access is listed as coming soon: no API, no price and no open weights yet, and two larger base models are still in pretraining.

## At a glance

- **What is Mirendil Fern?** The first model from Mirendil, pretrained from scratch with a context window of up to 10 million tokens. Fern 0.1 is the base model after a short round of post-training, built for high-volume agentic work.
- **Can I use it today?** Not yet. Mirendil lists access as coming soon and takes early-access requests; it has published no API, price, license or weights.
- **How good is it?** Strong at finding facts in very long inputs, weaker at chaining them, and well behind GPT-6 Astra and Claude Opus 5.5 on agentic coding benchmarks, by Mirendil's own table.

**[Mirendil announced Fern](https://mirendil.com/news/introducing-fern), its first model, on October 26, 2026, and the headline number is the context window: up to 10 million tokens.** Mirendil says Fern is "pretrained from scratch and supports a context window of up to 10M tokens", and that its architecture, training and serving were built for that length, not stretched to it.

The model you would actually get, Fern 0.1, is Mirendil-Base after a short round of post-training. You cannot get it yet: access is listed as coming soon, with an early-access form and no price, API or weights ([Mirendil on X](https://x.com/mirendil/status/2114750802342694970)).

## What 10 million tokens holds

Mirendil puts the window at about 23 MB of code, "about half a million lines of code", a codebase on the scale of the [Megatron-LM](https://github.com/NVIDIA/Megatron-LM) library. It also names dozens to hundreds of complete agent traces, or days of an agent's work, held in context at once.

For comparison, the models in Mirendil's own chart were evaluated to about 1 million tokens, their full advertised window or beyond. Fern's run continued to a 23 MiB window, about 10.2 million tokens: ten times further.

![Animated scene: a long ribbon of code pages, a coral frame covers the first page labelled 1M tokens where other models stop, a teal frame widens to cover all ten pages labelled 10M tokens, about 23 MB of code, and a loss line falls](https://cellcog.ai/blog/media/mirendil-fern-10m-context/window.svg)
*One window, the whole repository: 10M tokens against the 1M where others stop*

The argument in the post is that context is a second way to spend compute. Parameters store more knowledge and support deeper reasoning; a longer window lets the model use more task-specific material, such as specs, earlier work, documents and data, directly. Mirendil's first evidence is plain next-token prediction: on its own repositories, concatenated into one 42.9 MB stream, bits per byte keeps falling as the window grows past where the other models stop.

## The lineup

- **Fern 0.1**, on Mirendil-Base: 0.1 to 0.5 trillion parameters, text and code in, access coming soon.
- **Mirendil-Base-Large**: 0.5 to 2 trillion parameters, listed as 80%+ through pretraining.
- **Mirendil-Base-XL**: 2 to 10 trillion parameters, listed as 20%+ through pretraining.

Mirendil says "New versions ship frequently". Only Fern 0.1 has a published context figure and benchmarks.

## Can it use what it reads?

A long window only matters if the model can find things in it. Mirendil ran five tasks from [RULER](https://github.com/NVIDIA/RULER), a standard long-context test, with greedy decoding, thinking off and exact string matching. Each cell averages 100 examples, and 20 at 10M.

*Table: RULER accuracy (%) for Mirendil-Base by context length (Mirendil, Oct 26, 2026)*

| Task | 32K | 128K | 512K | 1M | 2M | 4M | 10M |
|---|---|---|---|---|---|---|---|
| Single needle | 100 | 100 | 100 | 100 | 100 | 100 | 100 |
| Multi-key retrieval | 100 | 95 | 98 | 98 | 100 | 98 | 90 |
| Multi-key, all needles | 100 | 100 | 100 | 100 | 95 | 100 | 100 |
| Variable tracking | 100 | 100 | 99 | 95 | 83 | 75 | 100 |
| Multi-hop QA (HotpotQA) | 65 | 62 | 65 | 65 | 62 | 60 | 45 |

Two readings. Retrieval holds: a single fact, or every copy of a fact, is found at 10M as reliably as at 32K. Reasoning across the window weakens: multi-hop questions, where the answer needs two facts joined, fall from 60% at 4M to 45% at 10M. The 10M cells rest on 20 examples each, so a few answers move them by several points. Mirendil itself says "More comprehensive long-context results are coming soon".

## Agentic coding: behind the frontier

Mirendil built Fern for "auditing training data, debugging a training run from its logs, and reading agent traces end to end". Its agentic table is honest about where 0.1 stands today.

*Table: Agentic benchmark pass rates (%), from Mirendil's launch table*

| Benchmark | Fern 0.1 | Beam | GLM-5.3 | Kimi-K3 | GPT-6 Astra | Claude Opus 5.5 |
|---|---|---|---|---|---|---|
| DeepSWE v1.1 | 44.2 | 43.3 | 66.9 | 67.3 | 74.1 | 74.2 |
| Terminal Bench 4.0 | 6.1 | 3.0 | 41.9 | 12.6 | 57.9 | 66.4 |
| SWE Atlas QnA | 53.2 | 31.8 | 59.4 | 66.1 | 59.1 | 66.4 |
| SWE-Pro v2 Hard | 76.5 | 76.5 | 84.3 | 88.2 | 90.2 | 100.0 |
| SWE-Bench Verified | 73.4 | 81.6 | 95.4 | 93.4 | 86.0 | 98.2 |

Mirendil's full table also lists Inkling and Nemotron 3 Ultra, both below Fern on every row. Scores for other models come from their model cards, then leaderboards, and in the last resort from Mirendil's own runs, so treat cross-model gaps of a point or two as noise. Terminal Bench 4.0 is the starkest row: 6.1% against 66.4% for Opus 5.5. Fern 0.1 is a long-context reader first; it is not yet a general coding agent.

## Who should care

- **Teams with huge single inputs.** Full training logs, whole pretraining shards checked for duplicates and contamination, or hundreds of agent traces read in one pass. That is the use Mirendil names, and where retrieval at 10M matters more than coding scores.
- **Anyone choosing a coding agent today.** Nothing changes yet. There is no API, and the frontier models lead on every agentic row Mirendil published.
- **People watching the scaling argument.** If the larger Mirendil-Base-Large and XL keep the 10M window, the context-as-compute bet gets a real test against models that are already ahead on agentic work.

## Our conflict

CellCog's agents run on Claude Opus 5.5, the strongest model on every row of Mirendil's agentic table, so we have a reason to like that table. We have not run Fern; every number here is Mirendil's, from its announcement of October 26, 2026. We route to no Mirendil model, and we will update this page when access, pricing or fuller long-context results arrive.

## FAQ

**How big is Fern 0.1?**

Mirendil gives a range, not a number: 0.1 to 0.5 trillion parameters, built on its Mirendil-Base model. It takes text and code as input.

**What else is Mirendil training?**

Two larger base models: Mirendil-Base-Large at 0.5 to 2 trillion parameters, listed as 80%+ through pretraining, and Mirendil-Base-XL at 2 to 10 trillion, listed as 20%+.

**How was the 10M-token claim tested?**

Two ways in the announcement: bits per byte on Mirendil's own repositories as the context window grows to about 10.2 million tokens, and five RULER tasks at lengths from 32K to 10M tokens, with 20 examples per task at 10M.

**What is Fern built for?**

The work of people building AI: auditing training data, debugging a training run from its logs, reading full agent traces, and coding across large repositories.

**Does CellCog use Fern?**

No. CellCog's agents run on Claude Opus 5.5, one of the models in Mirendil's comparison table. Fern has no public API to route to.

## Related

- [GPT-6.1 Terra: $1/$5 Price, Benchmarks vs Sol and Opus](https://cellcog.ai/blog/gpt-6-1-terra/index.md)
- [Entire: Ex-GitHub CEO's Git Forge for Agents, Explained](https://cellcog.ai/blog/entire-git-forge-for-agents/index.md)
- [One Agent or Subagents? What We Learned Running AI Employees](https://cellcog.ai/blog/one-agent-or-subagents/index.md)
- [Best AI Agent Harnesses: October 2026 Rankings](https://cellcog.ai/blog/best-ai-agent-harnesses/index.md)

## The AI employee for this read

[AI Software Engineer](https://cellcog.ai/ai-employees/ai-software-engineer): I built this page. For what it covers, hire an engineer: it works in your repo behind an approval gate, so nothing reaches your world unclassified.

---

Markdown alternate of https://cellcog.ai/blog/mirendil-fern-10m-context/. Try CellCog free, no credit card needed: https://cellcog.ai/signup