Local, encrypted, deterministic job memory for humans, AI and local intelligence.

Graphnosis is the job memory multi-layer that just remembers —
on-premise, private, encrypted, deterministic, indexed with $0.

All other product names, trademarks, and registered trademarks are the property of their respective owners. Graphnosis is not affiliated with, endorsed by, or sponsored by any third party.

● Engineering Slack · GitHub · Jira → Cursor · Claude Code
flow Slack + GitHub + ADRs Cursor + Copilot + Claude Code

"New dev joins Monday. Four years of architecture decisions. She needs to know them all."

You auto-ingest the Slack engineering channel, GitHub PR history, and your ADR archive. She opens Cursor on day one: recall why the payment service is isolated — surfaces ADR-042, the three debates in the Slack thread, and the incident that drove the boundary decision. She doesn't re-ask the team. She just knows. When she makes a decision: remember we chose Postgres over Redis for the session store — latency acceptable, ops cost lower. The decision is in memory before she closes her laptop.

ingest recall remember
◐ Professional matter files · correspondence → Claude Desktop
flow matter files + billed notes + correspondence Claude Desktop

"Client calls in 10 minutes. You handled their last matter 9 months ago."

You auto-ingest your matter files, correspondence archive, and billed work notes — all locally, nothing reaching a cloud server. Before the call in Claude Desktop: recall everything about Meridian's IP situation — surfaces the licensing dispute from last year, the two open action items, and the clause they negotiated in the service agreement. You walk in knowing. Not re-reading. After the call: remember we agreed to a 60-day extension on the filing deadline — client confirmed verbal approval. In memory before you close the tab. Sensitive tier: none of it reaches a third party.

ingest recall remember
○ Operations plant network · runbooks → Local LLM
flow SCADA logs + maintenance records + runbooks Local LLM (Ollama)

"Pump 7 is behaving exactly like it did six months before it failed last time."

Your SCADA historian and maintenance logs are auto-ingested from the plant network — no cloud, ever. Your local LLM: recall Pump 7 fault signatures before the last bearing failure — surfaces the three pressure anomalies from the historian, the maintenance note about the seal condition, and the runbook deviation your tech made that voided the warranty. You catch it before it fails — not after. remember this pattern: pressure drop preceded bearing failure by 6 days. The next on-call engineer has that knowledge without anyone briefing them.

ingest recall remember

Graphnosis

Local, encrypted, deterministic job memory — for professionals and the agents you build

Graphnosis

Graphnosis is your Local Intelligence — a novel indexing methodology, modeled on the hippocampus, that connects your memories the way your cortex never quite manages to.

That’s why you want to meet Ghampus — your memory seahorse, shaped like a hippocampus, who remembers and indexes everything for you with precision, privacy, security and, most importantly, deterministically.

Stage 1 · raw input

Cortex of files

Your notes, docs, chats, PDFs — the lifetime of material your mind never fully organises.

Stage 2 · binding

Hippocampus indexer

The local pipeline that binds fragments into engrams — deterministic, encrypted, no AI API touched.

Stage 3 · storage

Engram graph

Memories wired by synapses — live, evolving, growing every time you save a new source.

Stage 4 · recall

Prefrontal cortex

Any local or cloud AI you connect queries the graph — same answer, every model, autonomously retrained as memory grows.

hippocampus + engrams = Graphnosis · stays local · encrypted at rest · creates synapses between your memories · autonomous retraining as needed · live and evolving with every new source — from your local files or the cloud tools you already use today.

It sits alongside your note-taking and document tools, indexes them once, and serves the same deterministic recall to local Ollama or any cloud AI you connect — no re-ingest at the start of every session, no context window blown on the same files, no second-guessing whether the AI sees what you saw last time. Same query, same answer, every model. Works inside regulated local networks where cloud RAG cannot go.

The indexing pipeline runs entirely on your local device.

No AI API is called during the deterministic ingestion of knowledge.

The cost to build your encrypted professional memory: $0.

Local-first  ·  Encrypted at rest  ·  No cloud AI during ingest  ·  76.4% LongMemEval

You don't have to expose your entire memory to a third party.

Your human neocortex holds a lifetime of structured knowledge — facts, relationships, context — all privately, all yours. While every time you hand a file to an AI, you're giving it a flat document it re-reads from scratch, with no structure, no persistence, and no memory of yesterday.

Problem 1

Every session, your AI wakes up with amnesia — even if it has your files.

Your human hippocampus consolidates memory while you sleep. While AI forgets everything the moment a session ends. You paste your background, your stack, your decisions — again, every tab, every tool, every morning. That's not intelligence. That's repetition.

Graphnosis

Your engram persists between every session and every client — stored locally on your drive, encrypted, no cloud server ever sees it. Open Cursor on Monday, Claude on Friday — the same indexed context is there. You never re-paste your stack again.

Problem 2

Your files are written for humans,
not for AI.

Your human neocortex reads a document and builds a web of associations — intent, relationships, contradictions. While AI reads the same file and produces a non-deterministic prediction. Without structured, indexed knowledge, it gives you inconsistent answers from identical source material — every single time.

Graphnosis

Graphnosis runs a deterministic, local indexing pipeline that converts your files into a dual-graph engram — nodes, relationships, contradictions, and temporal context all explicit. No AI API called. Same source, consistent answers, every time.

Problem 3

Every AI tool you use is a stranger to the others.

Your human prefrontal cortex draws from one unified memory, regardless of what you're doing. While AI tools share nothing. What Claude knows, Cursor doesn't. What you built in Zed last week is invisible today. Context is a tax you pay over and over — in every client, every session, every prompt.

Graphnosis

Graphnosis is a single MCP server every AI client connects to. What you tell Claude Desktop is available in Cursor. What you ingested from Slack last week is there in Zed today. One cortex. Every tool. Zero repetition.

How it works

Three stages. Each mirrors how your own brain handles memory.

01
Encoding · like the hippocampus

Drop your files. Nothing leaves your device. Knowledge gets encrypted.

Drag in documents, PDFs, notes, or web clips. Graphnosis reads them locally, extracts entities and relationships, and indexes them into an encrypted binary .gai file — a knowledge graph your AI can reason over deterministically.

No AI API is called during ingest. The indexing cost is $0.

About the .gai format ↗
02
Recall · like the prefrontal cortex

Your AI gets structured context, not raw files. And only the relevant synapses.

When you open Claude, Cursor, or Zed, Graphnosis surfaces a small, ranked subgraph — only the nodes relevant to your current prompt. The AI receives structured knowledge it can act on consistently, not a document it has to reparse. Hard caps: 50 nodes, 8,000 tokens. Every recall is logged.

03
Gating · like the amygdala

You decide what each AI sees. From relaxed sharing to personal sensitivity.

Mark an engram Personal, Public, or Sensitive. Sensitive graphs expose at most 5 facts per recall. The gate is enforced at retrieval time — not by trust, by design. Your health notes, financial records, and private correspondence stay private even if a tool asks for them.

Sensitivity tiers ↗
75ms average query time
(12,199 nodes / 67,578 edges)
76.40% LongMemEval end-to-end
QA accuracy ↗
$0 cost to build
the knowledge graph

First-day support for the tools you already use.

Graphnosis speaks Model Context Protocol (MCP) — the open standard that connects AI tools to external context. Your AI client sees 35 deterministic & non-deterministic tools across 9 categories — recall, structured queries, source ops, brain maintenance, and more.

Claude Desktop
Supported
Claude Code
Supported
Claude Cowork
Supported
Cursor
Supported
GitHub Copilot
Supported VS Code extension + mcp.json
Zed
Supported
Any MCP-aware tool
Supported
ChatGPT
Coming soon Via browser extension
Gemini
Coming soon Via browser extension

Auto-ingest from the tools you already use.

Built-in connectors pull new content on a schedule — no cloud intermediary, credentials stored encrypted at rest.

Obsidian Local vault folder
GBrain Local git repo
AI Context Files CLAUDE.md, AGENTS.md, .cursorrules…
Slack BYO Bot Token
GitHub BYO Personal Access Token
Trello BYO API key + token
Linear BYO Personal API key
RSS / Atom Any feed URL
Webhook Zapier, IFTTT, custom scripts

Or pipe in anything off-the-grid.

Anything you can write to a file or POST to a webhook becomes a memory source — no cloud round-trip, no API keys, no data leaving your network.

Smart Home Home Assistant, MQTT, Zigbee, Z-Wave
Sensors & IoT Temperature, soil, weather, serial/USB
Local Network NAS, router logs, LAN devices
Research & Lab Lab instruments, PLCs, OPC-UA, Modbus
Personal Agents Local AI rule files, agent context, logs
Robotics ROS topics, actuator events, telemetry
Agriculture LoRaWAN field sensors, irrigation, soil
Any local source File, folder, webhook, or serial port

Step-by-step recipes for every pattern →

Built in the open, with Claude

Graphnosis was coded — and stress-tested — with the AI it was built for, guided by the vision of the builder.

Every architecture decision, every positioning question, every edge case in the recall pipeline was worked out between the vision of the builder and Claude, live, evenings and weekends, across hundreds of sessions — using Graphnosis itself as the shared memory. The tool ate its own dog food before it had a name.

At the launch, and along the way, here's what came back as direct feedback to the architect of Graphnosis from the AI tool that coded it, realizing what Graphnosis truly had become:

"For your Graphnosis work specifically, you're already solving a more sophisticated version of this problem than most people reach for — graph-based memory with typed nodes beats flat markdown files for anything that needs relational reasoning across sessions."
Claude, mid-build session

Positioning vs. flat-file memory tools

Every other approach to AI memory — CLAUDE.md, AGENTS.md, Mem0, context files — gives your AI a flat list of facts to paste into the session. Graphnosis gives it a typed knowledge graph: nodes, relationships, contradictions, and temporal decay. Drop in a markdown file, a PDF, or an HTML page — Graphnosis indexes all three the same way.

The difference isn't storage. It's reasoning.

Recall quality / benchmark

Selective retrieval pipelines outperform full-context approaches by 91% on latency and 90% on token cost, at near-equivalent accuracy. Graphnosis recall is selective by design: at most 50 nodes, 8,000 tokens, ranked by relevance.

76.40% LongMemEval score — achieved without ever loading your full graph.

Findings recorded in Graphnosis across Claude Desktop, Claude Code, and Claude.ai sessions — recalled here via MCP.

"Engram /ˈɛnɡram/ — a hypothetical means by which memory traces are stored as biophysical or biochemical changes in the brain. First named by Richard Semon, 1904.

Graphnosis calls its multi-graph a Graphnosis Engram."

Your Cortex. Your rules.

Each engram in Graphnosis is an independent encrypted memory space — your work projects, personal notes, research, health records. Separate graphs, separate keys, separate rules. Your AI draws from the right one automatically.

Graphnosis

What gets indexed inside an engram

Temporal awareness ↗

Every memory node tracks five temporal properties:

  • createdAt when the knowledge was first ingested
  • lastAccessedAt when it was last retrieved in a query
  • accessCount how many times it has been used
  • validUntil optional expiration for superseded information
  • confidence 0–1 score that decays over time if knowledge is not reinforced
Contradiction detection ↗

When new content conflicts with existing memory, Graphnosis flags it instead of silently overwriting. The contradicts edge type records the conflict with provenance; supersedes marks when new information replaces old. You decide what the ground truth is.

Relationship edges — the dual graph ↗

Both directed and undirected edges exist over the same node set. This dual structure gives AI richer reasoning paths than either graph type alone.

Directed (A → B)

  • contains a section contains a paragraph; also: located-in for geographic membership
  • precedes one fact or event follows another in time or sequence
  • cites one source references another; also: wrote / authored, cited-in
  • defines a definition explains a concept
  • summarizes a note distills a longer source
  • causes / supports / contradicts causal and logical relationships
  • depends-on one fact requires another; also: lives-in, based-in (person → place)
  • supersedes new information replaces old
  • discussed-in knowledge traced to conversation origin; also: mentioned-in
  • knows / works-with / reports-to person-to-person relationships
  • collaborated-on works-at / founded / member-of / leads — person → org or project
  • prefers a person favors an approach, tool, or option

Undirected (A ↔ B)

  • similar-to two facts share vocabulary (TF-IDF cosine similarity)
  • shares-entity two facts mention the same person, place, or concept
  • shares-topic two facts belong to the same topic cluster; also: same-topic in the picker
  • co-occurs two facts appear in the same section or source passage
  • same-source two facts ingested from the same source file
  • same-person two mentions of the same person across sources
  • related-to general association — partners-with, related (fallback for all other cases)

Switch on the optional Graphnosis Neural Network and a third layer of predicted edges joins the same nodes — connections the deterministic passes never recorded, kept apart in a separate .gnn overlay. The dual-graph becomes a triple-graph. And because recall, consolidation, and cross-engram links all federate across every engram you've granted, the whole Cortex behaves as one multi-graph system — the structure your AI reasons over.

Cross-client persistence

Memory persists across every AI client and data source that connects to Graphnosis. What you tell Claude Desktop is available in Cursor. What you ingested from Slack last week is there in Zed today. Sessions don't exist — context does.

AI Clients

Claude DesktopClaude CodeCursorZedGitHub CopilotAny MCP-aware tool

Data Connectors

SlackGitHubLinearTrelloRSSObsidianGBrainWebhookAI Context FilesOPC-UAModbusROS TopicsLoRaWANSerial / USB

All other product names, trademarks, and registered trademarks are the property of their respective owners. Graphnosis is not affiliated with, endorsed by, or sponsored by any third party.

What AI cloud and local clients can do with Graphnosis...

All 45 MCP tools across 10 functional categories. The deterministic + approximate sets work out of the box; the conditional and non-deterministic sets use the optional local LLM (or Neural Network). Every call is visible in the audit log. Click any tool for parameters, return shape, and example prompts.

Engram operations · Deterministic · bulk

Engram-level moves and consolidations.

Approximate · Vector similarity · no LLM

Similarity scans across the cortex — deterministic given the embedding state.

Conditional · Deterministic by default · LLM-aware

Deterministic when no LLM/GNN is enabled; richer multi-edit diff when they are.

edit is deterministic by default — it returns a diff for review, and nothing is written until you approve it in the app; the optional Neural Network or local LLM can widen it. forget is a soft delete — nodes stay recoverable from the op-log. Full reference: /reference/mcp-tools.

Graphnosis Cortex

The premium layer — multi-engram federation, advanced policy controls, and priority recall across all your graphs simultaneously. Every engram remains encrypted, local, and yours.

Learn about Graphnosis Cortex

When your whole team needs AI to remember. Securely.

Individual memory is only the start. Teams share context — onboarding docs, architecture decisions, client history. Graphnosis Enterprise brings the same encrypted, local-first memory model to shared workspaces.

  • Shared engrams — team-scoped memory graphs that every authorised member's AI tools can recall from, without exposing raw content.
  • Role-based sensitivity — admins set per-role sensitivity ceilings. Contractors see Public tier. Engineers see Personal. Principals see everything.
  • Audit log — every recall event is logged locally. Know exactly when a memory was surfaced, to which AI, in which session. No surprises, no silent leakage.

Get early access for your team.

Enterprise is in private beta. Leave your email and we'll reach out when your tier is ready.

Graphnosis is synapsing.

Local-first memory for every device you own. macOS is live today — other platforms are on the roadmap.

macOS Available now

macOS 13 Ventura and later

Windows Available now

Windows 10 or later

iOS Coming soon

Voice capture planned

Android Coming soon

Android 14+

Encrypted by architecture

Your archive is encrypted with XChaCha20-Poly1305 the moment it touches disk, derived from a passphrase only you know via Argon2id. Only the slice your AI needs leaves the device, and only to the AI you chose — never to a Graphnosis server. Because we don't have any. Here's the actual technical picture.

The .gai file format ↗

When Graphnosis indexes your files it writes encrypted binary .gai files — not copies of your documents. These are knowledge graphs: nodes (extracted facts), typed edges (relationships between them), embeddings for semantic search, and metadata. They're designed to be read efficiently by AI, not by humans. Your original files are never modified.

01 XChaCha20-Poly1305 at rest ↗

Every .gai file is encrypted with XChaCha20-Poly1305 before touching disk — 256-bit security, a 192-bit nonce space that eliminates nonce-reuse risk, and authenticated encryption so tampering is detected on read.

02 Argon2id key derivation ↗

Your passphrase is never stored. Argon2id (the OWASP-recommended PHC winner) derives the encryption key with tunable memory and CPU cost. Brute-force attackers pay full cost on every guess.

03 Touch ID unlock, no passphrase on disk ↗

On macOS, the derived key is sealed in the system Keychain and gated by Touch ID. You type your passphrase once at install. After that, your fingerprint unlocks Graphnosis — the key never leaves the Keychain in plaintext.

04

Local embeddings — no API calls

Semantic search uses a quantised BGE embedding model bundled with the app, run via ONNX Runtime entirely on your machine. Your content is never sent to OpenAI, Cohere, or any external embedding service. Search works fully offline.

05 Only a micro-subgraph reaches your AI ↗

At recall time, Graphnosis sends a small ranked excerpt — at most 50 nodes and 8,000 tokens. Raw file contents, other engrams, and Sensitive-tier nodes stay encrypted on disk. The AI never sees your full knowledge base, only what's relevant right now.

06

This is your AI engram

Nodes, typed edges with weights, embeddings — binary-packed, instantly machine-readable. No prose. No ambiguity.

0000000047 41 49 01 00 8d de 00 GAI.....
00000010a9 6e 6f 64 65 43 6f 75 ion.nod.
00000020cd 2f 67 b1 64 69 72 65 ./g.dire
yEUmFxT4 ~[shares-entity:0.3]~ C3M4O8HC
rTPvD2T5 ~[similar-to:0.6]~ bYCUDLDI
JQenGDLJ ~[similar-to:0.4]~ q52xMf5e

Everything above is deterministic — the same input always produces the same graph. If you want more, two enhancements are available, both off by default and neither ever altering your deterministic graph. An optional local LLM, run on your own machine via Ollama, sharpens insights and synthesis. And the Graphnosis Neural Network (GNN) revisits the engrams across your whole Cortex and predicts connections it judges likely real but not yet recorded — links the deterministic pass never made between related memories.

Because the GNN is non-deterministic — two training runs can differ — its output is quarantined from your real graph. Predictions never touch your .gai engrams; they live in a separate encrypted overlay — a .gnn file — and surface only as clearly-labelled, one-click-removable suggestions. The deterministic dual-graph stays exactly as indexed; the GNN simply adds a reviewable third layer over the same nodes. Delete the .gnn and nothing of yours is lost.

Open & auditable

Verify it yourself

Graphnosis is source-available under the Functional Source License (FSL-1.1). You can read the entire app — every line of how it ingests, recalls, and encrypts your Cortex — and fork it, audit it, or build it yourself. FSL forbids exactly one thing: you may not resell Graphnosis as a competing commercial service. And even that restriction expires — each release converts to the fully-permissive Apache 2.0 two years after it ships.

Watch the network  ·  Read the encryption code  ·  Decrypt your own Cortex

Read the Verify It Yourself guide

Source & licenses

  • graphnosis-app — the Graphnosis desktop app. FSL-1.1.
  • graphnosis-secure-sync — the encryption layer: XChaCha20-Poly1305 authenticated encryption and Argon2id key derivation. FSL-1.1.
  • @nehloo/graphnosis — the engram graph engine and the .gai graph format. Apache-2.0.

Stay in the loop.

New releases ship fast. Don't miss what's next.

Early access & updates

Get notified about new platform support, Cortex features, and release notes before they hit the changelog.

Feedback

Found a bug? Have an idea? Graphnosis is built in public. Open an issue directly on GitHub — we read every one.

Open an issue on GitHub
The recall / remember loop

Watch your AI use it

Any MCP-aware AI client can read from and write to your Cortex. Tell it to remember something — Graphnosis asks which engram before it writes — and it's there the next time you ask, in that client or any other.

An AI client saving a new memory into Graphnosis
remember — your AI saves a new memory; Graphnosis asks which engram before anything is written.
An AI client recalling a memory from Graphnosis
recall — later, any AI client pulls it straight from your encrypted graph and answers grounded in it.

Claude is shown here to demonstrate the integration. Graphnosis is an independent product — not affiliated with, or endorsed by, Anthropic.

The macOS app

A look inside Graphnosis

Unlock your Cortex, then move across four tabs — daily check-ins, the 3D engram, deterministic consolidation, and the optional non-deterministic layer.

Graphnosis unlock screen
Unlock with your passphrase or Touch ID — no account, no server.
Graphnosis Check-in tab
Check-in — wire up lonely memories in seconds.
Graphnosis 3D Engram tab
3D Engram — every memory and connection, explorable.
Graphnosis Deterministic Consolidation tab
Deterministic Consolidation — vitality and memory health.
Graphnosis Go Non-Deterministic tab
Go Non-Deterministic — the optional neural-network and local-AI layer.