What is Resonance Lattice?
In one line: it turns your own files into a single smart file an AI assistant can search and quote from — and that file also learns the world it covers. Answers come from your documents and from what's been learned about your world, not from the assistant's imagination — every claim carries a receipt you can check. And that's measured, not promised: with the file in the loop, made-up answers on a real corpus fell from roughly one in five to zero (the numbers).
This page explains the whole idea in plain language. No setup, no jargon — if you've never heard of the technology underneath, you're in the right place. Want to try it instead of read about it? Jump to Getting started.
The problem it solves
AI assistants are fluent and confident — but they have three habits that make them hard to rely on:
- They make things up. When an assistant doesn't know something, it often invents a plausible-sounding answer anyway.
- They forget. What you told it last week is usually gone.
- They can't reliably use your material. Your documents, your team's docs, your codebase — the assistant can't dependably look things up in them and cite what it finds.
Resonance Lattice — rlat for short — fixes the third problem, and
helps with the other two.
The idea, in everyday terms
Think of rlat as a way to give your assistant a
well-organised, searchable binder of your own material that it has to
cite. You point it at your files; it packs them into one searchable
file. When you ask a question, the assistant looks the answer up in that file
and tells you — showing exactly which document each fact came from, so you can
check it.
That one searchable file is called a knowledge model (it ends
in .rlat). It is just a normal file: you can copy it, share it, or
keep it on your laptop. It contains your text plus a built-in index that makes
searching by meaning — not just keywords — fast.
How it works, in three steps
rlat at a folder of documents. It
reads them and packs them into one knowledge model. One command, runs on
your machine.rlat finds the handful of passages most likely to hold the
answer — by meaning, so wording doesn't have to match.Why that's useful
- Answers you can trust. Every fact traces back to a real passage you can open and read. No more guessing whether the assistant made it up.
- Yours, and offline. It runs on your machine. No account, no cloud upload, no dials to tune — one recipe that just works.
- It remembers. Across sessions it keeps a small, private note of what's been useful, so it gets a little better at helping you over time (Memory & sessions).
- It checks itself. A knowledge model can audit its own shape and tell you where it's weak (see below).
It learns your world — with proof
A knowledge model holds more than your documents. Over time it can carry three kinds of learned knowledge about the world those documents describe — tested in three unrelated worlds: a garden, a law practice, a Microsoft Fabric tenant. The results are published.
- Stable facts — things that are simply true of your world: the garden's water restrictions, the practice's jurisdiction, the tenant's capacity.
- Standing rules — constraints every answer must respect: the garden is organic-only, the practice takes no family-law matters, the tenant allows no preview features. Serving these cut rule-breaking answers from 62% to 7% with no over-blocking (measured), and the effect held in the garden and the law practice, not just the software tenant (measured).
- What was tried and failed — recorded with its verdict, so the assistant stops suggesting it: the pest treatment that didn't work, the billing model the partners rejected, the integration that failed testing. A served failure record stopped 7 of 7 repeat recommendations (measured).
Each entry keeps a receipt — where it came from and when — so you can always see why the assistant believes it. And corrections are explicit: when a learned fact is later disproven, the record says so. Nothing is silently deleted.
It can notice its own gaps and conflicts
This is the part that makes rlat more than a search box. Because
it can see the shape of everything it holds, a knowledge model can quietly flag:
- Gaps — questions people keep asking that your documents can't actually answer.
- Contradictions — two documents that disagree about the same thing (often an old page nobody deleted).
- Stale facts — something fetched from the web that the world has since moved past.
Finding these is free and needs no AI service — it's done by the assistant you
already have. And nothing is changed behind your back: rlat
surfaces these for you to review. With your okay, it can fill a gap
from a trusted source (and show you where it got it), but it never edits your
documents on its own.
Want the full tour — the six-stage loop, the four skills, the options, and whether you ever need an API key? See How a knowledge model improves itself.
What it is — and isn't. rlat faithfully
represents what your documents — and the world facts it has captured —
say. That is grounding, not universal truth. If a document or a
captured fact is wrong, the answer drawn from it will be too — but you'll
always see the source and can judge for yourself. It is not a chatbot, not a
replacement for web search, and it never changes your original files.
Who it's for
Anyone who wants an assistant to answer reliably from a specific body of material — a team's documentation, a codebase, a research library, a product manual, a knowledge base — and to show its work. If "I need the assistant to actually use these documents, and prove where each answer came from" sounds like you, that's exactly what this is for.
rlat is for, and the
command that serves each one.