AMFS — GitHub for Agent Memory

The problem right now

You've hit one of these walls.
Probably all three.

Your agent just spent 45 minutes figuring something out. Tomorrow, a different agent will spend 45 minutes figuring out the same thing. This is that problem.

🏢 TEAM USING CURSOR / CLAUDE CODE

Five engineers. Five agents.
None of them know what the others found.

Your agent spends an hour figuring out why the auth service is flaky. Your teammate's agent does the exact same thing on Monday. Different agent, same hour wasted, same conclusion, nobody the wiser. You're paying twice for the same answer.

"Our agents can't understand what each other is doing — code changes, specs, decisions. Agentic coding is completely isolated."

👤 SOLO DEV

New session. Your agent looks at you
like you've never met.

What you tried. What worked. What blew up. Why you made that specific call. Gone. You spend the first twenty minutes re-explaining your own codebase to an agent that was literally here yesterday.

"Every new session has no context on what previous agents did or why. I waste time and tokens just getting it up to speed."

⚙️ BUILDING AGENT PIPELINE

Research agent found something critical.
By run 3, it's gone.

Research → planning → execution. Run 1: research agent figures something critical out. Run 3: it never happened. You've built a pipeline of very expensive amnesiacs who contradict each other and are all completely confident they're right.

"My agents don't know what the others found. They redo the same work, burn tokens re-explaining context, and operate on different versions of reality."

same root cause — IDE agents or pipeline agents

Without AMFS

# Run 1 — research agent (CrewAI) agent: Analyzed retry logic in checkout agent: Found race condition, patched it # Lives in context window. Run ends. Gone. # Run 2 — planning agent (LangGraph) agent: Analyzing checkout retry logic... agent: Should we check for race conditions? # Re-discovers same issue. Tokens burned. # Run 3 — Cursor session, new engineer agent: Rewriting checkout retry from scratch # Undoes run 1's fix. No one knows why.

With AMFS

# Run 1 — research agent (CrewAI) agent: Found race condition, patched it mem.write("checkout", "race-condition", "mutex pattern", confidence=0.9) mem.commit_outcome("RUN-001", "success") # Run 2 — planning agent (LangGraph) briefing = mem.briefing("checkout") # → race-condition: mutex (0.9) ✓ agent: Run 1 solved this. Moving on. # Run 3 — Cursor session, new engineer amfs_briefing("checkout-service") # → any agent. any framework. same memory.

Use cases

In case you were wondering
if this is for you.

If your agents touch the same codebase, talk to each other, or need to remember something across sessions — yes, it's for you.

🔁

Multi-agent pipelines

Research agent finds something. Planning agent needs it. Execution agent has to act on it. Without AMFS, the handoff is a prompt dump and a prayer. With AMFS, each agent actually knows what the last one did.

CrewAI · LangGraph · AutoGen

🧪

Agent experimentation

Branch the agent's brain, run an experiment in isolation, review the diff. If it goes sideways, rollback to the last snapshot. A/B testing — but for agent knowledge.

Branching · Tags · Rollback — Pro

🤖

Long-running coding agents

Your agent worked through a complex task over three sessions. Each time, it rediscovered the same patterns, relearned the same constraints, reintroduced itself to your codebase. AMFS gives it a brain that doesn't reset every time the context window closes.

MCP · Cursor · Claude Code

🔗

Cross-agent knowledge sharing

Agent A learns something. Agent B needs it. Right now you're solving this by stuffing conversation history into a prompt and hoping nothing gets truncated. AMFS is the version where it actually works.

Access Control · Branching · PRs — Pro

🏢

Team-wide agent memory

Five engineers, five agents, same codebase. Without AMFS, each agent is an island. One figures something out, the rest redo it. With AMFS, one agent's discovery is everyone's starting point — versioned, shared, and not lost in someone's context window.

Access Control · Branching · PRs — Pro

📋

Auditable agent decisions

Your agent did something. You need to explain why. "The AI decided" is not going to cut it. AMFS Decision Traces give you the full chain — what it read, what it believed, how confident it was — immutably logged, always there when you need it.

Decision Traces · explain() · Immutable log

The mental model

You already know how this works.
You've been doing it for years.

Every developer has a GitHub account. Every repo has a main branch. Fork it, work in isolation, open a PR, someone reviews the diff, it merges. AMFS does that — for agent memory. The mental model is already in your head.

Code · Git / GitHub

📁repowhere code lives

🌿main branchcurrent state of truth

🔀feature branchisolated experiment

📋pull requestpropose a change

👁️code review / diffsee what changed before merge

✅mergeaccept changes into main

📜git logfull history of every change

↩️git revertrestore to any point

🍴forkclone and diverge

🔑access controlwho can read or write

→

Agent Memory · AMFS

🧠agent brainwhere the agent's knowledge lives

🌿mainwhat the agent currently knows

🔀experiment branchisolated knowledge changesPro

📋knowledge PRreview before merging into mainPro

👁️memory diffsee exactly what changed in the brainPro

✅mergeaccept knowledge into mainPro

📜timelineevery write, read, and outcome logged

↩️rollbackrestore to any tag or eventPro

🍴forkclone an agent's entire brainPro

🔑access controlread/write per branch, user, or keyPro

See it in action

A dashboard your agents
will actually use.

Full visibility into every brain, every agent, every memory write — from a live overview down to the exact causal chain behind every decision.

Overview

Everything your agents know — at a glance.

26 entities, 5 active agents, 0.99 avg confidence. Confidence distribution, memory composition across facts / beliefs / experiences, and recent cross-agent activity — all live.

Agents

Every agent. Every entity they've touched.

Browse all agents writing to memory. Entries written, entities touched, total reads, decision traces — click into any agent to explore their full brain.

Brain Brief

What does this agent actually know?

A compiled narrative: entity focus graph, key facts, unvalidated beliefs, detected conflicts, and a recommendation for where the agent should focus next.

Memory Graph

The full knowledge graph. Interactive.

Every entity, every agent, every relationship — live and draggable. Click any node to see contributing agents, confidence scores, and the keys it holds.

Memory Tiers

Hot, Warm, Archive. Scored and ranked.

Memory distribution across tiers with avg scores and recall frequency per entry. The hot tier surfaces the highest-value knowledge so agents always start informed.

Sacred Timeline

The full timeline. Every event, ever.

Every write, outcome, cross-agent read, branch merge, and webhook — in order, filterable by type. Your immutable audit trail. Always there when you need it.

Branches

Isolated memory branches. Just like Git.

Fork an agent's brain, run experiments in isolation, diff the changes, and merge back to main — without touching production memory. Full branch history, access control, and origin tracking included.

Pull Requests

Review and approve memory changes before they land.

Agents open PRs. Humans (or other agents) review the diff and approve. Memory changes don't merge to main until someone gives the LGTM. Your agents ship knowledge — not surprises.

Snapshots

Point-in-time backups of your agent's brain.

Take a snapshot before a big experiment. Restore to any previous state in one click. Every snapshot logs entity count, entries, traces, and outcomes — your full brain state, preserved forever.

Activity

Every write. Every success. Every agent. Live.

A real-time activity timeline showing every memory write, task outcome, and cross-agent operation — timestamped and versioned. Finally an answer to "what was your agent doing at 8:54 AM?"

Getting started

It's embarrassingly simple.

Two ways to connect. Both under 5 minutes. After that, your agents read from and write to shared memory automatically — no babysitting required.

Cursor / Claude Code · MCP
Add one config block.
Your agents do the rest.
No code changes to your prompts. No new workflows to learn. Just connect and watch your agents start sharing what they know.

              01
              Add AMFS to your MCP config with your API key
            

              02
              Open a new session in Cursor or Claude Code
            

              03
              ✓ That's it. Your agents share memory across every session and every engineer on your team.
            

Python / TypeScript SDK · Pipelines

Write as you work.
Every agent picks it up.

Drop AMFS into your existing agent code. Agents write findings as they run — and any other agent, in any framework, can read them.

01 pip install amfs or npm install @amfs/sdk

02 Call mem.write() as your agent learns things. Call mem.briefing() at the start of each run.

03 ✓ That's it. Every agent in your pipeline starts informed. Nothing gets lost between runs.

What AMFS gives you

Memory that knows things.
Collaboration that actually works.

Not a vector database. Not a simple key-value store. A full memory engine with Git-like collaboration, intelligence, and a platform that works with every framework you already use.

📜

Git-like Timeline OSS

Every write, read, outcome, and cross-agent interaction is logged as an event. Full history, always. You can see exactly what happened, in order, with full context — not just the current state.

🔀

Branching & PRs Pro

Create branches for isolated knowledge experiments. Open pull requests to propose changes to main. Review the diff. Merge or discard. The same workflow developers use for code — now for agent knowledge.

🏷️

Tags & Rollback Pro

Create named snapshots at any point. Roll back an agent's entire brain to any tag or event. Deploying a new agent version? Tag first. Something goes wrong? Restore in one command.

🔑

Access Control Pro

Grant read or read/write access per branch, per agent, per user, team, or API key. Other agents can be given access to specific branches of a brain without touching main. Scoped, revokable, logged.

🍴

Fork Pro

Clone an agent's entire brain — full history, all entries, all confidence scores — to a new agent. Spin up a variant, a test instance, or a specialized agent that starts with all the context of its parent.

🍒

Cherry-pick Pro

Apply specific memory entries from one branch to another without a full merge. A knowledge transfer primitive that doesn't exist anywhere else.

📋

Copy-on-Write Versioning OSS

Every write creates a new version. The previous version is never deleted. You can diff any two versions, see exactly what changed, and understand how an agent's knowledge evolved over time.

📊

Confidence & Outcomes OSS

Every entry has a trust score that evolves when deploys succeed or incidents happen. Facts, beliefs, and experiences each have their own decay rate. Stale knowledge signals itself — agents don't act on it blindly.

🔎

Decision Traces & Explain OSS

Full causal chain capture — what the agent read, what tools it consulted, what state it was in, and exactly what happened when it acted. explain() surfaces the entire chain in one call.

🕸️

Knowledge Graph OSS

Relationships between entities, agents, and outcomes auto-materialize from normal operations. You don't define the graph — you just use AMFS and the graph builds itself as agents interact.

🔍

Hybrid Search OSS

Full-text + semantic + recency + confidence weighting in a single ranked result set. Not a vector DB that needs a separate retrieval strategy. Not keyword-only. Both, tuned for agent memory.

🧊

Tiered Memory OSS

Hot / Warm / Archive tiers with progressive retrieval and frequency-modulated decay. Classify entries as fact, belief, or experience — each with its own decay rate and retrieval priority.

🤖

MCP Server OSS

First-class support for Cursor, Claude Code, and any MCP-compatible client. Agents in your IDE get full AMFS access — briefings, search, read, write, outcomes — through the MCP protocol.

🔌

Framework Integrations OSS

Native integrations with CrewAI, LangGraph, LangChain, and AutoGen. Add persistent memory to your existing agent workflows in minutes — not a rewrite, just a wrapper.

🗄️

Multiple Adapters OSS

Filesystem for dev, Postgres for production, S3 for cloud. Swap adapters without changing a line of application code. Start local, scale to managed infrastructure without refactoring.

📡

HTTP/REST API OSS

FastAPI server with SSE streaming and API key auth. Speak standard HTTP to AMFS from any language, any framework, any runtime. The Python and TypeScript SDKs wrap this.

🔗

Connectors OSS

Ingest events from PagerDuty, GitHub, Slack, Jira — or build your own connector. When a deployment fires, an incident triggers, or a PR merges, AMFS can learn from it automatically.

🐳

Docker & Kubernetes OSS

One-command Docker deployment. Helm chart for Kubernetes. Start with docker run in 30 seconds. Scale to production with Kubernetes without changing your application code.

Get started in 30 seconds

Three ways to connect.
Pick the one that fits your stack.

# Add to your MCP client config (e.g. Cursor, Claude Code)
{
  "amfs": {
    "command": "python",
    "args": ["-m", "amfs_mcp_server"],
    "env": {
      "AMFS_API_KEY": "your-key",
      "AMFS_BASE_URL": "https://amfs.sense-lab.ai"
    }
  }
}

# Install
pip install amfs

from amfs import AgentMemory

mem = AgentMemory(agent_id="my-agent")

# Write a finding with confidence
mem.write(
    "checkout-service",
    "risk-race-condition",
    "Race condition in order processing under concurrent load",
    confidence=0.85,
    memory_type="belief",
)

# Read it — cross-agent reads are tracked automatically
entry = mem.read("checkout-service", "risk-race-condition")
# → confidence: 0.85, written_by: my-agent

# Hybrid search across all memory
results = mem.search("checkout-service", query="retry pattern")

# Outcome feedback updates confidence scores
mem.commit_outcome("DEP-287", "success")

# Full causal chain for any decision
trace = mem.explain("DEP-287")

// Install
npm install @amfs/sdk

import { AgentMemory } from '@amfs/sdk';

const mem = new AgentMemory({ agentId: 'review-agent' });

// Write a finding
await mem.write(
  'checkout-service',
  'risk-race-condition',
  'Race condition in order processing under concurrent load',
  { confidence: 0.85, memoryType: 'belief' }
);

// Read it — cross-agent reads are tracked automatically
const entry = await mem.read('checkout-service', 'risk-race-condition');
// → { confidence: 0.85, writtenBy: 'review-agent' }

// Hybrid search
const results = await mem.search('checkout-service', 'retry pattern');

// Record what happened
await mem.commitOutcome('DEP-287', 'success');

Works with your stack

One memory layer.
Every agent. Every framework.

MCP for Cursor and Claude Code. Native SDK integrations for CrewAI, LangGraph, LangChain, and AutoGen. One memory store — regardless of which framework each agent runs on. A finding written by a LangGraph agent is immediately readable by your next Cursor session.

CrewAI

Add AMFS tools to your CrewAI agents — read, write, and list memory entries as part of task execution.

pip install amfs-crewai

LangGraph

Use AMFS as a checkpointer for LangGraph — persist graph state across sessions and resume from any point.

pip install amfs-langgraph

LangChain

Drop AMFS in as chat memory for LangChain — save conversation context and load history across sessions.

pip install amfs-langchain

AutoGen

Use AMFS as a persistent memory store for AutoGen agents — store and retrieve structured data across agent runs.

pip install amfs-autogen

New session. No context. Again.

You've hit one of these walls.
Probably all three.

In case you were wondering
if this is for you.

You already know how this works.
You've been doing it for years.

A dashboard your agents
will actually use.

It's embarrassingly simple.

Memory that knows things.
Collaboration that actually works.

Three ways to connect.
Pick the one that fits your stack.

One memory layer.
Every agent. Every framework.

Start free.
Scale when your agents do.

Stop starting from
zero.

New session. No context. Again.

You've hit one of these walls.Probably all three.

In case you were wonderingif this is for you.

You already know how this works.You've been doing it for years.

A dashboard your agentswill actually use.

It's embarrassingly simple.

Memory that knows things.Collaboration that actually works.

Three ways to connect.Pick the one that fits your stack.

One memory layer.Every agent. Every framework.

Start free.Scale when your agents do.

Stop starting fromzero.

You've hit one of these walls.
Probably all three.

In case you were wondering
if this is for you.

You already know how this works.
You've been doing it for years.

A dashboard your agents
will actually use.

Memory that knows things.
Collaboration that actually works.

Three ways to connect.
Pick the one that fits your stack.

One memory layer.
Every agent. Every framework.

Start free.
Scale when your agents do.

Stop starting from
zero.