Memory
It remembers your work. You own the memory.
Memory is the difference between an assistant and an intelligence layer. Nova keeps a persistent, private record of what you're working on — captured in context, indexed by meaning, stored on your device, and erasable in one command. Here is exactly how it works.
The lifecycle
From a moment of work to usable memory.
Every memory Nova holds passes through the same short lifecycle — and the last step feeds the first, so the picture stays current instead of going stale.
Each step is deliberately simple. Together they turn scattered activity into a record you can trust, inspect, and correct.
- 01
Capture
in context
Nova notices a piece of work as it happens — a decision in a thread, a file that joins a project, a correction you make. It captures the moment in context, not as a stray note. - 02
Understand
extract what matters
It pulls out the parts worth keeping: the entities involved, the decision, the reason you gave, and where it came from. Raw activity becomes a small, meaningful record. - 03
Store
local · encrypted
The record is written to the memory index on your disk, encrypted at rest. Nothing leaves the machine for this to happen. - 04
Index
by meaning
It's indexed by meaning, not just keywords — so it can later be found by what it's about, even when your words don't match the ones stored. - 05
Retrieve
before acting
When a new task starts, Nova searches the index and loads the handful of records that bear on it — briefing itself before it does anything. - 06
Correct & forget
you decide
You can fix a record that's wrong or erase any of it. The index updates from what you keep, so memory stays accurate over time instead of drifting.
Scope
What it keeps — and what it won't.
Memory you can trust starts with a clear boundary. Nova keeps what makes your work make sense, and nothing you haven’t handed it.
What Nova remembers
- Your projects — the files, people, and threads that belong together
- Decisions you've made, and the reasons you gave
- Preferences: how you like things done, and what to leave alone
- What it did, what you corrected, and what worked
- Context that spans sessions, so tomorrow starts where today ended
What Nova never remembers
- Anything you haven't given it access to
- Passwords, keys, or secrets (never stored in memory)
- Your data sent off your machine to train a model — ever
- A permanent record you can't see or remove
- Activity in apps and files you've kept out of scope
Kinds of memory
Three kinds, one index.
Not everything is remembered the same way. Nova distinguishes what belongs to a project, what’s a standing preference, and what a task taught it.
Project memory
The files, people, threads, and decisions that belong to one body of work — held together as a single picture.
For example
The Aurora redesign: its design files, the launch thread, the teammate who owns pricing, and the call to ship the dark theme first.
Preference memory
How you like things done, and what to leave alone. The standing instructions you shouldn't have to repeat.
For example
You write commit messages in the imperative mood. You never want a calendar invite sent without being asked first.
Task memory
What Nova did, what you corrected, and what worked — so a repeated task starts from the last version you approved.
For example
Last month's invoice run: the steps it took, the one line you fixed, and the final format you signed off on.
Indexing
Indexed by meaning, not keywords.
A memory isn’t a copy of a file — it’s a small structured record of what mattered and why. Each one is indexed by meaning, so Nova can find it later by what you’re trying to do, even when your words don’t match the ones stored.
That’s the difference between search and memory. Search needs the right query. Memory surfaces the right thing because it understood it in the first place.
- project
- Aurora redesign
- entities
- Maya (design) · pricing.fig · #launch
- decision
- Ship the dark theme first
- reason
- “Fewer surprises for existing users” — you, Apr 12
- source
- Figma · Slack · your note
- recall cues
- dark theme · launch order · Maya's call
Retrieval
The right context, before it acts.
Memory is only useful if the right piece shows up at the right moment. When a task begins, Nova retrieves what bears on it — and briefs itself before doing anything.
Control
See it. Change it. Erase it.
Memory you can’t inspect isn’t trustworthy. Nova’s is meant to be opened.
- Inspect
Open the memory index and read what Nova holds — in plain terms, not a black box.
- Correct
Fix or remove any single record. The index updates from what you keep, so a wrong memory doesn't persist.
- Forget
Wipe everything with one command. It's local, so gone means gone — a reload proves it.
Why it compounds
The longer you use it, the further ahead it starts.
Memory isn’t a feature bolted on — it’s what makes every later task cheaper than the last. The context you supply by hand shrinks as what Nova already holds grows.
No re-explaining
The project context is already loaded. You give a nudge, not a briefing.
It notices connections
A file, a message, and a deadline that belong together are held as one picture.
It respects your calls
A decision made weeks ago is applied today — without you having to remember it.
Storage
Local-first, by design.
Your memory lives on your machine — not on our servers.
The memory index is a structured record of the projects, people, files, and decisions Nova has seen, kept encrypted at rest on your device. Because it’s local, using it needs no network round-trip and no account — it’s your file, on your disk, under your control.
How that fits the wider system is on the architecture page; the guarantees around it are on privacy & security.
Questions
Memory, answered plainly.
Does all this memory slow Nova down?
How much disk does it use?
Can I keep different projects separate?
Does my memory sync across devices?
Can I export what Nova remembers?
What happens to my memory if I remove Nova?
See it do real work.
Nova is in private preview. Request access, and we’ll write when it’s your turn.
Request access