⬡ Open Source · Apache 2.0
✦ GitHub for agent memory

Your agents are already running. Their knowledge is going nowhere.

AMFS gives every agent a brain — its own repo of what it knows. Branch it, diff it, review changes, merge them. Roll back to any point. Collaborate on memory the way developers already collaborate on code.

Try AMFS Pro → OSS on GitHub Read the docs →

pip install amfs · npm install @amfs/sdk · Docker · MCP · Works today

Python
pip install amfs
TypeScript
npm install @amfs/sdk
Docker
docker run -p 8080:8080 ghcr.io/raia-live/amfs
MCP (Cursor / Claude)
pip install amfs-mcp-server

The mental model

You already know how this works.

Every developer has a GitHub account. Every repo has a main branch. You fork it, work in isolation, open a PR, someone reviews the diff, it merges. AMFS does that — for agent memory.

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

The problem right now

Coding without Git was chaos.
Agent memory without AMFS is the same.

Remember emailing zip files to teammates? Manually merging changes because two people edited the same file? That's exactly where agent memory is today — and your team is already hitting the wall.

LAST WRITE WINS. ALWAYS.
Agent A learns something important.
Agent B overwrites it 3 seconds later.

You have two agents working on the same service. Agent A discovers a retry pattern that prevents cascading failures. Agent B finishes its task and writes to the same key with different conclusions. Agent A's knowledge is just gone. No conflict warning. No merge prompt. No history.

🔀
AMFS uses Copy-on-Write versioning. Nothing is ever lost. Every write creates a new version. With Pro branching, agents work in isolation and changes go through review before touching main.
EVERY SESSION. FRESH START.
Your agent ran for 2 hours.
Next session: complete amnesia.

Your agent did great work — figured out the deployment pattern, identified which configs drift, learned which services are flaky. Context window closes. New session starts. It asks the same questions again, makes the same mistakes again, and you debug the same things again.

🧠
The Memory Cortex compiles raw entries into ranked briefings. Every new agent session starts with a pre-compiled digest of what matters — across any machine, any session, any team member.
THE AGENT DID WHAT?
Something broke in production.
An agent made a decision. You have no idea why.

Your agent triggered a deployment, modified a config, or changed a downstream setting. Something went wrong. You have logs of what it did, but nothing about why — what it read, what it believed, what it was optimizing for. The causal chain is invisible. The post-mortem is a guess.

🔎
AMFS Decision Traces capture the full causal chain — what the agent read, which tools it consulted, what state it was in, and exactly what happened when it acted. explain() shows you everything.
GROWING AGENT TEAMS
One agent trusted another's output.
That output was 3 months stale.

Your research agent wrote a finding in January. Your deployment agent read it in April and acted on it. Nobody had reviewed whether it was still accurate. There's no confidence score, no staleness signal, no way to see the diff between what was true then and what's true now.

📊
AMFS tracks confidence scores that evolve with outcomes. Facts decay. Beliefs age. Experiences accumulate. When something succeeds or breaks in production, the scores update — automatically.

Use cases

What teams are building with AMFS.

Any time multiple agents touch the same knowledge, or any single agent needs to remember across sessions, AMFS is the layer that makes it work.

🔁
Multi-agent pipelines
A research agent discovers something. A planning agent uses it. An execution agent acts on it. A review agent updates the confidence based on what happened. Without AMFS, each handoff is a context dump into a prompt. With AMFS, knowledge compounds and every agent starts informed.
CrewAI · LangGraph · AutoGen
🧪
Agent experimentation with rollback
Testing a new prompt strategy or a different reasoning approach? Branch the agent's brain, run the experiment in isolation, review the diff against main before committing anything. If it goes wrong, rollback to the last tag. Same workflow as A/B testing code — now for agent knowledge.
Branching · Tags · Rollback — Pro
🤖
Long-running coding agents
Your Cursor agent worked through a complex refactor over three sessions. Each time it started, it re-discovered the same patterns, re-learned the same constraints, re-made the same decisions. AMFS gives it a persistent brain — it picks up where it left off, every time, without the rediscovery loop.
MCP · Cursor · Claude Code
🚨
Incident response & on-call agents
An on-call agent investigates an alert, identifies the root cause, and writes its findings with confidence scores. The next incident, it starts with a briefing — past patterns, known flaky services, previous mitigations. PagerDuty fires; the agent already has context before the first human looks at their phone.
PagerDuty · Connectors · Decision Traces
🏢
Team-wide shared agent knowledge
Your team has five engineers running agents against the same codebase. Each agent learns something. With AMFS, those learnings are shared, versioned, and access-controlled — the same way you share code on GitHub. One agent's discovery becomes every agent's starting point, without any agent blindly overwriting another's work.
Access Control · Branching · PRs — Pro
📋
Auditable AI decision trails
An agent made a call that affected a customer, triggered a deployment, or changed a system setting. You need to know exactly why — what it knew, what it read, what confidence it had in each piece of information. AMFS Decision Traces give you the full causal chain, immutably logged, ready to export.
Decision Traces · explain() · Immutable log

The agent memory loop

Knowledge that compounds.
Not knowledge that resets.

Each agent session picks up where the last one left off. Knowledge accumulates across agents, sessions, and machines. The next agent on the job starts with a briefing — not a blank page.

01
Identify yourself
The agent announces its identity and current task. AMFS uses this to scope what's relevant and log everything under the right context — no anonymous writes, ever.
02
Get a briefing
The Memory Cortex compiles a ranked digest of what matters for this task — recent entries, high-confidence findings, past incidents. The agent starts informed, not from scratch.
03
Search for specifics
Hybrid search across full-text, semantic similarity, recency, and confidence in one ranked result set. Not a vector DB. Not a keyword search. Both, plus more.
04
Read relevant entries
Every read is tracked automatically. The knowledge graph materializes from normal operations — who read what, which agent wrote it, when it was validated by an outcome.
05
Do the work
The agent does its job. It's got context. It's not repeating the same discovery loops. Every external tool call is captured in the decision trace.
06
Write findings
Discoveries, risks, patterns — written back with a confidence score and classified as fact, belief, or experience. Nothing overwrites. Every write creates a new version.
07
Record outcomes
Deployment succeeded? Incident triggered? AMFS commits the outcome and updates the confidence scores of everything that influenced the decision. Truth and trust evolve together.
08
Next agent starts at step 2
Knowledge compounds. The next agent — on any machine, in any session — inherits everything. Not the context window. The actual, accumulated, versioned brain.
# Agent memory loop — Python SDK from amfs import AgentMemory mem = AgentMemory(agent_id="checkout-agent") # 01 · Identify + task context mem.set_identity("checkout-agent", "Fixing retry logic") # 02 · Get a pre-compiled briefing briefing = mem.briefing(entity_path="checkout-service") # 03 · Search across all memory types results = mem.search("checkout-service", query="retry pattern") # 04 · Read a specific entry (read is tracked) entry = mem.read( "checkout-service", "retry-pattern" ) # → confidence: 0.85, written_by: review-agent # 06 · Write a new finding mem.write( "checkout-service", "risk-race-condition", "Race condition under concurrent load", confidence=0.85, memory_type="belief", ) # 07 · Record the outcome → updates confidence mem.commit_outcome("DEP-287", "success") # Next agent starts with this context ^ already compiled
# MCP — works in Cursor and Claude Code today amfs_set_identity("checkout-agent", "Fixing retry logic") amfs_briefing(entity_path="checkout-service") amfs_search("checkout-service") amfs_write("checkout-service", "key", "value...") amfs_commit_outcome("DEP-287", "success")

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 everything you already use

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

OSS vs Pro

OSS gives you a repo with full history.
Pro gives you GitHub.

The full memory engine is open source under Apache 2.0. Pro unlocks the Git collaboration layer — branching, PRs, access control, rollback, and a managed SaaS with a web dashboard.

Open Source · Apache 2.0
AMFS OSS
The full memory engine. Deploy yourself. Start in 30 seconds with Docker.
  • ✓ Versioned knowledge (Copy-on-Write)
  • ✓ Confidence scoring + outcome feedback
  • ✓ Decision traces + explain()
  • ✓ Knowledge graph
  • ✓ Hybrid search (full-text + semantic)
  • ✓ Tiered memory (fact / belief / experience)
  • ✓ Git-like timeline on main
  • ✓ MCP server · HTTP API · Python + TypeScript SDK
  • ✓ Filesystem, Postgres, S3 adapters
  • ✓ Docker · Kubernetes · CLI
  • ✓ Framework integrations (CrewAI, LangGraph...)
View on GitHub →
AMFS Pro
AMFS Pro
The full Git model for agent memory. Branching, PRs, access control, rollback, and a managed SaaS. OSS → GitHub upgrade.
  • ✓ Everything in OSS
  • ✓ Branching — isolated knowledge experiments
  • ✓ Pull Requests — review before merge
  • ✓ Access control — per branch, user, team, key
  • ✓ Tags + rollback — restore to any point
  • ✓ Fork — clone an agent's entire brain
  • ✓ Cherry-pick — selective knowledge transfer
  • ✓ Immutable decision traces
  • ✓ Automated pattern detection
  • ✓ Intelligence layer + web dashboard
  • ✓ Multi-tenant SaaS · managed infrastructure
Try AMFS Pro →

Your agents are already running.
Give them a brain that remembers.

30 seconds to deploy. Two env vars to connect to Pro. The mental model is already in your head. You've been using Git for years. AMFS is just Git — for the knowledge your agents build.

Try AMFS Pro → OSS on GitHub Read the docs

Apache 2.0 · pip install amfs · npm install @amfs/sdk · Docker · MCP