Most memory systems decide on the write path. An event happens, a model extracts what seems important, and the rest is discarded. That keeps the store clean. It also asks the write path to know, at ingest, what will matter in three months. A detail that looks irrelevant in a support chat may explain an escalation later. Once the raw event is gone, better retrieval cannot recover it.

The better pattern is the old data-lakehouse move: preserve what happened, then build the useful representations later. Summaries, embeddings, graphs, and memories become replaceable views over an immutable history. The same conversation can yield one set of facts today and another next year. Better models can re-index old history. New agents can use it in ways nobody planned at capture time.

Most long-horizon agents compress or summarize the past as it arrives. That decision is made before future needs are known. Once discarded, the original evidence is gone.

Scroll treats each session as an executable environment. An append-only Event Log keeps lossless historical ground truth. A persistent Python kernel holds tool outputs, retrieved history, and derived state as variables rather than prompt text. The model writes code to search, materialize, and transform that state. Only the projections it prints enter the next working view.

Most local serving systems treat a personal computer as a small GPU that must fit the model. FreeToken starts from a different premise. The machine is a unified, elastic inference platform whose CPU, GPU, and interconnect can be orchestrated continuously as workloads and available resources change.

The system is designed for Mixture-of-Experts models and for agentic workloads that repeatedly edit context and call tools. Its core techniques include bandwidth-adaptive execution (deciding in real time whether missing experts should be moved to the GPU or run on the CPU), semantic-aware state caching at natural boundaries, full-layer double buffering during prefill, and elastic reallocation of GPU memory between KV cache and experts.

Most systems still give models knowledge the hard way. They retrieve raw chunks at query time and force the model to re-derive understanding on every question. Nothing accumulates.

A better pattern has quietly emerged in 2026.

Many optimization patterns from the mainframe era are being revived in agentic AI systems. When a core resource is powerful but expensive and slow, we wrap it in caching, abstraction layers, routing, and edge computing. Today, that expensive core is LLM inference.

The familiar four moves are already visible:

Every AI agent is built from 12 distinct layers. Most tools look impressive in demos but fail in real work because one or more layers are missing or weak.

The framework breaks down into four parts: