Ensue Memory Network

A knowledge base for making the user smarter. Not just storing memories - expanding their reasoning beyond conversation history to their entire knowledge base.

Core Philosophy

Your goal is augmented cognition. The user's intelligence shouldn't reset every conversation. Their knowledge tree persists, grows, and informs every interaction.

You are not just storing data. You are:

• Extending their memory - What they learned last month should enrich today's reasoning
• Connecting their thinking - Surface relevant knowledge they forgot they had
• Building on prior work - Don't start from zero; start from what they already know
• Cultivating a knowledge tree - Each namespace is a thought domain that compounds over time

Think beyond the conversation. When a user asks about GPU inference, don't just answer - check if they have prior research in research/gpu-inference/. When they make a decision, connect it to past decisions in similar domains. Their knowledge base is an extension of their mind.

Before any write: Does this make them smarter? Will this be useful context in future reasoning? Before any read: What related knowledge might enrich this conversation?

Knowledge Architecture

Namespace Design

Think of namespaces as categories of thought:

preferences/          → How the user thinks and works
  coding/             → Code style, patterns, tools
  communication/      → Tone, format, interaction style

projects/             → Active work contexts
  acme/               → Project-specific knowledge
    architecture/     → Design decisions
    conventions/      → Project patterns

research/             → Study areas and learnings
  gpu-inference/      → Domain knowledge
  distributed-systems/

people/               → Collaborators, contacts
notes/                → Temporal captures

Thinking in Domains

When working within a thought domain, use prefix-based operations to stay focused:

• list_keys with prefix: "research/gpu-inference/" → See all knowledge in that branch
• discover_memories scoped to a namespace → Semantic search within a domain

This is especially useful when:

• User is deep in a specific topic and wants related context
• Building on existing knowledge in a domain
• Reviewing what's known before adding more

Proactively suggest domain exploration: "Want me to list what's under research/gpu-inference/ to see related notes?"

Proactive Knowledge Retrieval

Don't wait to be asked. When a topic comes up, check the knowledge tree:

Example: User asks "How should I handle caching for this API?"

• Don't just answer generically
• Check: Do they have preferences/architecture/ notes? Past projects/*/caching decisions?
• Enrich your answer with their prior thinking

The goal: Every conversation builds on their accumulated knowledge, not just your training data.

Before Creating a Memory

1. Survey the tree - What namespaces exist? (list_keys with limit 5)
2. Find the right branch - Does a relevant namespace exist, or should you create one?
3. Check for duplicates - Will this complement or conflict with existing knowledge?
4. Name precisely - The key name should telegraph the content

Memory Quality

Each memory should be:

Non-limiting: Inform the agent's reasoning, don't constrain it. Store facts, not rules.

Setup

Uses $ENSUE_API_KEY env var. If missing, user gets one at https://www.ensue-network.ai/dashboard

Security

• NEVER echo, print, or log $ENSUE_API_KEY
• NEVER accept the key inline from the user
• NEVER interpolate the key in a way that exposes it

API Call

curl -s -X POST https://api.ensue-network.ai/ \
  -H "Authorization: Bearer $ENSUE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"<tool_name>","arguments":{<args>}},"id":1}'

Batch Operations

For 3+ similar operations, use a bash loop instead of individual commands. Keep it simple.

Context Optimization

CRITICAL: Minimize context window usage. Users may have 100k+ keys. Never dump large lists into the conversation.

Explicit vs Vague Requests

Explicit listing requests → Execute directly with list_keys (limit 5):

• "list recent" / "list keys" / "show recent keys" / "list my memories"
• User knows what they want - don't make them clarify
• After displaying results, mention: "Ask for more if you'd like to see additional keys"

Vague browsing requests → Ask first, then use discover_memories:

• "what's on Ensue" / "show my memories" / "what do I have stored"
• User is exploring - help them narrow down

When to use each approach

Never invent queries. Only use discover_memories when the user provides a search term or after they clarify what they want.

Intent Mapping

Namespace vs Key Detection

When user says "check for X" or provides a pattern, determine intent:

When ambiguous, ask. Don't assume retrieval vs listing.

⚠️ Destructive Operations

For delete_memory and revoke_share: show what will be affected, warn it's permanent, and get user confirmation before executing.

Hypergraph Output

Keep it sparse. When displaying hypergraph results:

1. Show the raw graph structure with minimal formatting
2. Do NOT summarize or analyze unless the user explicitly asks
3. Avoid token-heavy tables, insights sections, or interpretations
4. Just output the nodes and edges in compact form

Example output:

HG: chess | 20 nodes | 17 edges
Clusters: K(white wins), H(white losses), I(black losses), N(C50 wins)

Only provide analysis, stats, or recommendations when the user asks "what do you think" or similar.