Lavett
Lavett captures supported project prompts locally, brings relevant history into later sessions, and lets you inspect exactly which stored source a recalled item came from—without a separate memory cloud or a model call in Lavett's default memory path.
“Decision: keep database migrations reversible and run them before deploying application code.”
“What did we decide about deploying database migrations?”
Synthetic illustration using the current receipt shape. The digest verifies the displayed stored source bytes; it does not prove the decision is correct or that recall is complete.
Lavett's default memory processing needs no separate memory API key. Your coding client may still require its own account, authentication or subscription.
Picking up a project shouldn't mean explaining it again.
Project decisions end up split across sessions and clients. Returning to the work can mean searching old chats, repeating context, or trusting a summary that no longer contains the detail you need.
Useful memory has to keep sources, corrections and scope visible. Old and new facts can conflict; a compact answer should still leave a route back to the record it came from.
One project memory, across supported clients on your machine.
Capture locally.
Supported hooks record eligible user prompts in a workspace-specific local store. You can also add selected notes explicitly.
Continue in another supported client.
A later Codex or Claude Code session in the same workspace can receive a compact packet of relevant history instead of reopening an entire transcript.
Check the receipt.
Inspect the stored sources and trace recalled context back to the exact local record.
Connected clients use the same project-scoped SQLite memory for that workspace on that machine. This is not cloud sync or automatic cross-device memory.
User prompts and explicitly added notes—not automatic recording of every model answer, tool output or transcript. Broader capture profiles are opt-in.
Lavett's default memory processing is local, and Lavett itself does not send the memory store to a remote memory service. When Lavett supplies recalled context to Codex, Claude or another client, that context is handled according to that client's own data policy.
Local storage is not encryption.Built for Codex and Claude Code first. Other integrations, including Gemini CLI, Cursor and VS Code, have narrower or different support. Live workstation verification so far is on Linux.
Working on a real workstation — not yet publicly released.
In the recorded workstation handoff, Codex and Claude Code both wrote workspace-scoped sources, and read-only inspection returned exact stored records. That is a local observation, not the still-pending clean-machine, two-direction demonstration.
The repository is still private. The audit and current-tree cleanup are recorded, but public-release gates remain. A focused default profile and the clean-machine cross-client demonstration are still ahead.
Local verification details
- ✓89/89 local build units across six integrated waves. Integrated is not promoted and does not complete external or human-validation outcomes.
- ✓7,291 passed / 11 skipped / 10 expected failures on 28 September 2026 at implementation 3116d4c.
- ✓123/123 offline proof gates, zero live model calls and $0 model cost, with unavailable historical holdouts still disclosed rather than restored.
- ✓Reproducible packages and isolated Linux install/removal smoke passed. Warm-cache verification is not clean-machine, cross-client or native macOS/Windows proof.
lavett integrate installlavett integrate doctorlavett packet showlavett ask --explainmake proofCapability examples from the private development tree, not an available public installer.
A useful signal, with the caveats attached.
In an early internal Claude Code study, Lavett reduced list-price-equivalent model usage by 8–11% on two passes of 16 short synthetic tasks, and by 51% on eight tasks with roughly 41 KB of project history. The 41 KB run was not faster. These are historical observations from one model and effort, with one run per arm per task in each pass and author-reviewed quality—not an independent result or a promise of savings on your projects. No quality difference was found in that review.
| Task pairs | Model usage, list-price equivalent | Answer time, excluding ingest | Tool calls, without → with |
|---|---|---|---|
| Short tasks ×16, pass 1 | −11.0% | −7.0% | 29 → 20 |
| Short tasks ×16, pass 2 | −7.7% | −10.7% | 30 → 20 |
| ~41 KB history ×8 | −51.2% | +3.1% | 19 → 14 |
Negative means less usage or answer time; positive means more. These are paired aggregate observations, not promises for every task.
- —Claude Code with Opus 5.5, medium effort, measured at 468f48e on 23 September 2026. This is not a new performance measurement of the current build.
- —One run per arm per task in each pass; synthetic tasks and author-reviewed quality. No independent validation or demonstrated quality advantage.
- —Usage means the client’s list-price equivalent, not the subscription bill, subscription allowance, raw token reduction or guaranteed financial savings.
- —Time excludes one-time ingestion. At 41 KB the recorded ingest was about 1.48 seconds; the +3.1% observation does not establish a reliable slowdown.
- —These batches do not pass the newer NBH-3 claim-tier gate. They remain directional, not decision-grade.
A larger, roughly 240 KB experiment recorded 55.7% lower list-price-equivalent usage, 37.4% less answer time excluding ingest, and 44 → 18 tool calls across eight task pairs. Its synthetic notes contained invalid future dates. That frozen suite is not claim-eligible; the corrected suite has not been run. These figures are retained as a research record, not evidence of a validated 240 KB product benefit.
Full historical accounting
The one-time ingest took about 30.7 seconds. Including ingest, total first-question time was 202.6 seconds without Lavett versus 373.8 seconds with it across the eight cases. One of eight packets missed a required note, which the model then found through additional searching. The invalid-date flaw makes this frozen suite ineligible for claims.
make proof runs the engine's offline proof without a model API key or a live model call. It does not rerun the model-based usage study above.
Public reproduction assets are pending release; there is no public checkout or package to promise yet.
Shared memory. Sources you can inspect.
Lavett combines project continuity with an inspection path. The receipt shows what stored record supports a recalled item, while keeping the difference between source integrity, relevance and truth visible.
Exact-source provenance
Recalled context can be traced back to the stored evidence that supports it.
Immutable raw evidence
Derivations preserve their source instead of silently rewriting it. This is not a promise of retention forever or impossible deletion.
Visible corrections
Correction and supersession trails remain inspectable, without guaranteeing perfect current-state selection on every question.
Local and deterministic by default
Default memory processing is local and reproducible. Recalled context still enters the selected host client under its data policy.
Model proposes, verifier decides
Optional model proposals can be checked against narrow deterministic rules. The simple default memory hook does not require that path.
Citation re-checking for supported formats
lavett check-adapter can re-check citations in supported external formats. It is not a universal fact-checker or an automatic check of every host answer.
Some tools are more mature, support more integrations, recall rephrased questions more effectively, or publish broader public benchmarks. Lavett has not demonstrated a matched head-to-head advantage.
Memory with aim.
A lavett is the carriage beneath the cannon: the structure that carries, stabilizes and aims it. The language model remains the engine; Lavett structures the input it receives.
An illustration, not a claim that every other tool always sends full raw history.
The simple default hook path does not use every part of the research architecture.
An evidence-packet compiler, with four surfaces.
Coding-agent memory
The default hook packet is deliberately simple and lexical today. Richer routing remains gated rather than being sold as the default recall path.
Current
A read-only, cited view of current state and its transition trail—not a free-form chatbot or a claim to ground truth.
Structure Atoms
Source-mapped, deterministically decodable representations on an optional, default-off path.
Appeals
A synthetic adviser-review vertical showing candidate activity evidence, contradictions and gaps. The adviser selects descriptors; there is no automated points or outcome award. It is not legal advice.
On optional model-assisted paths, a deterministic verifier can require exact source support before accepting a proposal. Its guarantee is narrow: grounding is not truth. A real quote can be cited for the wrong purpose and still pass parts of the verifier, so relevance, authorship and real-world correctness still require judgement.
Explore the technical architecture
These are engine capabilities behind paths such as lavett ask and compile-context. They are not all part of the simple default coding-agent hook, and their benefit is not established for every project.
Meaning Event Graph
Represents selected language as structured events with roles, time, attributes and evidence.
learner → omitted → article ("the")Concept Gravity
Can weight recurring or important concepts so retrieval has another signal beyond raw similarity.
concept recurs → gravity ↑Truth Lifecycle
Tracks states such as current, uncertain, contradicted, corrected and superseded with inspectable transitions.
belief → corrected → supersededMulti-Route Retrieval
Can search entities, timelines, corrections and evidence through multiple competing routes.
route(roles) ∥ route(evidence)Correction Trajectories
Keeps the arc of a correction available instead of reducing it to one isolated snapshot.
mistake → corrected → recursContext Compiler
Builds a task-specific cited packet and can report what it selected or omitted.
history → cited evidence packetScope-Bound Memory
Associates memory with an explicit workspace scope. This reduces mix-ups but is not a perfect-isolation guarantee.
answer ⊂ workspace scopeExplainable Memory Paths
Can expose the route, events and evidence used by supported engine queries.
answer ⟵ route ⟵ evidenceLicensing: code is Apache-2.0; adapted PIP data is OGL-UK-3.0; toy authority data is CC0-1.0. The bundled distribution expression is Apache-2.0 AND OGL-UK-3.0 AND CC0-1.0.
The limits stay beside the results.
- —No independent outside-user validation, public standard-memory-benchmark score or matched competitor head-to-head yet.
- —The 41 KB native run recorded +3.1% answer time, not a speed win.
- —The flawed 240 KB experiment was slower on first use and one packet missed a note. Its synthetic dates make it ineligible for claims.
- —Default recall is lexical; rephrasing can miss relevant material. No general paraphrase advantage is claimed.
- —Canonical engine measurements are in-sample. Historical blind-paraphrase estimates are withdrawn, not evidence for this release.
- —Raw-context and BM25 wins remain in the ledger rather than being selectively removed.
- —Exact provenance helps inspection; it does not prove completeness, semantic correctness, perfect isolation or that a host model used the evidence properly.
Legibility is not optional.
Persisted semantic artifacts on the relevant path must have a deterministic decoder back to faithful, human-readable source material. That contract makes Lavett's own representations inspectable; it does not expose the internal reasoning of Codex, Claude or another model.
The road from here.
Supported capture and exact-source inspection on the development workstation; not yet publicly released.
Audit and current-tree cleanup recorded; historical disclosure and remaining publication gates still open.
A small memory-and-receipt surface while retaining the complete opt-in capability surface.
First finish clean-machine platform checks and the two-direction receipt demo, then publish only after sign-off. A later founding-user period targets 10–20 people; recruitment is not open now.
Frozen head-to-head, public memory and trust benchmarks with losses included. Live or model runs need separate approval.
A research direction—not a model being trained now or a promised delivery.
Memory should have shape.
Language models need more than accumulated context. They need memory with structure, evidence and aim—and a representation a human can still read. Lavett is my attempt to build it.