Embeddings are opaque. The vector index returns snippets with similarity scores, but it does not show you what the agent retained, what it summarised, what it dropped. For a personal-assistant agent, "I have no idea what it actually knows about me" is a real problem. The channel's fix: stop relying on embeddings as the audit trail, and instead push a daily journal into an Obsidian vault, mirrored on GitHub, with semantic search running locally via the Smart Connections plugin.

This article is the most auditable of the three memory fixes (§5.3 embeddings, this Obsidian pattern, §5.6 Honcho). The trade-off is operational overhead — you set up an Obsidian vault, install the plugins, configure the auto-sync hook — but the payoff is that you can read exactly what the agent learned, edit it if it's wrong, and the durability is independent of any single agent install.

The source files are 41-obsidian-memory-fix.md (full) and the cross-references to U9wmg7dMWLM (the original memory-stack video) and txTowBmYXMc (the skills-vs-memory framing).

What you'll learn

  • The embeddings-only approach is opaque. You cannot see what the agent retained, edit it if it is wrong, or audit it for compliance.
  • The Obsidian vault pattern is transparent. Every daily journal is a readable markdown file in a vault you control, mirrored to a private GitHub repo, with semantic search via the Smart Connections plugin.
  • The three required Obsidian plugins are: Smart Connections (local embeddings, no API key, ~836K downloads at recording time), QMD as MD (clean journal format), and the GitHub mirror (durability independent of the agent install).
  • Discord topic-per-workflow is the channel's context-separation pattern: one topic per workflow, so the morning news brief and the deep research flow do not contaminate each other's contexts.
  • The cron timezone is a real footgun — pin it explicitly (Hong Kong time, not UTC), otherwise the morning brief fires at the wrong hour and is "a hell of an annoying thing" to debug.
  • The agent's voice converges to your voice by week 4–5 of running the Obsidian + GitHub pattern. Week 1–3 is foundation-building; the convergence is the long-term payoff.
  • Skills beat memory for repeated workflows — the Obsidian journal is for recall, skills are for action. Push recurring workflows into Skill files (§5.1 / Course 1 §1.5); reserve the Obsidian vault for preferences, decisions, and audit trail.

The black-box problem with embeddings

From 41-obsidian-memory-fix.md:

The Black Box Problem:

  • Embeddings are numbers, not readable text.
  • You can't review what's been saved.
  • Can't edit or correct stored memories.
  • Lose conversational context and nuance.
  • No way to build knowledge graphs over time.

The channel's framing is that even with embeddings enabled, you don't actually know what the agent retained — "a bunch of numbers, a bunch of vector whatever" is not auditable. For most personal-assistant use cases, that opacity is acceptable. For some — compliance, sensitive context, long-running projects with high-stakes decisions — it is not.

The Obsidian vault is the channel's answer: replace the embedding index (or supplement it) with a readable markdown journal. Every chat dumped into the vault is human-auditable, human-editable, and persists independent of the agent install.

The Obsidian + GitHub architecture

OpenClaw Memory (local)
    ↓
Obsidian (editing interface)
    ↓
GitHub (backup + version control)
    ↓
Retrieval Index (searchable)

Workflow:

  1. Agent saves to memory directory.
  2. Obsidian syncs and displays (human-readable).
  3. GitHub backs up (version control).
  4. Embeddings index (searchable, via Smart Connections or OpenClaw).

Benefits:

  • Edit memories in Obsidian (better UX than cat).
  • Version control via GitHub.
  • Backup and sync across devices.
  • Semantic search via Smart Connections or OpenClaw.

The pattern is not exclusive to OpenClaw — Hermes and Claude Code can both be configured to write daily journals to the same Obsidian vault. Combined with §5.6 Honcho for cross-platform profile sync, this is the channel's recommended multi-agent memory stack.

Step-by-step setup

Step 1 — install Obsidian. Download and install Obsidian — a markdown-based knowledge management tool.

Step 2 — install the required plugins.

Plugin 1: Smart Connections (by Brian Petro)

  • ~836,000 downloads at the time of recording.
  • Provides semantic vector search.
  • Includes local model for embeddings.
  • No API keys required.
  • Completely private.

The local-embeddings model is the critical feature: Smart Connections runs the embedding model on your machine, so there is no API key, no per-message cost, no data leaving your laptop. For users who want semantic search without paying OpenAI or trusting Honcho's hosted tier, this is the answer.

Plugin 2: QMD as MD

  • Formats notes in structured markdown.
  • Makes agent notes readable and editable.
  • Enables consistent formatting across days.

The QMD-as-MD plugin enforces a clean journal structure so the agent's daily dump is parseable, searchable, and human-readable.

Installation steps:

  1. Open Obsidian Settings.
  2. Go to Community Plugins.
  3. Browse and search for "Smart Connections."
  4. Install and enable.
  5. Repeat for "QMD as MD."

Step 3 — configure the agent to use Obsidian.

The daily journal workflow:

"At the end of each day:
1. Summarize our entire conversation
2. Mark down all topics we discussed
3. Note key decisions and preferences
4. Save as a markdown file: YYYY-MM-DD-daily-journal.md
5. Push to my Obsidian vault at: ~/Obsidian/Agent-Memory/
6. Commit to GitHub for backup"

The cron trigger for the daily journal (typically 11 PM local time) does this without manual intervention. The agent summarises the day, writes the file, commits to GitHub, and the next morning's session has the previous day's context loaded as part of its bootstrap.

Specify your timezone:

"Important: I'm in Hong Kong timezone (HKT).
All timestamps and cron jobs should use HKT, not UTC."

This is the §5.4 cron-timezone footgun. If you do not pin the timezone, OpenClaw runs the cron on UTC and the journal fires at the wrong hour — silent, annoying, hard to debug.

Step 4 — set up the GitHub backup.

Why GitHub:

  • Version control for your memory.
  • Backup in case of local data loss.
  • Sync across devices.
  • Track how your agent's understanding evolves.

Setup:

cd ~/Obsidian/Agent-Memory/
git init
git remote add origin [your-repo-url]

# Configure agent to auto-commit daily
"After saving the daily journal, commit to GitHub with:
git add .
git commit -m 'Daily journal: [date]'
git push origin main"

For continuous sync, configure an OpenClaw hook (covered in §5.3) to commit on every memory write. The GitHub mirror is the durability layer — even if the agent install is lost, the journal is recoverable.

Step 5 — create structured note templates.

Daily journal template:

---
date: YYYY-MM-DD
agent: [agent-name]
topics: [list of topics]
---