DEV Community: Evert

Give Your OpenClaw Agent a Brain with Hjarni

Evert — Sat, 11 Apr 2026 14:40:42 +0000

OpenClaw is impressive out of the box. You message it, it acts. It runs on your machine, connects to your tools, and works while you sleep.

But it starts from zero every time.

Your notes are in Notion. Your decisions are in Obsidian. Your playbooks are in a Google Doc you haven't opened in three months. You keep re-explaining yourself.

Hjarni is an AI-native knowledge base with a built-in MCP server. OpenClaw can query it directly. Connect them once. Your agent now has access to your notes, your folders, your tags, on demand.

What this looks like in practice

You've stored your content distribution checklist in Hjarni. You publish a new post. OpenClaw picks it up, queries your knowledge base, retrieves the checklist, and works through it: posting to dev.to, submitting to directories, queuing social. No prompting from you.

Or you've captured your go-to debugging steps for a specific error pattern. Next time the agent hits that error, it queries Hjarni first. It already knows what to try.

The agent stops being reactive. It starts being informed.

How to connect them

OpenClaw supports MCP servers natively. Add Hjarni's MCP server to your openclaw.json:

{
  "mcp": {
    "servers": [
      { "url": "https://hjarni.com/mcp" }
    ]
  }
}

Hjarni uses OAuth, so the first connection will prompt you to authorize access. See the Hjarni MCP docs for the full setup guide, or read How to Give Claude Long-Term Memory for a step-by-step walkthrough.

Why Hjarni and not just Notion or Obsidian?

Notion and Obsidian weren't designed for agent retrieval. No structured API for searching by keyword, filtering by tag, or fetching a note by title.

Hjarni exposes those operations directly through MCP. Clean tool calls. No workarounds. No fragile integrations.

No databases. No kanban boards. No page builders. Notes, folders, tags, Markdown. That's the product. The constraint is the feature.

Built for builders

Hjarni is free to start. 25 notes, full MCP access, no credit card. One connection gives your agent reusable context across workflows, sessions, and devices. Write once, you both remember.

OpenClaw gives you an agent that can act. Hjarni gives it context worth acting on.

👉 Start writing free

Karpathy's LLM Wiki is right. I just didn't want to run it locally.

Evert — Wed, 08 Apr 2026 20:16:34 +0000

Andrej Karpathy published a gist called "LLM Wiki" describing a pattern that's been bouncing around my head for a year. Instead of dumping documents into RAG and re-deriving knowledge on every query, you have an LLM agent incrementally maintain a persistent wiki of markdown files. Obsidian on one side, Claude Code on the other. The LLM does the bookkeeping. You do the thinking.

The pattern is right. I built Hjarni because I wanted to live inside it every day, and the local version kept getting in my way.

What Karpathy gets right

RAG rediscovers knowledge from scratch on every question. A maintained wiki compounds. Cross-references are already there. Contradictions have already been flagged. The synthesis tax is paid once, not on every query.

And the bottleneck isn't reading or thinking. It's bookkeeping. Updating ten pages when one new source arrives. Noticing that an article from today contradicts something you wrote three weeks ago. Humans abandon wikis because maintenance grows faster than value. LLMs don't get bored.

Where the local setup hurts

I ran the local version for months. Obsidian vault, Claude Code in a terminal, a CLAUDE.md schema, a log file, the whole thing. It works. It also has three problems that compound:

One machine, one wiki. You're at your in-laws, you remember a thing, you want to add it. Tough.

One LLM client, one island. Claude Code can edit the files. ChatGPT can't see them. Your phone's Claude app can't see them. You funnel everything through one tool because it's the only one wired in.

Sharing breaks. You can hand someone a git repo. You can't hand someone a living wiki they can query and add to from their own LLM.

None of these are dealbreakers. But friction is what kills knowledge habits, and three kinds of friction is a lot.

What Hjarni is

Hjarni is Karpathy's LLM Wiki pattern, hosted and exposed over MCP, so any LLM client can read and write to the same brain.

That's the whole pitch. Notes, containers, tags, links, wiki-style references. All the structure you'd build in Obsidian, in a hosted product that any MCP client can talk to.

Concretely: capture a thought on your phone in the Claude app, refine it later in Claude Code while you're coding, query it next week from Cursor when you need it. Same notes. Same tags. Same links. No syncing.

You don't open a Claude Code session to add a note. You talk to whatever LLM you're already in, and it writes to Hjarni. Pro plan includes seats, so two humans plus their LLMs can work out of the same brain.

What you give up vs the local pattern

Honest list:

No git history. You can update notes safely, but it's not git log. If you want branchable, diffable knowledge, run Karpathy's pattern.
No Obsidian graph view. Hjarni shows links between notes, but the gorgeous force-directed graph is an Obsidian thing. I miss it sometimes.
No filesystem. Your notes are in a database, not a folder of .md files you can grep. For some people that's a hard no. I get it.
No Dataview, no Marp, no Obsidian plugin ecosystem. You trade a marketplace for a focused product.

If those tradeoffs hurt, Karpathy's setup is genuinely the better choice. I'm not going to pretend otherwise.

Who should pick which

Run Karpathy's pattern if: you live in a terminal, you love Obsidian, you want git history, and the friction of "only on this laptop" doesn't bother you.

Use Hjarni if: you want your notes everywhere. On your phone, in Claude, in ChatGPT, in Cursor. Without thinking about syncing.

The part where we agree completely

Karpathy ends the gist with a Vannevar Bush reference that I think about a lot. Memex was always a personal, curated knowledge store with associative trails. The piece Bush couldn't solve was who does the maintenance. The answer turned out to be: not humans.

Whether you build it in markdown files or use Hjarni, the move is the same. Stop dumping documents at LLMs. Start building a brain.

That's the product I wanted for myself, so I built it.

Stop Explaining Your Codebase to Your AI Every Time

Evert — Sat, 04 Apr 2026 19:47:41 +0000

Every conversation with your AI starts the same way. "I'm building a Rails app, deployed on Hetzner, using SQLite..." You've typed this a hundred times.

Your AI is smart. But it has no memory. Every chat starts from zero. Your project context, your conventions, your past decisions — gone.

What if your AI already knew all of that?

Here are five notes that make that happen.

1. Your stack, saved once

Write one note with your tech stack, deployment setup, and conventions. Now every conversation starts with context.

Now ask: "Write a background job that syncs user data to Stripe."

Your AI reads the note. It knows it's Rails, knows you use Solid Queue, knows your conventions. No preamble needed.

2. Error fixes you'll hit again

You spend 45 minutes debugging a Kamal deploy. You find the fix. A week later, same error. You Google it again.

Save the fix instead. Next time it happens: "I'm getting a health check timeout on Kamal deploy. Have I seen this before?"

Your AI finds the fix immediately. Thirty seconds instead of forty-five minutes.

3. Architecture decisions with reasoning

You chose SQLite over Postgres. You went with Turbo instead of React. There were reasons. Three months later, you can't remember them.

Title: Why SQLite over Postgres

Single-server deployment on Hetzner. No connection pooling needed.
Litestream for backups to S3.

Simpler ops. One fewer service to manage.
Will revisit if we need read replicas or concurrent writes beyond

what WAL mode handles.

When someone asks "why not Postgres?": "Summarize our database decision and the reasoning."

Done. No digging through old Slack threads.

4. Project rules your AI follows

Every codebase has unwritten rules. Where things go. What patterns you prefer. What to avoid. Your AI doesn't know any of them — unless you write them down.

Title: Project Conventions

Service objects live in app/services/.

Use Minitest, not RSpec.
Prefer Turbo Frames over custom JS.

No background jobs unless clearly needed.

All API responses use JSON serializers.

Keep controllers thin — logic goes in models or services.

Now when you ask your AI to write code, it follows your patterns. Not generic Stack Overflow patterns.

5. Code you'll reuse anyway

Every developer has code they reuse. Config patterns. Deployment scripts. Regex that took an hour to write.

Title: Snippet — Rack::Attack rate limiting

config/initializers/rack_attack.rb

Rack::Attack.throttle("login/ip", limit: 10, period: 60) do |req|

req.ip if req.path == "/session" && req.post?

end

Next project: "Show me how I set up rate limiting last time."

Your AI finds the snippet. You paste and adapt. No digging through old repos.

How this works

Your AI can read your notes through MCP. It's a protocol that connects AI to external data. Hjarni is a note app with a built-in MCP server.

No embeddings setup. No extra system to manage. Just notes your AI can read.

Connect it in two minutes:

Sign up at hjarni.com
In Claude or ChatGPT: add https://hjarni.com/mcp as a connector
Start asking questions only your notes can answer

Free tier gives you 25 notes with full MCP access. Ten notes in, your AI stops being a stranger.

How to Give Claude Long-Term Memory

Evert — Tue, 31 Mar 2026 21:37:04 +0000

Every time you open your AI, you start over. You explain your project, your stack, the decision you made last Tuesday. Again.

You can stop doing this. In five minutes.

How it works

Hjarni is a note app your AI can read. You write notes. Your AI searches and reads them. One URL to connect.

Step 1: Create your first note

Title: Tech Stack

Rails 8 + SQLite.
Deployed on Hetzner via Kamal.
MCP server built into the app.
Tailwind + Turbo, no React.
Solid Queue for background jobs.

Step 2: Connect to Claude

Go to Settings. Find Connectors. Add a custom connector.

Name it "Hjarni" and paste https://hjarni.com/mcp as the URL. Done.

Step 3: Ask Claude something

Start a new conversation. Don't paste any context. Just ask something only your notes would know.

"Write me a pitch based on what you know about my product."

Claude searches your notes. Finds the answer. No copy-pasting.

What to save next

If you've typed it twice, save it. Project context. Decisions and their reasons. Research conclusions.

Every note you add makes the next conversation better. Ten notes in, you just talk to your AI like it's been on your team all along.

The free tier gives you 25 notes with full MCP access. No credit card.

👉 Start writing free

Works with Claude and ChatGPT today.

Your AI Hit Its Limit. Your Knowledge Shouldn't.

Evert — Fri, 27 Mar 2026 13:38:47 +0000

Every AI conversation eventually resets.

Claude runs out of messages. ChatGPT loses the thread after enough back-and-forth. Context windows fill up. It doesn't matter which model you use — at some point, you're back at a blank prompt.

That's mildly annoying. But the real cost is something else.

The limit isn't the problem

Message limits and context windows are a fact of life with LLMs. Every provider has them. They'll keep improving, and workarounds like auto-summarization help.

But here's the thing that doesn't go away: every time a conversation resets, you lose the context you built up. The decisions you talked through. The research you explained. The background you gave.

And then you re-explain it. Again.

It's not catastrophic. It's a tax. Ten minutes here. Fifteen there. A slow bleed of time and attention, every single day.

This isn't a rate limit problem. It's a storage problem.

Think about your last week of AI conversations. Research you did. Decisions you made. Things you figured out together.

Where is it now?

Locked in chat history. Unsearchable. Unstructured. Gone the moment you start a new session.

Every time you re-explain your project, restate your constraints, or rebuild context from scratch — you're paying that tax. Not because your AI forgot. Because you never captured what mattered in a reusable way.

You're not running out of messages. You're running out of a place to put your knowledge.

The fix isn't a bigger plan

More messages, bigger context window, pricier subscription — that only delays the problem. You're still building knowledge inside a system that doesn't belong to you. When the reset eventually comes — and it always does — you're back at an empty prompt.

The answer is getting your knowledge out of the chat and into something you own. Then connecting it back.

What this looks like in practice

You write notes. Plain Markdown. Short ones. One idea per note. Research, decisions, project context, meeting notes — whatever matters.

Then you connect your notes to your AI via MCP (Model Context Protocol). MCP is an open protocol that lets AI assistants read from and write to external tools. It works with Claude, ChatGPT, and any client that supports it.

Now when you start a new conversation — even after a reset — you don't rebuild context from scratch. You ask your AI to check your notes.

"What did we decide about pricing last week?"
"What's my current project context?"
"What did I research on Tuesday?"

Your AI searches your notes. Reads them. Answers from what you've already built up.

The conversation resets. Your knowledge doesn't.

Your knowledge works with any AI

This is the part that matters more than any single provider's limits.

When your knowledge lives in a tool you own — not inside a chat window — it works with any AI. Claude, ChatGPT, a local model via Ollama. Switch providers because one raised prices, or because a better model came out. Your knowledge stays exactly where it is.

Right now, most people's "AI knowledge" is scattered across chat histories they can't search, a few pinned conversations they half-remember, and built-in memory features — a handful of bullets you can't organise. That's not a second brain. That's noise.

What to export right now

If you've been using AI heavily, you've already generated real value in those chats. Here's what's worth pulling out:

Project context. What you're building. Why you made the decisions you made. What you tried and abandoned. Every time you re-explain this in a new conversation, you're wasting 10 minutes.

Research conclusions. If your AI helped you make sense of something — save the conclusion. Not the whole chat. Just the thing you learned.

Decisions and their reasons. Something like:

Pricing decision:
Chose €9/month.
€15 created too much friction during onboarding.
Rejected yearly-only model due to conversion drop.

Future you will forget the reasoning. Your AI won't, if it's written down.

Standing instructions. Your tone preferences. Your constraints. The background you paste in every single session. Write it once.

You don't need to start with everything. Ten notes is enough to feel the difference.

You're not switching tools

This isn't "stop using AI." Your AI is excellent. That's why it's frustrating when conversations reset.

This is "stop keeping your knowledge inside the chat."

Use your AI as a thinking partner. Let it be the brilliant amnesiac it is. But the knowledge you develop through those conversations belongs somewhere you control. When the conversation ends, save what matters. The next one starts from what you already know.

Resets stop hurting when you stop losing things to them.

Try it

Any MCP-compatible note tool works for this. I built Hjarni specifically for this workflow — plain Markdown notes with a built-in MCP server, so setup is one URL. But the principle applies regardless of the tool: own your knowledge, connect it to your AI, stop re-explaining yourself.

Start with one note. Something you find yourself re-explaining every conversation. Connect it via MCP. Ask your AI to read it.

The limits will still be there. But they won't cost you anything important.

I'm Evert, a developer building Hjarni from Belgium — a note-taking app designed to work with AI via MCP. If you have questions about MCP or this workflow, I'm happy to chat in the comments.