How to Give Claude Code & Cursor Persistent Memory Across Sessions with MCP

THARAGESH .A — Fri, 24 Jul 2026 08:50:37 +0000

Every time you start a new session in Cursor, Windsurf, or Claude Code, the AI agent starts with zero memory. It re-discovers your database schema, re-learns internal API patterns, and forgets architectural trade-offs you decided on yesterday.

To solve this, I created AgentHelm (agenthelm-mcp)—an open-source Model Context Protocol (MCP) server that acts as a versioned "Project Brain" for coding agents.

Here is how to set it up and how it works under the hood.

How It Works

AgentHelm uses a Brain Compiler pipeline to manage project knowledge:

Context Fetching (get_context): When an agent starts, it queries versioned architecture guidelines, schemas, and conventions.
Knowledge Proposals (propose_knowledge): When an agent learns a new pattern or settles a trade-off during execution, it proposes that decision back to the Project Brain.
Brain Compiler: The compiler checks for conflicts and releases the next version of the Project Brain for all future sessions.

30-Second Setup for Cursor & Claude Desktop

Add agenthelm-mcp to your .cursor/mcp.json or claude_desktop_config.json:


json
{
  "mcpServers": {
    "agenthelm": {
      "command": "npx",
      "args": ["-y", "agenthelm-mcp"],
      "env": {
        "AGENTHELM_CONNECT_KEY": "YOUR_CONNECT_KEY_HERE",
        "AGENTHELM_PROJECT": "your-project-name"
      }
    }
  }
}
You can generate a free connection key at agenthelm.online.

Using Python or Node.js SDKs
If you run custom autonomous agents, you can also use the native SDKs:

Python
bash
pip install agenthelm-sdk
python
from agenthelm import Agent
agent = Agent(key="ahe_live_...", name="Architect Agent", project="My App")
context = agent.get_context(category="database")
print("Project Context:", context.entries)
Node.js
bash
npm install agenthelm-node-sdk
typescript
import { Agent } from 'agenthelm-node-sdk';
const agent = new Agent({ key: 'ahe_live_...', name: 'Worker', project: 'My App' });
Resources & Links
Platform: agenthelm.online
GitHub: github.com/jayasukuv11-beep/agenthelm
npm: agenthelm-mcp
I'd love feedback on how you currently manage agent state across sessions!
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/u3c80vbov23sou9l5z3o.png)

I built a shared memory layer because my AI coding agents kept lying to each other

THARAGESH .A — Tue, 21 Jul 2026 06:25:34 +0000

A few months ago I noticed something annoying. I had Claude Code working
on the backend of a project and Cursor working on the frontend, same
repo. At some point the backend agent decided to rename a field —
subscription_plan became billing_tier — and the frontend agent never
found out. It just kept using the old name until something broke and I
spent twenty minutes figuring out why.

That's the whole origin story, honestly. Two agents, same codebase, zero
shared memory between them. Multiply that by a few weeks of work and you
get a project where nobody, human or agent, is entirely sure which
decisions are still true.

So I built something to fix it. It's called AgentHelm, and the short
version is: it's a shared, versioned knowledge base that multiple coding
agents can read from and write to, with an actual check for conflicts
before anything gets merged.

How it's wired up

It runs as an MCP server, so getting it into Claude Code or Cursor is
just adding a config entry — no plugin, no extra install step beyond
npx agenthelm-mcp.

When an agent wants to record a decision (a schema change, an API
contract, whatever), it goes through a small pipeline before it's
accepted:

the proposal gets validated for basic structure
evidence gets scored — did tests pass, is there a real commit behind this, was it reviewed
it's compared against everything already in the brain, using plain string-similarity checks, not an LLM call, so it's fast and consistent
if something conflicts, it stops there and gets flagged instead of guessing which one's right
otherwise it merges in, and the old version is marked superseded, never deleted

That last part turned out to matter more than I expected. Because nothing
gets thrown away, you end up with an actual history you can query:

\`bash
agenthelm blame my-project auth strategy

COMMIT v3.2.1 [auth-agent] 2026-07-16 14:02:11
DECISION: Migrate JWT secrets to Vault
REASON: Avoid credentials exposure. Stripping secrets from runtime config.
`\

So when something looks strange six weeks later, you're not guessing. You
can ask why it's there and get a real answer.

What it doesn't do yet

I'd rather say this plainly than let someone find out the hard way. When
two agents genuinely disagree — one says billing_tier, one says
subscription_plan — the system doesn't decide who's right. It flags it
and waits for a human. I went back and forth on this, but auto-resolving
ambiguous conflicts felt worse than just admitting it needs a person to
look.

It also adds real overhead. There's a network call before an agent starts
work, and the validation pipeline runs on every proposal. If you're
running one agent by itself for a quick task, you probably won't notice
much benefit, just the extra latency. Where it earns its keep is longer,
messier, multi-agent work, where the alternative is agents quietly
undoing each other's decisions.

And staleness is still an open problem. Right now the system checks new
information against what's already known, but nothing goes back and asks
whether an old fact is still true if nothing new happens to touch it.
That's next on my list.

Where this sits next to other tools

Worth being upfront, since there's real overlap in this space now. Ruflo
(formerly Claude Flow) is a much larger project focused on coordinating
what agents actually do — swarms, consensus, orchestration. This isn't
that. AgentHelm doesn't tell your agents what to do, it just keeps track
of what they've already decided and whether that's still consistent.

Ditto does something else again — memory that follows one person across
devices and agents. This is closer to the opposite: it's meant for a
project a few people (and their agents) are working on together, not one
person's personal context.

And most of the vector-store memory tools out there are built for
recall — search and retrieve something similar to what you asked for.
This adds an actual check for contradictions on top of that, which most
of them don't do.

If you want to try it

\bash npx agenthelm-mcp \\

Free up to 3 agents. Someone on Reddit already found a real setup issue —
Cursor's MCP config can break on path or Node version mismatches — so if
you hit that, I'd genuinely like to know, and I'm writing up proper
troubleshooting docs for it.

[repo : https://github.com/jayasukuv11-beep/agenthelm] · [site : agenthelm.online]

If you're running multiple agents on shared code and have solved this a
different way, I'd like to hear it.****

DEV Community: THARAGESH .A

How to Give Claude Code & Cursor Persistent Memory Across Sessions with MCP

I built a shared memory layer because my AI coding agents kept lying to each other

How it's wired up

What it doesn't do yet

If you want to try it