DEV Community: Abhishek Kundagol

The Two Ways AI Memory Breaks

Abhishek Kundagol — Thu, 20 Aug 2026 07:26:44 +0000

The interesting decision our memory system Memuron makes isn't "should I keep this."

It's "is this new, or is this something I already know, changed?"

Day 4. This one's about what we're building.

In the last post i said the hard part of the memory is deciding. I think most people hear that and picture a bouncer, something at the door turning away claims that don't make the cut.

That's the wrong picture. Throwing things away is one thing a memory system shouldn't do. Storage is cheap. The expensive question is structural.

Every new piece of information is either a genuinely new thing, or it's a change to something already in the record. Getting that wrong in either direction is what breaks systems.

Call every update a new memory and you get five near-identical claims about the same fact, drifting apart, all retrievable, none authoritative. Your agent picks one at random and sounds confident.

Call every new thing an update and you quietly overwrite distinct facts that happened to look similar. That one's worse, because it's silent.

So that judgement, new or changed, is the actual work. And it has to be made at write time, by something that can look at what's already known.

Two things we decided early. Nothing gets overwritten: a change appends, and the previous state stays in the record. And every one of those decisions gets stored with the reasoning behind it, so you can go back and see not just what the system concluded, but why it concluded it.

Neither is clever. Both are the kind of thing you can't add later.

Day 5: why nobody in your org chart owns any of this.

Your AI Memory Has No One in Charge

Abhishek Kundagol — Tue, 18 Aug 2026 05:15:51 +0000

Every time your AI stores something, it makes a decision.

Keep this or merge this with what we already know. Correct the old version or reject it since it is wrong.

In most systems today, nobody makes that decision. It's just an insert.

Day 3.

Think about how a good analyst handles new information. They don't just append it. They ask: does this contradict what I already have? Is this an update or a duplicate? Is the source reliable? Should this replace something?

That's the actual work of remembering. Not the writing down, the judging.

Now look at what most AI memory does. Embed the text. Insert the row and done. Every claim enters with equal standing. The correction doesn't overwrite the mistake, it just sits next to it. The duplicate becomes two votes for the same idea. The hallucination gets stores with exactly the same confidence as the verified fact.

Then six weeks later, retrieval pulls one of them out, and no one can tell you which one it was or why.

Writing is the easy half. Deciding is the whole problem.

Day 4: what happens when you put something in charge of that decision.

We at AlphaNimble building Memuron, a memory system for AI agents. This series is the thinking behind it, in the open.

Retrieval Is Not Memory

Abhishek Kundagol — Sat, 15 Aug 2026 06:10:57 +0000

"We have memory. We're using RAG."

You have retrieval. Those aren't the same thing, and the gap between them is where agents quietly go wrong.

Day 2.

RAG finds documents that look relevant to your question. That's it . That's the whole job. It's a very good search engine bolted to a very good writer.

But consider what it can't do.

Your customer changed their pricing tier in March. The old contract is still in the index. The new one is too. RAG doesn't know which one is true, it just knows both are relevant. It hands the model two answers and lets it guess.

Memory would know one of those facts replaced the other, and when.

That's the difference. Retrieval finds. Memory concludes.

Retrieval asks "what documents match?" Memory asks "what do I actually believe, what changed my mind, and when did that happen?"

One is lookup. The other is position.

This matters because a system that only retrieves can never be wrong and it can never be right either. It has no beliefs to correct. Every contradiction in your data is a contradiction it will faithfully pass along, forever, with total confidence.

Day 3: if memory means concluding things, then something has to decide what gets remembered. Right now, in most systems, nothing does.

We at AlphaNimble are building Memuron, a memory system for AI agents. This series is thinking behind it, in the open.

Context Windows Are Not Memory

Abhishek Kundagol — Fri, 14 Aug 2026 05:44:10 +0000

Everyone is racing to make AI smarter.
Almost nobody is asking what it's allowed to remember.

I'm starting a daily series on the least understood layer in AI. Day 1.

Here's the confusion at the center of it: we've started calling the context window "memory." It isn't.

A context window is a desk. You pile things on it, you work, and at the end of the session someone clears the desk. Bigger models just give you a bigger desk.

Memory is the filing cabinet. What survives the desk being cleared.

So picture hiring a brilliant analyst with no long-term memory. Every morning you re-brief them on the company, the customers, the decisions you already made together. They nod. They do genuinely excellent work. And by tomorrow, it's gone.

You'd never call that person a knowledge worker. You'd call it a very expensive Groundhog Day.

That is most "AI agents" running in production today.

The industry's answer has been to treat this as a storage problem. Bigger context. Another vector database. Stuff more in, hope the right thing comes out.

I think that's the wrong frame entirely. Memory isn't a storage problem.

It's a trust problem.

Tomorrow, Day 2: why RAG is not memory — and why confusing the two costs teams more than they realise.

—

We at Alphanimble building Memuron, a memory system for AI agents. This series is the thinking behind it, in the open. Every post is something I've had to figure out to build the thing.

AI #AIAgents #AIMemory

Your AI Doesn't Have Amnesia — It Has a Storage Problem

Abhishek Kundagol — Wed, 08 Jul 2026 05:35:03 +0000

I hit this wall over and over.

I'd have a long conversation with one LLM — Claude, ChatGPT, Gemini, whatever — and then want to continue the same thread in another. Maybe I started researching in ChatGPT and wanted to implement in Cursor. Maybe Claude had better reasoning for one part, but I needed a different tool for the next step.
The only workaround? Copy-paste the entire conversation. Every message. Every detail. Just to give the new model enough context to pick up where the last one left off.

It works, barely. But it's awful. You're manually shuttling context between tools that are supposed to be smart. And you're burning tokens on duplicated history — paying twice (or three times) for information you already established once.

That friction is where this problem really started for me. Not abstractly. Practically. Every time you switch AI tools, you start over — or you become the copy-paste middleware between siloed memories.

Every AI remembers you differently. None of them share.

ChatGPT has its own memory. Claude has connectors and conversation context. Cursor picks up rules and session context. Gemini holds a different slice of your preferences. Every custom agent, IDE plugin, and workflow tool stores what it learns separately.
Each platform is getting smarter. Each one remembers more. And none of them talk to each other.

You explain your tech stack in Claude, then again in Cursor. You set tone preferences in ChatGPT that your coding agent never sees. You research in one tool and reconstruct context from scratch in another.

It's not just inconvenient. It's a structural flaw: each AI owns its own memory, and there's no shared layer underneath.
And underneath most of these systems? Vector databases — similarity search over a bag of facts. Tell an agent "I like blue" on Monday and "actually, I prefer red" on Tuesday, and a plain vector store returns both. The agent gets a contradiction it can't resolve.

Every contradicted memory is a silent hallucination waiting to surface.

What we built: one memory graph, every agent

Memuron is a semantic memory layer for AI agents — not a vector bucket, but a managed knowledge graph that any tool can read from and write to.

Connect Cursor, Claude, ChatGPT, or your own agents via MCP or API, and they all work against the same durable memory. Start a conversation in one place. Continue in another. No copy-pasting. No re-explaining. No wasted tokens shuttling context you already established.

Memuron doesn't replace your AI tools. It gives them a shared brain.

How it works

The Guardian decides before it stores. Every write passes through an LLM pipeline that asks: is this a new fact, an update to something already known, or a link to a related memory? When preferences change, Memuron evolves the existing memory in place — it doesn't pile up contradictions.
A graph, not a pile of embeddings. Memories are typed nodes connected by semantic links. Agents can search, traverse, and reason over relationships — not just grab the nearest vector match.

One substrate, many clients. MCP-native integration means Cursor, Claude, and ChatGPT query and write to the same org-scoped graph. OAuth authentication — no API key wrangling in your editor.

What you get

Hybrid Graph Search — vector, lexical, and link-description matching fused together. Returns memories and the edge that made them relevant.
GraphFS — query your memory graph like a filesystem:
cwd /spaces/work ls | grep "auth" | semantic "rate limiting" | links
Spaces — separate work, personal, and project context, each with its own Guardian rules.
Document Ingestion — PDFs, DOCX, Markdown, images, and more, parsed into chunk nodes and linked into your graph. Resolve any chunk back to the original source.
URL & Folder Sync — fetch pages, sync local folders, keep stable identities so re-runs update instead of duplicate.
Context Assembly — prompt-ready blocks with citations, graph breadcrumbs, and hard token budgets.
Multi-Tenant Isolation — cryptographic tenant boundaries for B2B SaaS and team deployments.

- REST API + CLI — `uvx memuron` for scripts, CI, and custom integrations.

Memory that travels with you

The future of AI isn't ten separate brains that each forget what the others learned. It's one durable memory layer that every agent can tap into — smart enough to update itself, structured enough to query, and open enough to connect anywhere.
You shouldn't have to be the copy-paste layer between your AI tools. Memuron is that layer — so you can stop repeating yourself and start building on what you already know.
Memory that decides before it stores. One graph for every agent you use.