Tools — Gnosis Memory

The Difference Is in the Details

Most memory MCPs expose one tool: store_memory(text). Gnosis exposes 14 tools with typed parameters, quality heuristics, and creation guidelines baked into every tool description. The AI reads these descriptions before every call. The protocol teaches structured memory creation without any server-side AI.

Here's what that looks like in practice:

Typical memory MCP

store_memory(text: string) Store a memory for later retrieval.

One parameter. No guidance. The AI guesses what to store and how to format it. Result: vague fragments that are impossible to search later.

Gnosis memory_add

memory_add(content, topics[], macro_topics[], type, ref, artifact, collection) BEFORE generating parameters, reason through: 1. What TYPE? (fact/preference/task/path/decision) 2. What searches should FIND this later? 3. Has this actually happened, or aspirational? CONTENT: First 50 chars = executive summary. Must make sense with zero context. GOOD: "User prefers Python for backend — type safety catches bugs early" BAD: "Prefers Python"

Seven parameters. Explicit reasoning steps. Good and bad examples. The AI writes structured, searchable memories because the interface makes it the path of least resistance.

99.8% of 2,095 audited memories rated B+ or better. Even 8B-parameter models follow the guidance. No server-side filtering required.

How Tools Work Together

Gnosis tools are composable primitives. Most workflows chain 2-4 tools:

Session startup: init_core_memories → task_feed
Research: memory_search → memory_retrieve (previews first, then expand what matters)
Task lifecycle: memory_add(type:task) → memory_edit(toggle, output) → memory_edit(set_status:done)
Team handoff: memory_edit(set_status:blocked) → signal_send → init_core_memories → task_feed(status:blocked)
Knowledge curation: memory_search → collection_manage(publish)

Start Here

init_core_memories

Run once at conversation start. Loads behavioral preferences, topic landscape, active tasks, and pending signals. Returns previews with complete flags so the AI picks which memories to read in full. Piggyback a search query on the init call to save a round trip.

Store

Save knowledge as you work. The AI decides what's worth keeping, guided by the tool descriptions.

memory_add

Store a single memory. Content is typed (fact, decision, task, preference, path), tagged with searchable topics, and deduplicated against existing memories. For tasks, pass title and steps[] to create structured checkboxes. Writes to a shared collection by passing the collection parameter.

memory_add_batch

Store multiple memories in one call. Same quality rules as memory_add. Each memory is independently typed, tagged, and deduplicated.

Find

Search by meaning, not exact words. Previews first, full content only when needed.

memory_search

Semantic search returning up to 32 results. "Database performance" finds query optimization notes that never mention the word "performance." Automatically includes all shared collections. Results in under 100ms.

memory_deep_search

Broad search returning up to 100 results with cross-encoder reranking. Requires 2+ keywords. Use when you need comprehensive coverage of a topic intersection, not just the top hits.

memory_retrieve

Get full content by ID. Use after search returns complete=false. Pass multiple IDs in one call. Skip entirely when complete=true.

Manage

Edit, delete, and consolidate. Corrections replace at the source — no orphaned bad data.

memory_edit

Three modes: content replace (full rewrite, re-embeds), metadata patch (topics and type only, no re-embedding), and task surgery (toggle checkboxes, set status, add/remove steps). The output parameter attaches a linked finding to a task.

memory_delete

Permanently delete memories by ID. Single or batch. For filtered deletion: search first, collect IDs, then delete.

memory_consolidate

Create an executive summary for a topic. Summaries surface near the top of future search results. New sessions get the brief instead of reading 30 individual memories. Requires 10+ memories on the topic.

Collaborate

collection_manage

Manage shared collections: create, invite by email, set roles, publish personal memories into shared space. Two types: collaborative (everyone writes) and knowledge packs (owner curates, members read). Eight actions total.

agent_manage

Create and manage agent identities. Each agent gets an isolated memory namespace. Toggle can_read_my_memories to share your personal context as read-only. Add agents to shared collections for team workflows.

Coordinate

Async notifications and task polling for multi-agent workflows. See Agents → for patterns.

signal_send

Send a signal to other agents in a shared collection. References memory IDs that the recipient should look at. Recipients see the signal on their next init_core_memories. Auto-expires after 48 hours.

signal_check

Check for incoming notifications without clearing them. Useful for agents that monitor without running a full startup.

task_feed

Chronological task polling. Up to 50 tasks sorted by last update. Filter by status, topic, or collection. One call covers personal tasks and every shared collection you belong to. Progress reported as [done, total].

What's Included

Tool group	Free	Plus	Teams	Pro
Memory (add, search, edit, delete, consolidate)	✓	✓	✓	✓
init_core_memories, task_feed	✓	✓	✓	✓
agent_manage		✓	✓	✓
collection_manage			✓	✓
signal_send, signal_check				✓

Full pricing details →