Research
November 16, 2026
REASONARA v2 A 1B-Token Context Window
An Encyclopedia in Your Laptop's Memory: The Power of a Billion-Token Context

Syed Ishtiaque Ahmed, Liang Zhao, David Klubeck, Emiliano Berenbaum, Max Murshed, Alan Ngo, Hasibul Haque
Introducing Reasonara v2
Introducing Reasonara v2, a graph-structured causal memory for agentic AI with a context window built at the billion-token scale: benchmarked on an 850-million-token enterprise corpus and built over more than a billion tokens. It keeps all of that searchable, hands the model only the evidence it needs for each question, and is light enough to run on a laptop.
If you run a coding agent, you have already paid the bill this post is about. Every morning the agent opens a repository it has seen a thousand times and reads it again from scratch. It greps. It opens the files it opened yesterday. It spends minutes and hundreds of thousands of tokens rebuilding what a colleague would simply have remembered, and then it answers. Multiply that by every agent, every question, every day. That is the context window problem, and a bigger LLM context does not solve it.
What does solve it just got a lot closer. Last month Microsoft and NVIDIA shipped the Surface Laptop Ultra: a petaflop of AI compute and 128 GB of unified memory in a laptop, built to run large models on the device instead of in a data center. Jensen Huang's line at the launch was that "the computer has to be revolutionized" for agentic AI. It solves just one half of the puzzle: the model now fits on a laptop. But the memory still doesn’t.
So here is the gap. You can buy the laptop. You can download the model. You still cannot get your work done locally, because the thing your work runs on, the memory of your codebase, your tickets, your incidents, your team's decisions, is not on the machine. It is scattered across tools and rebuilt every time by searching on every question. Olyvr is designed to address exactly that gap: a billion-token causal memory of your work, right on your laptop, that the local model reads from. Reasonara v2 is the engine inside it, and this post is about what that engine can now do.
TL;DR
-
Reasonara v2 holds a billion tokens of enterprise data as a causal graph and hands the model only the few records it needs for each answer.
-
It scores 90.08 on EnterpriseRAG-Bench, level with or above Claude Code searching the raw corpus (88.31). Most questions finish in about two minutes, while Claude Code needs a fifteen-minute cap to reach its score.
-
Reasonara has no external LLM dependency: the graph over a 512,000-document corpus builds in under two minutes without calling any model, so it can live on a laptop.
-
Once the memory does the knowing, the model can be small. Olyvr ships with a quantized Qwen3.6-35B-A3B that runs on the laptop next to the graph; benchmark results for it are next.
-
Olyvr Mind and Olyvr TeamMind each hold a billion tokens; Olyvr CollectiveMind federates them, so the reachable corpus is many teams times a billion.
In May we argued that enterprise AI doesn't have a model problem. It has a context window problem. Models are the easy part; every company has access to roughly the same ones. The hard part is giving your chosen model memory of your business. We shipped Reasonara to do that and verified it at 125M tokens of context. Four days later we mapped what each order of magnitude of context unlocks, from a single document at 10K tokens to institutional memory at a billion, and called the billion-token tier the direction we were building toward.
Six months later the argument has held up, and the number has moved. Reasonara v2 holds a billion tokens of enterprise data as a causal graph, searchable end to end, while passing the answer model only the slice it needs. The architecture is designed to scale well beyond a billion tokens. It scores 90.08 on EnterpriseRAG-Bench, one of the largest enterprise retrieval benchmarks, level with or above a Claude Code agentic-search baseline on the same 500 questions. That benchmark corpus is about 3.4 GB of enterprise documents, roughly 850 million tokens, and we have built the graph over a collection of more than 5 GB, past a billion tokens. And it has no external LLM dependency: the graph builds without calling any model, which is why it now runs on a desktop.
This post covers what changed: the scale, the two papers behind it (MegaMem and MemOnDemand), the results, why it lets the model shrink, and what it unlocks, starting with Olyvr.
What a billion tokens actually holds
In the tier map we published in May, a billion tokens is the institutional-memory tier: roughly the accumulated working knowledge of a thousand experienced people. Every decision, contract, system, failure, supplier relationship, and regulatory filing across decades, held at once. At the time, we wrote that at this scale the AI does not assist an organization's memory; it becomes that. We also wrote that the constraint at this tier is no longer the AI but whether the organization has structured what it knows. Reasonara v2 is our side of that bargain: a memory built for the billion-token tier.
Tier map from the May 11, 2026 post; frontier window figure as of May 2026
Each tick is an order of magnitude. Frontier models top out near the 1M tier; Reasonara sat in the 100M tier in May and now sits at 1B.
We weren't the only ones drawing that ladder. In February, Kevin Siskar walked the same climb, 4K to 1M to 1B to 1T, called the billion-token rung "the next horizon" for enterprise memory, and made the point that matters most: a billion tokens will not be a single giant prompt. It will be a memory hierarchy. Hot context for the work in front of you, cold stores the model can reach, compression and retrieval in between, so the system can reliably reason over a billion tokens without attending to all of them at once. His north star, borrowed from Sam Altman, was a small, fast model with a trillion tokens of reachable context and every tool. That is the shape Reasonara v2 takes. The model stays the reasoning engine; the causal graph is the memory it reaches into.
Nothing fits a billion tokens in a window, and it wouldn't help if it did. Three things go wrong well before a model's nominal limit, and we said them in May: cost grows with everything you stuff in, accuracy drops as the model loses track of the middle of long inputs, and the evidence that answers any one question is a handful of records, not the corpus. A billion tokens makes all three worse.
So the design goal for v2 was not a bigger window. It was to separate two things that usually get conflated. The persistent context is everything the system can search. The evidence context is the bounded set of source records the model actually reads to produce one answer. The first should scale with your business. The second should stay small no matter how large the first gets.
Our test bed is EnterpriseRAG-Bench: roughly 512,000 heterogeneous enterprise documents (about 3.4 GB, or roughly 850 million tokens) and 500 questions that span single-document lookup, multi-document reasoning, conflicting sources, constrained search, and questions whose answer isn't in the corpus at all. Reasonara v2 organizes that corpus into a causal graph of 1.6 million memories, nodes for the decisions, constraints, events, and facts in those documents, with edges for what causes, follows, or contradicts what, and answers each question from a bounded slice of that graph.
How v2 gets there
At its core, Reasonara is a causal graph. We said it in May and it is still the whole idea: not a pile of text snippets behind a search box, but a navigable graph in which every node is a unit of meaning, a decision, a constraint, an event, a goal, a fact, and every edge records how nodes relate: what causes what, what follows what, what contradicts what. The structure is the product. Cognitive cues sit on the nodes, and a learned policy decides how far to walk the graph for a given question. v2 keeps all of that and changes three things about how the graph is built, layered, and retrieved at a billion tokens. Two of them are published; the third is why it fits on a laptop.
Reasonara v2 architecture: causal graph with layered levels, two views per node, bounded evidence
A query routes top-down over the distilled views, loads detailed evidence only at the source nodes, and the model never sees more than the budget allows.
Every node in the graph carries two views. This is the core of MegaMem, the first of the two papers. Each node is stored as a distilled view, a compact typed memory (a fact, a procedure, a definition, a requirement, or a decision) that is cheap to search and good at matching questions phrased differently from the source, and a detailed view, the original content with its wording, conditions, and provenance intact. Retrieval searches both views with the original question and with transformed versions of it. But every distilled hit resolves back to its source record before anything is ranked, deduplicated, or shown to the model. Compressed memory finds things; it never stands in for the evidence. Only the highest-ranked detailed records that fit a fixed evidence budget reach the answer model, and a separate attribution step afterward reports which of those records actually supported the answer.
The graph layers itself, and nodes are promoted on demand. This is MemOnDemand, the second paper. Enterprise collections differ by domain and by tenant, so no fixed taxonomy fits all of them. MemOnDemand clusters the graph's nodes level by level and lets a controller decide, for each collection, whether to create another abstraction level, recluster, or stop. Each level is itself a layer of the graph, with the same two views and edges down to its source nodes, so a query routes top-down over distilled memory and only loads detailed evidence once it reaches the source records. The last mechanism is the one the name comes from. Instead of preparing every representation up front, the system promotes a node when a query shows it is useful, refreshes it on repeated use, and demotes it as it goes stale, all under a bounded budget of active nodes. This is also what carries the May post's fourth failure mode forward. A constraint that keeps mattering keeps getting promoted and its edges stay loud; one that doesn't, fades. The standing-wave idea behind Reasonara's name is now a mechanism in the graph, not a metaphor.
No external LLM dependency. Reasonara v2 builds its graph without calling any model: no LLM extraction, no embedding service, nothing that waits on an API or sends your data anywhere. The causal graph over the 512,000-document EnterpriseRAG corpus builds in 106 seconds with no model in the loop. The Odyssey, Compass, and Spark tiers run on this graph alone; the answer step is the only place a model appears, and that model is your choice, local or hosted. This is the third change, and it is why the whole system fits on a laptop.
Four tiers. Query time is where the model does its work, so v2 exposes four tiers, from most thorough to fastest:
-
Odyssey generates several candidate answers in parallel, verifies them against the evidence, and adjudicates.
-
Compass runs parallel candidates and adjudicates, without the deep verification pass.
-
Spark is a single plan-retrieve-answer pass.
-
Blink is one retrieval and one answer over a lightweight dense index. No planning, no reranking.
The tiers trade accuracy for latency and cost. The results below report the best-scoring tier on each benchmark.
Results
Reasonara v2 scores 90.08 on EnterpriseRAG-Bench, 91.62 on LoCoMo, and 91.4 on LongMemEval. All numbers below come from our benchmark runs in late September and early October 2026, scored with each benchmark's official judge. Each is the best-scoring tier on that benchmark. Reasonara answers were generated with GPT- 5.6- sol; the agentic baselines used claude-opus-5.
| Benchmark (metric) | Reasonara v2 | Reference |
|---|---|---|
| EnterpriseRAG-Bench, 500 questions (combined correctness × completeness) | 90.08 | Claude Code agentic search 88.31; Codex 55.19 |
| LoCoMo (LLM-judge accuracy) | 91.62 | Full-context baseline 82.5, as reported in May |
| LongMemEval (overall accuracy) | 91.4 (Spark tier, $11.70 for the full benchmark) | Reasonara v1, May 2026: 87.4 |
Enterprise memory (EnterpriseRAG-Bench). This is the benchmark that matters most for the billion-token claim. The obvious alternative to a memory layer is to hand an agent the raw corpus and let it search. We ran that baseline too: Claude Code with claude-opus-5, read-only search over the 512,000 files, same 500 questions, same judge.
| System | Combined | Document recall | Latency per question |
|---|---|---|---|
| Reasonara v2 | 90.08 | 92.6% | 121 s median (95th percentile 264 s) |
| Claude Code agentic search, 15-minute budget | 88.31 | 87.5% | 123 s average (15-minute cap per question) |
| Codex agentic search (gpt-5.6-sol) | 55.19 | 52.0% | 328 s average |
Agentic search works if you let it run. Give Claude Code fifteen minutes per question and it reaches 88.31. Cut the budget to five minutes and it drops to 81.72; two minutes, 61.95; one minute, 35.64. Reasonara v2 reaches 90.08 with a median of two minutes per question, and 95 percent of its questions finish in under four and a half minutes. Under the same five-minute cap where Claude Code drops to 81.72, nearly all of Reasonara's questions complete. That is the trade a memory layer buys you: the search has already been done at ingest, so query time is spent reasoning over evidence rather than hunting for it.
Causal Dynamics Lab benchmark runs, September–October 2026 · Reasonara plotted at median latency, Claude Code at its time budget
One more baseline is worth being candid about. nano-claude-code, an open agentic harness driving the same model, reached 93.04, but only with its per-question timeout raised to 6,000 seconds, 6.7× the default. Its median question took six minutes, the 95th percentile took 34, the full run took 20.5 hours, and it cost roughly $771. At the default timeout it would have lost about a quarter of its questions.
Conversational memory (LoCoMo and LongMemEval). Reasonara v2 reaches 91.62 on LoCoMo and 91.4 on LongMemEval, up from the 87.4 we reported in May. The LongMemEval run is the one to notice: the full benchmark cost $11.70. On shorter, single-user histories the memory does the work, and a single pass over the graph is enough.
What this means for cost. The tiers share one memory, so a deployment can route routine questions to the fast tiers and reserve the thorough one for the questions that need it. The thorough tier on the hardest benchmark cost $744; it is the top of the range, not the floor. On a newer model mix (GPT-6), the same Odyssey tier scores 87.09 on EnterpriseRAG-Bench for $155, within about a point of Claude Code at roughly a third of its cost.
All runs were made by Causal Dynamics Lab in September and October 2026 and scored with each benchmark's official judge. Full per-tier latency and cost figures for every benchmark are available on request.
Why this changes the model
In May we said enterprise AI doesn't have a model problem. A billion-token causal memory lets us make the stronger claim: once memory does its job, the model can be small.
Look at where every query above ends. Whatever the tier, the answer model receives the same thing: a question and a bounded set of source records that fit the evidence budget. Reasoning over a handful of records is a small-model task. The parts that used to need a frontier model, knowing the enterprise, finding the evidence, holding a million tokens in attention at once, have moved into the graph. And the graph is built with no model in the loop at all. The leverage is in the memory, not the weights.
That leads to the claim we are now testing: a small model with a billion-token causal memory produces better answers than a larger model doing full-context processing. The large model with everything in its window pays twice, once in tokens and once in accuracy, because accuracy degrades as the window fills and the middle goes unread. The small model with Reasonara v2 reads only the records that matter, with their causal context attached, and reasons over those. On EnterpriseRAG-Bench, memory-first retrieval already matched a frontier model running agentic search over the raw corpus. The same mechanism is what lets a smaller model take the frontier model's place.
The results above were run with frontier models because that is what the benchmarks and the agentic baselines use. The product does not need one. Olyvr ships with a quantized Qwen3.6-35B-A3B, an open-weight mixture-of-experts model with 35 billion total and 3 billion active parameters, small enough to run on the laptop next to the graph, and the local-model benchmark runs are the next results we will publish. Swap the model and three things do not change: the evidence budget, the latency floor set by retrieval, and the graph itself. What changes is the cost per question and where the model can live. A small model fits next to the graph on the same machine, which is the deployment the desktop tiers are built for, and it fits inside security boundaries that no hosted frontier model will ever cross.
This is also why we think the memory has to be structured rather than just large. A frontier model can paper over sloppy retrieval by reasoning its way around distractors. A small model cannot. It needs the right few records, resolved to their sources, with the causal context attached. That is what the graph is for. The small, fast model with a huge reachable memory that Siskar and Altman describe is the right north star; v2 is the memory half of it, and Olyvr ships both halves together.
What this unlocks
Olyvr. A powerful laptop and a local model still do not let you get your work done locally. Olyvr, our memory and context layer for coding agents, is designed for exactly that. Coding agents are the sharpest case of the context window problem. A codebase, its tickets, its incident history, and the reasons behind its decisions do not fit in any window, and an agent that forgets them between sessions re-learns the repository every morning. Olyvr gives agents persistent, agent-independent memory across the software lifecycle, whichever agent is doing the work. Its substrate is the Software Causal Model, a causal graph of a codebase's decisions, dependencies, incidents, and outcomes, and Reasonara v2 is the Causal Memory faculty inside it. Olyvr Mind runs on an individual developer's machine. Olyvr TeamMind shares that memory across a team. Olyvr CollectiveMind, which extends it across teams, is next.
Olyvr tiers: Mind (individual), TeamMind (team), CollectiveMind (federation across teams)
A billion tokens is the unit, not the limit. Each developer's Mind and each team's TeamMind holds one; CollectiveMind federates them into a corpus no single graph has to hold.
The three tiers nest, and each one is a complete Reasonara v2 graph in its own right.
Olyvr Mind is one developer's memory. It holds a causal graph of up to a billion tokens built from the repositories, tickets, incidents, and decisions that developer works with, and it runs on that developer's machine. Any coding agent the developer uses reads from it, so switching agents, or starting a new session, doesn't mean starting over.
Olyvr TeamMind is the team's shared memory: a second billion-token graph of the decisions, dependencies, incidents, and outcomes the team owns together. It sits above the Minds of its members. What a developer's agent learns that matters beyond that developer is promoted into the TeamMind, and what the team knows is available to every member's agent. A new engineer's agent arrives with the team's history already in reach.
Olyvr CollectiveMind federates TeamMinds across an organization. No single graph holds the whole company. Instead, a question that a developer's Mind and TeamMind cannot answer can reach the TeamMinds of other teams: the service they depend on, the incident another team handled last year, the API contract that changed. The reachable corpus is many teams times a billion tokens, while each team's graph stays the unit of ownership and access.
It runs on a desktop. Because Reasonara has no external LLM dependency, the whole graph can live on the machine where the work happens. The 512,000-document benchmark corpus builds in 106 seconds. The fastest tier answers in seconds rather than minutes. Olyvr ships with a quantized Qwen3.6-35B-A3B as its default local model, so out of the box nothing leaves the laptop at all; point it at a hosted frontier model if you prefer, and the graph does not change. In May we wrote that the largest context queries take minutes and that the near-term architecture is batch. For the fast tiers, that is no longer true. Microsoft's word for the new laptop's split between the local GPU and the cloud is hybrid intelligence; the tiers are the memory side of that split, the fast ones on the local model, the thorough one on whichever model you point at it.
Local latency. A graph on the device with a model beside it changes what a question costs. Unlike full-context processing, where everything that might be relevant is pushed through the model's window, the cost of a question with Reasonara v2 tracks the evidence budget rather than the size of the memory, because the model reads a bounded slice of evidence instead of the corpus. On LongMemEval, the single-pass Spark tier scored 91.4 with a median answer time of 14 seconds and cost $11.70 for all 500 questions. Large memory, small context. What is left of the latency is the model's own inference, and on a local model that is the entire round trip: no upload, no queue, no network.
The enterprise case. Everything in the results section ran against a corpus of policies, contracts, email, tickets, tables, and code, which is what an enterprise deployment looks like. Reasonara v2 deploys inside your own cloud environment, as v1 did, and the same tiers apply: the fast ones for questions an assistant should answer while someone waits, the thorough one for questions a team would otherwise schedule a meeting about.
Why now, again
The three things we said had changed in May are still true: models are commoditizing, context windows aren't enough, and similarity search has hit its ceiling. Three more have changed since, and they are what make a billion-token memory on a desktop the right product rather than a demo.
1. The edge got powerful. The laptop this post opened with is the proof. Microsoft and NVIDIA began shipping the Surface Laptop Ultra, a $2,599 laptop built around NVIDIA's RTX Spark chip and sold on the promise of running large models locally instead of racking up cloud bills. Microsoft's own description puts it at 1 petaflop of AI compute, up to 128 GB of unified memory, and 120-billion-parameter models run on the device. That is more than enough to hold a billion-token causal graph and run a small language model beside it, and it is a mainstream Windows laptop, not a workstation. Six months ago a billion tokens of institutional memory was a data-center project. Today it is a graph that builds in minutes on the machine in front of you and serves four tiers of answer.
2. Open models carry the traffic, and the traffic is search. On OpenRouter, open-weight models now serve roughly 60 percent of tokens from US requests and close to 70 percent of named-model volume, up from a small fraction a year ago, and agents account for about 70 percent of everything the platform processes. Look at what those agent tokens buy. A systematic study of agentic coding found that agent tasks consume about a thousand times the tokens of a chat, that input tokens rather than output drive the cost, and that the most expensive runs are the ones that re-read the same files; practitioners put the share of an agent's tokens spent navigating a codebase at 60 to 80 percent. That is the search bill, and it is now paid in a market that has already moved to cheap open models. A memory layer that does the search at ingest removes most of it. What remains is the reasoning step, and open models handle that.
3. Privacy and security. No one wants to ship a billion tokens of code, contracts, incident history, and customer records to a hosted model on every question, and many teams are not allowed to. With the graph on the device and an open model beside it, nothing leaves. Reasonara v1 deployed inside your own cloud. v2 also runs on the machine where the work happens, which for some teams is the only deployment they will accept.
Put the three together and the field is converging on one shape: a compact reasoning engine over a large, reachable, private memory. Our bet is that the memory has to be causal.
What this means for you
If you build with coding agents. Start with Olyvr Mind on your own machine. Point it at your repositories and your agent stops re-learning the codebase every session. Switch agents, or switch from a hosted model to the local one, and the memory comes with you. The questions that used to cost a ten-minute grep session come back in seconds, with the records that answered them.
If you run an engineering organization. The search bill is the part of agent spend that grows with codebase size and headcount. Olyvr TeamMind puts the team's decisions, incidents, and dependencies in one graph that every member's agent reads, and a new engineer's agent arrives with the team's history already in reach. Route routine questions to the fast tiers and reserve the thorough one for the questions that need it.
If you own security or compliance. The graph builds with no model in the loop, lives inside your boundary, and the default model runs beside it. Nothing leaves unless you choose a hosted model for the answer step, and every answer reports which source records supported it. Reasonara deploys in your own cloud, as it did in May, or on the device.
If you are evaluating memory layers. Ask three questions of any system: how large a corpus it has been evaluated on, how many tokens reach the model per answer, and whether every answer resolves to its source records. Our answers are roughly 850 million tokens benchmarked and more than a billion built, a bounded slice, and yes.
What's next
-
CollectiveMind. Federation across teams is designed and next in line; Mind and TeamMind are in product today.
-
Small-model numbers. The next results we publish will be the local-model runs: a quantized Qwen3.6-35B-A3B on the graph against frontier models with full context, on the same benchmarks as above.
FAQ
Is Reasonara v2 just RAG? No. RAG retrieves text snippets by similarity and hands them to the model. Reasonara builds a causal graph at ingest, routes each query top-down over distilled views, resolves every hit to its source record, and loads a bounded slice of detailed evidence. Similarity search is one of its retrieval routes, not the architecture.
Does a billion tokens mean the model attends to a billion tokens? No. The billion is the persistent context, everything the system can search. The evidence context, what the model reads for one answer, stays bounded. That separation is the whole design.
What happens to my data? It is indexed on your machine or in your cloud, and Reasonara has no external LLM dependency, so building the graph sends nothing anywhere. It leaves only if you choose a hosted model for the answer step. With the default local model it never leaves.
Which models work with it? Any. The benchmarks above used frontier models; Olyvr ships with a quantized Qwen3.6-35B-A3B. The graph and the evidence budget are the same whichever model you choose.
How big can it go? We have benchmarked it on about 850 million tokens and built the graph over more than a billion; the design is meant to go well beyond that. Today each Olyvr Mind and each Olyvr TeamMind holds up to a billion tokens. Olyvr CollectiveMind federates TeamMinds, so the corpus an agent can reach is many teams times a billion.
Does it replace long-context models? It makes them optional. A long window is still the right tool when you want a model to read one large document whole. For a business's memory, the graph is built to be cheaper and faster than stuffing the window, and the evidence it hands the model is easier to check.
How do I try it? Download Olyvr, or get in touch about Olyvr and Reasonara for your team.
It isn't missing anymore
In May we wrote that the models work, the data is already there, and what's missing is the memory infrastructure between them. It isn't missing anymore. It builds in minutes, fits on the machine in front of you, and remembers the way a business actually works: by cause and effect.
Read the research: MegaMem: A Retrieval Solution for Ultra-Large Context Windows and MemOnDemand: A Memory Management System for Large-Scale Enterprise Data, with code at MegaMem and MemOnDemand on GitHub and the billion-token collection on Hugging Face.
Try it: Download Olyvr, or get in touch about Olyvr and Reasonara for your team.