Asking Naumu

Starting a thread

Every space opens on a chat thread. Type a message in plain language and send it - there's no syntax to learn and nothing to format. You can start a fresh conversation any time from the conversations list. Each thread keeps its own history, participants, and the changes that came out of it.

A chip above the composer shows whether Naumu will reply to your next message. In a thread that's just you and Naumu, it responds to everything; in a thread with other people it stays quiet until you @mention it or turn its auto-reply on from the chip. Mentioning a teammate in your message keeps Naumu quiet for that turn, so handing a question to a person never triggers an AI answer on top.

Asking a question vs. giving knowledge

The same chat box does two different jobs. Naumu decides which one you mean from what you write:

• Giving knowledge - you describe what you're working on, paste notes, or list people and projects. Naumu picks out the entities (the people, projects, and other things you mention) and the relationships between them, then proposes adding them to your memory.
• Asking a question - you ask about something already in the space. Naumu searches your memory and answers in the chat, without changing anything.

You never have to flag which one you mean. "Acme signed last week, owner is Dana" reads as knowledge; "who owns the Acme account?" reads as a question. When a message could go either way, Naumu may ask a clarifying follow-up rather than guess.

When it needs real decisions from you, Naumu can ask with an interactive card right in the chat: each question comes with tappable answer options (plus an Other field for an answer of your own), and once you've picked, Send posts your answers as an ordinary reply the conversation continues from.

When you ask how Naumu itself works, it answers from the docs and can include a docs card linking to the full article - and, where one helps, a docs screenshot with a caption right in its reply.

How Naumu reads your memory and proposes changes

Before it answers, Naumu loads your space and searches it for relevant context - so a new fact lands next to the things it relates to instead of off on its own. While it works, you'll see its status update ("Searching your memory," "Preparing memory changes").

When a message implies changes, Naumu replies with a diff - a card showing exactly what it wants to add or edit, ready for you to review. A diff can include new nodes (the entities themselves), new edges (the connections between them), attribute changes, and any new schema types (the categories Naumu sorts entities into). You can read it as a list, or switch to a Graph view to see how the proposed pieces connect. Nothing is written yet.

Naumu can also create a note during a conversation - for example, to capture a summary, a structured output, or a set of meeting minutes. When it does, a link to the new note appears in the thread. Point it at a note you already have, with #, and it edits that one in place instead - see Notes.

Accepting and rejecting diffs

The diff card puts you in control. Each row is one change Naumu wants to make:

1. Read the proposed changes.
2. Uncheck any row you don't want. The button updates to show what you're keeping - for example, Accept (5 of 8).
3. Select Accept to write the checked rows into your memory, or Reject to discard the whole proposal and tell Naumu what to change instead.

After you accept, the card shows Changes applied (or Partially applied, if you kept only some rows). Changed your mind? Select Undo all on the card, or undo a single row with its per-row undo button.

Proposals in shared spaces

In a shared space, a proposal from a private or topic-filed thread first assembles as the run finishes, then waits for you to Accept or Reject it. Accepting applies the changes. If the thread was private, Naumu then asks whether to share it - with everyone in the space, filed into #topics, or kept private. Keep it private and teammates still see the resulting memory changes, but the conversation behind them shows as a hidden conversation with only the author and date, never the thread itself.

Accepting writes to the shared memory, and new nodes take their type's default visibility - so in a shared space they are typically visible to every member even when the conversation that produced them stays private. To keep a whole category of facts private, set that type's default visibility to Invite only in the schema.

Which memory an answer used

Naumu never answers a shared thread from memory the room can't see. Every agent answer carries a small memory glyph in its header, beside the author name - hover it on desktop, tap it on mobile, and a card tells you which slice of memory that answer was allowed to draw on:

• Answered using your full Memory - a thread that's just you, so nothing is held back.
• Answered using Memory you both share - a direct message.
• Answered using Memory shared by everyone in this conversation - a private group thread.
• Answered using Memory shared by this thread's audience - a thread filed into topics; the card names them, for example Everyone in #launch can see this thread.
• Answered using Memory shared with the whole space - a space-visible thread, so the answer holds to what every member shares.
• Answered using public Memory only - a thread reachable on the web.

When a guest is in the conversation, the line says so - a guest is in this conversation, or limited by a guest's access - because the answer clamps to what the guest can see too.

The mark is per viewer: two people in the same thread can see different wording, since each card describes the audience in terms of the topics that reader can name. It is also frozen at the moment the answer was written - filing a thread into a new topic later doesn't rewrite what an older answer says, so the mark always describes the room the run actually ran in.

Mentioning nodes and people

Two pickers help you point at exactly what you mean:

• Type @ to mention a person (or Naumu itself). Mentioning Naumu pulls it into a multi-person thread; mentioning a person who isn't in the thread yet offers to add them.
• Type # to reference something already in your space - a node, note, view, or canvas. The reference becomes a clickable pill that tells Naumu exactly which entity you mean, so "connect #Acme to #Dana" leaves no room for confusion.

When Naumu wants to bring in someone who isn't already in the thread, it doesn't add them silently. It posts an approval card - "Add [person] to this conversation?" - with Add and Dismiss actions, so a new person joins a thread only when you say so.

Attachments and voice

You can give Naumu more than text. To add files to a message, use the attach button - or paste or drag them straight into the message box. Naumu can read and reason about images, PDFs, office documents (Word, Excel, PowerPoint, and their OpenDocument equivalents), plain text, and structured data files (JSON, XML, YAML). To speak instead of type, select the microphone: short clips are sent as audio, and longer recordings are saved as a transcribed note you can reference later.

Controlling when Naumu replies

The Naumu will reply chip above the composer always tells you whether the next message gets an AI answer - it replies to everything, replies only when tagged, or stays off. Click the chip (or press Tab) to flip auto-reply for the thread; the choice sticks until you flip it back, and it works even when other agents are in the conversation. A paused thread shows "Naumu is no longer auto-responding," with a Resume action to bring it back.

You don't have to wait for a reply to finish. Send a message while Naumu is thinking and it is steered into the answer in progress rather than queued behind it or starting a second one - your message carries a short "Steering the current response" caption until the run takes it in. If the run has already moved past the point your message would change, Naumu answers it next instead.

A status pill sits over the composer and tells you what the thread is doing: a jump-to-bottom arrow when you have scrolled away from the latest message, who is typing, and that Naumu is thinking while it works. Tap it to jump back to the bottom. While a reply is in progress the pill also carries Stop, which cuts the reply off; anyone who can post in the thread can use it. The composer's send button doubles as Stop as well, but only while your draft is empty.

Threaded replies and reactions

Chat works like a normal team conversation. Hover over a message to Reply to it - your reply shows a small quote of what it answers, so side discussions stay easy to follow. You can also react to any message with an emoji, from either the quick-reaction row or the full picker. Both replies and reactions work on messages from people and from Naumu alike.

Related

• Quickstart - create a space and accept your first diff
• Nodes & edges - what Naumu is actually building
• Schema - the node and edge types Naumu infers
• Search - how Naumu finds context before it answers