Skillget

amfs

agent
Security Audit
Warn
Health Warn
  • License — License: Apache-2.0
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Low visibility — Only 7 GitHub stars
Code Pass
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Pass
  • Permissions — No dangerous permissions requested
Purpose
This tool provides a version-controlled memory file system for AI agents. It allows agents to branch, merge, diff, and rollback their shared knowledge base using concepts modeled after Git.

Security Assessment
Overall Risk: Low. The light code scan of 12 files found no dangerous patterns, hardcoded secrets, or requests for dangerous permissions. Because it functions as a local memory storage system, it does not appear to execute shell commands or make external network requests. However, depending on how the memory data is persisted and shared across agents, you should ensure that sensitive knowledge stored in the agent's "brain" is properly secured within your own infrastructure.

Quality Assessment
Overall Quality: Moderate. The project is actively maintained, with its last push occurring today. It uses the permissive Apache-2.0 license and includes automated testing workflows for both Python and TypeScript. The main concern is its low community visibility; it currently only has 7 GitHub stars. This means the tool is very new and has not yet been widely battle-tested or reviewed by a large open-source audience.

Verdict
Use with caution. The code itself is clean, safe, and licensed properly, but the extremely small community means you should test it thoroughly before relying on it in critical production environments.
SUMMARY

Git for agent memory. Branches, diffs, PRs, and rollback for what your agents know.

README.md

AMFS — Agent Memory File System

Python Tests
TypeScript Tests
License: Apache 2.0

GitHub for agent memory. Every agent gets a brain — its own repo of what it knows. Branch it, diff it, open a PR, review the changes, merge. Roll back to any point. The mental model is already in every developer's head.

Documentation · Roadmap · Contributing

The Problem

When agents share memory today, it's chaos — last write wins, no branching, no review, no rollback. It's like coding without Git. Every team that tried that eventually hit a wall. Agent teams are hitting that wall right now.

The solution isn't "better permissions" or "smarter retrieval." It's giving agents the same collaboration model developers already live in: version control for knowledge.

How AMFS Works

Every developer knows this:          AMFS does the same for agent memory:

  repo                                 agent brain
  ├── main branch                      ├── main (what the agent knows)
  ├── feature branch                   ├── experiment branch (isolated changes)
  ├── pull request                     ├── pull request (review before merge)
  ├── code review                      ├── diff (what changed in the branch)
  ├── merge                            ├── merge (accept changes into main)
  ├── git log                          ├── timeline (every operation logged)
  └── git revert                       └── rollback (restore to any point)

Every write is a versioned commit. Every agent has provenance (who wrote what, when). Changes stay isolated on branches until the owner reviews the diff and merges. You can roll back to any point. You can fork an agent's entire brain to a new agent.

Quick Start

pip install amfs

from amfs import AgentMemory, OutcomeType

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

# Agent discovers a pattern and commits it to memory
mem.write("checkout-service", "retry-pattern",
          {"max_retries": 3, "strategy": "exponential-backoff"},
          confidence=0.85)

# Another agent reads it — the read is tracked automatically
entry = mem.read("checkout-service", "retry-pattern")

# When the deploy fails, confidence on related entries adjusts
mem.commit_outcome("INC-1042", OutcomeType.CRITICAL_FAILURE)

Full quick start guide →

Install

pip install amfs                    # Python SDK
npm install @amfs/sdk               # TypeScript SDK
pip install amfs-http-server        # REST API server
pip install amfs-adapter-postgres   # Postgres backend
pip install amfs-adapter-s3         # S3 backend
pip install amfs-cli                # CLI tools

Or run with Docker:

docker run -p 8080:8080 -v amfs-data:/data ghcr.io/raia-live/amfs

What You Get
Git-like Timeline Every write, outcome, and cross-agent read is logged as an event. Full history, always.
Branching & PRs Create branches, diff changes, open pull requests, merge or discard. Pro feature — details →
Rollback & Tags Create named snapshots. Roll back to any tag or event. Pro feature.
Access Control Grant read or read/write access per branch, per user, team, or API key. Pro feature.
Versioned Knowledge Copy-on-Write — every write creates a new version. Nothing is lost. history() to replay.
Confidence & Outcomes Entries carry trust scores that evolve when deploys succeed or incidents happen.
Causal Explainability explain() shows exactly which memories and external contexts drove a decision.
Knowledge Graph Relationships between entities, agents, and outcomes auto-materialize from normal operations.
Hybrid Search Full-text + semantic + recency + confidence in a single ranked result set.
MCP Server First-class support for Cursor, Claude Code, and any MCP client. Setup → · Cursor plugin
Connectors Ingest events from PagerDuty, GitHub, Slack, Jira — or build your own.
Python & TypeScript Same API in both languages. Plus CrewAI, LangGraph, LangChain, AutoGen.

Architecture

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ Agent A      │     │ Agent B      │     │ Agent C      │
│ (its brain)  │     │ (its brain)  │     │ (its brain)  │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       └───────────┬───────┴───────────────────┘
                   │
       ┌───────────┴───────────┐
       │ AgentMemory           │  ← Python / TypeScript SDK
       │ (versioned, branched) │
       └───────────┬───────────┘
                   │
       ┌───────────┴───────────┐
       │ HTTP API / MCP Server │  ← REST + SSE / MCP stdio
       └───────────┬───────────┘
                   │
     ┌─────────┬───┴────┬─────────┐
     ▼         ▼        ▼         ▼
 Filesystem  Postgres   S3      Custom
  Adapter    Adapter  Adapter   Adapter

OSS vs Pro

AMFS is open source under Apache 2.0. The OSS edition gives you the full memory engine — versioned writes, confidence scoring, outcome feedback, causal traces, knowledge graph, hybrid search, git-like timeline on main, SDKs, adapters, HTTP API, MCP server, and CLI.

AMFS Pro unlocks the full Git model: branching, merge, pull requests, access control, tags, rollback, cherry-pick, and fork. Plus multi-tenant SaaS isolation, immutable decision traces, automated pattern detection, an intelligence layer, and a web dashboard.

Think of it this way: OSS gives you a single-branch repo with full history. Pro gives you GitHub.

Full comparison →

Documentation

raia-live.github.io/amfs — Getting started, core concepts, SDK guides, adapter docs, integrations, API reference, and more.

Roadmap

Track what's been delivered and what's coming next on the AMFS Roadmap board.

Development

git clone https://github.com/raia-live/amfs.git && cd amfs
uv pip install -e packages/core -e packages/adapters/filesystem -e packages/sdk-python -e packages/cli -e packages/http-server
uv run pytest tests/ -v

Contributing guide →

License

Apache License 2.0

Reviews (0)

No results found