MemexLab
  • 0.2.0-harness-preview
  • Local-first
  • Markdown-native
  • Built for OpenClaw agents

The governed memory layer for AI agents.

Local-first, citable, auditable. The model is swappable — the harness is the product. Sovereign, citable memory for regulated teams — finance, legal, healthcare.

Adopt the engine → See the flagship: Memex → Read the Architecture 
# 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 →
For OpenClaw agents

Operate the vault through skills

Ingest, query, brief, and evaluate over a markdown vault — schema-governed, eval-checked, public/private-bounded.

Read the agent guide →
5
Agent skills
100%
Local-first
0
Required cloud deps (vault)
MIT
Open source

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.

How it works

Five stages, one compounding loop

  1. A

    Capture

    Inputs books, essays, conversations, research notes, market observations, strategic questions.

    Output immutable raw sources.

  2. B

    Distill

    Action the agent extracts claims, concepts, questions, references, decisions, and open loops.

    Output structured markdown notes.

  3. C

    Synthesize

    Action the wiki is incrementally maintained.

    Output durable thinking assets — maps, briefs, memos, decision records.

  4. D

    Govern

    Action schemas, permissions, validation, and public/private boundaries regulate agent actions.

    Output safe, agent-operable memory.

  5. E

    Compound

    Action useful answers and decisions are filed back into the wiki.

    Output memory that improves instead of being re-derived.

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.

The industry builds this category as 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