Photo From AI

Your AI Doesn’t Remember You. OpenWiki Brains Was Built to Fix That.

Most agent memory only holds onto what you explicitly say. OpenWiki goes out and builds context on its own, from the places you already work.

Your AI assistant does not actually remember anything on its own.

It only remembers what you tell it to remember.

Ask it about something you mentioned last week and never explicitly saved, and it has no idea what you’re talking about.

Open a new conversation, and most of what it seemed to know about you is gone.

You end up re-explaining the same background, the same project, the same names over and over because the memory was never really following your world. It was just holding onto whatever you personally handed it.

And as your project scales, this becomes very inefficient.

That is not a bug.

That is the entire design, and it has been the design for years.

If you want more such information about AI, consider subscribing to my newsletter, where you will get noise-free AI information every week

Link for the newsletter: Newsletter

The memory you already have isn’t what you think it is

Photo From AI

Ask most people how AI memory works, and they’ll say something like

“It just remembers stuff about me now.”

That’s true on the surface. Underneath, it’s reactive. You said something once, the system saved it, and it plays that fact back to you later.

That works fine for simple preferences. It falls apart the moment you want an agent to actually know what’s going on in your world.

Picture two ways an agent could handle memory.

• One waits. You tell it your project name, your deadline, your client’s name, one fact at a time. Forget to mention something and the agent simply doesn’t know it. Start a new session and most of that context is gone unless you explicitly saved it somewhere.
• The other doesn’t wait. Before you say a word, it’s already looked at your recent emails, your open project notes, your latest commits, and quietly built a working understanding of what you’re doing and who matters right now.

Almost every memory system on the market today is the first kind.

OpenWiki, a new open-source project from the LangChain team, is trying to be the second.

The new-hire test

Here’s the simplest way to think about the difference, no jargon required.

Photo From AI

Imagine two new employees on their first day.

The first one shows up blank. They ask you to explain everything, every time. What’s the project called? Who’s the client? What happened last week? You end up doing the remembering for them.

The second one already skimmed the company wiki, checked recent Slack threads, and glanced at the open tickets before their first meeting. They still ask questions, but they ask better ones, because they arrived with context instead of waiting for it.

Most AI agents today are the first employee. OpenWiki is trying to build the second.

What OpenWiki actually is

Photo from Github

OpenWiki didn’t start as a memory tool.

It started as a simple, useful open-source CLI: point it at a codebase, and it writes documentation for that codebase automatically.

As the code changes, the wiki updates with it. No manual doc-writing, no stale README files. You can even wire it into your CI pipeline so it opens a pull request with the updated docs on its own, instead of relying on someone to remember to run it by hand.

That’s the part that’s already been out for a while.

The new part, version 0.1.0, takes the same idea and turns it toward something bigger: a personal memory system for AI agents.

It works through what the project calls connectors.

You link OpenWiki to the sources you already use- Gmail, Notion, your Git repositories, X, Hacker News, or web search- and during setup, you tell it what to actually focus on.

Not everything, just what matters to you: active projects, research topics, people you’re working with, whatever you choose.

From there, it runs on its own. It pulls in relevant material from those sources and quietly assembles a local wiki, a structured, ever-updating file of what’s actually going on in your world.

When an agent needs context, it reads from that wiki instead of asking you to repeat yourself.

A LangChain team member summed up the whole idea in one line: agent memory has always been reactive. OpenWiki is trying to make it proactive.

How it actually builds the wiki

The mechanism is simpler than it sounds, and worth understanding in plain terms if you’re going to trust it with real context.

Each connector runs in two steps:

• First, it pulls raw data straight from the source- an email, a document, a commit, and writes it down exactly as it found it.
• Second, a separate process reads that raw material and synthesizes it into the actual wiki: organized, summarized, and structured so an agent can use it quickly.

Photo From AI

You can run all your connectors at once, or just one at a time, and you can connect the same type of source more than once.

Track two separate research areas through two separate web searches, for instance, and OpenWiki keeps them as distinct entries rather than mixing them.

Here’s roughly what it looks like to actually read that wiki into your own agent’s context, once it exists:

from pathlib import Path

def load_openwiki_context(topic: str) -> str:
    wiki_path = Path.home() / ".openwiki" / "wiki" / f"{topic}.md"
    if wiki_path.exists():
        return wiki_path.read_text()

    return ""  # nothing built yet for this topic
# Feed it into your agent's system prompt alongside the user's message
context = load_openwiki_context("active-projects")
system_prompt = f"Relevant background:\n{context}\n\nNow help with the user's request."

Nothing exotic. A file gets written to disk, and your own code decides when to read it.

Where this actually sits in the memory landscape

OpenWiki isn’t the only project trying to solve agent memory, and it’s worth being honest about how it’s different, not just louder.

Mem0, one of the more established open-source memory tools, works the other way: it gives agents an explicit API to save and recall facts, memory.add(), memory.search()called on demand. That's still reactive. The agent decides in the moment what's worth remembering.

OpenAI’s own Agents SDK takes a third approach entirely: it lets an agent learn from its own past runs, distilling lessons from previous attempts at the same kind of task into a summary file. That’s useful, but it’s about an agent improving at repeating its own work, not about knowing what’s happening in your Gmail this week.

Other names are circulating in this same space too, memU and Zep among them, each taking its own angle on what agent memory should actually look like. The field is young enough that nobody has settled on one right answer yet, and it’s worth watching rather than picking a permanent side too early.

OpenWiki’s actual contribution is narrower and more specific than “better memory.” It’s proactive context from sources you’re not even actively looking at in the moment. That’s a real gap the other two don’t fill.

What’s still unproven

This is version 0.1.0. It launched days ago.

None of what follows is a knock, it’s just the honest state of things.

The connector list is currently fixed: Gmail, Notion, Git repositories, X, Hacker News, and web search. If your context lives somewhere else, there’s nothing to plug in yet.

There’s no public data yet on how well the synthesis step holds up over months of use, whether the wiki stays accurate as your work shifts, or how it handles conflicting information from different sources. Anyone telling you they already know the long-term answer to that is guessing.

It’s also brand new from a team, LangChain, that ships fast and iterates in public. That’s a reasonable bet to make, but it is a bet, not a settled result.

There’s also a plain question worth asking before you connect your actual Gmail and Notion to anything this new: where does that ingested data live, who else can read it, and what happens if the tool changes hands down the line?

Being open source helps; you can inspect exactly what it’s doing, but it’s still worth checking before pointing it at anything sensitive.

Decision framework

Photo From AI

Key takeaways

• Most AI memory today is reactive: it only remembers what you explicitly say, one fact at a time.
• OpenWiki, from the LangChain team, is built to be proactive: it pulls context from Gmail, Notion, Git, X, Hacker News, and web search on its own.
• It works in two steps: connectors ingest raw data, then a synthesis step organizes that into a local wiki your agent can read.
• It started as a tool for auto-documenting codebases and expanded into personal memory with version 0.1.0.
• It solves a different problem than Mem0 (explicit recall) or OpenAI’s Agents SDK memory (learning from an agent’s own past runs). None of the three replace the others.
• It’s days old. The connector list is fixed for now, and there’s no long-term data yet on how the synthesis holds up over time.

The one thing worth remembering

Go back to the two new hires.

The one who waits to be told everything isn’t lazy. That’s just how most AI memory has been built. You are the one doing the remembering, and the agent is just holding onto whatever you handed it.

The one who shows up already caught up isn’t smarter. They just started the day with the wiki open instead of closed.

OpenWiki is a bet that the second version is the one worth building toward. It’s early, it’s unproven at scale, and it only reaches a handful of places your context actually lives. But the direction is the right question to be asking: not “how do we get agents to remember more,” but “why are we still the ones doing all the remembering.”

References

• OpenWiki Brains: Proactive Memory for AI Agents (LangChain Official Blog) https://www.langchain.com/blog/introducing-openwiki-brains-general-purpose-wiki-memory-for-agents
• OpenWiki (Official GitHub Repository) https://github.com/langchain-ai/openwiki
• Open Source AI Agents with Built-in Memory (Mem0 Blog, for comparison) https://mem0.ai/blog/open-source-ai-agents-with-built-in-memory
• Agent Memory, OpenAI Agents SDK Documentation (for comparison) https://openai.github.io/openai-agents-python/sandbox/memory/