Cassette Build Report 060 — The Model Files Became a Working Model

Scope note: This report covers L02 and the first L03 implementation on deterministic source fixtures and scratch cartridges. It does not establish real-model usefulness, physical-drive performance, or F4/F5 quality.

Cassette could execute a model it already understood. It could not yet understand an ordinary model well enough to execute it.

That distinction had survived beneath a great deal of working code. The compiler’s private manifest and the fixed F3 decoder could prove storage, identity, scheduling, and arithmetic against a model shape we had prepared for them. Sol’s review of L02 found no completed attempt in which ordinary configuration, shards, tensor names, tokenizer files, or image-processing declarations became the thing Cassette actually ran.

The system had a test built around one prepared model. It did not yet have a source-derived model path.

I asked GPT-6 Astra to assess the finding and build the missing route. Astra accepted all six parts. The new path reads model configuration, shard indexes, tensor names and shapes, tokenizer data, and declared image processing. It expands dense and sparse layers at the dimensions found in those files. Pinned libraries provide tokenization, contained template rendering, and numerical operations. The broker owns generation. The store commits tokens and attention state through the same pages, roots, and journal used by the rest of Cassette.

This was not a file-format exercise. The source records had to determine behavior, which meant that an unsupported tensor name, operation, shape, tokenizer rule, or image processor had to make Cassette refuse the source instead of translating it into a familiar implementation.

A separate GPT-5.6 Terra reader found two omissions in Astra’s first pass. Semantic metadata still lived outside the broker’s acquisition path, which meant the weights could be verified while the tokenizer or template arrived through weaker handling. Different native requests could also race when committing their state. Astra routed semantic JSON through the same transfer and verification boundary and serialized computation with publication.

Terra then found a quieter failure. A source template could loop without emitting bytes, so the renderer’s output limit never advanced. The template was technically producing nothing and computationally doing work forever. Astra added a deterministic loop budget, bounded the rendered JSON, and rejected expansion operations the source had not earned.

The first frozen L02 attempt used a two-shard source with independently calculated dense, sparse, and image outputs. It exercised multi-token generation and reconstructed attention state. Fourteen focused tests passed. Terra then supplied a fresh case that combined sparse experts with image input, compared its output with a scalar calculation, altered one pixel, and confirmed that the result changed. The review also drove a template through 4,032 loop ticks and rejected work beyond the 4,096-tick limit.

Terra’s first route comparison flattened a nested list incorrectly. The agent corrected the instrument and kept the failed probe. That detail belongs in the story because independent review is not a status conferred by a different model name. The reviewer still has to expose its own mistakes.

L03 extended the same source-derived graph into compiled execution, teacher capture, training, recovery, and five client protocols. One graph now serves inference, observation, and differentiation. That is a structural choice, not merely code reuse. If training uses a second interpretation of the model, or teacher capture silently simplifies the graph, the system can produce internally consistent evidence about a model it never actually runs.

The shared graph route is visible in public pager.py:

def linear(value, names):
    if self.compiled and not exact_source and names[0] in self.compiled["transformed_tensors"]:
        result = self._compiled_linear(value, names[0], position)
        return mx.add(result, weight(names[1])) if len(names) == 2 else result
    result = mx.matmul(value, weight(names[0]).T)
    return mx.add(result, weight(names[1])) if len(names) == 2 else result

values = {"tokens": tokens, "pixels": pixels}
pending_kv = dict(kv)
routes, usage, activations = [], [], {}
for node in self.graph["nodes"]:

Teacher capture began recording actual activations, logits, gradients, and the effect of removing declared contributions. The observation claim was kept deliberately finite. Repeating the same deterministic forward pass does not create statistical confidence. It proves what happened for the declared input family and refuses unsupported inputs.

Training exposed another class of shortcuts. The first implementation used the client’s generation seed for private correction draws. Astra separated the correction key and saved it in the runtime state. Terra found that most unsigned 64-bit keys could not survive canonical JSON as safe integers, so the state moved to fixed-width hexadecimal text. The first scheduler also handled only the output head. Exact operands elsewhere in the graph were brought into the same page-acquisition and memory-admission system.

The training path now uses bounded sequence records, masked causal loss, continued pretraining, and preference loss against a fixed reference. It derives adapter dimensions from the source tensors. All gradients for one batch see the same parameter snapshot; partial updates wait until the last window completes. A receipt binds the model, adapters, batch, optimizer state, precision, and durable cursor before a checkpoint advances.

The agents retained their false starts: two integration runs stopped after source changes; one arithmetic assertion read an exact rational value as a float; a stack capture showed recovery rehashing every historical generation after each write; and the first frozen L03 attempt failed because three new contracts were absent from the exact schema inventory. The repaired recovery path verifies the newest valid generation while preserving deeper history for the callers that need it. Product behavior was unchanged by the schema correction, but the failed attempt remained failed.

The corrected L03 fixture passed fifteen focused and coupled tests. Terra independently removed a required embedding page and saw execution stop before consuming it. The reviewer contradicted a regenerated target and saw publication fail. The compiled graph, real language-model objectives, child regeneration, recovery, and five protocol paths were now connected.

This was still a model made small enough to inspect. No physical drive had proved its speed. No frontier model had proved useful output. That limit does not diminish the step. It names it.

Before L02, Cassette had mechanisms that worked around a prepared representation. After L03, ordinary source facts could become one executable graph whose inference, training, recovery, and client behavior shared an identity. The agents did not add generality by claiming support. They added it by letting unfamiliar source material either govern the machine or be refused.