Why Jamgate: your agents shouldn't keep forgetting you

You are one person. But every AI you use treats you like a stranger it just met.

You design with one assistant, research with another, and write code with a third. Each one builds its own private picture of you over a conversation — and then throws it away. Open a new tool tomorrow and you start from zero: who you are, what you’re building, which machine you’re on, what you decided last week and why. You become the integration layer, ferrying the same context between tools by hand, re-explaining yourself for the hundredth time.

The obvious fix is shared memory: one place all your agents can read from and write to. Several systems now offer exactly that. The problem is what happens next.

Storing everything is not remembering

Most memory systems are built to capture. Say something, and it gets saved. That sounds helpful until you watch it run for a few months. The store fills with duplicates of the same fact, one-off chatter that mattered for exactly one message, and — worst of all — stale state presented as if it were still true. One production audit of a leading memory system found that 97.8% of its stored entries were junk: noise, repetition, and facts that had quietly expired.

A memory that’s 98% junk isn’t a memory. It’s a landfill you have to dig through. And the cost isn’t just storage — it’s trust. When an agent recalls “you’re on Windows” three months after you switched to Linux, or surfaces a preference you abandoned, you stop believing what it tells you. Bad memory is worse than no memory, because no memory at least doesn’t lie to you with confidence.

So sharing memory across agents is the easy half. Keeping that shared memory clean, current, and contradiction-free is the half nobody has solved. That’s the half Jamgate is about.

A gate, not a bucket

Jamgate sits in the write path. Before anything is stored, it has to get past a gate, and the bar is deliberately high: a memory is kept only if it is durable — still true after this session ends — and would actually change a future answer. “I’m debugging a flaky test right now” fails both tests. “I prefer TypeScript over JavaScript for new projects” passes.

Three things follow from treating the write path as the important one:

• Junk gets dropped at the door. Cheap rules catch the obvious noise; the calling agent’s own judgment does the main filtering; a thin classifier handles only the ambiguous middle. When it’s genuinely unsure, it asks you instead of guessing.
• Duplicates don’t accumulate. Saving the same fact twice doesn’t create two entries.
• New facts retire old ones by recency. Every memory is a timestamped event tied to a subject. When you move from Windows to Linux, the newer fact supersedes the older one — so the memory stays current instead of holding two contradictory entries and never throws your own outdated words back at you as if they were today’s truth.

Neutral on purpose

Jamgate runs as an MCP server, so any MCP-capable agent connects to the same memory — no lock-in to one vendor’s assistant. It runs locally, so your memory never leaves your machine, and it’s store-agnostic: a flat-file store by default, or bring your own. Same machine, every agent, one shared memory.

It’s early, but it’s real. The core works end to end today, and the harder problems — smarter classification, genuine contradiction handling, multi-device sync — are next. It’s open source, MIT-licensed, and built in the open, because the goal here is impact, not profit.

The pitch is small and stubborn: your agents should know you as well as a good colleague does — and should never confidently tell you something about yourself that stopped being true last month.