Now available on macOS

You gave AI your files. You prompted like it indexed them. It didn't… Until Graphnosis.

flow Slack + GitHub Cursor + Claude Cowork

"Cross-memory of a recurring code bug. Note down the lessons learned."

You auto-ingest your Slack export and GitHub PR history into Graphnosis private, local folder (kind of a human cortex). It indexes both in a multi-graph/engram (like the human hippocampus). In Cursor, you ask recall the report about yesterday's recurring crash — it surfaces from the indexed graph/engram (just like the human prefrontal cortex) the Slack thread where the root cause was debated, plus the PR that "fixed" it and the later commit that silently undid it. You have the full picture before writing a single line, and now you can simply tell Claude Cowork to remember the lessons learned from the latest recurring crash — it already knows what you're talking about.

ingest recall remember
flow Linear + Trello Claude Desktop Zed

"The Fed just moved. Which positions are exposed? Did I forget anything?"

You auto-ingest your Linear research tickets and Trello deal pipeline into your private, local Graphnosis folder (kind of a human cortex). It indexes both in a multi-graph/engram (like the human hippocampus). The Fed announces a surprise rate hike. In Claude Desktop: remind me which positions carry duration risk above threshold. It connects your research notes and pipeline cards, surfaces the two exposed holdings from the indexed graph/engram (just like the human prefrontal cortex) — one flagged three weeks ago in a ticket you'd forgotten. You switch to Zed and say recall the duration risk analysis and apply it to the model — no re-briefing, no digging through threads.

ingest remind recall
flow Slack + Claude Code Claude Cowork

"Our key volunteer left. Who holds the knowledge now?"

You auto-ingest your Slack volunteer channels and program documentation files into your private, local Graphnosis folder (kind of a human cortex). It indexes both in a multi-graph/engram (like the human hippocampus). Your longest-serving volunteer resigns on short notice. In Claude Code: correct the org chart - Maria is no longer the lead for the youth literacy program. You approve the diff — every reference updates. You switch to Claude Cowork and say recall everything Maria owned at work and draft an onboarding brief for her replacement — three years of institutional knowledge, surfaced from the indexed graph/engram (just like the human prefrontal cortex) in seconds.

ingest correct recall

Graphnosis

Graphnosis

Your files are the cortex. Your AI is the prefrontal cortex. What's always been missing is the AI hippocampus — the part that indexes, connects, and makes knowledge retrievable.

Graphnosis is your AI hippocampus. Local, encrypted, private.

Graphnosis' indexing pipeline is deterministic and runs entirely on your device. No AI API is called.
The cost to build your local, encrypted second cortex: $0.

Local-first  ·  No cloud AI during ingest  ·  Open-source engine  ·  Works with Claude, Cursor, Zed & more

You don't have to dump 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.

Claude Desktop Supported
Claude Code Supported
Cursor Supported
Zed Supported
Any MCP-aware tool Supported
ChatGPT
Coming soon Via browser extension
Gemini
Coming soon Via browser extension

"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
  • precedes one fact follows another in sequence
  • cites one source references another
  • defines a definition explains a concept
  • causes / supports / contradicts causal and logical relationships
  • supersedes new information replaces old
  • discussed-in knowledge traced to conversation origin
  • knows / works-with / reports-to person relationships

Undirected (A ↔ B)

  • similar-to two facts share vocabulary (TF-IDF cosine similarity)
  • shares-entity two facts mention the same person, place, or concept
  • co-occurs two facts appear in the same section
  • same-person two mentions of the same person across sources
  • related-to general association between people or concepts

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 CodeCursorZedAny MCP-aware tool

Data Connectors

SlackGitHubLinearTrelloLocal files & folders

What AI clients can do with Graphnosis

These are the tools your AI uses. You can see every call in the audit log.

The correct tool generates a diff preview parsed by a local LLM — nothing is written until you approve it in the app. forget is a soft delete; nodes are recoverable from the op-log.

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 Coming soon

Windows 11 · In development

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.

graphnosis-secure-sync
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

Encryption, key derivation, and graph operations are powered by @nehloo/graphnosis — open source, Apache-2.0.

The Graphnosis App is licensed under FSL-1.1 — source-available.

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