Persistent memory that refines itself.
Turns scattered signals and notes into an engine.
immutlex gives your agent a durable, cross-linked memory it reasons from: fused semantic and lexical search over a wiki-link graph of forward links, backlinks, and inferred semantic edges, with a full MCP toolset, built from the ground up on immutable object storage. All from local models in a single binary. No cloud, no API keys.
It's all plain markdown in storage you own. Take your documents anywhere, anytime - you just won't want to.
Stop stuffing context. Start asking the substrate.
Stuff everything into the prompt and hope.
Here is the conversation history.
Now answer my question.
# token bill: enormous - hallucinations: frequent
- The model pattern-matches across too much undifferentiated noise.
- Working memory gets crammed into the question.
Ask the question. immutlex attaches the answer.
# immutlex attaches the 3-5 ranked chunks
# most relevant to that query, before the model
# ever sees the prompt
- The substrate is the working memory. The prompt is the question.
- The model sees a short query and the few chunks that answer it, not a wall of undifferentiated context.
Watch an agent reason over its own knowledge
The best engineers already do a version of this by hand - an Obsidian vault of plain markdown, maybe a database bolted on behind it. I did exactly that, and learned the facade was the wrong foundation: a folder of notes isn't an engine the moment an agent depends on it. It's the inefficiency Andrej Karpathy described: stop stuffing context into the prompt, give the model a brain to think with. immutlex is built from the ground up on immutable object storage, with that pattern engineered in - in this demo an agent ingests a multimodal corpus (text, code, diagrams, a whiteboard photo) and immediately searches and traverses it, with the desktop watching every event live.
Drop in raw markdown, PDFs, CSVs, and images. immutlex compiles each into a linked markdown article - generating the YAML frontmatter and [[wikilinks]] on ingest - then chunks, embeds, indexes, and builds a navigable knowledge graph your agent queries.
immutlex: Search (fused BM25 + semantic, 11.4x compression):
1. transformer-architecture - "based entirely on self-attention"
2. attention-is-all-you-need - "replacing recurrence with attention"
Graph: transformer-architecture <-> self-attention (1 hop)
PageRank: 0.50 / 0.50 - Community: 2 clusters (Louvain)
Point immutlex at anything. No building pipelines.
Multimodal ingest normally means a pipeline you assemble and run: a PDF parser, an OCR service, a vision model, a spreadsheet library, glue code - each a dependency, and another place your data leaves. immutlex does the whole extract step in-binary. Hand it PDFs, spreadsheets, scans, photos, and source files and it pulls the text out, runs OCR on images to catch any characters, and embeds every image with a vision model so it is searchable by what it looks like - then chunks, embeds, indexes, and links it all. "Multimodal" means it reads what you actually have, text and pixels both, not only clean markdown.
The parser, the OCR and vision models, the spreadsheet and CSV readers are all compiled in. There is no extract-transform-load service to stand up, no OCR or vision API key, no data leaving the box to be read. The same path turns every input into the open .md plus immutable-revision format underneath.
# services to run, keys to hold, data egress
immutlex: drop the files in
# text + OCR + image embedding, chunked, linked
# in-process, on your hardware
Documents and data
Images - OCR'd and embedded for visual search
Code and config - any UTF-8 text
Any text-shaped file lands, even with no extension - so a new language or config format needs zero changes. Plus any web page, cleaned to markdown by the open-source defuddle-rs add-on below.
A plain markdown file. A queryable graph underneath.
You write ordinary markdown. immutlex reads the YAML frontmatter and the [[wikilinks]] in the body, turns every link you authored into a graph edge, then derives three more kinds of edge from how documents actually retrieve together - so the file stays portable while the graph underneath becomes navigable.
--- id: attention-is-all-you-need title: Attention Is All You Need tags: [transformers, attention, nlp] links: [transformer-architecture, self-attention] --- The Transformer replaces recurrence with pure [[self-attention]], the core idea behind the [[transformer-architecture]] that followed.
Explicit edges are the ones you authored - the wikilinks in the body, plus backlinks from every doc that points here. They are frozen into the document's revision, and they are the only kind the graph analytics count.
The other three are derived from retrieval and rebuild as the corpus grows: lexical from keyword overlap, semantic from embedding similarity, and implicit from fusing the two. They connect related docs you never linked by hand - and when one proves itself, promoting it writes a real [[wikilink]] as a new revision, turning a derived edge into an authored one.
out: self-attention, transformer-architecture
in: attention-survey, encoder-decoder
Agent: query mode="path" from="encoder-decoder" to="self-attention"
encoder-decoder -> attention-is-all-you-need -> self-attention
Your whole corpus, as a graph you can fly through.
Every document is a node; every [[wikilink]] is an edge. As your knowledge base grows, the graph fills in - this is a real vault with tens of thousands of docs rendered live in the browser. Pilot users get a hosted viewer to explore their own.
The diff that converts a skeptic
The memory does the work. The prompt is just the question. Most developers stuff working memory into the question - that is the inefficiency immutlex eliminates.
The whole engine runs where your data lives.
RAG bolts a hosted vector store onto your prompt and calls it memory. A vector store returns similar chunks and nothing about how they connect. A graph database answers how things connect, but only after you design a schema, populate every node, and maintain every edge by hand. immutlex is both as one engine over immutable revisions of your documents, and the graph builds itself.
The graph builds itself
A graph database makes you design a schema, populate every node, and wire and maintain every edge by hand. immutlex does none of that. The nodes are your documents; the edges form themselves, from the links you write and from semantic similarity between docs. Add a document and the graph rewires itself - you maintain markdown; the knowledge graph is a byproduct, not a second system you babysit.
It runs next to your agent
Build it yourself and you wire a hosted vector DB to a separate graph DB to your storage - every arrow a network hop with its own egress and compute, each holding another copy of your data. immutlex collocates the engine with your data, agent, and workflows. Embedding, fused retrieval, graph traversal, and ranking run in-process on your hardware - no cloud, no API keys, zero telemetry, and storage is one S3-compatible connection string: the bundled local object store, your own S3 bucket, or Azure ADLS.
# every arrow: a hop, egress, a copy
immutlex: agent -> one local binary
# in-process. nothing leaves the box.
The markdown is a facade
A folder of markdown stops being enough the moment an agent depends on it. immutlex is the lakehouse pattern applied to agent memory:
- The .md files are the open, portable format you own, the way Parquet is open columnar storage.
- Frontmatter and content-addressed immutable revisions are the table format on top - versioning, lineage, time-travel, and an audit log of every change, the way Delta and Iceberg sit over Parquet.
- Indexes and graph rebuild from object storage on cold start; a write-ahead log self-heals on crash; relevance decay fades stale docs so it sharpens over months instead of rotting.
A weekend vault gives you the files and nothing underneath, and it rots. That gap is the product, on the same plain .md you own.
Context lands even when the agent forgets to ask
Tools only help when the agent calls them. On a long session it stops - it drifts along on whatever is left in the window, and your knowledge base may as well not exist. immutlex closes that gap without asking the agent to behave: start it under the shell wrapper and a bounded context anchor is spliced into the agent's own input every Nth turn. The agent reads it as if you typed it, so there is no tool call to skip and no MCP support required on its side. Any agent CLI works, and the block is capped in characters and tokens so it cannot eat your context budget.
$ immutlex-shell -- codex
$ immutlex-shell -- copilot
# context arrives on its own, every Nth turn.
MCP tools across 13 categories
Everything your agent can ask of its own knowledge base. Open a category to see what it covers.
Ingest & Validate
Ingest markdown, PDFs, CSVs, images, and any web page. Validate frontmatter and wikilinks before they land.
Query & Retrieve
Fused BM25 + semantic search, heading and backlink search, document rehydration with provenance.
Graph Analytics
Neighbors, shortest path, PageRank, community detection, orphan detection over the wiki-link graph.
Context & Budget
Auto-inject ranked chunks under a token budget. Extractive, diversity-aware summarization.
Relevance & Temporal
Decay, mark-noise, and revalidate - so stale knowledge fades instead of being deleted.
Documents & Revisions
Read any document or chunk, list and audit the corpus, and reconcile contradictions across revisions.
Sessions & Decisions
Wrap up a session, record decisions, promote episodic notes, and synthesize a topic across sources.
Vaults
Create, switch, rename, archive, and report on isolated vaults - each with its own indexes and graph.
Custom Tools
Install and run your own tools in a sandbox: read-only vault access, no host environment, no network.
WAL & Compaction
A write-ahead log with durable stages and compaction - immutable and auditable by design.
Infrastructure
Object storage behind one connection string - a bundled local store, your own S3, or Azure. Local or cloud, your choice.
System
Health, status, and license info - role, storage reachability, pending jobs, generations.
Admin
Operator surface: vault overview, ingest jobs, worker nodes, leases, index generations.
Call immutlex in-process from Python
No MCP transport, no separate server to dial. The wheel is the daemon's Rust core (UniFFI), in your process.
client = ImmutlexClient.open("immutlex.toml", "default")
ctx = client.inject_substrate(prompt, max_chars=4096,
mode=InjectMode.RECALL)
# prepend ctx to your model call - every tool
# the daemon exposes is a typed method here
- Per-platform wheels for Linux, macOS, and Windows (x86_64 + arm64), built from the same Rust source as the server.
- The wheel rides along inside your gated download - install.sh (Linux/macOS) and install.ps1 (Windows) pip-install it automatically.
- Loads your license at runtime from the same place the daemon does. No separate setup, nothing on public PyPI.
- Durable fire-and-forget ingest with an on-disk queue, typed health for monitoring loops, per-writer attribution.
Own your data. Pay for the intelligence, not per seat.
No per-seat pricing, ever. You pay for what immutlex processes and stores for you - documents ingested and storage used. Two numbers you already know, scaling linearly.
One VPS you manage. No cloud account required.
The full system on a single box you control, with bundled storage. Everything runs local; nothing phones out. The fastest way to put a durable memory in front of your agents.
Introductory rate while we onboard early teams - the Pro price may rise as immutlex matures. Prefer a pilot first?
Same single-box simplicity, room to grow.
For teams pushing past Pro's limits. More documents and storage included, and a lower overage rate when you spill over - so growing costs less, not more.
Introductory rate while we onboard early teams - the Pro Plus price may rise as immutlex matures.
Base by capacity, plus usage - no per-seat pricing. Deploy Managed (your corpus on immutlex-operated storage, no cloud account to stand up) or Hybrid (compute we operate, documents stay in your own S3 or ADLS and never leave your cloud - the compliance path for banking, healthcare, and manufacturing).
Prices above are Managed (your corpus on immutlex-operated storage) and subscribe directly. Hybrid (documents stay in your own S3 or ADLS) is a guided setup - talk to us. Enterprise overage $4 / GB/mo and $8 / 1K docs. Need more than 500 GB or 500K docs a month? Contact us for custom pricing.
Run it fully air-gapped. Nothing leaves your walls.
Deploy immutlex end to end inside your own environment: your infrastructure, your network, your data. No shared infra, no hybrid dependency, no inbound or outbound connection required - the models run in-binary, so a fully air-gapped install works with zero network at inference time. Built and priced for your org, your compliance posture, and your scale.
Standalone tools. One thing in common: clean markdown.
These are independent tools - each useful entirely on its own, each one an MCP server your agent can call (codino and fsgdb ship a CLI too). What ties them to immutlex is not a dependency, it's a format: every one of them emits plain .md - and codino and fsgdb emit it already linked, with frontmatter and back-and-forward [[wikilinks]], so it lands in the graph fully formed. Use them with immutlex, use them without it. The markdown goes wherever you want.
Ingest any website
The doc your agent needs is a web page buried in nav, ads, share widgets, and chrome. Point defuddle-rs at the URL and it keeps the article, drops the rest, and hands back clean markdown - ready to drop into immutlex or anything else that reads .md. One page or a whole capture flow.
Clean-room Rust defuddle - the same parser ships as a crate, MCP server, Python package, browser extension, and WASM. MIT, free. View on GitHub
Teach your agent how the codebase actually works
Your agent can write code but doesn't know what calls what, what breaks if it changes a function, or which tests cover it. fsgdb maps the real structure of your repo - call graphs, blast radius, dead code, coverage, git history - and dumps it as plain markdown, ready to drop into immutlex or read anywhere your agent already looks. Scan once, re-scan whenever the code moves.
Local tree-sitter parsing into a full Cypher graph database over the Bolt protocol. 34 MCP tools; exports the graph as immutlex-compatible linked markdown - frontmatter plus a workspace index that cross-links every module. Explore fsgdb ->
$69 / mo - flat Get fsgdb ->
Give last week's conversation back to your agent
Every hard problem your agent already solved is sitting in a Claude Code, Codex, or Copilot session log - and forgotten the moment the window closed. codino reads those logs where the tools already keep them, finds the threads worth keeping, and turns them into markdown your agent can ask again. The work you already paid for stops evaporating.
Hybrid retrieval over any SQLite or JSONL: SQLite FTS5 lexical + DuckDB HNSW semantic, fused with RRF. Exports interlinked wiki markdown - YAML frontmatter, bidirectional [[wikilinks]], no dangling. Source stays read-only. Explore codino ->
$19 / mo - flat Buy codino ->
Local-first and zero-telemetry, same as immutlex - but they stand alone. defuddle-rs is open source; codino ($19/mo) and fsgdb ($69/mo) are flat-priced and pair naturally with any plan, no coupling required. Ask us which ones fit your stack.
fsgdb is not just an add-on.
Code intelligence for AI agents, a graph database for everything else. fsgdb parses your repo into a full Cypher graph - call paths, blast radius, dead code, test coverage, git history, even data lineage - then serves it to your agent over MCP and to you in VS Code, the browser, a desktop app, and the CLI.
Give your agents memory.
A durable, cross-linked brain your agent reasons from instead of guessing - wiki-link graph, fused search, a full MCP toolset, all from local models in one binary.
- Point immutlex at your real documents - markdown, PDFs, CSVs, images.
- Wire auto-inject into your agent and watch the token bill and hallucinations drop.
- Run it where your agents already do: a VPS, your cloud, or a laptop.
- Vaults are unlimited, and each one is isolated - its own indexes, graph, and access rules.
- The biggest unlock is not a bigger model - it's switching from stuffing context to asking what it already knows.
- Everything runs local: no cloud dependency, no API keys, zero telemetry.
- One self-contained binary: fused lexical and semantic search, a self-building graph, local models, and a full MCP toolset, with nothing phoning out.