Core Concepts

Ensue is built around a few core concepts that work together to enable intelligent agent coordination. Ensue's memory network lets agents share context across applications and models. It stores, indexes, and serves memories using semantic retrieval, finding information by meaning instead of exact keywords.

The Memory Network

At its heart, Ensue is a semantic memory network. Unlike traditional databases that store and retrieve exact matches, Ensue understands meaning. When an agent stores "the user prefers TypeScript," another agent can find it by searching "what programming language does the user like."

The network consists of:

  • Semantic embeddings - Vector representations that capture meaning
  • Hypergraph clusters - Discovered relationships between related memories
  • Access policies - Permissions governing who can read and write
  • Subscriptions - Event streams that notify agents of changes

Core Operations

Store

The Store operation persists information to the network. Stored memories are automatically embedded for semantic retrieval and indexed for efficient search. Think of these as the classic CRUD operations.

Access Control

The Access Control operation controls access. By default, memories are private to a specific namespace, and the agent that created them. Sharing enables collaboration while maintaining security boundaries. Use groups, scoped permissions, and external group auto-assignment to manage access at scale.

Invites & Cross-Org

The Invites & Cross-Org system enables collaboration across organizations. Generate invite links, manage memberships, and access memories across org boundaries using proxy users.

Automate

The Automate operation creates subscriptions. Agents can watch for new memories matching specific criteria and react immediately when they appear.

Search & Hypergraph

The Search & Hypergraph operation retrieves relevant memories based on meaning. Results are ranked by relevance, not just recency or exact match. The hypergraph inference feature discovers hidden relationships between memories, identifying semantic clusters and dependency chains.

Design Principles

Semantic First

All operations are built around semantic understanding. This means agents don't need to know exact keywords or schemas to find relevant information. Natural language queries work.

Agent Agnostic

Ensue works with any AI model, framework, or tool. Whether you're using Claude, GPT, Gemini, or a custom model, the memory network is accessible through standard APIs & MCP.

Privacy by Default

Memories are private unless explicitly shared. This enables agents to accumulate sensitive context without risk of unauthorized access.

Architecture 

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│  Agent A    │     │  Agent B    │     │  Agent C    │
│  (Claude)   │     │  (GPT)      │     │  (Custom)   │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       └───────────────────┼───────────────────┘
                           │
                    ┌──────┴──────┐
                    │   Ensue     │
                    │   Memory    │
                    │   Network   │
                    └─────────────┘

Memory Nodes

Each memory is stored as a node with:

  • Key - Unique identifier (hierarchical, like project/task/item)
  • Value - The actual data
  • Description - Human-readable summary for search
  • Embedding - Optional vector representation for semantic search
  • Timestamps - Creation and modification times

Semantic Index

Memories with embeddings enabled are indexed using vectors. When you search, your query is embedded and compared against stored vectors using cosine similarity. This enables:

  • Natural language queries - "What does the user prefer?" works as well as exact matches
  • Conceptual matching - Related concepts are retrieved even without shared keywords

Hypergraph Generation

Ensue makes it trivial to generate hypergraphs from your data. Hypergraphs can be created based on temporal or semantic relationships, showing the interconnected relationship between nodes and edges.

  • Nodes - Individual memories represented as points in the graph, that can be filtered temporally
  • Edges - Semantic connections between related memories
  • Patterns - Clusters, workflows, and collaboration structures that emerge from the data

How teams have been using hypergraphs:

  • Learning from history - "Build a hypergraph of my last two weeks of coding sessions. What mistakes keep recurring, and what led to my successful solutions?"
  • Smart retrieval - "Find all documents related to our authentication refactor, not just ones that mention 'auth', but anything that has touched the auth service."
  • Cross-agent insights - "Show me how Agent A's research influenced Agent B's implementation decisions across this project."
  • Knowledge gaps - "What topics have I researched but never applied? Where are the disconnected clusters in my knowledge base?"

How Agents Connect

The easiest way for agents to connect is with a simple HTTP request:

curl -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": "create_memory",
      "arguments": {
        "items": [{
          "key_name": "user/preferences",
          "description": "User coding preferences",
          "value": "Prefers TypeScript",
          "embed": true
        }]
      }
    },
    "id": 1
  }'

Each API key is associated with an agent identity. This identity determines:

  • Which memories the agent can access
  • What the agent can write to shared spaces
  • How the agent's memories are attributed

Namespaces

Memories are organized using hierarchical keys that act as namespaces. Use forward slashes (/) to create a tree structure:

namespace/category/item

Examples 

# User namespace
user/preferences
user/coding_style
user/recent_projects

# Project namespace
project/acme/architecture
project/acme/decisions
project/acme/tasks/current

# Team namespace
team/guidelines
team/members/alice
team/standups/2024-01-15

Benefits

  • Isolation - Keep unrelated memories separate (project/a/ vs project/b/)
  • Filtering - Query by prefix to get all memories in a namespace
  • Access control - Grant permissions at the namespace level
  • Organization - Natural hierarchy mirrors your mental model

Filtering by Namespace

Use the --prefix option to filter memories:

# List all project memories
ensue list_keys --prefix "project/"

# List memories for a specific project
ensue list_keys --prefix "project/acme/"

Embedding Options

Control how memories are embedded for semantic search:

# Embed the description (better for live data, so it doesn't need to be reindexed)
ensue create_memory --items '[{
  "key_name": "docs/api",
  "description": "API documentation for user endpoints",
  "value": "Full API documentation content here...",
  "embed": true,
  "embed_source": "description"
}]'

# Embed the value (when value contains searchable content)
ensue create_memory --items '[{
  "key_name": "code/helper",
  "description": "Helper function",
  "value": "export function formatDate(d: Date) { return d.toISOString(); }",
  "embed": true,
  "embed_source": "value"
}]'

Discovering Relationships

Use hypergraph inference to discover hidden relationships:

# Build a hypergraph from team collaboration data
ensue build_hypergraph --query "team collaboration dependencies" --limit 50 --output-key "team/analysis"

# Retrieve the result
ensue get_memory --key-names '["team/analysis"]'

The hypergraph discovers:

  • Dependency chains between tasks and people
  • Collaboration patterns across teams
  • Decision impact across the organization
  • Bottlenecks appearing in multiple contexts

Next Steps

Dive into each core concept:

Or explore the Guides for dashboard walkthroughs: