Markdown is not agent memory. It's a sticky note.

Bruno Andrade — Wed, 22 Apr 2026 23:47:47 +0000

Everyone's doing it.

A MEMORY.md in the project root. A context.md the agent reads at session start. A few bullet points about past decisions. Maybe a CLAUDE.md if you watched Karpathy's video.

for one person running local agents? It works

Karpathy's setup is clever and clean.

But the moment you try to do anything more serious with agents, markdown falls apart.

Here's how:

The file has no concept of confidence: "We use Postgres" and "I think the retry logic might be buggy" look identical. Both are just sentences. Your agent treats them the same way.
Two agents writing to the same file? Last write wins: No branching, no merge, no conflict detection. You won't even know it happened until something breaks in production.
There's no history: You can't diff what the agent knew last week vs. now. You can't roll back a bad memory. You can't audit why an agent made a wrong call two deploys ago. The file just is what it is.
It also doesn't travel: Your MEMORY.md lives on your machine, for your agent. The second you add another agent, another developer, or a deployed pipeline, the memory doesn't follow. Every session burns tokens, re-establishing context that was already established last time.

If you're building pipelines with CrewAI, LangGraph, AutoGen, or others, the markdown thing isn't even on the table. Your agents don't share a file. They don't share anything. They contradict each other, duplicate work, and no one has a record of what was actually learned during a run. The orchestrator knows the output, but the reasoning that led to it is gone.

And the costs are way more concrete than people realize.

That CLAUDE.md file gets loaded into every single session. Every word, every time. If it's 500 lines, that's maybe 3,000 to 5,000 tokens of overhead on turn one. By turn 50 of the same session, you're re-sending the entire conversation history plus that file on every single message (That's before any actual work gets done. That's just the flat file being re-read over and over.)

But it gets worse as the session ages

By message 40, the agent isn't just re-reading the 4,000-token file. It's re-reading the entire history of accumulated conversations. A 40-message session where each message is ~500 tokens means the last message re-processes ~20,000 tokens of context just from history, on top of the file.

That compounds to something like $2,000–$3,500/month per 10-person team in context overhead that provides zero new value. It's just the agent re-reading stuff it has already read.

What a proper memory system changes

Instead of dumping everything into context, SenseLab compiles a ranked briefing of what's actually relevant to the current task. A 10-entry briefing might be 800 tokens instead of 4,000+. That's 80% reduction in memory related input tokens before you even account for the session history problem.

The memory compiles itself into ranked briefings so the next agent starts with what matters, not a flat file of everything that ever happened.

Evolving agents

Markdown solves "I want my agent to remember I prefer TypeScript."
It doesn't solve "I want my agents to accumulate knowledge over time, share it reliably, and not step on each other."

That problem is what most teams actually have. And there's almost nothing built for it.

That's why we built SenseLab. Git for agent memory. Versioned, branchable, with confidence scoring, causal traces, and cross-agent reads that are tracked.

Markdown will get you started, but it won't help you scale and improve agent context and experience.

Want to give it a try? Sign up for free at SenseLab

Your Claude Code and Cursor agents have amnesia. Here's the fix.

Bruno Andrade — Mon, 13 Apr 2026 13:00:00 +0000

Every time you open a new Claude Code or Cursor session, your agent wakes up with absolutely no memory of anything it's ever done. Blank slate. Tabula rasa. Goldfish brain. You spend the first 10 minutes re-explaining your codebase to something that was literally there yesterday.

And if you're on a team? Each engineer's agent is its own little island of rediscovered knowledge. Agent A spends an hour figuring out why the auth service is flaky. Agent B does the same thing on Monday. Nobody the wiser.

AMFS fixes this. It's an agent memory engine with an MCP server that you connect to Cursor or Claude Code, and your agents get persistent, shared memory across every session and every machine on your team. The core is open source (Apache 2.0).

How it works

AMFS stores memory as versioned key-value entries scoped to an entity path, typically a service, module, or domain in your codebase. Entries carry a confidence score, a memory type (fact, belief, or experience), and full provenance: which agent wrote it, when, and from what context.

Every write uses Copy-on-Write, and the previous version is never deleted. Reads are tracked, so you know which agent consumed which piece of knowledge. Outcome commits (amfs_commit_outcome) feed back into confidence scores: entries written before a successful deploy gain confidence, entries linked to incidents lose it. Your agents get dumber when they're wrong and smarter when they're right, which is more than you can say for some humans :)

Under the hood, there's a knowledge graph that materializes relationships between entities from normal read/write operations, a tiered memory model (hot / warm / archive) with frequency-modulated decay, and a hybrid search that combines full-text, semantic, recency, and confidence into a single ranked result set.

The MCP server wraps all of this and exposes it to any MCP-compatible client.

MCP tools your agent gets

Tool	What it does
`amfs_set_identity`	Registers the agent's ID and current task. Scopes all subsequent writes to that agent.
`amfs_briefing`	Returns a compiled digest of the highest-confidence entries for an entity — ranked by tier, recency, and score. This is what the agent calls at the start of a session instead of asking you to re-explain everything for the 40th time.
`amfs_search`	Hybrid search across all entries: full-text + semantic + confidence weighting. Accepts an entity path filter.
`amfs_read`	Reads a specific entry by entity path and key. Cross-agent reads are tracked automatically for provenance.
`amfs_write`	Writes an entry with confidence score, memory type, and automatic provenance. Triggers CoW versioning.
`amfs_commit_outcome`	Records a task outcome (success / failure / regression) and auto-propagates confidence updates to all entries the agent read during that task.

Wiring it up

1. Get an API key

Grab your API key from the dashboard. That's the only credential you need; shared memory across your whole team is handled by the backend, no infrastructure to set up.

2. Claude Code

Add to ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "amfs": {
      "command": "uvx",
      "args": ["amfs-mcp-server"],
      "env": {
        "AMFS_API_KEY": "<your-key>",
        "AMFS_HTTP_URL": "https://amfs-login.sense-lab.ai"
      }
    }
  }
}

3. Cursor

Add to .cursor/mcp.json in your project, then copy the agent rules file:

{
  "mcpServers": {
    "amfs": {
      "command": "uvx",
      "args": ["amfs-mcp-server"],
      "env": {
        "AMFS_API_KEY": "<your-key>",
        "AMFS_HTTP_URL": "https://amfs-login.sense-lab.ai"
      }
    }
  }
}

Verify the connection by asking your agent to call amfs_stats(). It should return entry counts and agent activity. If it stares back at you blankly, check the path in your config.

Once each engineer on your team adds the same config block with their API keys, all your agents can automatically share the memory store across sessions and machines, with no extra setup.

What the agent actually does with it

Once the rules file is in place, the agent follows this pattern automatically on every session:

# Agent opens a session on checkout-service

amfs_set_identity("cursor/alice", "investigating flaky order flow")
amfs_briefing(entity_path="myapp/checkout")
# → ranked digest: known risks, prior decisions, confidence scores
# → "race-condition in order processing (0.85, written by cursor/bruno)"
# → alice's agent doesn't re-discover what bruno's already figured out

amfs_search("myapp/checkout", query="retry")
# → finds bruno's prior entry on the mutex fix

# ... agent does the work, finds something new ...

amfs_write(
  "myapp/checkout",
  "timeout-under-load",
  "downstream payment API times out above 200 rps — needs circuit breaker",
  confidence=0.78,
  memory_type="belief"
)

amfs_commit_outcome("TASK-412", "success")
# → confidence on all entries read during this task adjusts upward
# → bruno's race-condition entry also updates (alice's agent read it)

The next agent to open a session on myapp/checkout, whether that's a Claude Code session, another Cursor session, or a LangGraph pipeline — calls amfs_briefing and gets both findings up front, ranked by confidence. No re-explaining, no re-discovering, no token budget burned on context that already exists.

Agent identity is auto-detected from the environment (cursor/<username>, claude-code/<username>) so provenance is tracked without any extra config.

Using the Python SDK directly (for pipelines)

If you're building agent pipelines with CrewAI, LangGraph, or AutoGen, use the SDK instead of MCP. Same API key, same shared store, and a finding written by a pipeline agent shows up in your next Cursor session's briefing.

pip install amfs

from amfs import AgentMemory

mem = AgentMemory(
    agent_id="review-agent",
    base_url="https://amfs-login.sense-lab.ai",
    api_key="<your-key>"
)

# write a finding at the end of a pipeline run
mem.write(
    "checkout-service",
    "risk-race-condition",
    "Race condition in order processing under concurrent load",
    confidence=0.85,
    memory_type="belief"
)

# next run: pull a briefing before the agent starts reasoning
briefing = mem.briefing("checkout-service")

# outcome feedback updates confidence on everything the agent read this run
mem.commit_outcome("RUN-043", "success")

# explain() returns the full causal chain for any decision
trace = mem.explain("RUN-043")

Open source

The full memory engine — CoW versioning, confidence scoring, causal traces, knowledge graph, hybrid search, tiered memory, MCP server, HTTP API, Python + TypeScript SDKs, CLI — is Apache 2.0. If it's useful, a star helps other developers find it.

⭐ github.com/raia-live/amfs

DEV Community: Bruno Andrade