Lavett

Against flat context.

Modern language models can read enormous amounts of text, but a bigger context window does not create structured memory. It just postpones the same problem at a higher token cost.

Most AI memory still behaves like a pile: previous messages, compressed summaries, or retrieved chunks. Useful, but not the same as understanding how ideas connect, what changed, and what the evidence was.

A recurring mistake, a corrected belief, a changing goal, and a stable preference should not all live as equal pieces of text. They need structure, scope, evidence, and a lifecycle.

• —Raw context is expensive and grows without bound.
• —Summaries save space but quietly lose detail.
• —Vector search finds similar chunks but misses relationships.
• —Old facts and new facts are left to silently conflict.
• —Models struggle to track what changed over time.
• —Personalization needs remembered patterns, not just messages.

A support structure for reasoning.

A lavett is the carriage beneath the cannon: the structure that carries, stabilizes, and aims it. The barrel does the firing; the carriage decides where it points.

Lavett applies that idea to AI. The base language model stays the engine of language and reasoning. Lavett builds the support layer around it — memory, routing, context compilation, evidence paths, and semantic structure — so the same model reasons from better-aimed input.

The architecture inside Lavett

NodeWeb: the memory architecture.

• Meaning Event Graph

  Language is decomposed into structured events: subject, action, object, time, attributes, and evidence.

  learner → omitted → article ("the")

• Concept Gravity

  Recurring or important concepts gain weight over time, so retrieval is more likely to surface what actually matters.

  concept recurs → gravity ↑ → routing favors it

• Truth Lifecycle

  Facts are not treated as permanently equal. They can be current, uncertain, contradicted, corrected, or superseded — and the transition stays inspectable.

  old belief → corrected → marked superseded

• Multi-Route Retrieval

  Different routes search memory differently: entities, actions, timelines, corrections, contradictions, goals, and evidence — run in parallel and competed.

  route(roles) ∥ route(timeline) ∥ route(evidence)

• Correction Trajectories

  The system tracks the arc of a mistake instead of a single snapshot: mistake → correction → recurrence → improvement.

  mistake → corrected → recurs → resolved

• Context Compiler

  Instead of dumping raw chunks, NodeWeb compiles a task-specific briefing split into proof context, background, and what it dropped.

  chunks ✗ → compiled proof path ✓

• Scope-Bound Memory

  Memory is scoped by source workspace, so a coding-project answer is not contaminated by unrelated tutoring or research notes.

  answer ⊂ dominant workspace

• Explainable Memory Paths

  Every answer can show the memory route behind it — the roles, events, and evidence it actually used.

  answer ⟵ route ⟵ evidence span

How meaning is decomposed

RoleGraph: the original thesis.

Lavett does not only remember facts. It decomposes language into reusable, role-linked nodes — subjects, actions, objects, attributes, modifiers, time, locations, claims, and evidence — and tracks those roles across repeated occurrences in timeline order.

It also separates four things most systems flatten together: the literal surface form, the immediate error object, the broader practice target, and the wider domain topic. That separation keeps the graph from over-merging unrelated ideas and lets it compile smaller, evidence-backed proof paths.

RoleNode

a reusable canonical role part — learner, omit, article, yesterday

RoleOccurrence

one evidence-backed appearance, anchored to a source file and line range

RoleEdge

a typed, evidence-backed relationship — subject_performed_action, claim_supported_by_evidence

Today and tomorrow

The substrate underneath.

The readable proof path is an adapter for today’s LLMs — not the final form. Underneath, Lavett is building a layered substrate: raw archive pointers, sentence and clause capsules, a concept dictionary, the role graph, an inspectable semantic bytecode, and timeline and evidence indexes.

Clause capsules matter because one line often carries two signals. Lavett keeps them separate instead of flattening them into one event.

Readable proof paths are for today’s models. Semantic bytecode is for internal indexing now and, eventually, direct consumption by a memory-native model.

What this looks like in practice.

A learner repeatedly drops the article before a noun. NodeWeb stores it not as another message, but as a correction trajectory in the role graph.

learner        → omitted        → article
error_object   → article ("the")
practice_target→ English article usage
concept        → has_gravity    → recurring
status         → unresolved

Honest, narrow results

The evidence so far.

Still small and inspectable. Extraction is heuristic, contradiction logic is narrow, and the open target is keeping proof-path compression evidence-complete as the benchmark grows.

Measurement, not model hype

Research instrumentation.

Current measurement threads include:

• sufficient-statistic routing
• proof-carrying memory
• entropy-proportional compute
• predictive-coding memory
• negative memory
• interference-typed belief
• Grounding Conservation Principle
• canonical semantic hashing
• holographic memory
• capability-preserving forgetting
• epistemic half-life
• semantic error-correcting codes

A constraint, not a feature

Legibility is not optional.

One rule overrides every other goal in the project, including compression and efficiency: nothing Lavett stores, routes, derives, or emits is allowed to exist without a deterministic, total decoder back to faithful human-readable text. A representation without a registered decoder is rejected at write time.

Honestly scoped: this makes the Lavett substrate auditable by construction. It does not make a consuming model’s internal forward-pass interpretable — no deployed technique does. The strategy is to push as much reasoning as possible into the legible substrate and watch the residual rather than pretend it away.

The thesis.

Lavett starts from a simple suspicion: the next improvement in useful AI may not only come from larger models, but from better support structures around them.

If memory can be represented as a living web of meaning — with evidence, scope, recurrence, contradiction handling, and task-specific routing — then smaller, more accessible models may become more capable at long-term reasoning, tutoring, project memory, and personal context.

We are testing whether structured memory routing can improve:

• long-conversation recall
• contradiction handling
• evidence quality
• provenance
• token efficiency
• explainability
• personalization
• smaller-model usefulness

A staged plan

The road from here.

Lavett is staged deliberately, evidence before hype. Today’s work sits at the start of that ladder; each stage has to earn the next.

1. Stage 0now

   Research prototype

   inspectable CLI, storage, evaluation

2. Stage 1now

   Evidence-grade benchmark

   beat raw context on a real metric

3. Stage 2

   Semantic memory addon

   drop-in memory for existing LLMs

4. Stage 3

   Specialized product layer

   one vertical where memory pays off

5. Stage 4

   Research architecture

   reproducible results vs strong baselines

6. Stage 5

   Memory-native model

   the moonshot

Tutoring is the first benchmark only because it is easy to evaluate — not the destination. The same substrate aims at:

• long-form conversation & advice
• coding & project memory
• research assistants
• education & tutoring
• personal & project memory

Current status.

Lavett is early. NodeWeb runs today as a Python research prototype: a CLI-first memory engine with SQLite storage, heuristic meaning-event and RoleGraph extraction, multi-route retrieval, evidence-aware context compilation, ablation-backed evaluation, and bounded baseline tooling. The codebase is being kept clean for eventual open-source release, but the research is still young.

A Bruket research project.

Bruket is the workshop behind Hyral, KVITT, Spegeln, Vilse, and Lavett.

Where Hyral works on housing discovery, KVITT on receipt intelligence, Spegeln on public-record transparency, and Vilse on emergent-simulation worlds, Lavett is Bruket’s research branch for AI memory systems and language-model support structures.

• HyralDirect landlord contact routes for renters, not another listings portal.
• KVITTBehavioral spending intelligence, read straight from your receipts.
• SpegelnA mirror held up to power, built only from public record.
• VilseAn emergent civilization MMO where economies and institutions are built, not scripted.
• Lavettstructured AI memory · you are here