# Plan: 262K context on 6GB VRAM, matching Claude

**Goal.** `recursion + local model == frontier model`, under one hard constraint:
**6GB VRAM**. Parameter count is NOT constrained -- a 35B model whose experts stream
from system RAM is in scope, because only its resident footprint has to fit.

This was initially mis-scoped as "small model", which pushed everything toward 2-4B
models and made capability the bottleneck. The constraint is VRAM alone.

Two independent claims. Keeping them separate matters, because one is proven and
one is not:

| claim | status |
|---|---|
| A. 262K of context served within 6GB VRAM | **proven, reproduced 4x** |
| B. ...and it produces the correct answer | **MET** via ctxstream (2026-08-24) |

**Claim B was closed by removing the model from the aggregation step, not by a
bigger model.** See "How claim B was actually met" below. The MoE expert-offload
work is no longer on the critical path for correctness; it remains the route to
higher-quality *extraction* per fragment.

---

## Hardware

| machine | GPU | role |
|---|---|---|
| desktop | RTX 3080 20GB + Tesla P100 16GB | orchestration, Claude CLI, dev |
| `rickesh-Laptop` @ `10.147.20.104` | **RTX 3060 Laptop, 6144 MiB**, 62GB RAM | the constraint; all VRAM claims measured here |

The laptop runs Ollama 0.32.15 in a container (`ollama-bench`, reversible, no
system install). The desktop reaches it via
`ssh -f -N -L 11436:127.0.0.1:11434 rickesh@10.147.20.104`, so candidate runs use
the 3060 while the desktop GPU stays free. Set
`RLM_TEST_OLLAMA_URL=http://127.0.0.1:11436`.

---

## What is measured

**VRAM vs context on the 6GB card** (flash-attn + `q8_0` KV, matching the desktop
service config — without those the KV blows up and the direct arm is unfairly
handicapped):

| `num_ctx` | footprint | fits 5.5GB usable |
|---:|---:|:---:|
| 8,192 | 3.2 GB | yes |
| 16,384 | 3.3 GB | yes |
| **32,768** | **3.3 GB** | **yes — the ceiling** |
| 65,536 | 10.4 GB | no (31% GPU) |
| 131,072 | 10.9 GB | no (28% GPU) |

KV is nearly free to 32k, then the allocator falls off a cliff. **Direct maxes at
32,768 tokens.**

**RLM at 261,226 tokens on that card:** peak **4.23 / 4.24 / 4.25 GB** across three
runs. Fits, with ~1.2GB headroom. VRAM is flat in total context because the corpus
lives in CPU RAM as a REPL string and only chunk-sized slices reach the KV cache.
That is an **8x context multiple at constant VRAM**.

**Model ceilings.** `gemma4:e4b` = 131,072; `qwen3:4b` = 262,144 trained context.
1M is not reachable with these weights — that was the Claude `[1m]` variants, not
local GGUF.

**6GB-class candidates** (32k ctx, measured):

| model | footprint | fits 6GB | tool_ok |
|---|---:|:---:|---:|
| Gemma 4 E2B q4_0 | 1.8 GB | yes | 0.95 |
| **Gemma 4 E4B** | **3.5 GB** | yes | 0.90 |
| Qwen3 4B | 5.3 GB | marginal | 0.65 |
| Ornith 1.5 9B Q4_K_M | 6.2 GB | **no** | 0.95 |

E4B's 9.6GB GGUF is only 3.5GB resident (MatFormer / per-layer embeddings) — file
size badly overestimates VRAM here.

---

## What failed, and why it matters

**The reference is not a reliable oracle at this size.** Opus 4.8 [1m] over 439,742
tokens answered the *same* question two different ways on byte-identical input
(`Spatial Relationship` correct, `Normal scene Understanding` wrong), and is 2/3
across three samples. Ground truth must come from Python, with Opus scored as a
candidate. `bench/reference_reliability.py` quantifies this; it is cost-capped
because a call is $0.26 warm and $4.79 cold.

**The candidate's failure moved three times as plumbing was fixed:**

| attempt | calls | answer | defect |
|---|---:|---|---|
| 1 | 7 | prose | read ~33% of corpus |
| 2 | 11 | `Category: Spatial` | correct arithmetic, truncated label |
| 3 | **65** | `Category: Counterfactual` | swept corpus, well-formed, **wrong** |

Attempt 3 consumed 425,054 input tokens — it genuinely read everything and answered
in the required format. **The remaining gap is aggregation accuracy: a 4B correctly
combining 65 chunk-level counts.** That is a capability question, not plumbing.

### Guards added (none leak the answer)

| guard | catches |
|---|---|
| `require_repl` | answering from an empty REPL (measured: 1 call, pure guess) |
| `min_coverage=0.8` | answering from a partial read |
| `max_answer_chars` | returning the corpus instead of an answer |
| placeholder check | returning `Label: [least_common_status]` unsubstituted |
| `ContextTruncated` | Ollama silently clipping 50k→16,387 tokens |
| `QuotaExhausted` | rate limits scored as wrong answers |

`map_chunks(question)` was added to the REPL: it splits the entire context and
queries every chunk concurrently, collapsing the chunk-and-loop code a 4B fails to
write. It moved sub-calls from 17 → 75 and *reduced* wall-clock 16.6m → 7.8m.

### Scoring traps hit (both fixed)

- `gold in answer` passed a raw corpus dump because the dump contained the gold
  label. Strict scorers now reject replies with >2 ` || ` separators or over a
  length bound; the dump is a regression test.
- Caching a single sample of a non-deterministic reference froze a *wrong* answer
  as the oracle. The cache is now keyed on
  `sha256(model + instruction + context)`, so any change invalidates it.

---

## Remaining work

1. **Close claim B.** The candidate sweeps correctly but aggregates wrong. Options,
   cheapest first:
   - Make chunk-level output machine-parseable (ask each chunk for strict
     `label<TAB>count` lines) and aggregate in Python rather than trusting the
     model to combine 65 prose summaries.
   - Try E2B and Ornith 9B as the *root* (both scored 0.95 on tool behaviour vs
     E4B's 0.90); Ornith needs a card above 6GB or a smaller quant.
   - Root = Sonnet/Opus with sub-calls on the local 4B — the paper's own
     BrowseComp arrangement, untested here.
2. **Terminal-Bench baselines** — never produced a valid run. The ufw rule
   (`sudo ufw allow from 172.16.0.0/12 to any port 11435 proto tcp`) is in place and
   the bridge works; the suite needs re-running for E2B / E4B / Qwen3-4B.
3. **Quantify reference reliability** — run `bench/reference_reliability.py` for N
   samples to put a number on Opus's instability at 440k.
4. **Decide the finetune** — nothing is trained yet. Base and training data are
   both open (see below).
5. **MoE expert-offload — see the dedicated section below. This is the main line.**

---

## How claim B was actually met

`~/Projects/ctxstream` (C++17, zero third-party deps). The corpus is treated like
a video stream, and the model is removed from every step it was failing:

| video | ctxstream |
|---|---|
| manifest | segment plan, computed in code before any model call |
| buffer | N segments in flight |
| decoder | model sees ONE segment, emits `key<TAB>number`, never prose |
| playback | reduce — aggregation in code, strategy chosen explicitly |

Result on the 957,493-char imagined-risk corpus — the exact task that defeated
every earlier attempt, same 4B, same RTX 3060:

    17 segments · failed=0 · records=611 · unparsed_lines=3 · keys=15 · 641s
    Category: Spatial Relationship        <- gold, correct

Opus 4.8 [1m] on the same corpus: 2/3 correct, self-inconsistent on byte-identical
input, $4.79/call. The 4B on a 6GB laptop: correct, $0.00.

Still to confirm: the same pipeline against the full 262,144-token synthetic
ledger used by `bench/rlm_262k.py`, to show it holds at that size too.

---

## Main line: frontier-class quality inside 6GB via MoE expert-offload

The constraint is VRAM, not parameters. A Mixture-of-Experts model can put nearly
all of its weight in system RAM and keep only the always-active tensors resident,
so **35B-class quality is reachable inside 6GB**. This attacks the actual blocker
directly: a 4B cannot aggregate 65 chunk-level summaries; a 35B-A3B plausibly can.

### The candidate

`ornith-ai/Ornith-1.5-35B-A3B` (`Qwen3_5MoeForConditionalGeneration`), Q4_K_M =
21.7GB on disk. From its config: **40 layers, 256 experts, top-8 per token**,
`moe_intermediate_size` 512, and **30 of 40 layers use linear attention** (only 10
are full attention).

| component | params | ~Q4 size | placement |
|---|---:|---:|---|
| experts (256 x 3 x 2048 x 512 x 40) | ~32.2B | ~19.3 GB | **CPU RAM** |
| attention + embeddings + router + shared experts | ~1.7B | **~1.2 GB** | **GPU** |

Two properties make this unusually favourable: experts are tiny and fine-grained
(~1.9 MB each), and the 3:1 linear-attention ratio makes the KV cache far smaller
than a normal 35B — so long contexts cost little VRAM.

Laptop capacity as measured: **51 GB RAM available, 483 GB disk, 5.8 GB free VRAM.**
The 21.7 GB of experts fit in RAM with room to spare.

### Tooling

**Ollama cannot do this** — it exposes only `num_gpu` (a layer count), which would
naively push ~75% of layers to CPU including attention. The local llama.cpp build
already has the right flags:

    -cmoe,  --cpu-moe            keep ALL MoE weights on CPU
    -ncmoe, --n-cpu-moe N        keep MoE weights of the first N layers on CPU
    -ot,    --override-tensor    per-tensor placement by regex

`ghcr.io/ggml-org/llama.cpp:server-cuda` avoids building on the laptop.

### Steps

1. Pull `Ornith-1.5-35B-Q4_K_M.gguf` (21.7GB) to the laptop.
2. Run `llama-server` with `--n-gpu-layers 99 -cmoe`, so every layer's attention is
   on GPU and every expert FFN is on CPU. Measure resident VRAM; tune with
   `-ncmoe N` if there is headroom left under 6GB.
3. Add an OpenAI-compatible backend to `rlm_haiku/utils/llm.py` — llama-server
   serves `/v1/chat/completions`, not Ollama's `/api/chat`. Keep the
   `ContextTruncated` check: it needs a processed-token count from the response.
4. Re-run the equivalence test with this as the RLM **root** (sub-calls can stay on
   a cheap fast model, which is the paper's own BrowseComp arrangement).

### Known cost, stated up front

Expert streaming is memory-bandwidth-bound. Only ~3B params are active per token,
but a *different* ~600 MB of experts is touched every token, so throughput is set
by RAM bandwidth rather than compute — expect single-digit to low-double-digit
tokens/sec on a laptop. RLM multiplies that by ~65 sub-calls plus ~325k tokens of
prefill across chunks. **Minutes becomes tens of minutes to hours.** If quality
parity lands, that is the trade: VRAM and quality bought with wall-clock.

Fallbacks if throughput is unusable: `-ncmoe N` to pin as many expert layers on GPU
as fit (~4 GB spare / 1.9 MB per expert ~= 2,100 of 10,240 slots, so roughly 20%
resident); or a smaller MoE. True per-token LRU expert paging is what would help
most, and llama.cpp does not implement it (ktransformers, MoE-Infinity do).

## Open decisions

- **Finetune base and data.** Deferred pending baselines. Worth knowing:
  `empero-ai/Qwable-9B-Claude-Fable-5` already exists — Qwen3.5-9B fully fine-tuned
  on Fable-5 traces + `gpt5.5-terminal`, tagged `agentic-coding`. That is close to
  what we were going to build; evaluate it before training anything.
- **Release scope.** `Rickesh/rlm-oolong-reproduction` is published (harness +
  results, MIT, no weights). Nothing is trained, so there is no model release yet.
  Ollama.com namespace is separate from HF and needs your handle.

## Non-obvious findings worth keeping

- Ollama auto-sizes context to the prompt up to a ceiling, then **silently** falls
  back: 30,021 tokens pass intact, 50k and 70k both clip to exactly 16,387, with no
  error. `num_ctx` is **ignored** on the Anthropic-compatible `/v1/messages` and
  honoured on native `/api/chat`, which is also the only route reporting
  `prompt_eval_count` — the thing that makes truncation detectable.
- Terminal-Bench puts each task on its own compose network, so firewall rules
  scoped to `docker0` do not match. Scope by source subnet.
- RLM *hurts* when the context fits the window: OOLONG-131k, Haiku, 0.269 recursive
  vs 0.428 direct. It only pays when the context does not fit.
- The "behave like Claude" system prompt bought **zero** tool-selection accuracy
  across 4 models (deltas 0.00 / 0.00 / -0.05 / -0.05) while halving output tokens.

## Running things

```bash
# fast checks, no model calls
python -m pytest tests/test_equivalence.py -v

# equivalence, candidate on the 3060 (reference is cached; $0)
RLM_TEST_OLLAMA_URL=http://127.0.0.1:11436 \
  python -m pytest tests/test_equivalence.py -v -m integration -s

# 262k on the 6GB card (run ON the laptop)
python3 bench/rlm_262k.py --model gemma4:e4b --target-tokens 262144 \
  --num-ctx 8192 --max-prompt-chars 20000 --workers 2

# VRAM curve
python3 bench/vram_curve.py --model gemma4:e4b --budget-gb 5.5

# ask a question about an oversized file with a local model
python3 rlm_ask.py --file huge.log --query "which error appears most often?"
```