How to Build a Self-Updating Knowledge Base with LLM Agents

15 Jul 2026

#ai#productivity#automation#knowledgemanagement#llm

A translated and adapted piece based on Ben Holmes's breakdown of a system where AI agents automatically turn your raw notes into an organized, interconnected knowledge base — complete with tags, sources, a wiki, and live visualizations.

Note: This is an adaptation of a thread by Ben Holmes (@BHolmesDev), creator of the Markdown notes app Hubble.md, which the workflow below is built around. Original source: https://x.com/bholmesdev/status/2074499909785461170

You may have seen Andrej Karpathy talk about "LLM wikis" — a way of turning your scattered thoughts into easy-to-navigate notes, wikis, and visualizations. It's an incredibly powerful setup for researchers, developers, chaotic note-takers, and honestly, pretty much everyone.

Here's a system that gets agents to organize your "second brain" automatically:

Start taking notes in Markdown

Add an /enrich-note skill that has agents tag notes, attach sources, and create backlinks

Add a wiki skill that pulls notes together into a persistent knowledge base

Set up automations that run these skills on a schedule

Add visualizations that render straight from your notes in real time

A full video walkthrough of the setup is also available on YouTube.

Step 1. One folder of raw Markdown

We'll keep notes in Markdown so agents can access them easily. You can use Obsidian, or — if you want something friendlier, closer to Apple Notes — try Hubble.md, the app I built myself.

Following Karpathy's advice, every note you write by hand (or dictate) goes into a raw/ folder. These are raw, unfiltered thoughts that your agents will later process. Here's an example I dictated using a voice transcription tool after listening to an episode of the Acquired podcast about Ferrari.

Notice there's no metadata, no backlinks — honestly, you don't even need a title. The agent fills in all of that for you.

Step 2. The /enrich-note skill

Now let's have agents enrich these notes with details that make them searchable. I wrote a skill for this called /enrich-note. Like every skill mentioned in this piece, you can install it with a single command from the skills repository.

The skill does three things:

Tags. It maintains a shared tag registry in a tags.md file, where each tag has a one-line description. I recommend keeping source-type tags (blog, podcast, video) separate from topic and interest tags (ai-hardware, business, rust). The agent is instructed to reuse existing tags and be reluctant to invent new ones — otherwise, in my experience, agents tag way too liberally.

Sources. If a note came from somewhere specific — a podcast, a book, a video — the agent does a quick web search, finds the source URL, and writes it into the frontmatter.

Related notes. The agent scans the rest of your archive for genuinely related notes and adds them as wiki-links under a ## Related section.

This can get pricey, but it's no more expensive than handing an agent a coding task in a small-to-medium repo. I personally have hundreds of notes. If you test this on a larger archive, I'd love to hear what you learn and what optimizations you find.

After processing, that same Ferrari note from the Acquired podcast looks quite different.

Notice the enrichedAt marker. That's how the automation knows which notes have already been processed — idempotency matters once you start running this on a schedule.

Step 3. A skill for the wiki

Enriched notes are searchable, but they're still fragments. The next level is a wiki: a persistent, interlinked knowledge base that the agent builds out of your notes. This is straight from Karpathy's llm-wiki gist, which I recommend reading in full.

The core idea: ask the agent to generate an easy-to-navigate landing page around some area of interest (in my case, coding-agent techniques or religious studies). This is useful to you because it creates a browsable index of people, places, and things. But it's also useful for agents themselves when navigating questions about your own notes.

Instead of RAG-style retrieval, where the model "rediscovers" your knowledge from scratch on every query, the agent maintains a cumulative artifact — entity pages, topic summaries, an index, a changelog. As Andrej puts it: "The LLM is the programmer, and the wiki is the codebase."

To get started, paste the gist into your agent along with one sentence describing what you want. Something like:

Read this: https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f. Set up a wiki in wikis/latest-ai/ that tracks coding-agent techniques from my notes — model prompting, orchestration patterns, useful agent skills, etc. Pull in anything relevant from raw/.

The agent lays out a folder structure, writes its own AGENTS.md schema with maintenance instructions, and ingests your existing notes.

I then wrote a skill to "refresh" this wiki over time — /refresh-wiki. It looks for new or changed notes in raw/, pulls relevant ones into each wiki, updates entity and concept pages, and checks for contradictions, orphaned pages, and stale claims.

Here's a trimmed view of the index.md for my "Latest in AI" wiki. It's built from podcast and video notes over the past few months, and every entry links to a full page the agent writes and maintains.

I also keep a Bible-study wiki based on Lee Strobel's "The Case for Christ." The book is a long series of interviews with experts, so the agent built a "people" index with a page for each interviewee — who they are and what they claimed. This has been genuinely useful for revisiting arguments weeks later, since without a glossary the names all blur together for me.

Step 4. Automations

Skills are useful, but I don't want to manually rerun them every time I browse my notes or ask an agent a question. Both skills have loop variants designed to run on a schedule:

/enrich-notes-loop wraps /enrich-note and walks through all recently created notes, using enrichedAt to skip ones already processed.

/refresh-wiki walks your wikis/ folder and updates every wiki it finds. (Keep your wikis in a wikis/ folder — all of this is customizable.)

I'd suggest trying two approaches: local automations to get started, and cloud automations to make things reliable.

Local automations via Codex

There are several ways to schedule runs. One is a local automation that runs on your machine and wakes up on a cron schedule to tidy your notes folder. The Codex app offers this under its Scheduled tab. Click "Create with chat," pick the folder where your notes live, and specify the skill to run. I'd recommend a nightly run. For /enrich-notes-loop you can dial the reasoning level down, since the task is less ambiguous. For wiki generation, a higher level lets the model be more thoughtful and creative. Tune it to your needs.

Cloud automations

Local automations are the easiest to set up, but they have an obvious downside: your machine needs to be on and running for the job to complete. Codex does try to make sure scheduled jobs run even with the laptop lid closed — but when I left town for a few days, my automations stopped working because I forgot to plug in my laptop. 🤦‍♂️

oz.dev — to spin up a cloud sandbox connected to open-weight models

Obsidian Sync — to sync Markdown notes to the cloud

Obsidian's headless CLI — to access those notes programmatically from the cloud sandbox

Oz is Warp's cloud platform for hosting agents. Yes, you mostly pay for token usage, but open-weight models like Kimi k2.6 are extremely token-efficient (3-4x more efficient than Claude models) while still being solid quality.

Here's what each scheduled run looks like:

An agent uses the Obsidian CLI to pull your archive into a cloud sandbox

It runs /enrich-notes-loop or /refresh-wiki

It pushes the results back, and they sync down to your machine

I wrote two more skills to run this with the necessary cloud sandbox setup: /enrich-notes-loop-cloud and /refresh-wiki-cloud. These are thin wrappers that sync the archive down, run the base skill, and sync back up.

Setting up the environment and schedule is a handful of oz CLI commands, so I wrapped that into a skill too: /setup-oz-automations.

First, create an account: go to oz.dev and click "start an agent" — that takes you to a sign-in flow where you can create an account. Then install the skills (if you haven't already) and hand the rest off to the agent.

Run the /setup-oz-automations skill. It checks whether you have Warp's Oz platform skill installed (installing it via npx skills add warpdotdev/oz-agent-skill if not), asks for your archive name and Obsidian auth token, then sets up the environment and both schedules: a nightly note-enrichment run and a weekly wiki refresh.

Any schedule can be paused with oz schedule pause, and every run leaves behind a session transcript you can review in the Oz dashboard.

Step 5. Visualizations

So now we have a nice network of Markdown files with tags, backlinks, index pages, and deep wikis. But what if we push past plain text? Since it's all just Markdown files in one folder, an agent can build interactive HTML visualizations right on top of them.

I made a few examples you can plug into your own system, as long as your notes live in a raw/ folder:

Notes burndown — a GitHub-style activity graph showing how consistently you journal over time. I use it to build the habit of writing regularly.

Thought constellation — shows your notes as a graph clustered by your most common tags (a byproduct of /enrich-note). It's helped me spot my most-referenced notes worth revisiting, and gaps where I should focus more (apparently I need to read more...).

These can be one-off visualizations regenerated on a schedule, similar to the /enrich-note and wiki examples. But if you want them updating "live" as they read files off disk, you can view them inside Hubble.md — the Markdown notes app I mentioned earlier. It lets you view HTML apps alongside your notes and injects a runtime API for reading files in the current folder, so visualizations can update programmatically.

Just start writing

All the skills and visualizations live in this GitHub repo. To get started, just ask your agent to convert whatever notes you already have into Markdown (Apple Notes, Notion, Granola, and others all support this). Then try out some of the skills I've shared and see if they're useful to you.

Build a wiki around your next research project, hobby, or agent coding session. Come up with a new visualization and share it — I'd love to see what you build. And yes, go try oz.dev and Hubble.md :)

Resources from this article

Original source and author: Original X thread by Ben Holmes (@BHolmesDev) Hubble.md — the author's Markdown notes app

Skills (GitHub): Full skills repository /enrich-note — enriches a note with tags, sources, and links /enrich-notes-loop — batch enrichment on a schedule /refresh-wiki — updates the wiki /enrich-notes-loop-cloud — cloud version of enrichment /setup-oz-automations — sets up cloud automations in Oz

Tools and references: Andrej Karpathy's llm-wiki gist oz.dev — Warp's cloud platform for hosting agents Warp's Oz skill — install via npx skills add warpdotdev/oz-agent-skill Obsidian and Obsidian Sync — for storing and syncing Markdown notes

For AI Agents

Read with AI

Short prompt for a summary, takeaways, and applying this to your task.

ChatGPT Claude

Audio Version

Listen to This Article

Alpha version: audio generated via local TTS, errors possible.

Download MP3

Want to discuss your own task?

Tell us about the workflow you want to improve. We will help you identify the practical next step.

Request a free consultation Explore our services

Stop Hiring. Start Scaling. Deploy Your AI Digital Workforce.

Cost & Scale

Accuracy

Availability

Built for Local Entrepreneurs Like You

Chatbots & AI Assistants

Business Process Automation (n8n, Make.com)

Content Farms & AI Copywriting

Marketing Automation (email, CRM, ads)

What Our Clients Say

Your Path to Autonomous Operations

Challenge Briefing

Why Businesses Switch to AImpress

Practical products for AI-enabled work.

LocalWhisper

AImpress Learning

Recent Updates