The Exomind

A durable technical knowledge base gives an agent somewhere to recover decisions, evidence and constraints after a conversation ends. The goal is continuity: the next investigation should begin with relevant source material rather than a reconstruction from memory.

This blueprint separates source preservation, curated knowledge, retrieval and maintenance. It applies to an authorized engineering archive and does not rely on a private ingestion history or claims of perfect recall.

Separate sources, knowledge and tools

Keep original material in a source layer with its provenance and access requirements. Store reviewed summaries, decisions and technical notes in a curated layer. Keep the scripts that transform or retrieve those materials in a third location.

knowledge-project/
  sources/       # authorized originals and source inventory
  content/       # reviewed technical notes and decisions
    overview.md
    architecture/
    decisions/
    research/
  tools/         # ingestion, checking and maintenance
  CLAUDE.md      # routing and workflow instructions

The names are illustrative. The important boundary is ownership: which files are originals, which are derived, and which process may change them. A folder name communicates that boundary but does not enforce it.

Use a short overview for navigation and durable rules. Keep detailed evidence in focused documents with stable references. Do not claim an overview is automatically loaded merely because the file exists; configure the relevant client or explicitly open it.

Refactor by meaning and verify preservation

Split a large document where a coherent topic or record boundary exists. Keep the original available while reviewing the result. Preserve source references, dates and relationships that make an extracted section intelligible.

For structured exports, define a stable record identifier and compare both identifiers and normalized content before and after transformation. Equal record counts cannot prove zero loss: duplicated, truncated or altered records may leave the count unchanged.

For documents with a text layer, inspect extraction quality against the original. For scans or audiovisual sources, identify whether OCR or transcription has occurred and what remains unprocessed. An inventory entry is not the contents of the source.

When several agents ingest material, assign nonoverlapping ownership where possible and reconcile edits before integration. Each derived claim should retain a link to supporting evidence. Disagreement belongs in the record rather than being silently averaged into a summary.

Make a small authorized collection retrievable

QMD provides local keyword, vector and reranked retrieval for document collections. The current upstream quick start uses the @tobilu/qmd package. This article’s commands are a small starting example; review the installed version and collection configuration before running maintenance.

npm install -g @tobilu/qmd
qmd collection add ./content --name technical-content
qmd update && qmd embed
qmd query "Why was this architecture selected?" -c technical-content

Run the example only against a collection you are authorized to index. The update command can execute configured collection update hooks, so inspect imported configuration instead of treating all indexing as a passive read.

Evaluate retrieval with representative questions whose expected sources are known. Include exact terminology, synonyms, ambiguous questions and questions with no supporting evidence. Inspect the returned passages and the final answer separately.

Local retrieval describes where that component runs. If retrieved text is then supplied to a cloud model, it leaves the machine through that model request. Account policy, model endpoint, logs and connected tools remain part of the data-flow assessment.

Collection names are not access controls

A collection filter scopes a query. It is not a confidentiality boundary if the same client can remove the filter or query another collection. Do not combine differently authorized material merely because one daemon can index it.

Use an access architecture that enforces the required boundary: appropriately separated processes, indexes, operating-system permissions or an authenticated retrieval service. Decide which identity can read each source and ensure derived summaries do not broaden that audience.

Cross-project retrieval is useful only where the caller is authorized for all returned material. Keep organizational knowledge in approved storage and keep personal workflow configuration outside repositories that should not contain it.

Operate retrieval as a service when useful

A persistent process can avoid repeated startup work. On a managed workstation, use an appropriate supervisor with explicit executable paths, an intended bind address and observable logs. Measure the benefit before adding another service.

An HTTP endpoint responding is only one health signal. Also check the client’s MCP connection and an authorized retrieval against a known source. A successful CLI status command does not prove that the daemon, index freshness and embeddings are all healthy.

Document the supported start, stop and recovery procedures. After changing the executable or its runtime dependencies, verify which version the running process uses. A supervisor restart policy improves availability but does not mean a service will run forever without inspection.

Serialize maintenance and preserve failures

Index updates and embedding should have a single owner for a shared index. A commit hook can request maintenance, but it should not launch an independent database writer every time a repository changes.

Use a durable queue or pending marker and a lock shared by all writers, including upgrade jobs. Acquire ownership before running update. Run embedding only after update succeeds. Record the exact job result and keep pending work when a required step fails.

If another change arrives while a job runs, retain it for another pass; do not clear a newer request when acknowledging an older one. Make the last successful completion and the most recent failure distinguishable.

How the queue and lock are implemented depends on the operating system and deployment. A few background shell lines do not establish those guarantees. Test overlapping requests, failed updates and interrupted jobs in an isolated environment before trusting the automation.

Upgrade deliberately

Automatic nightly upgrades are one possible policy, not a requirement. A reviewed, pinned upgrade can be more appropriate for a workflow with compatibility constraints.

Before upgrading, record the installed version, inspect relevant changes and preserve a recoverable installation and index backup where needed. Require installation success before restarting the service. Then verify the running version, connection and representative retrieval.

If a check fails, return a failure result and preserve diagnostic evidence. Do not log the requested version as successfully running merely because installation was attempted. Clear only the failure state that the checks actually resolved.

Configure memory independently

Agent memory is distinct from the search index and shared project documentation. Claude Code’s memory documentation describes native storage and the supported autoMemoryDirectory setting. Choose the store deliberately rather than deriving a hidden directory name and replacing it with an unchecked symlink.

For an existing store, stop concurrent writers and verify backups before a separate migration step. Inspect source and destination types, preserve conflicting files, and merge deliberately. Test both a read and a write in a fresh session before retiring the previous configuration.

A symlink can be a convenience, but it is not the only portability mechanism and it does not synchronize files. Git, copying and other controlled synchronization each need their own access and conflict-handling decisions.

Give automation bounded responsibilities

Instructions can describe routing, source citation and maintenance. They do not grant permission to publish, send messages or change another repository. Keep those boundaries aligned with the user’s authorization and the owning project’s rules.

A useful agent-maintained record might capture an architecture decision, compute a release comparison from structured inputs or draft a sourced technical report. Treat exact calculations as code and narrative synthesis as something to verify.

For every output, keep the supporting originals reachable. Retrieval can miss evidence; a summary can misstate it; maintenance can fall behind. The system improves continuity when these limits remain observable, not when they are hidden behind a promise of instant perfect recall.