A Bruket research project

Lavett

Memory with aim.

Structured memory routing for language models.

Lavett is a Bruket research project exploring support structures for language models — systems that help AI reason from a living web of meaning instead of a flat pile of tokens.

Against flat context.

Modern language models can process enormous amounts of text, but bigger context windows do not automatically create structured memory.

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.

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 lifecycle.

• —Raw context is expensive and grows without bound.
• —Summaries save space but quietly lose detail.
• —Vector search finds similar chunks but can miss relationships.
• —Old facts and new facts are left to 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.

Lavett applies that idea to AI systems. The base language model remains the engine of language and reasoning. Lavett builds the support layer around it — memory, routing, context compilation, evidence paths, and semantic structure.

First architecture under Lavett

NodeWeb Memory Routing LM

NodeWeb is the first architecture being developed under Lavett. It is an experimental memory-routing layer that turns language into connected meaning events: entities, actions, objects, corrections, contradictions, goals, and evidence.

The first version does not try to replace existing language models. It asks a narrower, testable question: can an ordinary or smaller model become more useful when it is given better memory structure?

• Meaning Event Graph

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

  learner → struggles_with → Swedish word order

• Concept Gravity

  Recurring or important concepts gain weight over time, making the system more likely to retrieve what actually matters.

  word order recurs → gravity ↑ → tutoring focuses there

• Truth Lifecycle

  Facts are not treated as permanently equal. They can be current, uncertain, contradicted, corrected, or superseded.

  old belief → corrected later → marked superseded

• Multi-Brain Routing

  Different routes search memory differently: entities, actions, timelines, corrections, contradictions, goals, and evidence.

  route(entities) ∥ route(timeline) ∥ route(evidence)

• Correction Trajectories

  For learning, the system tracks the arc of a mistake: mistake → correction → recurrence → improvement.

  mistake → corrected → recurs → resolved

• Context Compiler

  Instead of dumping raw chunks into the model, NodeWeb compiles a task-specific briefing: relevant entities, high-gravity concepts, evidence, warnings, and open uncertainties.

  chunks ✗ → compiled briefing ✓

• Explainable Memory Paths

  The system should be able to show why it answered something by exposing the memory route behind the answer.

  answer ⟵ route ⟵ evidence

What this looks like in practice.

A learner repeatedly writes one sentence the wrong way. NodeWeb stores it not as another message, but as a correction trajectory.

learner        → made_mistake   → Swedish word order
mistake        → corrected_to   → "Jag förstår inte"
concept        → has_gravity    → recurring
status         → unresolved
next_practice  → V2 word order

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 and 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
• language-learning personalization
• token efficiency
• evidence quality
• explainability
• smaller-model usefulness

The long-term aim.

The long-term aim is not only to build a clever memory layer. It is to move toward AI systems that are more accessible, more inspectable, and more useful over time.

If NodeWeb proves itself, Lavett will explore how structured memory routing can support smaller models, local models, personal tutors, project assistants, and eventually broader language-model systems that ordinary people can actually use and understand.

Current status.

Lavett is early. NodeWeb currently exists as a local research prototype: a CLI-first memory system with SQLite storage, meaning-event extraction, routing experiments, benchmark scaffolding, and inspectable memory paths.

The goal at this stage is not polish. The goal is evidence.

A Bruket research project.

Bruket is the workshop behind Hyral, Kvitt, Spegeln, the unnamed MMO, and Lavett.

Where Hyral focuses on housing discovery, Kvitt on receipt intelligence, and the MMO on world-building, 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

Memory should have shape.

Lavett is a bet that language models need more than longer context. They need memory with structure, evidence, and aim.

NodeWeb is the first attempt to build that support structure.