Skip to content

Architecture

Built native. Built local-first.

For the technical reader. Nova is a native desktop application, not a wrapper around a chat API. Perception feeds a local, encrypted memory index; a reasoning engine plans and verifies; model orchestration stays on-device by default with an optional cloud router; and tool execution is permissioned and reversible.

The stack
Desktop applicationnative · on your machine
Perceptionscreen · files · apps · system
Memorylocal · encrypted · yours
Reasoning engineplanning · tool use · asks when unsure
Model orchestrationlocal-first · optional cloud
Tool executionpermissioned · reversible
Context rises from perception and memory into the reasoning engine; actions descend through tool execution into your apps. Model orchestration serves the engine from the side — local first, cloud only on request.

Subsystems

Every layer, in detail.

Six subsystems, each with a single responsibility. For each: what it does, where it runs, and what it talks to.

Desktop application

runs
Native, per platform
talks to
Your hardware · the OS

Nova runs natively on your computer and uses your hardware — CPU and GPU — directly. No browser in between, and the work never has to leave the device to be understood.

Perception

runs
On-device
talks to
The OS · your apps → Memory, Reasoning

A single event stream fuses what Nova can see — the active window, the files a project touches, running apps, system state — into one coherent, current picture of your work.

Memory

runs
On-device, encrypted at rest
talks to
Perception ↔ Reasoning

A structured index of projects, people, files, and decisions, stored on-device and encrypted at rest. Indexed by meaning so the right context is retrieved before anything runs. Inspectable and erasable.

Reasoning engine

runs
On-device, model-orchestrated
talks to
Memory · Orchestration · Tools

Turns a request into a small sequence of reversible steps, selects the right tools, checks its own results, and pauses to ask when the answer matters. Understanding precedes action.

Model orchestration

runs
Local by default · cloud opt-in
talks to
Reasoning → local / cloud models

A router decides whether a reasoning step can be handled on-device or genuinely needs more, and — only with your say-so — calls optional cloud reasoning. Local by default; every cloud call is deliberate, named, and never used to train on your data.

Tool execution

runs
On-device, within your permissions
talks to
Reasoning → your applications

The layer that actually operates applications — opening, editing, moving, drafting — within the permissions you grant, one reversible step at a time, with an undo you can trust.

built natively per platform · Windows first · macOS and Linux to follow

Where models fit

A router, not a hard-wire.

The reasoning engine doesn’t call one model. It hands each step to an orchestration layer that keeps work local when it can, and asks to use the cloud only when a step genuinely needs it.

The default path never leaves the machine. The cloud path is opt-in, per task, and named before it happens — the full data-flow lives on local + cloud.

Model orchestration
Reasoning step
Router
local or cloud?
Local model
The default. On-device, nothing leaves the machine.
Cloud model
Opt-in, per task. Named before it happens, never trained on.

Data flow

Following one request through the stack.

A single request, traced from arrival to learning — so you can see where each subsystem takes over.

  1. 01

    A request arrives

    From you directly, or from a pattern Nova noticed and asked about. Nothing proceeds without an intent to serve.
  2. 02

    Perception assembles the picture

    The active window, the files in play, and the relevant app state are fused into one current view of the work.
  3. 03

    Memory retrieves context

    The index is searched by meaning, and the handful of records that bear on the task are loaded — before any plan is formed.
  4. 04

    Reasoning forms a plan

    The engine settles on the goal and breaks it into small, reversible steps — or pauses to ask if it isn't sure.
  5. 05

    Orchestration routes each step

    The router runs the step on a local model where it can, and asks to use the cloud only when a step genuinely needs it.
  6. 06

    Tools execute, within permission

    Each step operates a real application inside the scope you granted, one reversible move at a time.
  7. 07

    Verify, then learn

    The result is checked against the goal; what worked and what you corrected is written back to memory, and the loop is ready to start further ahead.

Extensibility

Designed to open up.

The foundation is built. The near-term focus is strengthening it; the longer arc is a platform.

Bring-your-own models and keys, a developer SDK, and third-party tools are part of the long-term direction — so Nova can reason over more of your work and act through more of your tools. These are planned, not shipped, and we’ll say so plainly until they are.

The foundation is built and working today — memory, perception, file understanding, desktop control. The reasoning on top is being strengthened, and the platform pieces above are built outward from it.

Questions

The engineering, answered plainly.

Is Nova a web app or an Electron wrapper?
No. Nova is a native desktop application built per platform, using your hardware directly. It isn't a browser tab pretending to be an app, and your work doesn't route through a web page to be understood.
Where do the AI models actually run?
On-device by default. A router keeps the everyday loop local and reaches for optional cloud reasoning only when a step needs it and you allow it. The full data-path is on local + cloud.
How does Nova operate my applications?
Through the tool-execution layer, which acts within the permissions you grant, in small reversible steps, with an undo you can trust. The boundaries and guarantees are on privacy & security.
Can I extend Nova, or plug in my own tools and models?
That’s the long-term direction — a developer SDK, third-party tools, and bring-your-own models and keys — but it’s planned, not shipped. We’ll mark it plainly until it’s real.
What of this architecture is real today?
The foundation is built: memory, perception, and tool execution work today, and the reasoning engine runs. Stronger reasoning, better verification, and the optional-cloud router are what we’re strengthening now. The roadmap tracks the honest state of each.

See it do real work.

Nova is in private preview. Request access, and we’ll write when it’s your turn.

Request access