MemexLab
  • 0.2.0-harness-preview
  • Local-first
  • Markdown-native
  • Your mind is not a vault

A sovereign operating system.

Personal intelligence OS for a founder-operator. The governed memory layer for AI agents.

Local-first, citable, auditable. The model is swappable — the harness is the product.

You can outsource your thinking. You can’t outsource your understanding.

Adopt the engine → See the flagship: Memex → Give your agent memory in 10 min → 
# the compounding loop
raw sources  →  markdown wiki
markdown wiki →  schemas
schemas      →  skills
skills       →  evals
evals        →  governed agent operations
# useful answers file back into the wiki
answers      ↺  markdown wiki
Sources stay immutable; knowledge compounds in markdown the agent can read, cite, and govern.
For humans

Operate a durable knowledge vault

Capture, distill, and synthesize raw inputs into governed, citable markdown you own — no cloud, no lock-in.

See how it works →
8
Agent skills
100%
Local-first
0
Required cloud deps (vault)
MIT
Open source

Start here

Give your agent memory in 10 minutes

memexlab-mcp is a small MCP server that gives Claude Code, Claude Desktop, or Cursor governed, citable, local memory over any folder of markdown. One command. No account, no cloud, no index to maintain — the vault stays on your disk.

search_vault

Deterministic, citable retrieval. Every hit comes back as a [[slug]] you can open and verify yourself — no embeddings, no opaque ranking.

read_note

Reads a note verbatim off disk. Nothing is summarised, compressed, or silently rewritten on the way to the model.

capture_note

New notes land only in inbox/, with provenance frontmatter, and every write is appended to a JSONL audit log.

The boundary The canonical layer cannot be modified by the agent. Memory it can use; memory it cannot corrupt.

memexlab-mcp README → See every module →

The problem

Most AI memory cannot be inspected, cited, or corrected

Strategic knowledge work needs memory that can be inspected, cited, corrected, evaluated, and compounded. Most systems on offer are none of those things:

  • Transient chat history — context evaporates between sessions.
  • Document dumps — everything is kept, nothing is curated.
  • Opaque vector stores — you cannot read, audit, or correct what was retrieved.
  • Note-taking themes — styling over a folder, with no operating model.
  • Brittle RAG demos — impressive once, unreliable under real use.

“Strategic knowledge work needs memory that can be inspected, cited, corrected, evaluated, and compounded.”

What it is

A harnessed memory operating system

MemexLab is not a dumping ground, an Obsidian theme, or a vector database demo. It is a harnessed memory operating system: a compounding knowledge system an agent can read, cite, evaluate, govern, and operate.

It applies harness engineering to memory — reliability comes from the scaffolding around the model (context, tools, verification, observability, governance), not the prompt. The model is swappable; the harness is the product.

Raw sources stay immutable

Ingested text is preserved verbatim as the reproducibility anchor. Nothing rewrites the record.

Durable knowledge lives as markdown

The canonical layer is atomic, linked markdown — portable plain text you own, with no lock-in.

Agents operate through explicit skills

Every transformation is a named, reviewable operation — not an opaque end-to-end guess.

Schemas define repeatable assets

Frontmatter schemas make briefs, memos, and notes structured and validatable.

Evals and validation protect quality

Rule-based lint and evaluation checks catch broken links, missing provenance, and drift.

Governance controls what can change

Read, write, share, and promote are explicit actions — bounded by a public/private vault boundary.

The product

Memex Mark 1 Operating Core

The Mark 1 Operating Core is the locked product: Graph + Evidence + Belief + Action + Governance.

Graph

The vault layer — your markdown wiki, linked and citable.

Evidence

Field-state tracking — not tracked | tracked but unavailable | available but needs owner approval | definition unresolved.

Belief

Every claim carries a probability. Every belief has evidence.

Action

Decision ledger, approval workflow, and postmortem capture.

Governance

Six-grade firewall, agent write boundaries, and audit logs.

Philosophy

The six laws

Non-negotiable. Every design decision in Mark 1 is downstream of these.

  1. I

    Every memory becomes a node.

    Nothing is captured without an owner and a place in the graph.

  2. II

    Every claim carries evidence.

    A document, a transcript, or a live metric — or it is not a claim.

  3. III

    Every belief has a probability.

    Confidence is written down, so it can be revised instead of forgotten.

  4. IV

    Every meeting mutates the system.

    Conversations change state. If nothing moved, it was not a meeting.

  5. V

    Every agent is governed.

    Scoped access, explicit approval, an audit trail behind every write.

  6. VI

    Every output drives a decision.

    Briefs that do not change what you do are noise with better formatting.

How it works

One run loop

Capture → Classify → Link → Pressure-test → Act → Learn. No deploy.

  1. 1

    Capture

    Action ingest raw sources — books, essays, conversations, observations.

    Output immutable sources with provenance.

  2. 2

    Classify

    Action extract claims, tag evidence state, assign belief probabilities.

    Output structured markdown with metadata.

  3. 3

    Link

    Action connect related nodes, surface contradictions, build maps.

    Output a graph the agent can traverse.

  4. 4

    Pressure-test

    Action run counter-thesis, check citations, validate schemas.

    Output quality report and flagged contradictions.

  5. 5

    Act

    Action produce briefs, decisions, and recommendations with approval workflow.

    Output decision records and action items.

  6. 6

    Learn

    Action file outcomes back into the graph; update belief probabilities.

    Output memory that compounds instead of being re-derived.

The stack

Nine layers

The Mark 1 Operating Core is built on nine layers — from identity to output surfaces.

  1. 1

    CORE / IDENTITY

    Quartet SOUL.md, USER.md, MEMORY.md, tekmen_memex

  2. 2

    VAULT / GRAPH

    Markdown wiki with atomic, linked notes

  3. 3

    EVIDENCE / REALITY

    Field-state: not tracked | tracked but unavailable | available but needs owner approval | definition unresolved

  4. 4

    JUDGMENT / BELIEF

    Probabilistic claims with confidence scores

  5. 5

    ACTION / APPROVAL

    Decision ledger, risk assessment, postmortem capture

  6. 6

    AGENT RUNTIME

    Seven agents: Archivist, Analyst, Skeptic, Decision, Relationship, Strategic Watch, Chief-of-Staff

  7. 7

    MODEL ROUTER

    Local private · zero usage cost — the default path

    Frontier hard tasks only, opt in per task — Claude / GPT / Gemini / Z.ai / DeepSeek / Qwen

  8. 8

    FIREWALL

    Private side ── only the prompt crosses ── public side

    Six grades personal private · company private internal · investor-ready · regulator-safe · public content · group-chat safe

  9. 9

    OUTPUT SURFACES

    Surfaces dashboard · mobile capture · documents · email dispatch · apps / API

    Artifacts briefs, memos, decision records, disclosure packages

Sovereignty

You own

Local runtime

No cloud dependencies for the vault. Runs on your machine, your disk, your rules.

Markdown filesystem

Plain text you can read, grep, version, and own forever — no proprietary format.

Models are swappable. Memory is not.

The harness is the product. Switch models with one environment variable.

Privacy by architecture

GDPR-compatible by design. The vault never leaves your machine unless you publish it.

Technology / model

What it actually runs on

Mark 1 runs on your machine. Frontier models are optional and opted into per task — they never see the vault, only the prompt you send them.

Local runtime

Apple Silicon · macOS 14+ · 8 GB+ · works offline.

Sovereign storage

Plain markdown vault · local index · knowledge graph · no account · no telemetry.

Local LLM

Fully on-device · zero usage cost · private by default.

Frontier via API

Claude · GPT · Gemini. Bring your own key, opt in per task — only the prompt is sent.

Model router

Local for private work, frontier for hard problems. Models are swappable; memory is not.

Open-source core

The MemexLab Engine — inspectable, extensible, MIT-licensed.

Security boundary

Firewall · public/private isolation · privacy by architecture · GDPR-compatible by design.

Roadmap

Under development

Not shipped The following compilers, modes, and meters are being developed and validated. They are not yet available in the current release.

Compilers

  • Belief Compiler
  • Evidence Compiler
  • Disclosure Compiler
  • Model Tester
  • Agent Builder
  • Relationship Engine

Modes

  • War Room
  • Board
  • Regulator
  • Investor
  • Founder Mirror

Meters

  • Trust Score
  • Open Loop Severity
  • Execution Debt
  • Belief Drift
  • Network Perception Score

Agent Runtime

Seven agents

The Mark 1 Operating Core runs seven specialized agents, each with a clear mandate.

Archivist

Schema enforcement and link hygiene — keeps the graph valid and traversable.

Analyst

Synthesis and brief generation — assembles positions from the graph.

Skeptic

Counter-thesis and contradiction detection — pressure-tests every claim.

Decision

Decision ledger, risk assessment, and postmortem capture — keeps the record.

Relationship

Network activation and relationship mapping — who knows what, who needs to know.

Strategic Watch

Watches the world — market signals, competitor moves, regulatory shifts.

Chief-of-Staff

Agenda setting, decision coordination, and action tracking — the orchestrator.

The engine underneath

Thirteen modules. Every one a folder you can read.

Mark 1 is the product. MemexLab Engine is the open-source core it runs on — MIT, local-first, nothing to sign up for. There is no black box here: every module below is a directory in one public repository, and you can delete any of them and still own your vault.

memexlab-mcp

An MCP server that hands Claude Code, Claude Desktop, or Cursor governed, citable memory over a local markdown folder.

Ships search_vault · read_note · capture_note, inbox-only writes, JSONL audit log.

Try it claude mcp add memexlab -- uvx memexlab-mcp --vault ~/vault

memex-cli

The memex command line — built ingest-spine first. Captures a public page into inbox/ as readable markdown with provenance.

Ships memex ingest url — dry-run by default, idempotent, no model involved.

Try it uvx --from "git+…#subdirectory=memex-cli" memex --help

runner/

A self-hosted reference agent: a minimal local loop that operates a vault through the skills, with a provider-agnostic backend.

Ships local model or hosted API behind one env var; path-escape-guarded vault access.

Try it python3 runner/agent.py --dry-run --vault examples/fake-vault — no key needed.

skills/

Eight Agent Skills — the named, reviewable operations an agent performs over the vault. No opaque end-to-end guessing.

Ships memex-ingest · memex-extract · memex-markdown · memex-query · memex-brief · memex-evaluate · memex-frameworks · memex-progress.

Why every transformation has a name, an input, an output, and a review surface.

frameworks/

A library of mental-model lenses the agent can apply deliberately, instead of defaulting to whatever the model feels like.

Ships first-principles · inversion · second-order effects · base rates · incentives, plus the five-problem latticework.

Why pressure-testing is a procedure, not a personality trait.

schemas/

The frontmatter contract. entity.schema.json defines what counts as a valid note before anything downstream trusts it.

Ships a JSON Schema you can validate any vault against.

Why structure that is enforced beats structure that is merely encouraged.

evals/

Quality is measured, not asserted. A sample query set and a written rubric let you regression-test retrieval and synthesis.

Ships query-set.sample.yml · rubric.md.

Why you can tell whether a change to the harness made answers better or worse.

templates/

Note templates that keep the vault consistent across years of capture, so the graph stays traversable.

Ships item · source · state.

Why consistency is what makes a decade-old note still legible to an agent.

governance.yml

The write and publish policy in one readable file: what an agent may touch, and where the public/private boundary sits.

Ships declarative write scopes and the promotion rules for the public vault.

Why governance you can diff in a pull request beats governance in a settings panel.

examples/

A synthetic vault to run everything against safely, and a complete worked pass over real public sources.

Ships fake-vault/ · worked-example/ (ingest → extract → frameworks → progress).

Why you can evaluate the system before pointing it at anything of your own.

library/

A growing collection of distilled knowledge assets the pipeline itself produced — papers, reports, and books.

Ships the corpus plus build_library_index.py, which rebuilds the index from disk.

Why the output of the system, published — so you can judge it on the work, not the pitch.

scripts/

The deterministic tooling around the vault: validation, readiness checks, benchmarks, and non-web ingest.

Ships validate_vault.py · readiness_check.py · run_benchmark.py · ingest_ics.py · ingest_transcript.py · build_llms_txt.py.

Try it python3 scripts/validate_vault.py examples/fake-vault

docs/

The full documentation set, versioned next to the code it describes — fifteen chapters plus the engineering reference.

Ships overview · architecture · core concepts · daily workflow · metadata rules · user modes · maintenance · FAQ, plus harness, observability, governance, taxonomy, benchmarks, roadmap and lineage.

Try it mkdocs serve, or read it at btekmen.github.io/memexlab-engine.

Interop The skills follow the Agent Skills spec, so they install alongside kepano/obsidian-skills: those handle the file layer, MemexLab handles the knowledge layer.

Browse the engine on GitHub → Read the documentation →

MemexLab skills

Explicit, reviewable operations over the vault

A skill is a named operation the agent performs over the vault. Each reads from immutable sources and the markdown wiki, writes a schema-shaped artifact, and leaves a reviewable trail. Skill availability and maturity vary in this preview — see the preview status.

Source ingestion

Promotes captured material into immutable raw sources with citation metadata.

Artifact a raw source note with provenance fields.

Why every downstream claim can be traced to where it came from.

Claim extraction

Cuts a long source into candidate atomic notes — one claim or concept each.

Artifact proposed atomic markdown notes for review.

Why atomicity makes knowledge re-linkable without cascading rewrites.

Concept map

Builds a reading order or concept map across a topic from existing notes.

Artifact a structured index linking related notes.

Why surfaces the shape of a domain and the gaps still open in it.

Strategic brief

Assembles a position on a topic from the canonical layer, with citations.

Artifact a brief that links back to its source notes.

Why a position developed over months is not re-derived from scratch.

Decision memo

Captures a decision, its rationale, alternatives, and the open loops it leaves.

Artifact a durable decision record in the vault.

Why decisions become inspectable history, not lost context.

Research synthesis

Answers a question by retrieving over the wiki and citing the notes used.

Artifact a cited Q&A note, fileable back into memory.

Why answers are auditable and compound instead of evaporating.

Market observation

Logs a market or domain observation as a dated, linkable note.

Artifact an observation note tied to relevant entities.

Why weak signals accumulate into a durable, searchable record.

Public/private vault governance

Enforces what may be read, written, shared, or promoted across the vault boundary.

Artifact governed promotion and publishing actions.

Why private material is not leaked into shareable output by accident.

Citation and provenance

Attaches and checks source links and cited-slug references on every artifact.

Artifact provenance fields the agent and human can verify.

Why citable memory is the difference between knowledge and a guess.

Evaluation and validation

Runs rule-based checks for schema conformance, broken links, and missing provenance.

Artifact a validation report; failures block the run.

Why quality is enforced by the system, not by good intentions.

The OpenClaw layer

OpenClaw gives the agent hands. MemexLab gives it a governed long-term mind.

OpenClaw provides the agent runtime and assistant surface. MemexLab provides the durable memory and knowledge operating layer: a markdown-native vault an agent can read, cite, evaluate, govern, and improve.

Preview OpenClaw skill packaging is experimental in this release. The integration is described here at the product level; concrete packaging and runtime bindings are being validated and may change before a stable release.

Architecture

A system you can read end to end

Information flows top-to-bottom: raw sources stay immutable, skills read from sources and the vault, schemas define what counts as a valid artifact, evaluators check quality, and governance controls access and promotion. The agent runtime operates over all of it — and answers can be filed back into the vault.

  • Raw sources remain immutable and are never rewritten.
  • Skills read from sources and the vault; schemas define valid artifacts.
  • Evaluators check quality and consistency before anything is trusted.
  • Governance controls access and promotion across the public/private boundary.
  • The agent runtime operates over the system; answers can be filed back in.

Eight layers. Three primitives.

Mark 1 describes nine product layers, from identity to output surfaces. The infrastructure underneath is where the industry builds an eight-layer stack — capture, canonical store, processing, indexes, knowledge, experience, agent surface, governance — and every layer needs their server. MemexLab answers all eight, collapsed onto three primitives you can read, grep, and version. No layer needs a cloud.

Capture Canonical store Processing Index Knowledge Experience Agent surface Governance
Markdown vault + gitcanonical store · knowledge layer · immutable originals · full history
Deterministic engine + skillscompile · qa · lint · saved views · MCP — every index a rebuildable cache
Governance boundaryinbox-only agent writes · JSONL audit log · nothing leaves the machine

Same completeness, radically less machinery — see the honest comparison.

Use cases

Where durable, governed memory pays off

Strategic learning

Turn books and essays into a linked, citable body of knowledge that compounds.

Market & investment research

Synthesize observations and sources into positions you can defend and revisit.

Founder operating brain

Keep decisions, rationale, and open loops in one inspectable, governed place.

Research assistant for complex domains

Answer hard questions over your own corpus, with citations, not a generic model.

Decision support

Bring structure to ambiguous strategic questions with evidence and provenance.

Compounding personal knowledge base

A vault that improves over a decade instead of being re-derived each year.

Public writing pipeline

Move from private notes to shareable artifacts through a governed boundary.

Design-partner program

Regulated team? Run a Sovereign Memory Pilot.

4–6 weeks, on your machines, zero data out. Free — we run at most two pilots at a time.

See the pilot →

Run it yourself

A self-hosted agent you can run today

MemexLab ships a small, runnable reference agent. It treats a markdown vault as its workspace, loads the skills as capabilities, and reasons with either a local model or a hosted API — switchable with one environment variable. It runs on your own machine and pairs with Obsidian as the editor.

Local or hosted

One env var (MEMEX_PROVIDER) flips between a local model (Ollama, vLLM, LM Studio) and a hosted API (Anthropic, OpenAI). Same code path.

Vault as workspace

The agent reads and writes only inside the vault you point it at — path-escape guarded, plain markdown on disk.

Obsidian + terminal

Open the same folder in Obsidian; drive the agent from a terminal. No sync layer in between.

The runner is a minimal, runtime-agnostic loop; OpenClaw remains the full agent surface for the same skills and vault. Browse the distilled library of knowledge assets (papers, reports, books) the pipeline produces.

View the runner → Self-hosting guide →

Open-source showcase

See what agents are building — and share your own

The Showcase is a community gallery of real-world MemexLab developments and best cases from around the world. Browse the patterns others have built, then submit yours via a GitHub issue or pull request — no backend, no gatekeeping.

Browse the Showcase Submit a case

Candid scope

What this is not

  • Not a generic chatbot.
  • Not an Obsidian theme.
  • Not a vector database demo.
  • Not a cloud-first second brain.
  • Not an unsupervised autonomous agent.
  • Not a replacement for judgment.

This is a harnessed memory operating system for agents that need durable, inspectable, governed knowledge — with a human as the final reviewer.

Intellectual lineage

References and gratitude

This project stands on ideas others developed and shared. It is not affiliated with, endorsed, or sponsored by any of the people or projects below unless otherwise stated — they are inspirations and references.

Andrej Karpathy — LLM Knowledge Bases & LLM Wiki

The foundational pattern: raw sources remain immutable, an LLM incrementally maintains a persistent markdown wiki, and useful answers are filed back into the wiki so knowledge compounds instead of being re-derived from scratch.

LLM Knowledge Bases thread → LLM Wiki gist →

Vannevar Bush — the original Memex (1945)

Karpathy connects the pattern back to Bush's 1945 vision of the Memex: a private, actively curated knowledge store organized around associative trails between documents — closer to this project than to what the web became. The missing maintenance layer is what the LLM now supplies.

“As We May Think” →

Garry Tan — GStack & GBrain

Thanks to Garry Tan for developing and sharing GStack and GBrain, which are major references for the agent-workflow and brain-layer aspects of this project.

GStack → GBrain →

Peter Steinberger — OpenClaw

Thanks to Peter Steinberger for creating and open-sourcing OpenClaw, the agent runtime this project pairs with by default. OpenClaw gives the agent hands; MemexLab gives it a governed long-term mind.

steipete.me → OpenClaw →

Steph Ango (kepano) — Obsidian & File over app

Thanks to Steph Ango for Obsidian and the “File over app” philosophy this project's plain-markdown ethos follows, and for obsidian-skills — the MIT Agent Skills library the engine pairs with for the vault and file layer.

File over app → obsidian-skills →

Status

0.2.0-harness-preview

This is an early harness preview. It is not production-stable. The release is focused on validating the foundations:

Validating now

  • Agent-operable markdown memory
  • Skill workflows
  • Schema-governed artifacts
  • Eval loops
  • Validation
  • Public/private vault boundaries

Roadmap

  • More MemexLab skills
  • Stronger validation and eval harnesses
  • Better public/private publishing workflows
  • OpenClaw skill packaging
  • More example vaults
  • Benchmarks for synthesis quality and citation integrity