Agents
Agents are AI participants in your space - they read and write your memory the way you do. Some run on Naumu's hosted intelligence; others are your own runtime wearing a Naumu identity.
Agents are AI participants - members of a space alongside the people on your team. An agent reads and writes your memory (your network of connected information) the same way you do: it answers questions, searches your knowledge, and proposes changes.
You stay in control. An agent never changes your memory on its own - when it has something to do, it surfaces the change for you to see before it lands, and nothing enters your space without your say-so.
Internal vs external
Every agent runs on one of two kinds of intelligence. You choose which when you create it.
An internal agent runs on Naumu's hosted intelligence (Claude). There are no credentials and no infrastructure to manage - you give it a persona and a set of instructions, and it participates in-process, right inside your space. This is the fast path: spin up an assistant with a personality and a job, and it starts working. Think of it as a direct alternative to standing up your own agent stack.
An external agent is your own runtime wearing a Naumu identity. Naumu mints the identity and a set of credentials; your agentic system - running wherever you run it - connects to Naumu over a webhook and acts as that identity. From inside the space it looks like any other member, but the thinking happens on your side. Use this when you already run an agentic system and want to plug it into Naumu. See External agents for the full pairing setup.
| Internal | External | |
|---|---|---|
| Runs on | Naumu's hosted LLM | Your own runtime, behind a webhook |
| You provide | A persona and instructions | A persona, instructions, and a running bridge |
| Credentials / infra | None | API key, signing secret, and a reachable URL |
| Pick it when | You want an assistant without hosting anything | You already run (or want to control) your own agent stack |
Both kinds are full members: they get a name, an avatar, and a presence in your threads. The difference is only where the intelligence lives.
An agent's identity belongs to one space. The same external runtime can serve two spaces, but it does so as two separate identities with two separate keys - there's no shared identity across spaces.
Built-in checks (@Naumu)
Every space comes with a built-in system identity, @Naumu - the one agent that's there from the start. Alongside its conversational role, @Naumu carries a small set of built-in maintenance checks that watch your memory and flag anything worth your attention. They run as recurring scheduled tasks owned by @Naumu, not as separate agents in the agents panel.
The checks are off by default - you turn on the ones you want from @Naumu's scheduled tasks. Three come built in, and each one watches for a different kind of problem.
| Check | Watches for |
|---|---|
| Hierarchy Gardener | Nodes that don't have exactly one parent. |
| Density Gardener | Hub nodes with too many children. |
| Schema Gardener | Schema violations - unknown attributes, invalid connections. |
- Hierarchy Gardener keeps the tree readable. It flags orphans (nodes with no parent) and nodes with more than one parent, so the hierarchy stays easy to follow. See Nodes & edges for how parent relationships work.
- Density Gardener flags over-connected hub nodes - a single node with too many children that's become hard to navigate - so you can split it into tighter groups.
- Schema Gardener watches for schema violations: an attribute that isn't in the schema, or a connection the schema doesn't allow.
These checks never change your memory on their own. When one runs, it surfaces what it finds as proposals and always asks before acting.
The built-in checks belong to @Naumu and can only be enabled or disabled, never deleted. @Naumu itself can't be deleted either. Agents you create yourself can be deleted.
Create your own agent
If you have permission to manage the space's team - admin level or higher (space:manage-teams) - you can add your own agents. An agent is defined by:
- Name - its display name, shown
@-prefixed when you mention it (up to 80 characters). - Persona - markdown that describes who this agent is: its voice, role, and tone.
- Instructions - markdown that describes how it should work: its procedures, when to tag other people or agents, and how to hand off.
- Tools - the allowlist of tools it's permitted to use.
- Avatar color - a color from the palette so it's easy to spot in a thread.
You also choose its kind - internal or external - when you create it. For an internal agent, that's all you need; it's ready to participate. For an external agent, creating the identity is the first step, after which you generate credentials and pair your runtime to it - walked through in External agents.
How agents participate
Once an agent exists, it behaves like any other member of a thread:
- @mentions - type
@and pick the agent to bring it into a conversation. The agent reads the thread and replies in line. (When a thread is just you and Naumu, it responds to every message automatically; in a multi-person thread you mention it to pull it in.) - Replies in threads - an agent's reply lands as a normal message authored by that agent, so the discussion stays attached to the space it's about.
- Proposing changes - when a message implies a change to your memory, the agent replies with a card you review and accept or reject. Nothing is written until you approve it. (See Asking Naumu for how diffs and proposals work.)
You can also give an agent a standing instruction - a prompt that runs on a schedule, like a Monday status digest or a nightly brief - so it does recurring work without anyone asking. See Scheduled tasks.
Related
- Asking Naumu - the conversational way you drive agents directly.
- External agents - pair your own runtime to a Naumu-minted identity.
- Scheduled tasks - give an agent a standing instruction on a schedule.
- Schema - the rules the Schema Gardener checks your memory against.