Core concepts

The vocabulary of Naumu - spaces, nodes, edges, schema, views, and topics - explained in one place.

Updated July 22, 20265 min read

Naumu has a small vocabulary. Once these few terms click, the rest of the product is easy to navigate. Read top to bottom - each term builds on the one before it.

Space

A space is a memory: a collection of things and the connections between them. It is the top-level container for everything you store - all your nodes, the edges between them, the schema that governs them, your views, and your chat threads. (Each of those terms is explained below.)

Most teams keep one space per project, product, or company.

Switching spaces switches the whole workspace at once: the sidebar, your memory, and chat all follow the space you currently have open. A space can be private to you or shared with others.

Node

A node is a single thing in your space. Every node has three parts:

A type - what kind of thing it is (for example Feature, Task, Decision, or Member).
Attributes - the structured fields the type gives it. An attribute can be a single choice from a list, multiple choices, text, a number, a date, or a yes/no value. For example, a Task carries a Status (Todo, In Progress, Done) and a Priority (P0 through P3).
Content - free-form body text attached to the node, for any detail that does not fit a field.

Nodes are the building blocks of a space. Everything else simply describes how they relate, what shape they take, or how you look at them.

Edge

An edge is a labeled relationship between two nodes. Each edge has a direction (it runs from a source node to a target node) and a label that names the relationship - for example a Feature PART_OF a Product, or a Task ASSIGNED_TO a Member.

One kind of edge is special: a parent edge. Each node has at most one parent, and parent edges chain together to form the hierarchy of your space - the tree that organizes everything in it.

Every other edge is a cross-link. Cross-links connect the tree sideways, relating two nodes without changing where either one lives in the hierarchy.

Node IDs are unique only within a single space. The same ID can appear in a different space and mean something else.

Schema

The schema is the blueprint for a space. It defines three things:

the node types available,
the attributes each type can hold (and the values those attributes accept), and
the connections each type is allowed to make - including which type it sits under as a parent.

Those connections come in three strengths:

a parent - where a node of this type belongs in the hierarchy,
required connections - relationships a node of this type must have, and
suggested connections - relationships that are encouraged but optional.

The schema is what keeps a growing space consistent, rather than letting it drift into a pile of loosely related notes.

You do not need a schema to begin: a space with none yet is still valid, and you can add types as you go.

Topic

A topic is a named, channel-like container that organizes a space's content and, in the same move, decides who can see it. Threads, notes, canvases, and views are homed in topics; members join a topic, and joining grants access to what's filed there. Filing something is therefore both how you organize it and how you share it - there is no separate visibility setting.

Topics are how a team's work is divided into readable areas and how outside guests are brought in one area at a time. See Topics for the full model.

View

A view is a saved, filtered way of looking at your nodes. Instead of browsing your whole memory, a view narrows to just the nodes you care about - say, every Task with a Status of In Progress - and presents them in a layout you choose: a table, a kanban board, a timeline, or a calendar.

A view's audience comes from where it is filed - kept private to you, shared with the whole space, or filed into topics. While you are editing one, your changes live as a draft until you save them - so you can experiment with filters and layouts without disturbing the saved view.

Thread and chat

A thread is a conversation inside a space. Threads and their messages are nodes too - of the built-in types Thread and Message - so a conversation lives in the same memory as everything it discusses.

This is what powers chat: you talk to Naumu inside a thread, and the discussion stays attached to the space it is about. Messages can be written by people or by agents (more on those next).

Agents

Agents are AI participants in your space. They read and write your memory the same way you do - answering questions, proposing changes, and helping keep the structure clean. Routine upkeep of your space runs as scheduled tasks on a timer, and you can add agents of your own.

An agent is either internal or external. An internal agent runs on Naumu's hosted LLM - you give it a persona and instructions, and it participates in your space directly, with no credentials or infrastructure of your own. An external agent is your own runtime that embodies a Naumu-minted identity, connecting through a bridge so the system you run can speak in your space as that agent.

You stay in control: when an agent proposes a structural change to your memory, it arrives as a diff you can accept or reject before it is applied.

Spaces - create and manage the workspace your memory lives in.
Quickstart - create your first space and add a few nodes.
Claude - connect AI clients like Claude and ChatGPT to your spaces over MCP.

Anything missing?

Tell us what would make these docs better.

Quickstart Sidebar