How it works
An intelligence that keeps the thread.
Most AI answers a message and forgets it. Nova runs a loop — it perceives your work, remembers it across sessions, reasons about what you're doing, acts across your desktop, and learns from the result. The context survives, so it already knows where you left off.
In plain English
What Nova is.
Nova is software that runs on your computer and holds the context of your work over time.
Every assistant you’ve used lives inside one window and forgets the moment you close it. You re-explain the project, the files, the decisions — again and again. That re-explaining is the tax you pay for tools with no memory.
Nova removes it. It keeps a persistent, private record of what you’re working on, on your device, and works across your whole desktop rather than inside a single app. Because it remembers, it can pick up where you left off, notice what connects, and do the small things without being briefed from scratch.
The difference isn’t a smarter answer. It’s continuity — an intelligence that understands your work as it accumulates, not one conversation at a time.
The loop
Seven stages, always turning.
This is how Nova is built to work. Each stage feeds the next, and the last feeds back into the first — so every pass is a little sharper than the one before.
Stage by stage
How information moves through the system.
Each stage receives something and produces something for the next. Follow the receives and produces lines and you can trace a piece of work all the way around the loop.
Perception
Nova reads what is actually on your machine — the window you're in, the files a project touches, the app you just opened. It sees the work, not a description of it.
Memory
It ties what it sees to what it already knows: this project, these people, the decision you made last week. Relevant records are retrieved before anything is done.
Reasoning
It works out what you're trying to accomplish and whether it has enough to proceed — or whether it should ask. Understanding comes before action.
Planning
A request becomes a small sequence of concrete, reversible steps. Nothing sweeping happens in one opaque move.
Action
It operates real applications the way you would — opening, editing, moving, drafting — one step at a time.
Verification
It checks the result against the goal and its own constraints, and catches and corrects its mistakes rather than pressing on.
Learning
What worked, what you corrected, and what you prefer are written back to memory — so the next turn of the loop starts further ahead.
produces: updated memory → receives: the next picture · the loop closes
The loop in motion
One real pass, start to finish.
The same seven stages, following a single task — resuming a coding project after two weeks away.
This is illustrative. The loop it shows works today; stronger reasoning and deeper software-development workflows are what we’re still expanding.
- 01
Perception
You reopen a project you left two weeks ago. Nova sees the repository, the editor, and the branch you're on. - 02
Memory
It retrieves what you were building — the payment flow — the reason for the last change, and the constraint a teammate asked you to keep. - 03
Reasoning
It works out that you're resuming the refund path, and that the edge case you flagged is still open. It has enough to help, so it doesn't need to ask. - 04
Planning
It proposes three reversible steps: re-run the failing test, isolate the branch that breaks, and draft the fix for your review. - 05
Action
With your go-ahead it runs the test and prepares the change — one step at a time, each visible. - 06
Verification
It checks the fix against the constraint and the test, catches that one case still fails, and says so instead of declaring success. - 07
Learning
Your correction and the working approach are written back — so next time it starts from the fix, not the blank page.
Desktop intelligence
Why it isn't a chatbot.
Other tools are excellent at what they do. The difference is architectural — where the intelligence lives, and whether it remembers. No criticism intended; just the shape of each.
Nova’s foundation is built: memory, perception, file understanding, and desktop control work today. The loop above runs; stronger reasoning, better verification, and deeper development workflows are what we’re strengthening next.
Questions
The loop, answered plainly.
Is Nova watching my whole screen, all the time?
How is this different from an agent that just clicks around my screen?
What happens when it gets something wrong?
Do I prompt it, or does it act on its own?
How much of this loop works today?
See it do real work.
Nova is in private preview. Request access, and we’ll write when it’s your turn.
Request access