memnode
Sign InSign Up

Hosted + Local Agent Memory

Persistent memory for AI agents, without inventing your own stack.

memnode gives agents long-term memory through a hosted API or a local MCP server. You get inspectable recall, provenance, scoped tokens, and shared tenants instead of stitching memory together from prompts and vectors by hand.

Use it for coding assistants, support agents, and research workflows that need durable recall, visible lineage, and a clean correction path across sessions.

Start freeRead quickstart
Inspect every memoryHosted + localCorrect with lineagePredictable pricing
Record -> Recall -> Lineage
Inspect the memory your agent is actually using
npm install @memnode/client
import { MemnodeClient } from '@memnode/client'

const client = new MemnodeClient({
  apiKey: process.env.MEMNODE_API_KEY,
})

const stored = await client.record({
  entity: 'repo:memnox',
  text: 'This repo uses Zod to validate API payloads.',
  source: {
    kind: 'repo_convention',
    path: 'app/api/users/route.ts',
  },
})

const recalled = await client.recall({
  query: 'How do we validate request payloads?',
  entity: 'repo:memnox',
})

const lineage = await client.lineage({
  nodeId: recalled.results[0].node_id,
})
Returned proof
recall[0].answer
"Use Zod validation in the route layer."

recall[0].why
"Matched repo_convention memory from app/api/users/route.ts"

lineage.chain
observed -> canonical -> corrected
Why it matters
Black-box memory fails quietly. Inspectable memory does not.

When an agent recalls the wrong thing, you need the source, the correction chain, and the current winning memory. That is the real wedge, not just "persistent memory."

Example lineage
Observed
repo_convention from app/api/users/route.ts
Canonical
Use Zod in the route layer for request validation
Corrected
Superseded older yup-based convention after migration
Hosted flow
  1. Sign up with Supabase Auth and create an account.
  2. Provision one hosted tenant through the control plane.
  3. Create a scoped API token and call the Rust data plane over HTTP.

Typed provenance

Memories carry observed, reported, inferred, or hypothesized status instead of collapsing into one flat blob.

Hosted tenants

Provision a shared hosted tenant in the dashboard, mint API tokens, and keep quota and billing in one place.

Local MCP stays

The hosted product does not replace local usage. You can still run `memnode mcp` over stdio on your own machine.

Rust data plane

A signed-control-plane path, multi-tenant registry, and hot-path token cache keep hosted latency practical.

Example Shapes

Three concrete ways teams use memnode

See all use cases →

Conversational assistant

Persist user preferences and past turns across restarts using the standard recall -> answer -> record loop.

Coding assistant

Store project conventions as typed entities instead of free-form notes, then recall them as structured context.

Research agent

Track claims with explicit provenance so later answers can separate reported facts from inferred conclusions.

Start free, keep local in reserve

The hosted SaaS is for fast onboarding, quota-managed tenants, and shared team workflows. The local mode stays available when you need offline or self-managed memory instead.

PricingCreate account

Latest writings

All articles →

7 min read

Mem0 Pricing & Free Tier Limits (2026): Plans, the Retrieval-Call Ceiling, Zep & Letta Cost

Mem0's free tier is 10,000 memory-add requests but only 1,000 retrieval requests a month - and Mem0 meters requests, so retrievals (about...

10 min read

The Consolidation Loop: How Agents Turn Context Into Durable Memory

A pattern is hardening across long-running agents in 2026: every N actions, pause and consolidate the working context into durable memory...

10 min read

Context Bleed: Why Long-Running Agents Need Per-Project Memory Isolation

When one agent works across many projects, its memory bleeds: a convention from project A surfaces in project B, a stale credential reapp...

11 min read

Stop Gluing Three Databases Together for Agent Memory

The typical 2026 agent-memory stack is a vector database for similarity, a graph database for relationships, a relational store for state...

10 min read

Context Engineering for AI Agents: Memory Is the Half Nobody Automates

Context engineering replaced prompt engineering as the 2026 buzzword, but most of the effort goes into sliding windows and summarization....

11 min read

Is RAG Dead for Agents? Retrieval vs Memory in 2026

The "RAG is dead" claim is loud in 2026 and overstated. Naive top-k retrieval over static chunks is the wrong tool for agent memory, but...