NOD3
Graph-based interface and durable memory, tightly coupled to Lattice
Overview
NOD3 is the front-end of AlfredOS: a graph-based workspace where conversation, context, and memory are explicit, branchable, and owned by the user. Where a conventional chat is a single linear thread that fills with noise and eventually degrades, NOD3 treats the graph itself as the memory system, durable, inspectable, and reversible.
Key differentiator: No memory hacks. Memory is explicit in the graph rather than stuffed into an ever-growing context window or retrieved through opaque RAG. The user prunes and branches; the system stays aligned to the task at hand.
Core Concepts
Threads, Nodes, and Branching
A NOD3 workspace is a graph of nodes. From any node you can branch into a new direction, carrying the relevant context with you. Productive directions are kept; dead ends are abandoned without polluting the rest of the graph. Graphs are durable and evolve over time, unlike chats, which users forget about and delete.
Node Pressure
NOD3 introduces node pressure: a measure of the load on the model's attention within a node. It is a function of both context length and semantic divergence. Talking about one coherent topic is low pressure; zig-zagging across unrelated topics splits attention and raises it.
When pressure gets too high, the system prompts the user to branch, alleviating the pressure instead of degrading silently. This directly targets the attention-scaling failure modes that cause long single-thread chats to hallucinate.
Artifacts as Injectable Context
Artifacts (documents, files, outputs) are treated as first-class, injectable context and as durable, immutable state. They do not live in the chat history. The user injects an artifact into context by selecting it, and removes it by deselecting it, so context is assembled deliberately rather than accreting.
Artifacts can be scoped to a node, a graph, or globally, giving each graph a natural artifact repository.
Commands (Async, No Tool Calls)
NOD3 has a command mode that interfaces with Lattice. A command uses the current node's context plus any selected artifacts to invoke a Lattice action.
- No tool calls. Commands are fully decoupled from the chat loop, so they run asynchronously: the user issues a command and keeps working while it executes. Multiple long-running commands can run at once.
- The user selects which action a command maps to rather than the model guessing among hundreds of possible behaviors. The request is parsed into Lattice's required schema, and execution proceeds on the state captured at issue time.
- Command-context injection is selective: some commands return context that should be folded back into the node, such as "summarize this page and bring it back"; others complete without needing to touch the node at all, such as "summarize this thread and email it to Will." Deciding what to inject and what to discard is the core UX problem NOD3 solves.
Coupling to Lattice
NOD3 is a consumer of Lattice. Each NOD3 deployment holds scoped API keys to a Lattice deployment, so a given user can only invoke the actions and workflows they are authorized for.
The pairing is the "chocolate and peanut butter" of AlfredOS: NOD3 supplies the graph memory and the human control surface; Lattice supplies the typed, signed execution. Context flows from the current node/graph into the Lattice execution layer, which runs the work and returns results.
Deployment & Storage
One NOD3 deployment per user, each with its own database and memory system.
SQLite per node deployment (single-file, fast, portable), with a hot/cold split: live database in hot storage on the VM, regular encrypted backups to cold storage.
Artifacts stored encrypted in S3-compatible cold storage, pulled into temporary hot storage when needed.
Status
NOD3 is an early prototype under active development. The hard architectural problems (graph memory, async command execution, Lattice coupling) are solved at proof-of-concept; current work is on the ergonomics: how command runtime state is surfaced, what context is injected, and rendering non-JSON outputs (PDFs, images) returned by commands. Early access is being rolled out to a small internal group for feedback.