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

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.

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.

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 principles

Every memory becomes a node. Every claim carries evidence. Every belief has a probability. Every meeting mutates the system. Every agent is governed. Every output drives a decision.

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

    GPT / Claude / Z.ai / DeepSeek / Qwen local

  8. 8

    FIREWALL

    Six grades: personal private; Company private internal; investor-ready; regulator-safe; public content; group chat safe

  9. 9

    OUTPUT SURFACES

    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.

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 Treasury
  • Agent Black Box Recorder
  • Relationship Radar

Modes

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

Meters

  • Trust Score
  • Open Loop Severity
  • Execution Debt
  • Belief Drift
  • Network Perceptron Score (NPS)

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.

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